gpt2

Generates text one token at a time using a 12-layer transformer decoder with 768 hidden dimensions and 12 attention heads, trained on 40GB of diverse internet text via causal language modeling. The model predicts the next token's probability distribution across a 50,257-token vocabulary by processing input sequences through self-attention mechanisms that learn contextual relationships. Inference can run on CPU, GPU (CUDA/ROCm), or TPU with automatic mixed precision support.

Provides pre-trained weights in 8+ serialization formats (PyTorch .pt, TensorFlow SavedModel, JAX, ONNX, TFLite, Rust, SafeTensors) enabling deployment across heterogeneous infrastructure without retraining. The model uses HuggingFace's unified Hub API to auto-detect framework and load weights, with automatic dtype conversion (fp32→fp16→int8 quantization) and device placement (CPU/GPU/TPU). SafeTensors format provides faster loading and security scanning for untrusted model sources.

Encodes raw text into token IDs using Byte-Pair Encoding (BPE) with a 50,257-token vocabulary learned from training data, handling subword segmentation, special tokens, and Unicode normalization. The tokenizer uses a merge table built during training to greedily combine frequent byte pairs, enabling efficient representation of out-of-vocabulary words via subword composition. Includes special tokens for padding, end-of-sequence, and unknown characters, with configurable max_length for sequence truncation.

Enables task-specific adaptation by continuing training on custom text corpora using the same causal language modeling loss (predicting next token given previous tokens). Fine-tuning updates all 12 transformer layers via backpropagation, with configurable learning rates, batch sizes, and gradient accumulation for memory-constrained setups. Supports LoRA (Low-Rank Adaptation) for parameter-efficient fine-tuning, reducing trainable parameters from 124M to ~1M while maintaining 90%+ performance.

Provides multiple decoding algorithms (greedy, beam search, nucleus sampling, top-k sampling) to control text generation diversity and coherence through temperature, top_p, top_k, and repetition_penalty parameters. Greedy decoding selects highest-probability token (deterministic, fast). Beam search explores multiple hypotheses in parallel (slower, higher quality). Nucleus sampling (top-p) filters tokens to cumulative probability threshold (diverse, controllable). Repetition penalty reduces likelihood of repeated n-grams, preventing degenerate loops.

Processes multiple sequences of varying lengths in a single forward pass using dynamic padding and attention masks, avoiding redundant computation on padding tokens. The model pads shorter sequences to the longest sequence in the batch, creates binary attention masks (1 for real tokens, 0 for padding), and uses these masks in self-attention to prevent attending to padding. This reduces per-sample latency by 30-50% vs sequential inference while maintaining identical outputs.

Reduces model size and inference latency by converting weights from fp32 (4 bytes per parameter) to fp16 (2 bytes, ~2x speedup) or int8 (1 byte, ~4x speedup) using post-training quantization or quantization-aware training. Int8 quantization uses symmetric or asymmetric scaling to map floating-point ranges to 8-bit integers, with optional per-channel quantization for better accuracy. Quantized models fit in 500MB (int8) vs 500MB (fp32), enabling mobile and edge deployment.

Enables task adaptation through in-context learning by prepending task examples and instructions to the input prompt, allowing the model to infer task intent without fine-tuning. The model learns from examples in the prompt context (few-shot learning) or follows natural language instructions (zero-shot), with performance scaling with number of examples (1-shot, 3-shot, 5-shot). Prompt structure, example ordering, and instruction clarity significantly impact output quality — no learned parameters change, only input context.

Measures model quality through perplexity (cross-entropy loss on held-out text) and task-specific metrics (accuracy, F1, BLEU, ROUGE) on benchmarks like GLUE, SuperGLUE, and WikiText. Perplexity quantifies how well the model predicts next tokens (lower is better); task-specific metrics evaluate downstream performance after fine-tuning or few-shot prompting. Evaluation uses standard datasets and metrics from HuggingFace Datasets library, enabling reproducible comparisons across models.

Trains a smaller student model to mimic GPT-2's behavior by matching its output distributions (soft targets) rather than hard labels, using a combination of distillation loss (KL divergence between student and teacher logits) and task loss. The student learns to replicate teacher predictions without learning the underlying task, enabling 2-10x compression with 5-15% accuracy loss. Temperature parameter controls softness of targets — higher temperature (T=10) creates softer targets for easier learning.