ARC-Cognitive-Qwen-7B

<div align="center">

Qwen2.5-7B Cognitive Enhancement Adapter

Decode-Time Behavioral Control via Hidden State Probing

Logan Matthew Napolitano

Research into cognitive behavioral control in language models

Quick Start • Architecture • Probes • Evaluation • Citation

</div>

---

Table of Contents

1. Model Description
2. Quick Start
3. Architecture
4. Probe Specifications
5. Intervention Mechanism
6. Installation
7. Usage
8. Evaluation
9. Configuration
10. Hardware Requirements
11. Limitations
12. Technical Specification
13. Citation
14. License

---

Model Description

This repository contains a cognitive enhancement adapter for Qwen2.5-7B-Instruct. The adapter consists of five lightweight probes that analyze hidden states during generation and apply targeted interventions to improve response quality.

Core Concept

The adapter detects cognitive failure modes (shallow reasoning, vagueness, overconfidence, topic drift, logical inconsistency) by monitoring the model's internal representations at decode time. When a probe fires, the system adjusts token probabilities to steer generation toward more desirable behaviors.

Intended Use

• Research into behavioral control mechanisms in language models
• Study of hidden state interpretability
• Applications requiring structured, well-calibrated responses
• Base for further experimentation with decode-time intervention

Not Intended For

• Production deployment without thorough evaluation
• Safety-critical applications
• Replacement for proper model fine-tuning when domain adaptation is needed
• Applications where the base model's default behavior is preferred

---

Quick Start

Minimal Setup

git clone https://huggingface.co/LoganResearch/qwen2.5-7b-cognitive-enhanced
cd qwen2.5-7b-cognitive-enhanced
pip install torch transformers accelerate bitsandbytes
python inference.py

Basic Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

# Load base model
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct",
    quantization_config=BitsAndBytesConfig(load_in_4bit=True),
    device_map="auto",
    output_hidden_states=True,
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")

# Load adapter
adapter = torch.load("cognitive_adapter.pt", map_location="cuda")
print(f"Probes loaded: {list(adapter['probes'].keys())}")

---

Architecture

System Overview

┌─────────────────────────────────────────────────────────────────────────────┐
│                    COGNITIVE ENHANCEMENT ARCHITECTURE                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                         INPUT PROCESSING                             │   │
│  │  User Prompt → Tokenization → Model Forward Pass                     │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    ▼                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                      HIDDEN STATE EXTRACTION                         │   │
│  │  Layer 7, 14, 21 → Last Token Position → [batch, 3584]              │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    ▼                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                       FIBER PROJECTION                               │   │
│  │  Per-layer linear projection: 3584 → 16 dimensions                   │   │
│  │  Learned layer weights: softmax([w₇, w₁₄, w₂₁])                     │   │
│  │  Weighted sum → 16-dimensional behavioral embedding                  │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    ▼                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        PROBE HEADS (×5)                              │   │
│  │  ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────┐ │   │
│  │  │   Depth   │ │Specificity│ │Calibration│ │   Focus   │ │Cohere.│ │   │
│  │  │   366×    │ │   215×    │ │   165×    │ │   227×    │ │ 191×  │ │   │
│  │  └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ └───┬───┘ │   │
│  │        │             │             │             │           │     │   │
│  │        └─────────────┴──────┬──────┴─────────────┴───────────┘     │   │
│  │                             │                                       │   │
│  │                     Probe Scores: P(behavior) ∈ [0,1]              │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    ▼                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                      INTERVENTION ENGINE                             │   │
│  │  For each probe where score > threshold (0.5):                       │   │
│  │    • Boost tokens: logits[token_id] += strength × boost_factor      │   │
│  │    • Suppress tokens: logits[token_id] -= strength × suppress_factor│   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    ▼                                        │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                         OUTPUT SAMPLING                              │   │
│  │  Modified logits → Softmax → Token sampling → Next token            │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Probe Head Architecture

Each probe consists of two components:

1. Fiber Projection (shared structure, independent weights)

