granite-20b-code-instruct-8k-2048-Calibration-FP8

Premium FP8 quantization with 2,048 code-optimized calibration samples

This is a premium FP8 quantized version of ibm-granite/granite-20b-code-instruct-8k featuring rigorous code-optimized multi-dataset calibration for production-grade reliability. Quantized by TevunahAi on enterprise-grade hardware.

🎯 Recommended Usage: vLLM

For optimal performance with full FP8 benefits and code-optimized quality, use vLLM or TensorRT-LLM:

Quick Start with vLLM

pip install vllm

Python API:

from vllm import LLM, SamplingParams

# vLLM auto-detects FP8 from model config
llm = LLM(model="TevunahAi/granite-20b-code-instruct-8k-2048-Calibration-FP8", dtype="auto")

# Generate code
prompt = "Write a Python function to calculate fibonacci numbers:"
sampling_params = SamplingParams(temperature=0.7, max_tokens=256)

outputs = llm.generate([prompt], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

OpenAI-Compatible API Server:

vllm serve TevunahAi/granite-20b-code-instruct-8k-2048-Calibration-FP8 \
    --dtype auto \
    --max-model-len 8192

Then use with OpenAI client:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="token-abc123",  # dummy key
)

response = client.chat.completions.create(
    model="TevunahAi/granite-20b-code-instruct-8k-2048-Calibration-FP8",
    messages=[
        {"role": "user", "content": "Write a Python function to calculate fibonacci numbers"}
    ],
    temperature=0.7,
    max_tokens=256,
)

print(response.choices[0].message.content)

vLLM Benefits

✅ Weights, activations, and KV cache in FP8
✅ ~20GB VRAM (50% reduction vs BF16)
✅ Native FP8 tensor core acceleration on Ada/Hopper GPUs
✅ Single GPU deployment on RTX 4090, RTX 5000 Ada, or H100
✅ Premium 2048-sample code-optimized calibration
✅ Production-grade code quality

⚙️ Alternative: Transformers (Not Recommended)

This model can be loaded with transformers, but will decompress FP8 → BF16 during inference, requiring ~40GB+ VRAM. For 20B models, vLLM is strongly recommended.

Transformers Example (Click to expand)

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Loads FP8 weights but decompresses to BF16 during compute
model = AutoModelForCausalLM.from_pretrained(
    "TevunahAi/granite-20b-code-instruct-8k-2048-Calibration-FP8",
    device_map="auto",
    torch_dtype="auto",
    low_cpu_mem_usage=True,
)
tokenizer = AutoTokenizer.from_pretrained("TevunahAi/granite-20b-code-instruct-8k-2048-Calibration-FP8")

# Generate
prompt = "Write a Python function to calculate fibonacci numbers:"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Requirements:

pip install torch>=2.1.0 transformers>=4.40.0 accelerate compressed-tensors

System Requirements:

~40GB+ VRAM (decompressed to BF16)
Multi-GPU setup or A100/H100
CUDA 11.8 or newer

⚠️ Warning: vLLM is the recommended deployment method for 20B models.

📊 Model Details

Property	Value
Base Model	ibm-granite/granite-20b-code-instruct-8k
Architecture	Dense (20B parameters)
Context Length	8K tokens
Quantization Method	FP8 E4M3 weight-only
Framework	llm-compressor + compressed_tensors
Calibration Samples	2,048 (4-8x industry standard)
Calibration Type	Code-optimized (4 datasets)
Storage Size	~20GB (sharded safetensors)
VRAM (vLLM)	~20GB
VRAM (Transformers)	~40GB+ (decompressed to BF16)
Target Hardware	NVIDIA RTX 4090, RTX 5000 Ada, H100
Quantization Time	124.8 minutes (~2.1 hours)

🏆 Premium Code-Optimized Calibration

This model was quantized using TevunahAi's premium code-focused calibration process:

Calibration Details

Total Samples: 2,048 (4-8x industry standard)
Datasets Used: 4 code-focused sources
Coverage: Comprehensive across coding tasks

Dataset	Samples	Purpose
HuggingFaceH4/CodeAlpaca_20K	512	Code instruction pairs
garage-bAInd/Open-Platypus	512	STEM/reasoning (includes code)
teknium/OpenHermes-2.5	512	Diverse instructions
theblackcat102/evol-codealpaca-v1	512	Evolved code examples

Why Code-Optimized Calibration?

Most FP8 quantizations use generic chat data for calibration. TevunahAi uses 2,048 samples from 4 code-focused datasets, ensuring:

✅ Superior code generation quality
✅ Better handling of programming syntax
✅ Optimized for multiple languages
✅ Accurate completion of complex code
✅ Production-grade reliability for coding tasks

For code models, generic calibration isn't enough. TevunahAi uses code-specific data.

🔧 Why FP8 for Code Models?

With vLLM/TensorRT-LLM:

✅ 50% memory reduction vs BF16 (weights + activations + KV cache)
✅ Single GPU deployment on RTX 4090 (24GB) or RTX 5000 Ada (32GB)
✅ Faster inference via native FP8 tensor cores
✅ Better throughput with optimized kernels
✅ Code-optimized calibration maintains quality

With Transformers:

