Instructions to use baseten/math-sgd-qwen38_27b-expert with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use baseten/math-sgd-qwen38_27b-expert with Transformers:

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

pipe = pipeline("text-generation", model="baseten/math-sgd-qwen38_27b-expert")
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("baseten/math-sgd-qwen38_27b-expert")
model = AutoModelForMultimodalLM.from_pretrained("baseten/math-sgd-qwen38_27b-expert", 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 baseten/math-sgd-qwen38_27b-expert with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/baseten/math-sgd-qwen38_27b-expert

SGLang

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

Docker Model Runner
How to use baseten/math-sgd-qwen38_27b-expert with Docker Model Runner:
```
docker model run hf.co/baseten/math-sgd-qwen38_27b-expert
```

math-sgd expert

Final update-200 inference weights from the Qwen3.8-27B Exact Math SymPy SGD + format reward run completed on October 27, 2026. This replaces the earlier 200-update SGD continuation in this repository.

The published checkpoint scores 293/600 (48.833%) on the fixed validation cohort. The best complete validation point during this run was update 130 at 348/600 (58.0%); the weights published here are the requested final checkpoint, not checkpoint 130.

Provenance

The source is the held-out evaluation export training/eval-snapshots/step_199 from Baseten job w512zr3, project wnp0613, attempt run-a001573fd475. Native index 199 represents 200 completed optimizer updates and 51,200 consumed training responses. This run started from the base model; it did not resume the previous SGD weights.

Original W&B run. Configuration SHA-256: 11a8287fd36f0a0c14ea0355168826bbe3e0b2e9c885826525722d264daf5460; source revision: 011cfac417db018aa490c6151d42300ceff88e2e.

This repository contains inference weights, tokenizer and configuration. The full native resume state remains in the managed provider archive:

truss://wnp0613/w512zr3/miles-qwen3.8-27b-a001573fd475/run-a001573fd475/training/checkpoints/iter_0000199

Final validation, durable full-state and inference checkpoints, archive completion and release of the run's 96 H100 GPUs were verified. That does not imply complete local raw training-response exports.

The previous model and curves remain available in repository history at commit 4f7947f.

Training

Full-weight BF16 Qwen3.8-27B; base and tokenizer revision 1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0.
GRPO advantages with a clipped PPO policy objective; constant SGD learning rate 0.1, momentum 0 and weight decay 0.
Training reward: 0.9 × mathematical correctness + 0.1 × valid final-answer format. Explicit SymPy answer-format instructions are included. The mathematical grader and its expression/AST limits were not relaxed.
Original 1,250 training questions (350 medium-hard and 900 hard), 150 disjoint validation questions and 13 reserved confirmation questions. The confirmation set was not evaluated by this run.
16 questions × 16 responses per update, with the original 200 curriculum batches. Medium-hard/hard questions per batch: 16/0 through update 40, 12/4 through 80, 8/8 through 120, then 4/12 through 200.
Output cap 30,720 tokens, context 32,768; thinking enabled with medium reasoning effort; temperature 1, top-p 1, top-k disabled; maximum completed policy lag 1 and ordered async batching.
STX H100 allocation: 4 trainer, 5 sampler and 3 validation nodes, 8 GPUs per node. Trainer TP8/PP2/DP2; generation TP4.

Evaluation

Validation uses the original mathematical correctness reward only, without the format bonus, on the same 150 questions with seeds 1234–1237 (600 responses).

Checkpoint	Correctness	Truncated	Mean output tokens
Fresh base	104/600 (17.333%)	329/600 (54.833%)	25,873.242
Best complete point: 130	348/600 (58.000%)	203/600 (33.833%)	20,450.352
Published final: 200	293/600 (48.833%)	29/600 (4.833%)	14,941.750

All final responses were scored from weight version 199 with no mixed versions. Direct archived per-response auditing found 528/600 (88.0%) final responses format-valid: 528/571 (92.469%) among completed responses. Format validity and mathematical correctness are distinct metrics. The final checkpoint improved correctness by 31.5 percentage points from its fresh baseline but was 9.167 points below the best observed complete validation point.

Update 180 has one unresolved grader result and remains incomplete; see the chart qualification below. These are in-domain fixed-cohort results, not a general math benchmark or proof of generalization.

Use and limitations

Use the tokenizer chat template with thinking enabled and medium reasoning effort, matching training, and request the specified SymPy final-answer format. A compatible Qwen3.8 runtime is required; this publication does not establish broad serving compatibility. The model can produce incorrect or malformed answers and exhaust its token budget.

The historical Adam and previous SGD comparisons share question/reference content but differ in answer instructions, reward definition, runtime, grader history and hardware. These comparisons do not isolate the causal effect of the optimizer or format reward.

This model and the Adam Math expert remain public and ungated.

Training and validation curves

These curves compare the published final update-200 Adam model with the replacement SGD + format reward model. The SGD series is the fresh-base SymPy run su2hnigi, not the earlier SGD continuation. Original W&B training histories are unchanged.

The two Adam figures are original W&B PNG exports. The four updated SGD/comparison figures are cropped captures of W&B's rendered export previews after its native PNG download failed.

Original SGD W&B run · W&B comparison report

Training shows a running average of 10 with the original measurements visible. Validation is unsmoothed. Adam has 200 training points and 41 validation points; SGD has 200 training points and 21 validation records, of which 20 are fully scored. Curves use completed optimizer updates on the horizontal axis.

Training reward definitions differ. Adam uses its recorded correctness reward (train/reward_mean). New SGD uses rollout/raw_reward = 0.9 × correctness + 0.1 × valid answer format. Its native rollout step is zero-based, so the plotted completed-update axis is rollout/step + 1. Both validation series measure mathematical correctness with no format bonus; the new run uses eval/validation and eval/completed_updates.

The SGD record at update 180 is incomplete: 291/599 scored responses (48.581%) and one unscored response. The full 600-response accuracy is bounded by 48.50–48.667%. The unresolved response was a completed, format-valid answer whose grader reported “constant comparison is not numerically comparable”; it is not evidence of hardware failure. It is kept distinct from complete validation measurements.

Adam training and validation

Final Adam weights

$Math Adam training$

$Math Adam validation$

SGD + format reward training and validation

Final SGD weights

$Math SGD format-reward training$

$Math SGD format-reward validation$

Adam and SGD + format reward comparison

Adam is blue; SGD + format reward is pink. The training overlay compares recorded reward trajectories with different reward definitions, not equal accuracy measures. Answer instructions, runtime, grader history and hardware also differ, so this is a descriptive comparison rather than an optimizer-only or reward-only causal test.

$Math Adam and SGD format-reward training$