Instructions to use jsbaicenter/JSBAI-Coder-4B-NVFP4 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use jsbaicenter/JSBAI-Coder-4B-NVFP4 with Transformers:

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

pipe = pipeline("text-generation", model="jsbaicenter/JSBAI-Coder-4B-NVFP4")
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("jsbaicenter/JSBAI-Coder-4B-NVFP4")
model = AutoModelForCausalLM.from_pretrained("jsbaicenter/JSBAI-Coder-4B-NVFP4", 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 jsbaicenter/JSBAI-Coder-4B-NVFP4 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/jsbaicenter/JSBAI-Coder-4B-NVFP4

SGLang

How to use jsbaicenter/JSBAI-Coder-4B-NVFP4 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 "jsbaicenter/JSBAI-Coder-4B-NVFP4" \
    --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": "jsbaicenter/JSBAI-Coder-4B-NVFP4",
		"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 "jsbaicenter/JSBAI-Coder-4B-NVFP4" \
        --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": "jsbaicenter/JSBAI-Coder-4B-NVFP4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use jsbaicenter/JSBAI-Coder-4B-NVFP4 with Docker Model Runner:
```
docker model run hf.co/jsbaicenter/JSBAI-Coder-4B-NVFP4
```

jsbai-aaron commited on 24 days ago

Commit

720f668

verified ·

1 Parent(s): 470f34b

Upload README.md with huggingface_hub

Browse files

Files changed (1) hide show

README.md +41 -33

README.md CHANGED Viewed

@@ -12,47 +12,54 @@ tags:
 - reinforcement-learning
 library_name: transformers
 pipeline_tag: text-generation
 ---
-<p align="center">
-  <img src="https://cdn-uploads.huggingface.co/production/uploads/69b0868703a7e83e476092ec/RIr7Vy21qoIEFJrMAE8qn.png" alt="SDSU JSBCAI Center Logo" width="400">
-</p>
-# James Silberrad Brown Center for AI Research
-The **James Silberrad Brown Center for Artificial Intelligence (JSBCAI)** is an interdisciplinary research hub at San Diego State University dedicated to advancing artificial intelligence through foundational research, applied innovation, and student-driven inquiry.
 # JSBAI-Coder-4B-NVFP4
-**An agentic coding model that runs on your laptop.** JSBAI-Coder-4B is a 4B-parameter model fine-tuned from Qwen3.5-4B for multi-step, tool-using software engineering: the capability class currently gated to 27B+ models, at a size that fits consumer GPUs.
 ## Results
-| Benchmark | Qwen3.5-4B (base) | **JSBAI-Coder-4B** | Δ |
 |---|---|---|---|
-| **Live-60** (real-world SWE, t32) | 15.0% | **21.7%** | **+44% relative** |
-| **IFEval** (excl-empty, 8K) | 84.66 | **87.21** | +2.55 |
-| **Held-out SWE** (unseen instances, K=8) | 10.1% | **82.9%** | **+72.8pp** |
-| MMLU-Pro (generative) | TBD | TBD | TBD |
 | Terminal-Bench 2.1 | TBD | TBD | TBD |
-*Held-out SWE: 121 never-trained coding instances solved with verified test execution. The gains are broad-spectrum generalization, not benchmark memorization. Our decontamination protocol is published with the model.*
 ## What it does
-- **Agentic software engineering**: multi-turn bug investigation, tool orchestration (bash, file editing, test running), patch generation and verification, in real repositories inside sandboxed containers
-- **Interleaved reasoning**: thinks before each tool call, like much larger reasoning models
-- **Quality held**: instruction-following *improved* over base (87.21 vs 84.66 IFEval). The agentic gains cost nothing on general quality.
-- **Laptop-scale**: ~5GB VRAM (the NVFP4 quantized variant of JSBAI-Coder-4B)
-## Training methodology
-**Teacher-seeded agentic RL.** The model was produced in three stages:
-1. **Seed SFT**: a small curated set (~1,875 verified trajectories) from GLM-5.3 (a 744B-A40B open model) bootstrap the student into the agentic tool-use distribution
-2. **GRPO with verifiable rewards**: 145 batches of on-policy RL on a difficulty-banded pool of real SWE tasks (237 unique instances), where the reward is *actual test execution*. The model's patch must make the hidden tests pass.
-3. **Generalization gates**: held-out never-trained instances verified the transfer at every phase boundary (10.1% to 82.9% pass rate).
-The RL phase is the capability engine: the seed SFT contributes the behavioral format, the verification-driven RL builds the problem-solving. We extensively studied on-policy distillation from the teacher (logprob-scoring) and found the signal prefers stylistic imitation over correctness at every model family and tier we tested. Those negative results and the mechanism are documented in our technical report.
 ## Usage
@@ -61,26 +68,27 @@ from vllm import LLM
 llm = LLM(model="jsbaicenter/JSBAI-Coder-4B-NVFP4", quantization="modelopt", max_model_len=131072)
 ```
-Recommended sampling: `temperature 1.0, top_p 0.95`. The model uses the Qwen3.5 chat template with interleaved thinking (the `nemotron_v3`/`qwen3` reasoning parser in vLLM) and `qwen3_coder` tool-call format.
-A quantized NVFP4 variant (~5GB) and an MTP-boosted speculative decoding head (for faster inference) are available from the same organization.
 ## Limitations
-- 4B-scale knowledge limits: obscure factual recall and extreme-domain reasoning remain behind larger models
-- The agent loop is tuned for sandboxed container environments; other deployment contexts are untested
-- Safety behaviors inherited from the base model; the RL phase was reward-verification only (no safety-specific training). See the base model card
 ## Lineage & credits
 - **Base model**: [Qwen/Qwen3.5-4B](https://huggingface.co/Qwen/Qwen3.5-4B) (Apache-2.0)
-- **Distillation teacher (seed data)**: GLM-5.3 (Z.AI), served locally; training data generated and verified by us
-- **Quantization**: NVIDIA ModelOpt (NVFP4)
-- **Technical report**: coming soon (the arXiv submission covers the full methodology, the ablations, and the negative results)
 ## License
-Apache-2.0 (matching the base model).
 ## Citation

 - reinforcement-learning
 library_name: transformers
 pipeline_tag: text-generation
+datasets:
+- nvidia/Nemotron-Post-Training-Dataset-v2
 ---
 # JSBAI-Coder-4B-NVFP4
+**An agentic coding model that runs on your laptop.**
+JSBAI-Coder-4B is a 4B-parameter model, fine-tuned from Qwen3.5-4B, that investigates bugs, edits files, runs commands, and verifies its own fixes in real software repositories. Agentic coding at this level has required 27B+ models. This one fits on a consumer GPU.
 ## Results
+We reserved 121 real software bugs that the model never saw during training. Before fine-tuning, it solved 10% of them. After training, it solved **83%**, verified by running each project's hidden test suite. The model learned to fix bugs in general, not just the ones it practiced on.
+| Benchmark | Qwen3.5-4B (base) | **JSBAI-Coder-4B** | Change |
 |---|---|---|---|
+| **Generalization test** (121 unseen bugs, tests run to verify) | 10.1% | **82.9%** | **+72.8 points** |
+| **Live-60** (60 real-world engineering tasks, solved end-to-end in containers) | 15.0% | **21.7%** | **+44% relative** |
+| **Instruction-following** (IFEval) | 84.66 | **87.21** | +2.55 |
+| MMLU-Pro | TBD | TBD | TBD |
 | Terminal-Bench 2.1 | TBD | TBD | TBD |
+The instruction-following score *improved* over the base model. The coding gains cost nothing on general quality. Gains of this kind usually trade one for the other.
+Our decontamination protocol is published with the model: none of these benchmark problems overlap the training data.
 ## What it does
+- **Investigates and fixes bugs in real repositories.** The model explores a codebase, reads the failing code, writes a patch, and runs the tests to check itself, inside a sandboxed container.
+- **Thinks before each action.** Like much larger reasoning models, it reasons between tool calls.
+- **Runs on consumer hardware.** ~5GB VRAM (the NVFP4 quantized variant).
+## How we trained it
+Three stages, each with a plain-language summary:
+1. **Seed demonstrations.** GLM-5.3, a frontier 744B open model, generated roughly 1,875 coding trajectories. We verified every one by running the actual tests before using it. These demonstrations taught our model the *format* of agentic coding: how to use tools, when to run tests, what a working solution looks like.
+2. **Reinforcement learning on real bugs.** The model then practiced on 237 curated software engineering problems: ones it could sometimes solve, but not reliably. For each problem, the model repeatedly attempted a fix. Solutions that made the real hidden tests pass were reinforced; failures were not. This phase, 145 batches of on-policy GRPO, built the actual problem-solving ability.
+3. **Generalization checks.** At every stage boundary, we re-tested the model on problems it had never trained on. The 10.1% to 82.9% jump above is the result.
+### Training data
+- **[NVIDIA Nemotron-Post-Training-Dataset-v2](https://huggingface.co/datasets/nvidia/Nemotron-Post-Training-Dataset-v2)**: a portion of its general instruction-following, structured-output, and tool-use data anchored the model's general capabilities.
+- **Our distilled seed set**: ~1,875 verified coding trajectories generated by GLM-5.3 (Z.AI), each confirmed by running the real test suite before use.
+- **Open SWE datasets**: a blend of open software-engineering problem sets provided the RL practice pool.
+- **The RL phase used no static data at all**: the model generated fresh attempts each batch, and only test-verified outcomes became training signal.
 ## Usage
 llm = LLM(model="jsbaicenter/JSBAI-Coder-4B-NVFP4", quantization="modelopt", max_model_len=131072)
 ```
+Recommended sampling: `temperature 1.0, top_p 0.95`. The model uses the Qwen3.5 chat template with interleaved thinking (the `qwen3` reasoning parser in vLLM) and `qwen3_coder` tool-call format.
+The full-precision BF16 release and an MTP-boosted speculative decoding head (for faster inference) are available from the same organization. This variant was quantized with [NVIDIA ModelOpt](https://github.com/NVIDIA/Model-Optimizer).
 ## Limitations
+- A 4B model has 4B knowledge: obscure facts and extreme-domain reasoning still favor larger models.
+- We tuned the agent loop for sandboxed container environments; other deployment contexts are untested.
+- Safety behaviors come from the base model; the RL phase optimized test-passing only, with no safety-specific training. See the base model card.
 ## Lineage & credits
 - **Base model**: [Qwen/Qwen3.5-4B](https://huggingface.co/Qwen/Qwen3.5-4B) (Apache-2.0)
+- **Demonstration generator**: GLM-5.3 (Z.AI), served locally
+- **General training data**: [nvidia/Nemotron-Post-Training-Dataset-v2](https://huggingface.co/datasets/nvidia/Nemotron-Post-Training-Dataset-v2)
+- **Quantization**: [NVIDIA ModelOpt](https://github.com/NVIDIA/Model-Optimizer) (NVFP4)
+- **Technical report**: coming soon, covering the full methodology, the ablations, and our negative results on teacher-logprob distillation.
 ## License
+Apache-2.0, matching the base model.
 ## Citation