Instructions to use SurjoLabs/Blaze-SFT with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use SurjoLabs/Blaze-SFT with Transformers:

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

pipe = pipeline("text-generation", model="SurjoLabs/Blaze-SFT", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("SurjoLabs/Blaze-SFT", trust_remote_code=True, device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use SurjoLabs/Blaze-SFT with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/SurjoLabs/Blaze-SFT

SGLang

How to use SurjoLabs/Blaze-SFT 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 "SurjoLabs/Blaze-SFT" \
    --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": "SurjoLabs/Blaze-SFT",
		"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 "SurjoLabs/Blaze-SFT" \
        --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": "SurjoLabs/Blaze-SFT",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use SurjoLabs/Blaze-SFT with Docker Model Runner:
```
docker model run hf.co/SurjoLabs/Blaze-SFT
```

Blaze-SFT (48.3M)

Blaze-SFT is the instruction-tuned variant of SurjoLabs/Blaze, a 48.3M parameter causal language model.

Blaze-SFT was full-parameter fine-tuned on the Smol-Smoltalk dataset at an extended context window of 2,048 tokens (doubled from the 1,024-token base context). It scores 14.84 on the Intelligence Index, keeping over 96% of its base reasoning capabilities while adding basic conversational and chat ability.

This release also fixes critical bugs in modeling_blaze.py so the model actually generates text properly with Hugging Face generate(), fixing broken single-token KV caching, cache crashes in Transformers 5.x, and PCIe GPU-to-CPU stalls.

Architecture Specifications

Parameter	Value
Total Parameters	48,251,136
Physical Layers	14 (1 prelude + 12 recurrent + 1 coda)
Recurrent Passes	2 (effective computational depth: 26 layers)
Hidden Dimension	512
Intermediate Size	1,536
Attention Heads	8 Query, 4 Key-Value (2:1 GQA)
Head Dimension	64
Vocabulary Size	8,192 (tied embeddings)
Context Length	2,048 tokens
Fine-Tuning Dataset	HuggingFaceTB/smol-smoltalk

Bug Fixes in modeling_blaze.py

We fixed several issues in the original modeling code to make it ready for real use:

Fixed KV-Cache Decode Bug: During single-token generation (q_len = 1, kv_len > 1), is_causal was previously set to True in PyTorch SDPA. This caused the model to only attend to token 0 and masked out all previous tokens, completely breaking text generation. We set is_causal = False for decode steps so it correctly attends to the full cached history.
Fixed Transformers 5.x DynamicCache Crash: Calling past_kv.update() on recurrent passes threw an IndexError: list index out of range because slots 15 to 26 were never allocated. We now pre-allocate missing slots dynamically and track recurrent passes cleanly via _current_pass.
Generation API & NoneType Crash: Fixed prepare_inputs_for_generation to slice position_ids, cache_position, and input_ids cleanly. Handled num_logits_to_keep = None to stop generate() from crashing with a TypeError.
Eliminated PCIe GPU-to-CPU Stalls: Removed a synchronous torch.all(attention_mask == 1) check inside the attention layer that was stalling the GPU 26 times per token. Replaced memory-allocating repeat_interleave() with zero-copy view expansions, and added native FlashAttention support.
Zero Weight Degradation: Weights were not modified or retrained during these code fixes. Logit parity check confirms exactly 0.00000000 difference against original checkpoints.

Benchmark Results

Evaluated 0-shot using normalized accuracy (acc_norm):

Benchmark	Blaze (Base)	Blaze-SFT	Metric
PIQA	62.51%	61.75%	acc_norm
ARC-Easy	41.84%	41.29%	acc_norm
ArithMark-3.0	37.80%	37.90%	acc_norm
HellaSwag	31.84%	31.86%	acc_norm
ARC-Challenge	24.91%	24.23%	acc_norm
Intelligence Index	15.45	14.84	Normalized Composite

Intelligence Index Calculation

The Open SLM Intelligence Index adjusts each raw score above the random-chance floor:

Normalized Score = 100 * (score - chance) / (100 - chance)

HellaSwag (score: 31.86%, chance: 25, weight: 1.00) -> 9.14
Combined ARC (score: 32.76%, chance: 25, weight: 1.00) -> 10.35
PIQA (score: 61.75%, chance: 50, weight: 1.00) -> 23.50
ArithMark-3.0 (score: 37.90%, chance: 25, weight: 0.65) -> 17.20

Intelligence Index = (9.14 + 10.35 + 23.50 + 0.65 * 17.20) / 3.65 = 14.84

Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "SurjoLabs/Blaze-SFT"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

messages = [
    {"role": "user", "content": "Explain why the sky is blue in two simple sentences."}
]

prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=64,
    do_sample=True,
    temperature=0.7,
    top_p=0.9,
    eos_token_id=tokenizer.eos_token_id,
)

response = outputs[0][inputs.input_ids.shape[1]:]
print(tokenizer.decode(response, skip_special_tokens=True))

Limitations

Parameter Size: At 48.3M parameters, Blaze-SFT is built for ultra-lightweight, edge-device tasks. It is not meant for complex multi-step reasoning, advanced math, or heavy factual knowledge. We aim to finetune this model in order to test downstream capability of the architecture.
Hallucinations: Like any model of this size, it can generate confident-sounding incorrect statements.

License

MIT

Downloads last month: 1,253

Safetensors

Model size

48.3M params

Tensor type

BF16

Model tree for SurjoLabs/Blaze-SFT

Base model

SurjoLabs/Blaze

Finetuned

(1)

this model

Finetunes

1 model

SurjoLabs
/

Blaze-SFT