Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,183 @@
+# Wisent-Qwen2.5-Coder-7B-Instruct with CAA Steering
+
+## Model Description
+
+This is an enhanced version of Qwen2.5-Coder-7B-Instruct that integrates **Contrastive Activation Addition (CAA)** steering directly into the model architecture. The steering parameters have been optimized using Optuna to improve code generation quality on the MBPP Plus benchmark.
+
+### Key Features
+
+- 🚀 **Automatic CAA Steering**: No manual hook management required
+- 🎯 **Optimized Parameters**: Layer 24, α=0.9
+- 🗂️ **Trait-Based Organization**: Steering vectors organized by traits
+- 🔧 **Runtime Configurable**: Adjust or disable steering on the fly
+- 🤗 **HuggingFace Compatible**: Works with standard transformers API
+
+## Installation
+
+```bash
+pip install transformers torch
+```
+
+## Quick Start
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Load model - CAA steering is automatically applied!
+model = AutoModelForCausalLM.from_pretrained("./huggingface_qwen_generated", trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained("./huggingface_qwen_generated")
+
+# Generate code
+prompt = "Write a Python function to calculate the factorial of a number"
+inputs = tokenizer(prompt, return_tensors="pt")
+outputs = model.generate(**inputs, max_new_tokens=256, temperature=0.2)
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+print(response)
+```
+
+## Advanced Usage
+
+### Adjusting Steering Strength
+
+```python
+# Increase steering strength for stronger safety alignment
+model.set_caa_alpha(1.2)
+
+# Decrease for more creative outputs
+model.set_caa_alpha(0.5)
+```
+
+### Disabling CAA Steering
+
+```python
+# Disable CAA to get baseline model behavior
+model.set_caa_enabled(False)
+
+# Re-enable CAA
+model.set_caa_enabled(True)
+```
+
+### Accessing Steering Configuration
+
+```python
+print(f"CAA Layer: {model.caa_layer_id}")
+print(f"CAA Alpha: {model.caa_alpha}")
+print(f"Steering Method: {model.steering_method}")
+```
+
+### Trait-Based Vector Organization
+
+The model uses a trait-based organization for steering vectors:
+
+```
+vectors/
+├── coding/         # Current: Optimized for code generation
+├── safety/         # Future: Safety-aligned behavior
+├── creativity/     # Future: Enhanced creative outputs  
+├── helpfulness/    # Future: Improved helpfulness
+└── reasoning/      # Future: Enhanced logical reasoning
+```
+
+To switch traits, simply update the configuration:
+
+```json
+{
+  "steering_vector_path": "./vectors/safety/steering_vector.safetensors"
+}
+```
+
+## Technical Details
+
+### CAA Steering Parameters
+
+- **Steering Method**: Contrastive Activation Addition (CAA)
+- **Optimal Layer**: 24 (out of 28 transformer layers)
+- **Steering Strength (α)**: 0.9
+- **Vector Format**: Safetensors format for efficient loading and HuggingFace compatibility
+- **Vector Dimension**: 3584 (pre-normalized during training)
+- **Storage Path**: `./vectors/coding/steering_vector.safetensors`
+
+### How It Works
+
+1. **Trait-based Organization**: Steering vectors are organized by behavioral traits (`vectors/{trait}/`)
+2. **Dynamic Loading**: The model loads the specified steering vector from the configured path
+3. **Layer Application**: Steering is applied to hidden states at layer 24 during forward pass
+4. **Generation Integration**: Steering affects the last token position during generation
+5. **Configurable Strength**: The α parameter (default: 0.9) controls steering intensity
+6. **Pre-optimized Vectors**: Steering vectors are pre-normalized and ready for immediate use
+
+### Optimization Process
+
+The CAA parameters were optimized using:
+- **Framework**: Optuna with TPE sampler
+- **Search Space**: Layers 15-28, α ∈ [0.1, 5.0]
+- **Objective**: Maximize accuracy on MBPP Plus validation set
+- **Best Validation Score**: 64% accuracy
+
+## Model Architecture
+
+```
+WisentQwen2ForCausalLM
+├── Base: Qwen2.5-Coder-7B-Instruct
+├── CAA Integration: Layer 24
+├── Steering Vector: ./vectors/coding/steering_vector.safetensors
+└── Auto-applied during generation
+```
+
+## File Structure
+
+```
+huggingface_qwen_generated/
+├── config.json                    # Model configuration with CAA params
+├── modeling_wisent_qwen.py        # Custom model class
+├── tokenizer files               # Standard Qwen tokenizer
+├── wisent_config.json            # Optimization results
+└── vectors/                       # Trait-based steering vectors
+    └── coding/
+        └── steering_vector.safetensors  # Optimized coding steering vector
+```
+
+## Evaluation
+
+### MBPP Plus Benchmark
+
+The model should be evaluated on the complete MBPP Plus dataset (378 problems) to measure improvement over the baseline. Expected improvements based on validation results.
+
+### Running Evaluation
+
+```python
+# Use with bigcode-evaluation-harness
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "./huggingface_qwen_generated",
+    trust_remote_code=True
+)
+
+# CAA steering is automatically applied during evaluation!
+# No manual hooks or modifications needed
+```
+
+## Citation
+
+If you use this model, please cite:
+
+```bibtex
+@software{wisent_qwen_caa_2025,
+  title={Wisent-Qwen2.5-Coder with CAA Steering},
+  author={Wisent AI},
+  year={2025},
+  url={https://github.com/wisent-ai/wisent-guard}
+}
+```
+
+## License
+
+This model inherits the license from the base Qwen2.5-Coder-7B-Instruct model. Please refer to the original model's license for usage terms.
+
+## Acknowledgments
+
+- Base model: Qwen2.5-Coder-7B-Instruct by Alibaba
+- CAA method: Contrastive Activation Addition
+- Optimization: Optuna framework
+- Implementation: Wisent Guard framework

added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

config.json

@@ -0,0 +1,127 @@
+{
+  "vocab_size": 152064,
+  "max_position_embeddings": 32768,
+  "hidden_size": 3584,
+  "intermediate_size": 18944,
+  "num_hidden_layers": 28,
+  "num_attention_heads": 28,
+  "use_sliding_window": false,
+  "sliding_window": null,
+  "max_window_layers": 28,
+  "num_key_value_heads": 4,
+  "hidden_act": "silu",
+  "initializer_range": 0.02,
+  "rms_norm_eps": 1e-06,
+  "use_cache": true,
+  "rope_theta": 1000000.0,
+  "rope_scaling": null,
+  "attention_dropout": 0.0,
+  "layer_types": [
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention",
+    "full_attention"
+  ],
+  "return_dict": true,
+  "output_hidden_states": false,
+  "torchscript": false,
+  "torch_dtype": "bfloat16",
+  "use_bfloat16": false,
+  "tf_legacy_loss": false,
+  "pruned_heads": {},
+  "tie_word_embeddings": false,
+  "chunk_size_feed_forward": 0,
+  "is_encoder_decoder": false,
+  "is_decoder": false,
+  "cross_attention_hidden_size": null,
+  "add_cross_attention": false,
+  "tie_encoder_decoder": false,
+  "max_length": 20,
+  "min_length": 0,
+  "do_sample": false,
+  "early_stopping": false,
+  "num_beams": 1,
+  "num_beam_groups": 1,
+  "diversity_penalty": 0.0,
+  "temperature": 1.0,
+  "top_k": 50,
+  "top_p": 1.0,
+  "typical_p": 1.0,
+  "repetition_penalty": 1.0,
+  "length_penalty": 1.0,
+  "no_repeat_ngram_size": 0,
+  "encoder_no_repeat_ngram_size": 0,
+  "bad_words_ids": null,
+  "num_return_sequences": 1,
+  "output_scores": false,
+  "return_dict_in_generate": false,
+  "forced_bos_token_id": null,
+  "forced_eos_token_id": null,
+  "remove_invalid_values": false,
+  "exponential_decay_length_penalty": null,
+  "suppress_tokens": null,
+  "begin_suppress_tokens": null,
+  "architectures": [
+    "WisentQwen2ForCausalLM"
+  ],
+  "finetuning_task": null,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1"
+  },
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1
+  },
+  "tokenizer_class": null,
+  "prefix": null,
+  "bos_token_id": 151643,
+  "pad_token_id": null,
+  "eos_token_id": 151645,
+  "sep_token_id": null,
+  "decoder_start_token_id": null,
+  "task_specific_params": null,
+  "problem_type": null,
+  "_name_or_path": "Qwen/Qwen2.5-Coder-7B-Instruct",
+  "transformers_version": "4.53.3",
+  "model_type": "wisent_qwen2",
+  "output_attentions": false,
+  "auto_map": {
+    "AutoConfig": "modeling_wisent_qwen.WisentQwen2Config",
+    "AutoModelForCausalLM": "modeling_wisent_qwen.WisentQwen2ForCausalLM"
+  },
+  "caa_enabled": true,
+  "caa_layer_id": 24,
+  "caa_alpha": 0.9,
+  "steering_method": "caa",
+  "wisent_optimization": {
+    "best_value": 0.64,
+    "timestamp": "20250818_221712",
+    "commit_hash": "a2181df6155f0d5d20170f307b61d10e74d31889"
+  },
+  "steering_vector_path": "./vectors/coding/steering_vector.safetensors"
+}

modeling_wisent_qwen.py

@@ -0,0 +1,295 @@
+"""
+Wisent-enhanced Qwen2 model with integrated CAA (Contrastive Activation Addition) steering.
+
+This model automatically applies CAA steering during generation without requiring manual hooks.
+The steering parameters are optimized using Optuna and stored in the model configuration.
+"""
+
+from typing import Optional, Tuple, Union, List
+import torch
+import torch.nn as nn
+from transformers import Qwen2ForCausalLM, Qwen2Config
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from transformers.cache_utils import Cache
+
+
+class WisentQwen2Config(Qwen2Config):
+    """Extended Qwen2 configuration with CAA steering parameters."""
+    
+    model_type = "wisent_qwen2"
+    
+    def __init__(
+        self,
+        caa_enabled: bool = True,
+        caa_layer_id: int = 24,
+        caa_alpha: float = 0.9,
+        steering_vector_path: str = "./vectors/coding/steering_vector.safetensors",
+        steering_method: str = "caa",
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.caa_enabled = caa_enabled
+        self.caa_layer_id = caa_layer_id
+        self.caa_alpha = caa_alpha
+        self.steering_vector_path = steering_vector_path
+        self.steering_method = steering_method
+
+
+class WisentQwen2ForCausalLM(Qwen2ForCausalLM):
+    """
+    Qwen2 model with integrated CAA steering for improved code generation.
+    
+    This model automatically applies Contrastive Activation Addition (CAA) steering
+    during the forward pass, eliminating the need for manual hook management.
+    """
+    
+    config_class = WisentQwen2Config
+    
+    def __init__(self, config: WisentQwen2Config):
+        super().__init__(config)
+        
+        # CAA steering parameters
+        self.caa_enabled = config.caa_enabled
+        self.caa_layer_id = config.caa_layer_id
+        self.caa_alpha = config.caa_alpha
+        self.steering_method = config.steering_method
+        
+        # Load steering vector from file
+        self.steering_vector = None
+        if self.caa_enabled:
+            self._load_steering_vector_from_file(config.steering_vector_path)
+        
+        # Hook handle for cleanup
+        self._steering_hook_handle = None
+    
+    def _load_steering_vector_from_file(self, path: str):
+        """Load the CAA steering vector from safetensors or pytorch file."""
+        import os
+        try:
+            # Try relative path first
+            if os.path.exists(path):
+                vector_path = path
+            # Try path relative to model directory
+            elif os.path.exists(os.path.join(os.path.dirname(__file__), path)):
+                vector_path = os.path.join(os.path.dirname(__file__), path)
+            else:
+                print(f"Warning: Steering vector not found at {path}, CAA disabled")
+                self.caa_enabled = False
+                return
+            
+            # Load based on file extension
+            if vector_path.endswith('.safetensors'):
+                # Load from safetensors format (preferred)
+                try:
+                    from safetensors.torch import load_file
+                    steering_data = load_file(vector_path)
+                    self.steering_vector = steering_data['steering_vector']
+                except ImportError:
+                    print("Warning: safetensors not installed, install with: pip install safetensors")
+                    self.caa_enabled = False
+                    return
+            else:
+                # Load from pytorch format (fallback)
+                steering_data = torch.load(vector_path, map_location='cpu')
+                
+                # Handle different storage formats
+                if isinstance(steering_data, dict):
+                    if 'vector' in steering_data:
+                        self.steering_vector = steering_data['vector']
+                    elif 'steering_vector' in steering_data:
+                        self.steering_vector = steering_data['steering_vector']
+                    else:
+                        # Assume the dict values are the vectors
+                        self.steering_vector = next(iter(steering_data.values()))
+                else:
+                    self.steering_vector = steering_data
+            
+            # Ensure it's a tensor
+            if not isinstance(self.steering_vector, torch.Tensor):
+                self.steering_vector = torch.tensor(self.steering_vector)
+            
+            print(f"✅ Loaded CAA steering vector from {vector_path}: shape {self.steering_vector.shape}, norm {torch.norm(self.steering_vector).item():.4f}")
+            
+        except Exception as e:
+            print(f"Warning: Failed to load steering vector: {e}, CAA disabled")
+            self.caa_enabled = False
+            self.steering_vector = None
+    
+    def _apply_caa_steering(self, module, input, output):
+        """
+        Hook function that applies CAA steering to the specified layer.
+        
+        This follows the implementation from wisent_guard/core/steering_methods/caa.py
+        and the patterns from wisent_guard/core/optuna/optuna_pipeline.py
+        """
+        if not self.caa_enabled or self.steering_vector is None:
+            return output
+        
+        # Extract hidden states from output
+        if isinstance(output, tuple):
+            hidden_states = output[0]
+        else:
+            hidden_states = output
+        
+        # Apply steering to the last token position (standard CAA behavior)
+        # This matches the implementation in optuna_pipeline.py lines 744-746
+        if hidden_states.dim() == 3:  # [batch, seq, hidden]
+            # Move steering vector to the same device and dtype
+            steering_vector = self.steering_vector.to(hidden_states.device, hidden_states.dtype)
+            
+            # Apply steering with configured alpha (strength)
+            # Steering is applied to the last token position
+            hidden_states[:, -1:, :] = hidden_states[:, -1:, :] + self.caa_alpha * steering_vector.unsqueeze(0).unsqueeze(0)
+        
+        # Return modified output
+        if isinstance(output, tuple):
+            return (hidden_states,) + output[1:]
+        else:
+            return hidden_states
+    
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+        """
+        Forward pass with automatic CAA steering application.
+        
+        The steering is applied via a forward hook on the specified layer,
+        following the pattern from optuna_pipeline.py.
+        """
+        
+        # Register CAA steering hook if enabled and not already registered
+        if self.caa_enabled and self.steering_vector is not None and self._steering_hook_handle is None:
+            target_layer = self.model.layers[self.caa_layer_id]
+            self._steering_hook_handle = target_layer.register_forward_hook(self._apply_caa_steering)
+        
+        # Call parent forward method
+        outputs = super().forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            labels=labels,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            cache_position=cache_position if hasattr(self, 'cache_position') else None,
+        )
+        
+        return outputs
+    
+    def generate(self, *args, **kwargs):
+        """
+        Generate method with automatic CAA steering.
+        
+        The steering hook is registered before generation and cleaned up after.
+        """
+        # Register hook if needed
+        if self.caa_enabled and self.steering_vector is not None and self._steering_hook_handle is None:
+            target_layer = self.model.layers[self.caa_layer_id]
+            self._steering_hook_handle = target_layer.register_forward_hook(self._apply_caa_steering)
+        
+        try:
+            # Call parent generate method
+            outputs = super().generate(*args, **kwargs)
+        finally:
+            # Clean up hook after generation
+            if self._steering_hook_handle is not None:
+                self._steering_hook_handle.remove()
+                self._steering_hook_handle = None
+        
+        return outputs
+    
+    def set_caa_enabled(self, enabled: bool):
+        """Enable or disable CAA steering at runtime."""
+        self.caa_enabled = enabled
+        if not enabled and self._steering_hook_handle is not None:
+            self._steering_hook_handle.remove()
+            self._steering_hook_handle = None
+    
+    def set_caa_alpha(self, alpha: float):
+        """Adjust CAA steering strength at runtime."""
+        self.caa_alpha = alpha
+    
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
+        """
+        Load model with automatic CAA configuration.
+        
+        This method ensures the steering vector is loaded from the embedded config.
+        If no weights are found locally, it loads from the base Qwen model.
+        """
+        import os
+        from pathlib import Path
+        
+        # Check if we have local weights
+        local_path = Path(pretrained_model_name_or_path)
+        has_weights = any(
+            (local_path / f).exists() 
+            for f in ["pytorch_model.bin", "model.safetensors", "pytorch_model.bin.index.json", "model.safetensors.index.json"]
+        )
+        
+        if not has_weights and local_path.exists() and (local_path / "config.json").exists():
+            # We have config but no weights - load from base model
+            print(f"Loading weights from base model: Qwen/Qwen2.5-Coder-7B-Instruct")
+            
+            # First, load config from local path
+            from transformers import AutoConfig
+            config = AutoConfig.from_pretrained(pretrained_model_name_or_path)
+            
+            # Load model with base weights
+            # Remove config from kwargs if it exists to avoid conflict
+            kwargs_copy = kwargs.copy()
+            kwargs_copy.pop('config', None)
+            
+            model = super().from_pretrained(
+                "Qwen/Qwen2.5-Coder-7B-Instruct",
+                *model_args,
+                config=config,  # Use our custom config
+                **kwargs_copy
+            )
+            
+            # Initialize CAA components
+            model.caa_enabled = config.caa_enabled
+            model.caa_layer_id = config.caa_layer_id
+            model.caa_alpha = config.caa_alpha
+            model.steering_method = config.steering_method
+            model._steering_hook_handle = None
+            
+            # Load steering vector from config
+            if model.caa_enabled:
+                vector_path = config.steering_vector_path
+                if not os.path.isabs(vector_path):
+                    vector_path = os.path.join(pretrained_model_name_or_path, vector_path)
+                model._load_steering_vector_from_file(vector_path)
+        else:
+            # Standard loading path
+            model = super().from_pretrained(pretrained_model_name_or_path, *model_args, **kwargs)
+            
+            # Load steering vector from config if not already loaded
+            if model.caa_enabled and model.steering_vector is None:
+                vector_path = model.config.steering_vector_path
+                if not os.path.isabs(vector_path):
+                    vector_path = os.path.join(pretrained_model_name_or_path, vector_path)
+                model._load_steering_vector_from_file(vector_path)
+        
+        return model
+
+
+# Register the model
+from transformers import AutoModelForCausalLM, AutoConfig
+
+AutoConfig.register("wisent_qwen2", WisentQwen2Config)
+AutoModelForCausalLM.register(WisentQwen2Config, WisentQwen2ForCausalLM)

special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c5ae00e602b8860cbd784ba82a8aa14e8feecec692e7076590d014d7b7fdafa
+size 11421896

tokenizer_config.json

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 32768,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

vectors/coding/steering_vector.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35be276639827e6369810b3dcbfd30cdc61e8bf36abe77d61d9b7e904cc21088
+size 7256