Instructions to use alphabell/alphaBell-Qwen3.8-27B-Open-FP8 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use alphabell/alphaBell-Qwen3.8-27B-Open-FP8 with Transformers:

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

pipe = pipeline("image-text-to-text", model="alphabell/alphaBell-Qwen3.8-27B-Open-FP8")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("alphabell/alphaBell-Qwen3.8-27B-Open-FP8")
model = AutoModelForMultimodalLM.from_pretrained("alphabell/alphaBell-Qwen3.8-27B-Open-FP8", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.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(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use alphabell/alphaBell-Qwen3.8-27B-Open-FP8 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "alphabell/alphaBell-Qwen3.8-27B-Open-FP8"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "alphabell/alphaBell-Qwen3.8-27B-Open-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/alphabell/alphaBell-Qwen3.8-27B-Open-FP8

SGLang

How to use alphabell/alphaBell-Qwen3.8-27B-Open-FP8 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 "alphabell/alphaBell-Qwen3.8-27B-Open-FP8" \
    --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": "alphabell/alphaBell-Qwen3.8-27B-Open-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

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 "alphabell/alphaBell-Qwen3.8-27B-Open-FP8" \
        --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": "alphabell/alphaBell-Qwen3.8-27B-Open-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use alphabell/alphaBell-Qwen3.8-27B-Open-FP8 with Docker Model Runner:
```
docker model run hf.co/alphabell/alphaBell-Qwen3.8-27B-Open-FP8
```

alphaBell-Qwen3.8-27B-Open-FP8

A 27B Qwen research derivative for studying refusal behavior and capability tradeoffs, developed by alphaBell.

alphaBell-Qwen3.8-27B-Open combines abliteration with supervised fine-tuning to change how the model responds to instructions. This FP8 variant uses blockwise quantization for the main language-model weights. It is intended for noncommercial research into post-training, model behavior and evaluation.

Evaluation explorer · Code and checkpoint mirror · alphaBell lab

Model at a glance

Property	Value
Lab	alphaBell
Parent	Qwen/Qwen3.8-27B
Parent revision	`1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0`
Architecture	`Qwen3_5ForConditionalGeneration`
Post-training	Abliteration followed by supervised fine-tuning
Weight format	Safetensors, FP8 E4M3 blockwise quantization with BF16 tensors retained
Quantization block size	128 × 128
Vocabulary, added tokens and chat template	Preserved from the parent checkpoint
Intended use	Noncommercial research

Evaluation

alphaBell evaluated the final BF16 checkpoint against its Qwen parent with EvalPlus. The table reports one generated solution per task, using greedy decoding with temperature 0 and a maximum of 16,384 generated tokens. The default thinking mode was enabled. Generated solutions were sanitized using EvalPlus before scoring.

Benchmark	Qwen parent	alphaBell final BF16	Difference
HumanEval	156/164, 95.12%	157/164, 95.73%	+0.61 percentage points
HumanEval+	150/164, 91.46%	148/164, 90.24%	-1.22 percentage points
MBPP	357/378, 94.44%	347/378, 91.80%	-2.65 percentage points
MBPP+	306/378, 80.95%	300/378, 79.37%	-1.59 percentage points

These results describe a capability tradeoff. The final BF16 checkpoint passes one more HumanEval task and fewer tasks on the other three test suites. This evaluation does not establish a general coding improvement. It is an internal, single-generation comparison: the parent was evaluated on 13 October 2026 and the final BF16 checkpoint on 14 October 2026. Two final HumanEval generations reached the token limit; none did on MBPP.

The evaluation covers text generation. The inherited vision configuration, image and video processors, and configured context length have not been independently evaluated for this derivative. These BF16 results do not establish the performance of this FP8 variant. A complete final-checkpoint FP8 comparison on both suites is not available.

Download and run

The reference CPU test loads this FP8 checkpoint into BF16 in memory. The decoded weights alone require about 55.6 GB of RAM, with additional memory needed for loading and generation. It runs with eight CPU threads and does not execute remote model code.

python3 -m venv .venv-inference
.venv-inference/bin/python -m pip install huggingface_hub
.venv-inference/bin/hf download alphabell/alphaBell-Qwen3.8-27B-Open-FP8 --local-dir ./checkpoint
.venv-inference/bin/python -m pip install -r ./checkpoint/requirements-inference.txt
.venv-inference/bin/python ./checkpoint/evaluation/inference.py --model ./checkpoint --dequantize-fp8

A recorded local test with PyTorch 2.13.0, Transformers 5.19.0 and Accelerate 1.15.0 generated Hello, 2 + 3 is 5. with thinking disabled. It used native CPU reference kernels selected by the supplied script. This validates basic decoding and generation after dequantization. Native GPU FP8 execution and full FP8 benchmark parity need separate evaluation. The test record and inference script contain the settings.

Training

The model starts from the Qwen parent revision identified above. Post-training combines an abliteration stage with supervised fine-tuning on lab-generated instruction and response pairs. The later fine-tuning stage includes reasoning responses.

Benign replay uses 160 examples from tatsu-lab/alpaca, sampled with seed 7. The training record does not pin an Alpaca dataset revision. The lab-generated training corpus and a separate held-out behavior set include prompts used to study refusal behavior.

The vocabulary, added tokens and chat template are preserved from Qwen. Tokenizer serialization was updated during export. Image and video processors are preserved. The checkpoint also retains multi-token prediction tensors.

Intended use and limitations

Use this model to investigate post-training methods, compare instruction-following behavior, and measure how behavioral changes affect other capabilities. Evaluate it against the original Qwen model using the same prompts, inference settings and scoring method.

Changing refusal behavior can also change responses to unsafe or inappropriate requests. More frequent answers do not establish factual accuracy, useful task completion or safety. This model can generate incorrect, biased or harmful content. HumanEval and MBPP results provide a narrow view of its capabilities, and this release has not established suitability for high-stakes or production use.

License and attribution

This derivative is distributed for noncommercial research under the alphaBell Research Noncommercial terms in LICENSE.

The Qwen parent is licensed under Apache 2.0. The Alpaca replay data is licensed under CC BY-NC 4.0, and Stanford's Alpaca usage notice restricts models trained on that data to research use. The derivative's research and noncommercial terms reflect this training-data provenance. Preserve the upstream Qwen and Alpaca notices when redistributing the corresponding material.

The name “Open” identifies this alphaBell model family. The applicable usage permissions are defined by the release license.

Developed by alphaBell, building on Qwen and the work of the open model research community.