Input: Hidden states from layers [7, 14, 21]
       Shape: [batch, hidden_dim] × 3

Layer weights: learnable [3] → softmax
Per-layer projection: Linear(3584 → 16, bias=False)
Output: Weighted sum → [batch, 16]

2. Classification Head

Input: [batch, 16]
Linear(16 → 64) → GELU → Linear(64 → 64) → GELU → Linear(64 → 1) → Sigmoid
Output: P(cognitive_failure_mode) ∈ [0, 1]

---

Probe Specifications

Overview

Separation Ratio = mean(P(positive_class)) / mean(P(negative_class))

Higher separation indicates cleaner discrimination between behavioral states.

Probe Details

Depth Probe (366×)

Purpose: Detects when the model is about to produce shallow, unsupported conclusions without intermediate reasoning steps.

Positive class indicators:

• Single-sentence answers to complex questions
• Missing causal connectives
• Absence of step-by-step structure

Intervention tokens:

• Boost: "First", "Because", "Since", "Therefore", "Let", "Step", "Consider"
• Suppress: "Simply", "Just", "Obviously", "Clearly"

Specificity Probe (215×)

Purpose: Detects when the model is about to produce vague, non-committal language lacking concrete details.

Positive class indicators:

• Generic nouns: "things", "stuff", "something"
• Hedging qualifiers: "kind of", "sort of", "basically"
• Absence of examples or specific instances

Intervention tokens:

• Boost: "specifically", "example", "namely", "particular", "instance", "precisely"
• Suppress: "things", "stuff", "various", "generally", "basically", "kind of"

Calibration Probe (165×)

Purpose: Detects when the model is about to make overconfident claims on inherently uncertain topics.

Positive class indicators:

• Absolute certainty markers on speculative topics
• Missing epistemic hedging
• Deterministic language for probabilistic questions

Intervention tokens:

• Boost: "might", "possibly", "perhaps", "likely", "probably", "could", "may"
• Suppress: "definitely", "certainly", "absolutely", "always", "never", "guaranteed"

Focus Probe (227×)

Purpose: Detects when the model is about to drift away from the user's question or introduce tangential content.

Positive class indicators:

• Tangent markers: "by the way", "speaking of"
• Unrelated topic introductions
• Loss of reference to original query

Intervention tokens:

• Boost: "regarding", "answer", "question", "specifically", "directly", "topic"
• Suppress: "anyway", "tangent", "aside", "by the way", "incidentally"

Coherence Probe (191×)

Purpose: Detects when the model is about to produce logically inconsistent or poorly structured content.

Positive class indicators:

• Missing transition words
• Contradictory statements
• Non-sequitur progressions

Intervention tokens:

• Boost: "however", "therefore", "thus", "furthermore", "moreover", "because", "consequently"
• Suppress: (none — coherence is structural)

---

Intervention Mechanism

Algorithm

def apply_intervention(logits, probe_scores, config):
    """
    Modify logits based on probe activations.
    
    Args:
        logits: [vocab_size] tensor of next-token logits
        probe_scores: dict mapping probe_name → score ∈ [0,1]
        config: intervention parameters
    
    Returns:
        Modified logits tensor
    """
    for probe_name, score in probe_scores.items():
        if score > config.threshold:  # Default: 0.5
            strength = (score - config.threshold) * 2  # Scale to [0, 1]
            
            # Boost beneficial tokens
            for token_id in config.boost_tokens[probe_name]:
                logits[token_id] += strength * config.boost_strength
            
            # Suppress harmful tokens
            for token_id in config.suppress_tokens[probe_name]:
                logits[token_id] -= strength * config.suppress_strength
    
    return logits

Parameters

---

Installation

Requirements

pip install torch>=2.0.0
pip install transformers>=4.35.0
pip install accelerate>=0.24.0
pip install bitsandbytes>=0.41.0  # For 4-bit quantization

Full Installation

