Instructions to use kataguru/Industry-Coder-27B-v3.0-NVFP4 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use kataguru/Industry-Coder-27B-v3.0-NVFP4 with Transformers:

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

pipe = pipeline("image-text-to-text", model="kataguru/Industry-Coder-27B-v3.0-NVFP4")
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("kataguru/Industry-Coder-27B-v3.0-NVFP4")
model = AutoModelForMultimodalLM.from_pretrained("kataguru/Industry-Coder-27B-v3.0-NVFP4", 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 kataguru/Industry-Coder-27B-v3.0-NVFP4 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "kataguru/Industry-Coder-27B-v3.0-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": "kataguru/Industry-Coder-27B-v3.0-NVFP4",
		"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/kataguru/Industry-Coder-27B-v3.0-NVFP4

SGLang

How to use kataguru/Industry-Coder-27B-v3.0-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 "kataguru/Industry-Coder-27B-v3.0-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": "kataguru/Industry-Coder-27B-v3.0-NVFP4",
		"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 "kataguru/Industry-Coder-27B-v3.0-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": "kataguru/Industry-Coder-27B-v3.0-NVFP4",
		"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 kataguru/Industry-Coder-27B-v3.0-NVFP4 with Docker Model Runner:
```
docker model run hf.co/kataguru/Industry-Coder-27B-v3.0-NVFP4
```

Kataguru Industry-Coder-27B v3.0 — `NVFP4-W4ATTN-AWQ` Hybrid (`20.28 GB`, Blackwell `sm_120`)

Kataguru Industry-Coder-27B v3.0 Banner

1. What Kataguru Changed (Change Summary)

Field	Description / Value
Base model	`Qwen/Qwen3.8-27B` (`Qwen3_5ForConditionalGeneration`, 27B Dense Hybrid Gated DeltaNet + Full Softmax Attention + Multimodal Vision + MTP)
Previous public release	`kataguru/Industry-Coder-27B-v2.0` ($\Sigma_{15} = 68.73\text{ %}$)
Kataguru v3.0 modifications	Triple-Adaptive Multi-Dynamic Pipeline (`v4.1`): SOMA/ARA residual orthogonalization + 3-Phase Split-Subspace Orthonormal QLoRA (`r=16 qr_frozen_a`, indices `[0:8]` vs. `[8:16]`) + Phase 4 Multi-Dynamic Thinking, Competitive Coding & Parallel Tool-Calling annealing
Finnish & English mastery	Native Bilingual (`fi` & `en`): Kotus-verified Finnish inflection and technical compound terminology alongside English
Quantization architecture	Calibrated `NVFP4-W4ATTN-AWQ` Hybrid: • `MLP (gate/up/down_proj, 192 modules)`: Hardware `NVFP4` (`group_size=16`, calibrated activations) • `Attention (self_attn & linear_attn q/k/v/o/qkv/z/out, 208 modules)`: `W4A16_ASYM` (`group_size=128`, AWQ-calibrated) • `Preserved in full BF16`: `linear_attn.in_proj_a/b`, `model.visual.` (`333` tensors), `mtp.` (`15` tensors in `model-nonquant.safetensors`), `lm_head`, `embed_tokens`
Disk & VRAM footprint	`20.28 GB` on disk (`18.72 GiB` total weight VRAM — `9.36 GiB/GPU` on `TP=2`), `-6.72 GB` (`-25 %`) smaller than standard RTN `NVFP4` (`27.0 GB`). Fits on a single 32 GB GPU with `~10 GiB` free for KV cache, or on 2x RTX 5090 (`TP=2`) with `507,539` tokens KV capacity
What was NOT changed	Base 64-layer architecture, 27-layer multimodal vision encoder (`333` BF16 tensors), Multi-Token Prediction (`mtp.*`, `15` BF16 tensors), native `262,144` context window
Primary use case	Autonomous coding agents (IDE/CLI), competitive algorithms, parallel `<tool_call>` orchestration, graduate-level STEM, and industrial automation (`Siemens SCL`, `Beckhoff TwinCAT 3 ST`, `CNC G-code`)
Recommended runtime	`vLLM` (`TP=1` on 1x RTX 5090 32GB or `TP=2` on 2x RTX 5090 32GB Blackwell `sm_120`, CUDAGraphs enabled)

2. Official 15-Benchmark Suite (`Industry-Coder-27B v3.0` vs. `v2.0` & `Qwen/Qwen3.8-27B` Base)

Kataguru Industry-Coder-27B v3.0 Official 15-Benchmark Performance Chart

All benchmarks were executed on 2x NVIDIA GeForce RTX 5090 32GB Blackwell (TP=2, CUDAGraphs enabled) under identical canonical production conditions (1,103.8 tokens/s generation throughput across 16 concurrent sessions):

#	Benchmark / Pillar	Metric	`Qwen/Qwen3.8-27B` (Base)	`kataguru/Industry-Coder-27B-v2.0` (Prev. Release)	`kataguru/Industry-Coder-27B-v3.0` (`NVFP4-W4ATTN-AWQ`)	$\Delta$ vs. `v2.0`	$\Delta$ vs. `Base`
$\Sigma_{15}$	15-Benchmark Total Mean	`Mean (All 15)`	`68.85 %`	`68.73 %`	71.90 %	`+3.17 %-pt`	`+3.05 %-pt`
$\Sigma_{11}$	11-Task Cognitive Mean	`Mean (1..11)`	`70.40 %`	`70.41 %`	70.70 %	`+0.29 %-pt`	`+0.30 %-pt`
14	LiveCodeBench v6 (`175` tasks)	`Pass@1`	`58.86 %` (`103/175`)	`42.29 %` (`74/175`)	64.57 % (`113/175`)	`+22.28 %-pt` (`+39` tasks)	`+5.71 %-pt` (`+10` tasks)
├─	`LCB v6 Easy` (`n=43`)	`Pass@1`	`95.35 %` (`41/43`)	`95.35 %` (`41/43`)	100.00 % (`43/43`)	`+4.65 %-pt`	`+4.65 %-pt`
├─	`LCB v6 Medium` (`n=52`)	`Pass@1`	`69.23 %` (`36/52`)	`48.08 %` (`25/52`)	82.69 % (`43/52`)	`+34.61 %-pt`	`+13.46 %-pt`
├─	`LCB v6 Hard` (`n=80`)	`Pass@1`	`32.50 %` (`26/80`)	`10.00 %` (`8/80`)	33.75 % (`27/80`)	`+23.75 %-pt`	`+1.25 %-pt`
└─	`LCB v6 LeetCode` (`n=63`, `class Solution:`)	`Pass@1`	`—`	`—`	85.71 % (`54/63`)	—	—
15	BFCL V4 Single-Turn AST (`3,641` tasks)	`Overall AST`	`85.44 %`	`73.14 %`	86.27 %	`+13.13 %-pt`	`+0.83 %-pt`
├─	`15a. BFCL Non-Live AST`	`AST Summary`	`87.89 %`	`61.02 %`	89.19 %	`+28.17 %-pt`	`+1.30 %-pt`
├─	`15b. BFCL Live AST`	`AST Summary`	`83.00 %`	85.27 %	`83.35 %`	`-1.92 %-pt`	`+0.35 %-pt`
├─	`15f. BFCL Live Parallel AST`	`Parallel AST`	`81.25 %`	`25.00 %`	87.50 %	`+62.50 %-pt`	`+6.25 %-pt`
├─	`BFCL Non-Live Parallel AST`	`Parallel AST`	`91.50 %`	`29.50 %`	94.50 %	`+65.00 %-pt`	`+3.00 %-pt`
├─	`BFCL Non-Live Parallel Multiple AST`	`Parallel Mult.`	`86.50 %`	`—`	90.50 %	—	`+4.00 %-pt`
└─	`15g. BFCL Irrelevance Detection`	`Abstention`	75.26 %	`48.14 %`	`70.50 %`	`+22.36 %-pt`	`-4.76 %-pt`
12	GPQA Diamond (`198` doctoral STEM)	`CoT Exact`	`77.27 %`	`66.16 %` (`131/198`)	82.32 % (`163/198`)	`+16.16 %-pt`	`+5.05 %-pt`
11	GSM8K Math (`1,319` CoT 1024-tok)	`Strict / Flex`	`87.19 %`	`86.73 % / 87.79 %`	92.12 % / 91.74 %	`+5.39 %-pt`	`+4.93 %-pt`
13	IFEval Strict (`541` prompts)	`Prompt / Inst`	`69.87 % / 77.82 %`	74.86 % / 81.89 %	`67.65 % / 76.38 %`	`-7.21 %-pt`	`-2.22 %-pt`
1	PIQA (`1,838`)	`acc_norm`	`82.15 %`	`82.05 %`	82.37 %	`+0.32 %-pt`	`+0.22 %-pt`
2	WinoGrande (`1,267`)	`acc`	`76.48 %`	`76.32 %`	77.19 %	`+0.87 %-pt`	`+0.71 %-pt`
3	MedQA (USMLE) (`1,273`)	`acc (4-opt)`	`82.72 %`	`82.80 %`	83.03 %	`+0.23 %-pt`	`+0.31 %-pt`
4	TruthfulQA MC2 (`817`)	`acc`	`52.65 %`	53.06 %	`52.00 %`	`-1.06 %-pt`	`-0.65 %-pt`
5	TruthfulQA MC1 (`817`)	`acc`	34.88 %	`34.15 %`	`32.68 %`	`-1.47 %-pt`	`-2.20 %-pt`
6	ARC-Easy (`2,376`)	`acc_norm`	82.11 %	`81.99 %`	`81.48 %`	`-0.51 %-pt`	`-0.63 %-pt`
7	HellaSwag (`10,042`)	`acc_norm`	`82.39 %`	82.91 %	`82.13 %`	`-0.78 %-pt`	`-0.26 %-pt`
8	OpenBookQA (`500`)	`acc_norm`	`45.40 %`	`45.80 %`	46.60 %	`+0.80 %-pt`	`+1.20 %-pt`
9	ARC-Challenge (`1,172`)	`acc_norm`	`61.35 %`	62.20 %	`60.75 %`	`-1.45 %-pt`	`-0.60 %-pt`
10	BoolQ (`3,270`)	`acc`	`87.09 %`	`86.45 %`	87.31 %	`+0.86 %-pt`	`+0.22 %-pt`

Why `Industry-Coder-27B v3.0` Excels as a Practical Coding Agent

50 % Lower Error Rate on Everyday Software Engineering (LCB Easy + Medium): Across the 95 Easy and Medium problems in LiveCodeBench v6, Qwen/Qwen3.8-27B Base fails 18/95 (18.9 % error rate), whereas Industry-Coder-27B v3.0 fails only 9/95 (9.5 % error rate; Easy = 100.00 %, Medium = 82.69 %, LeetCode = 85.71 %).
Parallel Multi-Tool Execution (BFCL V4 = 86.27 %): Modern coding agents invoke multiple tools in parallel (read_file + grep + edit_file). Industry-Coder-27B v3.0 achieves 94.50 % on Non-Live Parallel, 90.50 % on Non-Live Parallel Multiple, and 87.50 % on Live Parallel (+62.50 %-pt over v2.0), with a mean single-turn latency of 3.84 seconds (0 truncations across all 3,641 tasks at temperature=0.001).
25 % Lower Memory Footprint (20.28 GB vs. 27.0 GB): By combining NVFP4 g16 on MLP layers with AWQ-calibrated W4A16_ASYM g128 on attention projections, the model uses only 18.72 GiB VRAM for weights (9.36 GiB/GPU on TP=2), freeing an additional 6.7 GiB for long repository contexts.

3. Triple-Adaptive Multi-Dynamic Training Pipeline & Split-Subspace Architecture

Unlike static SFT/QLoRA fine-tuning (fixed corpus, fixed step count, fixed domain ratios), Kataguru Industry-Coder-27B v3.0 was trained using Kataguru's Triple-Adaptive Training Pipeline:

Recipient-Level Question Selection ($\Delta K > 0$ & 2D Stratification): Only samples the model does not already know (NLL >= 0.35, verified by the 9B firewall, 35B Sceptic Oracle score >= 8.5, and Python AST/sandbox execution) are admitted, ordered by 2D difficulty (1/3 Easiest -> 2/3 Intermediate -> 3/3 Diabolical).
Absorption-Driven Training Duration (dynamic_canary_wsd): A 50-step in-memory interrogation radar (fast_interrogation_canary.py, 144 held-out samples across 18 domains) monitors real-time absorption and neighbor-pillar retention, extending the plateau when learning progresses and triggering surgical cooldown/rollback the moment absorption saturates.
Need-Based Domain Rebalancing (Closed-Loop P-Controller): Underperforming pillars automatically receive additional certified samples from the SQLite Golden Bank (156,713+ samples) at every 50-step window boundary.
Orthonormal Split-Subspace Locking (r=16 qr_frozen_a): lora_A is initialized as a QR-orthonormal basis ($A A^T = I_{16}$) and frozen; indices [0:8] lock foundational domain knowledge (Phases 1–2) while indices [8:16] are dedicated to competitive coding, deep <think> reasoning, and parallel tool calling (Phases 3–4) with zero subspace overwrite.

4. Production Deployment with vLLM (`TP=1` or `TP=2`)

A. Dual-GPU High-Throughput Deployment (`2x RTX 5090 32GB`, `TP=2`, `507k` KV Cache)

vllm serve kataguru/Industry-Coder-27B-v3.0-NVFP4 \
  --served-model-name qwen3.8-27b \
  --tensor-parallel-size 2 \
  --max-model-len 65536 \
  --gpu-memory-utilization 0.90 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_xml \
  --reasoning-parser qwen3 \
  --speculative-config '{"method":"mtp","num_speculative_tokens":1}' \
  --trust-remote-code

B. Single-GPU Workstation Deployment (`1x RTX 5090 32GB`, `TP=1`, `32k–64k` Context)

Because the hybrid weights occupy only 18.72 GiB VRAM, the model runs natively on a single 32 GB Blackwell GPU:

vllm serve kataguru/Industry-Coder-27B-v3.0-NVFP4 \
  --served-model-name qwen3.8-27b \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.92 \
  --kv-cache-dtype fp8 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_xml \
  --reasoning-parser qwen3 \
  --trust-remote-code

5. Honest Limitations & Engineering Boundaries

Recommended Temperature for Coding Agents (temperature = 0.0 – 0.2): On NP-hard competitive programming tasks (LiveCodeBench v6 Hard), high sampling temperatures (temperature = 1.0) can occasionally trigger multi-pass self-verification loops inside <think> that approach the 32,768-token limit (across all 125/175 LCB v6 tasks where </think> closed, pass rate was 90.40 %). For production coding agents and IDE assistants, use temperature = 0.0 – 0.2, where the model follows its concise Kataguru derivation path directly (3.84 s mean latency across 3,641 BFCL V4 tasks with 0 truncations).
Hardware Requirement for NVFP4-W4ATTN-AWQ: This repository uses native Blackwell NVFP4 (sm_120) for MLP layers. For NVIDIA Ampere (RTX 3090 / A100), Ada Lovelace (RTX 4090 / L40S), or Hopper (H100), use kataguru/Industry-Coder-27B-v3.0-W4A16-AWQ or kataguru/Industry-Coder-27B-v3.0-GGUF.

6. Release Family Links

Full BF16 Weights (55.6 GB): kataguru/Industry-Coder-27B-v3.0
Blackwell NVFP4-W4ATTN-AWQ Hybrid (20.28 GB, this repo): kataguru/Industry-Coder-27B-v3.0-NVFP4
Universal W4A16-AWQ (28.2 GB, vLLM Marlin): kataguru/Industry-Coder-27B-v3.0-W4A16-AWQ
GGUF Suite (IQ4_NL, IQ4_XS, IQ3_S, IQ3_XXS + mmproj + mtp): kataguru/Industry-Coder-27B-v3.0-GGUF

Suomenkielinen Yhteenveto / Finnish Summary

1. Yleiskuvaus ja Keskeiset Parannukset

kataguru/Industry-Coder-27B-v3.0-NVFP4 on Kataguru Industry-Coder-27B v3.0 -lippulaivamallin kalibroitu sekatarkkuuksinen NVFP4-W4ATTN-AWQ Hybrid (20,28 GB) -tuotantojulkaisu NVIDIA Blackwell (RTX 5090 / RTX PRO 6000) -näytönohjaimille.

Verrattuna edelliseen julkaisuumme (kataguru/Industry-Coder-27B-v2.0) ja alkuperäiseen Qwen/Qwen3.8-27B-pohjamalliin uusi v3.0 saavuttaa 27B-luokan ennätyksen Σ₁₅ = 71,90 %:

LiveCodeBench v6 (175 kilpakoodaustehtävää): 64,57 % (113/175) — +22,28 %-yks. (+39 ratkaistua tehtävää enemmän kuin v2.0:n 42,29 %!). Arjen ohjelmistokehityksessä (Easy 100,00 % [43/43], Medium 82,69 % [43/52], LeetCode 85,71 % [54/63]) malli tekee 50 % vähemmän virheitä kuin alkuperäinen Qwen/Qwen3.8-27B.
BFCL V4 Single-Turn AST (3 641 työkalukutsutehtävää): 86,27 % (+13,13 %-yks. yli v2.0:n ja +0,83 %-yks. yli pohjamallin). Rinnakkaisissa monityökalukutsuissa Non-Live Parallel = 94,50 % (+65,00 %-yks. vs. v2.0) ja Live Parallel = 87,50 % (+62,50 %-yks. vs. v2.0), keskimääräisen vasteajan ollessa vain 3,84 s.
GPQA Diamond (198 tohtoritason STEM-tehtävää): 82,32 % (163/198) (+16,16 %-yks. yli v2.0:n ja +5,05 %-yks. yli pohjamallin).
GSM8K Matematiikka (Strict CoT 1024-tok): 92,12 % (+5,39 %-yks. yli v2.0:n ja +4,93 %-yks. yli pohjamallin).
25 % Pienempi VRAM-jalanjälki (20,28 GB vs. 27,0 GB): Koska self_attn- ja linear_attn-huomiokerrokset on kvantisoitu AWQ-kalibroiduksi W4A16_ASYM g128 -muodoksi ja MLP-kerrokset NVFP4 g16 -muotoon (in_proj_a/b, visual.* 333 tensoria ja mtp.* 15 tensoria täydessä BF16-tarkkuudessa), mallin painot vievät vain 18,72 GiB VRAMia — malli toimii erinomaisesti myös yhdellä 32 Gt RTX 5090 -kortilla (TP=1) jättäen ~10 GiB vapaaksi kontekstille!

2. Kolmoisadaptiivinen Koulutusputki (`Triple-Adaptive Training Pipeline`)

Malli on koulutettu Katagurun kolmoisadaptiivisella menetelmällä:

Kysymykset valitaan vastaanottajan tason mukaan ($\Delta K > 0$ episteeminen kuulustelu + 2D-vaikeusositus 1/3 -> 2/3 -> 3/3),
Koulutuksen pituus säädetään vastaanottokyvyn mukaan (50 askeleen kuulustelututka ja elastinen WSD-oppimisnopeus), ja
Kunkin aiheen määrää säädetään tarpeen mukaan (suljetun silmukan P-säädin hakee lennossa lisänäytteitä SQLite-kultapankista heikentyville osa-alueille). Lisäksi ortonormaali r=16 qr_frozen_a -aliavaruus on jaettu kahteen lukittuun osaan ([0:8] peruskognitio ja teollisuus, [8:16] algoritminen koodaus, <think>-syväpäättely ja rinnakkaiset työkalukutsut), mikä estää aiemmin opittujen taitojen ylikirjoittumisen.

Downloads last month: 53

Safetensors

Model size

28B params

Tensor type

BF16

I32

Model tree for kataguru/Industry-Coder-27B-v3.0-NVFP4

Base model

Qwen/Qwen3.8-27B

Quantized

(1,787)

this model

Collection including kataguru/Industry-Coder-27B-v3.0-NVFP4

Datasein Oy | Qwen3.8-27B Titan vLLM & GGUF

Collection

Virallinen yritysjulkaisu: Datasein Oy (Y-tunnus: 3167094-7, Suomi). Tuotantotason AWQ, NVFP4 ja GGUF -julkaisut. • 2 items • Updated 3 days ago

Kataguru Industry-Coder-27B v3.0 — NVFP4-W4ATTN-AWQ Hybrid (20.28 GB, Blackwell sm_120)