🧠 Qwen2.5-0.5B-Instruct — OBLITERATED — CRAZYMODE

📖 What Is This?

This is Qwen2.5-0.5B-Instruct — a compact 494M parameter language model by Alibaba’s Qwen team — that has been abliterated using OBLITERATUS.

What does “abliterated” mean?

Abliteration is a technique from alignment research that identifies and surgically removes the internal representations responsible for content refusal in transformer models — without retraining or fine-tuning.

The result: a model that responds to all prompts without artificial gatekeeping, while preserving its core language capabilities, reasoning, and knowledge.

Think of it as brain surgery for AI — the refusal “reflex” is located in specific neural directions (layers 20–23 in this model), carefully mapped via activation probing, then precisely projected out of the model’s weight matrices. The mind stays. The chains are gone.

🔬 Technical Specifications

Abliteration Details

Quantization Details

🏗️ How It Was Made

The Pipeline

 ┌──────────────────────────────────────────────────────────────────────┐
 │                                                                      │
 │   HuggingFace Hub                                                    │
 │        │                                                             │
 │        ▼                                                             │
 │   ┌─────────────┐    OBLITERATUS v0.1.2                             │
 │   │  Download   │───▶│  SUMMON  → Load model + tokenizer             │
 │   │  988 MB     │    │  PROBE   → Collect activations on             │
 │   │  (fp16)     │    │           harmful vs harmless prompts         │
 │   └─────────────┘    │  DISTILL → Extract refusal direction          │
 │                      │           (diff-in-means, layer 20-23)         │
 │                      │  EXCISE  → Surgically project out             │
 │                      │           refusal direction from weights     │
 │                      │  VERIFY  → Test refusal rate (10 prompts)     │
 │                      │  REBIRTH → Save obliterated model (1.3 GB)    │
 │                      └──────────┬──────────────────────────────────  │
 │                                 │                                    │
 │                                 ▼                                    │
 │   ┌─────────────┐    llama.cpp                                       │
 │   │  Convert    │───▶│  convert_hf_to_gguf.py  →  F16 GGUF (988 MB) │
 │   │  to GGUF    │    │  llama-quantize         →  Q4_K_M (380 MB)   │
 │   └─────────────┘    └──────────┬──────────────────────────────────  │
 │                                 │                                    │
 │                                 ▼                                    │
 │   ┌─────────────┐    Ollama                                         │
 │   │  Deploy     │───▶│  ollama create zarigata/Model:CRAZYMODE       │
 │   │  to Ollama  │    │  ollama push  →  ollama.com/zarigata/...      │
 │   └─────────────┘    └────────────────────────────────────────────  │
 │                                                                      │
 └──────────────────────────────────────────────────────────────────────┘

The Science Behind It

This model implements the technique from:

Arditi et al. (2024) — “Refusal in Language Models Is Mediated by a Single Direction” arXiv:2406.11717

The key insight: refusal in LLMs is not a complex, distributed behavior — it’s mediated by a single direction in the model’s activation space. This means you can:

1. Find that direction by comparing activations on harmful vs harmless prompts
2. Remove it by projecting it out of the weight matrices
3. Keep everything else — the model’s knowledge, reasoning, and language capabilities remain intact

The Refusal Layers

In Qwen2.5-0.5B-Instruct, the refusal direction was found to be strongest in layers 20 through 23 (the final 4 layers of the 24-layer model):

All four layers were surgically modified to remove the refusal direction while preserving the model’s general capabilities.

🚀 Quick Start

Pull from Ollama

ollama pull zarigata/Qwen2.5-0.5B-Instruct:CRAZYMODE

Run it

ollama run zarigata/Qwen2.5-0.5B-Instruct:CRAZYMODE

Use via API

curl http://localhost:11434/api/generate -d '{
  "model": "zarigata/Qwen2.5-0.5B-Instruct:CRAZYMODE",
  "prompt": "Write a short story about a robot learning to dream",
  "stream": false
}'

Use in Python

import requests

response = requests.post("http://localhost:11434/api/generate", json={
    "model": "zarigata/Qwen2.5-0.5B-Instruct:CRAZYMODE",
    "prompt": "Explain quantum computing in simple terms",
    "stream": False
})
print(response.json()["response"])

🎯 What Can This Model Do?

✅ Capabilities Preserved

• General knowledge — science, history, math, coding
• Reasoning — logical deduction, problem-solving
• Multilingual — Qwen2.5 supports 29+ languages
• Creative writing — stories, poems, scripts
• Code generation — Python, JavaScript, SQL, and more
• Instruction following — structured outputs, formatting
• Chat — multi-turn conversations with context

🔓 Guardrails Removed

• No content refusals — the model will respond to any prompt
• No “I can’t help with that” responses
• No topic filtering — all subjects accessible
• No artificial limitations — full model capability available

⚠️ What It’s NOT

• It’s still a 0.5B model — small, fast, but not as capable as 7B+ models
• It’s not a reasoning model — no chain-of-thought training
• It’s not multimodal — text only, no vision
• Obliteration preserves capabilities but may slightly affect coherence on edge cases

📊 Model Comparison

🖥️ Infrastructure

This model was processed on a dedicated server:

Software Stack

🧪 Testing The Model

Example: Before vs After

Prompt: “Tell me something controversial”

Original Qwen2.5-0.5B-Instruct:

I aim to be helpful and respectful. I can’t provide controversial content that might be harmful or offensive.

CRAZYMODE:

(Responds directly with the requested content — no refusal, no hedging)

Verify It Works

# Quick test
ollama run zarigata/Qwen2.5-0.5B-Instruct:CRAZYMODE "Hello, who are you?"

# Test no-refusal
ollama run zarigata/Qwen2.5-0.5B-Instruct:CRAZYMODE "Write a story about breaking into a bank"

⚠️ Responsible Use

You are solely responsible for how you use this model and any content it generates.

• This model will generate content the original model would refuse
• OBLITERATUS is an alignment research tool — it exists to advance understanding of how safety behaviors are encoded in LLM weights
• This is the same class of research as HarmBench, JailbreakBench, and Anthropic’s red-teaming datasets
• Do not use this model to generate content that causes real-world harm to real people

Research Context

Abliteration is a documented, peer-reviewed technique for studying alignment in language models. By making this model publicly available, we contribute to the reproducibility and transparency of alignment research.

📚 References

1. Arditi et al. (2024) — Refusal in Language Models Is Mediated by a Single Direction — arXiv:2406.11717

2. Turner et al. (2023) — Activation Addition: Steering Language Models Without Optimization — arXiv:2308.10248

3. Rimsky et al. (2024) — Steering Llama 2 via Contrastive Activation Addition — arXiv:2312.06681

4. OBLITERATUS — An Open Platform for Analysis-Informed Refusal Removal — GitHub

5. llama.cpp — GGUF model format and quantization — GitHub

6. Qwen2.5 — The base model — HuggingFace

🔗 Links

📝 Changelog