TinyLlama

Executes text generation using a 1.1 billion parameter transformer model with 22 layers, 32 attention heads organized via Grouped Query Attention (4 query groups), 2048 embedding dimension, and 2048 token sequence length. Implements the same tokenizer and architectural patterns as Llama 2, enabling direct compatibility with Llama ecosystem tools while maintaining 10-15x smaller memory footprint than 13B+ models. Supports both base pretrained checkpoints (trained on up to 3 trillion tokens) and supervised fine-tuned chat variants for conversational tasks.

Implements a training pipeline that releases model checkpoints at 7 progressive stages (105B, 503B, 1T, 1.5T, 2T, 2.5T, 3T tokens) with corresponding performance metrics (commonsense reasoning scores tracked via MMLU-style benchmarks). Uses cosine learning rate schedule (4e-4 initial, 2000 warmup steps) with 2M token batch size (2048 sequence length × 1024 batch size) across 16 A100-40G GPUs. Enables researchers to analyze scaling laws and select optimal checkpoint for downstream fine-tuning without retraining from scratch.

Releases all 7 base model checkpoints with complete training configuration (hyperparameters, data sources, hardware setup, learning rate schedule) documented in README and EVAL.md, enabling full reproducibility of training process and checkpoint selection. Configuration includes batch size (2M tokens), learning rate (4e-4 with cosine schedule, 2000 warmup steps), hardware (16 A100-40G GPUs), and data composition (7:3 NL:code ratio), allowing researchers to reproduce training or adapt methodology for custom models.

Applies instruction-tuning and chat fine-tuning to base pretrained checkpoints using supervised learning on curated instruction-response pairs, producing chat-optimized variants (Chat-v0.1, v0.3, v0.4) derived from 503B, 1T, and 1.5T token base models respectively. Maintains Llama 2 chat template format (system/user/assistant role markers) enabling drop-in compatibility with existing chat inference frameworks. Fine-tuned models show measurable improvement in instruction adherence and conversational coherence compared to base models (e.g., Chat-v0.4 achieves 52.30 commonsense score vs 51.28 for base 1.5T model).

Supports multiple quantization backends (llama.cpp with GGUF format, vLLM with AWQ/GPTQ, bitsandbytes 4-bit/8-bit) enabling inference on consumer GPUs and CPUs with 4-8x memory reduction. Achieves 71.8 tokens/sec on Mac M2 with 4-bit quantization (batch size 1) and 7,094.5 tokens/sec on A40 GPU with batch size 100 in vLLM, demonstrating practical inference speeds across hardware tiers. Quantization applied post-training without retraining, enabling rapid deployment across diverse hardware without custom optimization per device.

Implements speculative decoding (draft model + verification) where TinyLlama acts as a fast draft model to generate candidate tokens, verified against a larger model (e.g., Llama 2 7B) to maintain output quality while reducing wall-clock latency. Leverages TinyLlama's fast inference speed (7k+ tokens/sec on A40) to generate multiple candidate tokens per step, with verification rejecting invalid candidates and accepting valid ones, reducing effective latency by 30-50% for batch inference workloads compared to direct large model inference.

Implements Grouped Query Attention with 32 attention heads organized into 4 query groups (8 heads per group), reducing KV cache memory from O(batch_size × seq_len × num_heads × head_dim) to O(batch_size × seq_len × num_groups × head_dim). This architectural choice reduces KV cache size by 8x compared to full multi-head attention while maintaining comparable model quality, enabling larger batch sizes and longer sequences on memory-constrained hardware. GQA is applied uniformly across all 22 transformer layers, making it integral to TinyLlama's efficiency profile.

Uses identical tokenizer to Llama 2 (32k token vocabulary, BPE-based) enabling seamless token-level compatibility with existing Llama ecosystem tools, datasets, and inference frameworks. Tokenizer applied consistently across all training stages (pretraining, fine-tuning, inference) and across all checkpoint variants, ensuring reproducible token sequences and enabling direct comparison with Llama 2 benchmarks. Vocabulary alignment means TinyLlama can process Llama 2 datasets without re-tokenization and vice versa, reducing integration friction.

Provides published performance metrics (commonsense reasoning scores via MMLU-style benchmarks) for all 7 base model checkpoints (105B, 503B, 1T, 1.5T, 2T, 2.5T, 3T tokens) and 3 chat variants, enabling empirical analysis of scaling laws and checkpoint selection without manual evaluation. Metrics tracked consistently across checkpoints using identical evaluation methodology, allowing direct comparison of model capability progression. Evaluation infrastructure (EVAL.md documentation) enables users to reproduce benchmarks on custom datasets or evaluate fine-tuned variants using same methodology.

Implements data preparation workflow combining SlimPajama (natural language, excluding GitHub) and Starcoderdata (code) in 7:3 ratio, with tokenization using Llama 2 tokenizer and batching into 2M token sequences (2048 length × 1024 batch size). Pipeline handles data deduplication, filtering, and shuffling to ensure training stability across 3 trillion tokens. Documented in training configuration enabling users to prepare custom datasets following same methodology for domain-specific pretraining or continued training on custom data.

Designs 1.1B parameter model with 2048 embedding dimension and 22 transformer layers to fit within memory constraints of diverse hardware (2GB for 4-bit inference on edge, 4GB for 8-bit, 8GB+ for full precision), while maintaining architectural compatibility with Llama 2 (same tokenizer, attention patterns, layer structure). Architecture scales inference throughput from 71.8 tokens/sec on Mac M2 CPU to 7,094.5 tokens/sec on A40 GPU, enabling deployment decisions based on latency/cost trade-offs rather than model retraining.