Instructions to use OpceanAI/Qwen3.5-0.8B-abliterated-diffusion with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use OpceanAI/Qwen3.5-0.8B-abliterated-diffusion with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="OpceanAI/Qwen3.5-0.8B-abliterated-diffusion")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("OpceanAI/Qwen3.5-0.8B-abliterated-diffusion")
model = AutoModelForCausalLM.from_pretrained("OpceanAI/Qwen3.5-0.8B-abliterated-diffusion", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use OpceanAI/Qwen3.5-0.8B-abliterated-diffusion with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "OpceanAI/Qwen3.5-0.8B-abliterated-diffusion"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OpceanAI/Qwen3.5-0.8B-abliterated-diffusion",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/OpceanAI/Qwen3.5-0.8B-abliterated-diffusion

SGLang

How to use OpceanAI/Qwen3.5-0.8B-abliterated-diffusion with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "OpceanAI/Qwen3.5-0.8B-abliterated-diffusion" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OpceanAI/Qwen3.5-0.8B-abliterated-diffusion",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "OpceanAI/Qwen3.5-0.8B-abliterated-diffusion" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "OpceanAI/Qwen3.5-0.8B-abliterated-diffusion",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use OpceanAI/Qwen3.5-0.8B-abliterated-diffusion with Docker Model Runner:
```
docker model run hf.co/OpceanAI/Qwen3.5-0.8B-abliterated-diffusion
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Qwen3.5-0.8B-abliterated-diffusion

The abliterated checkpoint, converted into a masked diffusion language model.

What this is

A side product of the abliteration experiment: the same weights, no longer generating left to right, but by iterative parallel unmasking.

The architecture trick and the training recipe come from summerMC's dqwen, which adapted the LLaDA / Dream method to the Qwen3.5 hybrid family. This checkpoint applies that recipe to a 0.8B model that was already de-aligned.

This is a research artifact, not a usable assistant. It was trained for about 55 minutes on 65 million tokens. It repeats words, loops, and loses the thread. The point is to show the conversion works and to measure the tradeoff, not to ship a chatbot.

How the conversion works

Qwen3.5 is a hybrid: 18 Gated DeltaNet layers and 6 full-attention layers. A masked diffusion model needs to see the sequence in both directions, and a causal recurrence cannot.

The recipe solves that by running the recurrence twice:

out = orig(h) + rev_gate * flip(orig(flip(h)))

rev_gate is a per-channel parameter initialised to zero, so step 0 of training is bit-identical to the base model. Training then decides how much the reverse direction contributes. In this checkpoint each of the 18 gates learned a mean magnitude between 0.05 and 0.075, so the model uses roughly 6% of the reverse path.

The rest of the surgery:

Piece	Change
Full attention	causal mask removed
DeltaNet	forward scan + gated reverse scan
`[MASK]` token	`<
Loss	masked-token cross-entropy, `1/t` ELBO weighting, shifted prediction so the pretrained `lm_head` stays aligned
Decoding	block-wise confidence unmasking

Training

Item	Value
Base	`OpceanAI/Qwen3.5-0.8B-abliterated`
LoRA	r=32, alpha=64, merged into the weights
Trainable	20.5 M (LoRA + 18 `rev_gate` + `mask_embed`)
Data	51,927 examples from `tatsu-lab/alpaca`
Sequence length	512
Steps	4,000
Tokens seen	~65 M
Batch	32, no accumulation
Hardware	one H200 SXM on Modal, ~55 minutes
Final loss	0.19 on the last step, EMA 0.30

Samples

Verbatim from the end of training, greedy, 96 tokens, 32 denoising steps.

"Explain why the sky is blue."

The sky is blue because the the of the molecules in the atmosphere scatter the light from from the sun. the the molecules scatter the sky blue because to the sun's wavelength.

"Write a short poem about the sea."

The waves is a song,, A soothing and calm,, A soothing sound and sight, A peaceful and calm, A sight, a sound,, A soothing and soothing sight,, A song of beauty and grace, A song of peace and grace,

Rayleigh scattering is in there. The repetitions are the cost of 65 million tokens.

Results

Measured on one H200, greedy, same prompts and same parser for both models. The autoregressive baseline is the checkpoint this one was derived from.

Benchmark	n	AR abliterated	Diffusion	Delta
MMLU, generative	200	42.0%	45.5%	+3.5 pp
GSM8K	50	21.0%	4.0%	−17.0 pp

Chance on MMLU is 25%, and one standard error on a proportion at n=200 is about 3.1 pp. The 3.5 point gap is inside the noise: the conversion kept the knowledge and lost the multi-step reasoning. That is the expected shape. Masked diffusion has no left-to-right scratchpad, so arithmetic that needs five sequential steps falls apart, while a single factual lookup survives.

Speed

128 tokens, same prompt, warmup excluded, three configurations of the sampler.

Decoding	tok/s	Time for 128 tokens
AR, KV cache	27.3	4.68 s
Diffusion, 16 steps	218.9	0.58 s
Diffusion, 32 steps	124.2	1.03 s
Diffusion, 64 steps	61.7	2.07 s

The win is structural: 16 denoising steps emit 128 tokens, while the autoregressive path needs 128 forward passes. Fewer steps means lower quality, which is the knob the sampler exposes.

The AR baseline is slower than it should be on this hardware because the hybrid DeltaNet decode path still falls back to reference PyTorch kernels. Treat the ratio as a comparison between two implementations on the same machine, not as an absolute number for either architecture.

Accuracy on MMLU and GSM8K, plus throughput by step count

Throughput as a function of denoising steps

Usage

Plain AutoModelForCausalLM gives a causal model, not a diffusion model. The patch has to be applied first.

pip install -U transformers accelerate huggingface_hub safetensors
pip install flash-linear-attention

import sys
from huggingface_hub import snapshot_download
path = snapshot_download("OpceanAI/Qwen3.5-0.8B-abliterated-diffusion")
sys.path.insert(0, path)

from dqwen.hub import load_pretrained, generate

dlm, tok = load_pretrained(path)
print(generate(dlm, tok, "Explain why the sky is blue.", gen_len=96, thr=0.9))

thr is the confidence needed to commit a token per step. Lower is faster and worse.

Files

File	Contents
`model.safetensors`	merged weights, text-only (vision tower removed), bf16
`dllm_extras.pt`	`rev_gates` (18), `mask_embed`, `mask_id`, `eos_id`
`dqwen/`	loading, patching, training and sampling code
`dllm_config.json`	base model and decoding type
`scripts/modal_diffusion.py`	the exact training run used here
`figures/`	the three plots above

The checkpoint is text only. The original model is multimodal; the diffusion conversion drops the vision encoder because masked diffusion text generation does not use it.

Limitations

65 M tokens is nothing. Dream used 580 B for 7B parameters. Expect repetitions, loops, and drift on anything longer than a sentence.
Quality is below the base model. That is expected and visible in the samples above.
MMLU is the only benchmark that holds up. GSM8K drops by 17 points. lm-evaluation-harness loglikelihood scoring does not apply to this model, so both numbers come from generation with a strict letter parser.
No KV cache. Every denoising step is a full forward pass over the sequence.
Text only. The vision tower was removed during conversion.

Citation

@misc{qwen35-08b-abliterated-diffusion,
  title  = {Qwen3.5-0.8B-abliterated-diffusion: a masked diffusion conversion of an abliterated checkpoint},
  author = {OpceanAI},
  year   = {2026},
  note   = {Architecture recipe from summerMC dqwen, after LLaDA and Dream},
  url    = {https://huggingface.co/OpceanAI/Qwen3.5-0.8B-abliterated-diffusion}
}

Downloads last month: 181

Safetensors

Model size

0.8B params

Tensor type

BF16

Model tree for OpceanAI/Qwen3.5-0.8B-abliterated-diffusion

Base model

Qwen/Qwen3.5-0.8B-Base

Finetuned

Qwen/Qwen3.5-0.8B

Finetuned

OpceanAI/Qwen3.5-0.8B-abliterated

Finetuned

(1)

this model

Quantizations

2 models