greghavens/fabletron-nemotron-3-super-120b

Fabletron — Nemotron-3-Super-120B-A12B · Fable-5 (LoRA adapter)

QLoRA fine-tune of NVIDIA Nemotron-3-Super-120B-A12B (120B-total / 12B-active hybrid Mamba-2 + Latent-MoE, nemotron_h) on the pi_agent split of Glint-Research/Fable-5-traces, targeting reasoning, agentic planning, and tool-use.

This repo holds the PEFT/LoRA adapter (the fine-tune delta, ≈4.95 GB) plus the tokenizer and ChatML template, and serves as the index for the merged/quantized exports below. The adapter is ≈5 GB rather than a few MB because LoRA is applied across all 512 routed experts (see Training).

Available formats

Format	Where	Notes
LoRA adapter (this repo)	greghavens/fabletron-nemotron-3-super-120b	the fine-tune delta (≈4.95 GB); compose on the base model
GGUF Q4_K_M (LM Studio / llama.cpp)	…-120b-GGUF	merged + runnable (≈80 GiB); most universal
NVFP4 (vLLM / TensorRT-LLM, Blackwell)	…-120b-NVFP4	NVIDIA ModelOpt FP4 (≈67 GB); native Blackwell FP4 tensor cores

Use the GGUF for daily driving; this adapter to compose on top of the base model.

Use (apply the adapter)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

base = "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B"   # or unsloth/… 4-bit
tok = AutoTokenizer.from_pretrained("greghavens/fabletron-nemotron-3-super-120b", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    base, trust_remote_code=True, torch_dtype=torch.bfloat16,
    attn_implementation="eager", device_map="auto")
model = PeftModel.from_pretrained(model, "greghavens/fabletron-nemotron-3-super-120b")

trust_remote_code=True and attn_implementation="eager" are required by nemotron_h; it also needs the Mamba-2 kernels (causal_conv1d, mamba_ssm). Prompt format is ChatML (<|im_start|> / <|im_end|>). For single-GPU inference prefer the GGUF sibling.

Training

• Method: QLoRA (4-bit NF4 base) via Unsloth. LoRA r=8, α=16, dropout=0, bias=none. Targets (by regex) attention q/k/v/o_proj, Mamba-2 in_proj/out_proj, and the up/down_proj of all 512 routed experts + the shared expert — this MoE is non-gated, so up/down_proj is the full expert FFN (there is no gate_proj). The MoE router (mixer.gate, an nn.Parameter) and the MoE-latent fc1/fc2_latent_proj stay frozen.
• Data: Glint-Research/Fable-5-traces, config pi_agent, ChatML, response-only loss.
• Schedule: 1 epoch (248 steps), grad-accum 16, lr 2e-5 cosine + warmup.
• Final training loss: ≈0.74 true per-token CE (final-phase mean; Unsloth logs loss × grad-accum, so the raw logged value is ÷16 here).
• Evaluation (held-out Fable-5 pi_agent, 81 rows, base → fine-tuned): cross-entropy 1.12 → 0.78, perplexity 3.07 → 2.18.
• Date: 2026-06-29.

Provenance & license

This is a derivative of two upstream works, and downstream use must comply with both:

• Base model: NVIDIA Nemotron-3-Super-120B-A12B — see NVIDIA's model license.
• Dataset: Glint-Research/Fable-5-traces — AGPL-3.0, and distilled from Anthropic Claude outputs (subject to Anthropic's usage terms).

Released as a research artifact. license: other reflects the combination of the above.

Intended use

Research on hybrid Mamba-2/MoE reasoning models, agentic/tool-use experimentation. Not safety-aligned beyond the base model; evaluate before any production deployment.

Benchmarks

Fabletron is a Fable-5 fine-tune of Nemotron-3-Super-120B-A12B. This repository hosts the LoRA adapter (apply on top of base Nemotron-3-Super-120B-A12B) build. The results below were produced through a deployed NeMo Evaluator at full context length (262 144) with a 32 768-token generation budget, comparing base Nemotron-3-Super against the Fabletron fine-tune in its two served formats — GGUF (llama.cpp) and NVFP4 (vLLM / Blackwell).

Accuracy

Benchmark	Base Nemotron 3 Super	Fabletron (GGUF)	Fabletron (NVFP4)
IFEval	89.6	90.4	87.4
GSM8K	96.6	96.5	96.5
MMLU-Pro	81.1	81.5	81.2
HumanEval+	87.8	89.6	89.6
MBPP+	95.5	96.6	96.8
BFCL (v3 · multi_turn + ast)	31.7	53.6	53.9

Scores are % (higher is better). The standout is function-calling (BFCL): 31.7 → 53.6 — base Nemotron largely fails multi-turn and parallel tool use, which the fine-tune resolves (single-tool calls 0.8 → 85.7, multi-turn 0 → 45). General reasoning and coding hold or improve slightly, and NVFP4 tracks the GGUF fine-tune within noise — the only give-back to quantization is IFEval strict (≈2 points).

Throughput

Mean per-request decode rate across the 6 benchmark families (tok/s, client-side, parallelism 4): base 45.7 · Fabletron GGUF 46.3 · Fabletron NVFP4 63.8. The NVFP4 build serves at ≈1.4× the GGUF (llama.cpp) rate on an RTX PRO 6000 (Blackwell).

_{BFCL = Berkeley Function-Calling Leaderboard v3 (multi_turn,ast, native tool-calling, via nvidia_bfcl 26.3). Base and GGUF share the llama.cpp engine; NVFP4 runs on vLLM. Output truncation at this budget is ≈0 across families (MMLU-Pro shows ≈3.5% length-capped generations, intrinsic to the benchmark and near-identical for all three models, so it does not bias the comparison).}