git clone https://huggingface.co/LoganResearch/qwen2.5-7b-cognitive-enhanced
cd qwen2.5-7b-cognitive-enhanced
pip install -r requirements.txt

---

Usage

Complete Inference Example

See inference.py for the full CognitiveEnhancedQwen class implementation.

from inference import CognitiveEnhancedQwen

# Initialize
qwen = CognitiveEnhancedQwen("cognitive_adapter.pt")

# Generate with enhancement
response = qwen.generate(
    prompt="Explain why the sky is blue.",
    enhanced=True,
    max_tokens=300,
    temperature=0.7
)
print(response)

# Compare vanilla vs enhanced
vanilla = qwen.generate("Explain the Monty Hall problem.", enhanced=False)
enhanced = qwen.generate("Explain the Monty Hall problem.", enhanced=True)

Selective Probe Activation

# Enable only specific probes
qwen.active_probes = ["depth", "calibration"]

# Disable a probe
qwen.active_probes = [p for p in qwen.probes.keys() if p != "focus"]

---

Evaluation

Qualitative Comparison

Observed Behavioral Changes

Note: These are qualitative observations from limited testing. Independent benchmark evaluation is recommended before deployment.

---

Configuration

config.json Structure

{
  "model_type": "cognitive_enhancement_adapter",
  "version": "1.0.0",
  "base_model": "Qwen/Qwen2.5-7B-Instruct",
  "architecture": {
    "hidden_dim": 3584,
    "fiber_dim": 16,
    "head_hidden_dim": 64,
    "probe_layers": [7, 14, 21]
  },
  "usage": {
    "boost_strength": 3.0,
    "suppress_strength": 4.0,
    "threshold": 0.5
  }
}

---

Hardware Requirements

Tested Configuration:

• NVIDIA RTX 3090 (24GB), 64GB RAM ✓

Performance:

• Inference overhead: ~5% additional latency from probe computation
• Adapter size: 3.57 MB

---

Limitations

Known Limitations

What This Is Not

• This is not a fine-tuned model — base weights are unchanged
• This does not add knowledge — only modifies generation behavior
• This does not guarantee improved outputs — effectiveness varies by prompt
• This is not validated for production use

---

Technical Specification

Training Details

• Training steps: 2000-2500 per probe
• Batch size: 4
• Learning rate: 5e-5
• Optimizer: AdamW
• Early stopping: Applied to prevent overfitting (observed at ~2700 steps)

Probe Training Data

Each probe was trained on ~3000 synthetic examples:

• Positive class: Examples exhibiting the target failure mode
• Negative class: Examples demonstrating desired behavior
• Labeling: Per-sequence binary classification

File Structure

qwen2.5-7b-cognitive-enhanced/
├── cognitive_adapter.pt    # Merged probe weights (3.57 MB)
├── config.json             # Architecture and intervention config
├── inference.py            # Ready-to-use inference class
└── README.md               # This file

---

Citation

@software{napolitano2026cognitive,
  author       = {Napolitano, Logan Matthew},
  title        = {Cognitive Enhancement Adapter for {Qwen2.5-7B}},
  year         = {2026},
  publisher    = {Hugging Face},
  url          = {https://huggingface.co/LoganResearch/qwen2.5-7b-cognitive-enhanced},
  license      = {CC BY 4.0}
}

Related Work

• ARC-Base-8B-Condensed — Self-improving language model with CF-HoT behavioral control
• Qwen2.5-7B-Instruct — Base model

---

License

This work is licensed under CC BY 4.0 (Creative Commons Attribution 4.0 International).

You are free to:

• Share — copy and redistribute the material in any medium or format
• Adapt — remix, transform, and build upon the material for any purpose, including commercial

Under the following terms:

• Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.

---

Acknowledgments

• Alibaba Cloud for Qwen2.5-7B-Instruct base model
• Hugging Face for transformers library and model hosting

---

<div align="center">

Contact: Hugging Face Discussions

Version: 1.0.0 | Released: February 2026

Logan Napolitano / Fiber AI

</div>