✅ Smaller download size (~20GB vs ~40GB BF16)
✅ Compatible with standard transformers workflow
⚠️ Decompresses to BF16 during inference (no runtime memory benefit)
❌ Requires 40GB+ VRAM - impractical for most setups

For 20B code models, vLLM is essential for practical deployment.

💾 Model Files

This model is sharded into multiple safetensors files (all required for inference). The compressed format enables efficient storage and faster downloads.

🔬 IBM Granite Code Models

Granite Code models are specifically trained for enterprise code generation. This 20B parameter version offers:

Strong code generation across 100+ programming languages
Optimized for enterprise coding tasks
8K context window (2x the 8B model)
Excellent balance of capability and efficiency
Apache 2.0 license for commercial use

📈 IBM Granite Code Family

TevunahAi provides premium FP8 quantizations for the IBM Granite Code family:

Model	Parameters	Context	Quantization Time	VRAM Usage
granite-8b-code-instruct-4k-2048-Calibration-FP8	8B	4K	55.8 min	~8GB
granite-20b-code-instruct-8k-2048-Calibration-FP8 (this)	20B	8K	124.8 min	~20GB
granite-34b-code-instruct-8k-2048-Calibration-FP8	34B	8K	Coming soon	~34GB

All models calibrated with identical premium 2048-sample code-focused datasets.

⚖️ Comparison: Standard vs Premium Calibration

TevunahAi offers two quantization tiers for this model:

Version	Calibration	Samples	Datasets	Quant Time	Use Case
Standard FP8	Basic	512	1 generic	~47 min	Quick deployment
Premium FP8 (this)	Code-optimized	2,048	4 code-focused	125 min	Production-grade

When to Choose Premium:

✅ Production deployments
✅ Quality-critical applications
✅ API services at scale
✅ Benchmarking and evaluation
✅ Enterprise code generation

When Standard is Fine:

✅ Quick testing
✅ Development/prototyping
✅ Resource-constrained environments
✅ Non-critical applications

🔬 Quantization Infrastructure

Professional hardware for premium calibration:

CPUs: Dual Intel Xeon Max 9480 (224 threads, 128GB HBM2e @ 2000 GB/s)
Memory: 256GB DDR5-4800 (16 DIMMs, 8-channel per socket, ~614 GB/s)
Total Memory Bandwidth: ~2,614 GB/s aggregate
GPU: NVIDIA RTX 5000 Ada Generation (32GB VRAM, native FP8 support)
Software: Ubuntu 25.10 | Python 3.12 | PyTorch 2.8 | CUDA 13.0 | llm-compressor

Why This Matters:

2.1 hours of rigorous quantization and validation
Code-specific calibration requires specialized datasets
Professional infrastructure enables quality impossible on consumer setups

📚 Original Model

This quantization is based on ibm-granite/granite-20b-code-instruct-8k by IBM.

For comprehensive information about:

Model architecture and training methodology
Supported programming languages
Evaluation benchmarks and results
Ethical considerations

Please refer to the original model card.

🔧 Hardware Requirements

Minimum (vLLM):

GPU: NVIDIA RTX 4090 (24GB) or RTX 5000 Ada (32GB)
VRAM: 20GB minimum, 24GB+ recommended
CUDA: 11.8 or newer

Recommended (vLLM):

GPU: NVIDIA RTX 5000 Ada (32GB) / H100 (80GB)
VRAM: 24GB+
CUDA: 12.0+

Transformers:

GPU: Multi-GPU setup or A100 (40GB+)
VRAM: 40GB+ (single GPU) or distributed
Not recommended for practical deployment

📖 Additional Resources

vLLM Documentation: docs.vllm.ai
TensorRT-LLM: github.com/NVIDIA/TensorRT-LLM
TevunahAi Models: huggingface.co/TevunahAi
llm-compressor: github.com/vllm-project/llm-compressor
IBM Granite: github.com/ibm-granite

📄 License

This model inherits the Apache 2.0 License from the original Granite model.

🙏 Acknowledgments

Original Model: IBM Granite team
Quantization Framework: Neural Magic's llm-compressor
Quantized by: TevunahAi

📝 Citation

If you use this model, please cite the original Granite work:

@misc{granite2024,
  title={Granite Code Models},
  author={IBM Research},
  year={2024},
  url={https://huggingface.co/ibm-granite/granite-20b-code-instruct-8k}
}

🌟 Why TevunahAi Premium Calibration FP8?

Task-Optimized Calibration

TevunahAi doesn't use one-size-fits-all calibration:

Model Type	Calibration Focus	Example Datasets
Code Models	Code-specific	CodeAlpaca, evol-codealpaca
General Models	Diverse instructions	UltraChat, SlimOrca
MoE Models	Balanced distribution	Multi-task datasets

The right calibration for the right model.

The Difference is in the Details

Aspect	Standard FP8	TevunahAi Premium FP8
Calibration Samples	128-512	2,048
Datasets	Single generic	4 code-focused
Calibration Time	Minutes	2.1 hours
Edge Case Handling	Adequate	Superior
Code Quality	Good	Excellent
Production Ready	Maybe	Absolutely
Infrastructure	Consumer/Prosumer	Enterprise-grade