Nandi-Mini-600M-Early-Checkpoint

Introduction

Nandi-Mini-600M-Early-Checkpoint is an early-stage checkpoint (After 250 Billions tokens) from the upcoming Nandi-Mini-600M model family, this is not the final model, a compact multilingual language model focused on strong efficiency, deployment flexibility, and Indic language support.

The model is being trained completely from scratch and is designed to deliver strong performance at low compute and memory budgets. This checkpoint is shared to provide an early look into the model’s scaling behavior and training progress.

This release is an early checkpoint and not the final converged model. Performance is expected to improve further with continued training and scaling.

📢 We will soon share technical blog ! Stay tuned!

Architectural Highlights

Nandi-Mini-600M introduces several efficiency-focused architectural optimizations designed for compact yet capable language models.

Shared KV (Shared Key-Value Vectors)

Shared KV is one of the core architectural ideas explored in Nandi-Mini. Instead of computing separate Key and Value projections, both reuse a shared latent representation, while a lightweight Key normalization step is applied specifically for attention computation.

This design reduces KV-cache memory usage by ~50% during inference with only a small increase in compute overhead, since RoPE and Key normalization are applied dynamically during attention computation.

Nandi supports two KV cache modes:

"kv_cache_mode": "shared"

Uses Shared KV, reducing KV-cache memory by ~50% with slightly higher compute overhead.

"kv_cache_mode": "vanilla"

Uses standard separate Key-Value caching for maximum inference compatibility and lower compute overhead.

KV-Cache Memory Comparison

• Vanilla KV → Standard KV-cache memory usage
• Shared KV → ~50% lower KV-cache footprint

Shared KV is part of our broader focus on deployable foundation models optimized for:

• On-premise AI systems
• Memory-constrained deployments
• Edge devices
• Long-context inference workloads

This remains an active research area within the Nandi model family, and we plan to share deeper technical details in upcoming engineering blogs.

Model Details

• Type: Causal Language Model
• Training Stage: Early Pretraining Checkpoint (250 Billions tokens)
• Parameters: ~600M
• Architecture: Transformer decoder
• Positional Encoding: RoPE
• Normalization: RMSNorm + QK Norm
• Activation: SwiGLU
• Attention: GQA + Shared KV
• Embeddings: Tied embeddings with factorized design
• Context length: 2,048 tokens (planned to be extended to 32,000 tokens)
• Vocabulary Size: 131,072

📊 Benchmark Results

This is not the final model, this is an early checkpoint. So the results are not final. Only 20% training is done.

General Benchmarks

Tokenization Fertility Score Across Languages

🌍 Supported Languages

The model is trained on English and a diverse set of Indic languages, including:

Hindi, Bengali, Tamil, Telugu, Marathi, Gujarati, Kannada, Malayalam, Punjabi, Odia

🚀 Usage

!pip install transformers=='5.4.0'

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "FrontiersMind/Nandi-Mini-600M-Early-Checkpoint"

tokenizer = AutoTokenizer.from_pretrained(
    model_name,
    trust_remote_code=True
)

device = "cuda" if torch.cuda.is_available() else "cpu"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    trust_remote_code=True,
    dtype=torch.bfloat16
).to(device).eval()


#model.config.kv_cache_mode = "shared" # Use this one if wants to save 50% KV cache, but this will slight more compute
model.config.kv_cache_mode = "vanilla"

prompt = """The night was quiet and the streets were empty"""

model_inputs = tokenizer(
    [prompt],
    return_tensors="pt"
).to(model.device)

outputs = model.generate(
        **model_inputs,
        max_new_tokens=50,
        do_sample=True,
        temperature=0.3,
        top_k=20,
        top_p=0.95,
        repetition_penalty=1.1,
        pad_token_id=tokenizer.eos_token_id,
        use_cache=True,  
    )

response = tokenizer.decode(
    outputs[0],
    skip_special_tokens=True
)

print(response)