AI Engineering
Quick Reference

A non-linear function applied to a neuron's output (ReLU, GELU, SiLU, tanh). Without non-linear activations, a deep network collapses to a single linear transformation regardless of depth. Practical: Modern transformers use GELU or SiLU (also called Swish). If you see "SiLU" in a config, that's the same thing as "Swish". Encounter these when reading model configs on HuggingFace.

A small trainable module inserted into a frozen pre-trained model, allowing task-specific fine-tuning without updating the original weights. See also: LoRA, PEFT. Practical: Adapters are how most "fine-tuning" is actually done in production — full fine-tuning of a 70B model needs 16× H100s; an adapter fits on one.

The default optimizer for training transformers. Adam = adaptive moment estimation; AdamW decouples weight decay, which the original Adam got wrong for L2 regularization. Practical: If you see training code that doesn't specify an optimizer, it's almost always torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=0.01). The learning rate 1e-4 is the "1e-4 rule" for fine-tuning LLMs.

AGI stands for Artificial General Intelligence, which means an AI system with general, human-level (or beyond) ability to learn, reason, and apply knowledge across a wide range of tasks and domains. Practical: You'll hear "AGI" in two contexts: (1) serious research papers comparing model performance to human baselines; (2) marketing. Know which is which. The technical community has largely moved on to more specific terms like "expert-level AI" or "human-competitive AI" because "AGI" is too vague to measure.

Agentic AI refers to AI systems designed to act as autonomous or semi-autonomous agents: they can set or interpret goals, plan and sequence actions, use tools (like web browsers, code, or APIs), make decisions based on feedback, and adapt over time to complete tasks. Practical: "Agent" in 2025–2026 almost always means an LLM in a while-loop: it generates a plan, calls a tool, observes the result, repeats. The simplest pattern: ReAct (Reason + Act). More complex: planner-executor, multi-agent debate, tree-of-thought. Read the LangChain or LlamaIndex agent docs to see current patterns.

AI Alignment means making sure an AI system's goals and behavior match what people actually want—our values, rules, and intentions. Practical: On a co-op you'll see alignment in three forms: (1) RLHF — training on human preference data; (2) constitutional AI — using a rubric to grade outputs; (3) red-teaming — humans trying to break the model. The first thing every new model card has is an alignment/safety section.

AI Benchmarks are standardized tests used to measure and compare how well AI systems perform on specific tasks, like answering questions, recognizing images, writing code, or following instructions. Practical: Common ones: MMLU (general knowledge, multiple choice), HumanEval (Python coding), GSM8K (math word problems), HellaSwag (commonsense), TruthfulQA (avoiding lies), MATH (competition math), BIG-Bench (200+ tasks), SWE-bench (real GitHub issues), Chatbot Arena (human pairwise ELO). Don't trust a single number — always look at the task distribution.

AI fluency is the capacity to collaborate productively and responsibly with AI systems through understanding their capabilities, limitations, and implications. This encompasses the practical skills to leverage AI tools effectively, the critical thinking to evaluate their outputs, the ethical awareness to use them responsibly, and the adaptability to evolve alongside rapidly changing AI technologies. Practical: On the job, this is more important than any specific technical skill. Know: when an LLM is the right tool, when it's not, and how to verify its output. The biggest "AI mistake" interns make is trusting the output without checking.

AI Safety is the field focused on ensuring AI systems behave reliably and don't cause harm, even when they're powerful, widely deployed, or operating in unexpected situations. Practical: In a corporate co-op, "safety" usually means: jailbreak resistance, PII redaction, refusal behavior on harmful requests, output filtering. Read the model card for whatever model you use — the safety section is part of the contract.

AI workflow is the end-to-end process of building, deploying, and maintaining an AI system, from collecting data to making predictions. It includes stages like data preparation, model training, testing, and deployment, with each step building on the previous one to create a functioning AI application. Practical: The actual pipeline in a real company: data collection → labeling → training/finetuning → eval → deployment → monitoring → drift detection → retraining. The model is maybe 20% of the effort. The data and the monitoring are 80%.

An Algorithm is a set of step-by-step instructions for solving a problem or completing a task, similar to a recipe. Practical: In ML, "algorithm" usually means the learning algorithm (SGD, Adam) or the inference algorithm (greedy decoding, beam search). Almost everything else is just data plumbing.

AI safety company that makes the Claude model family. Their constitutional AI approach is a major contribution to alignment. The Anthropic API is OpenAI-compatible in spirit but with different parameter names (e.g. max_tokens vs max_tokens — same — but messages schema differs slightly). Practical: The Anthropic cookbook (https://docs.anthropic.com/en/docs/cookbook) is one of the best free resources for prompt engineering examples.

Artificial Intelligence (AI) is a term coined in 1955 by John McCarthy, Stanford's first faculty member in AI, who described it as "the science and engineering of making intelligent machines." Practical: When someone says "AI" in 2026, they almost always mean one of: (1) an LLM, (2) a generative model of any kind, (3) a classifier. The broader definition (anything that mimics human cognition) is still academically correct but rarely what people mean in a meeting.

An Attention Mechanism is a method in neural networks that helps a model focus on the most relevant parts of the input when producing an output. Practical: Attention is the only concept you absolutely must understand. The math: for a query Q and a set of key-value pairs (K, V), output is softmax(QKᵀ / √d) · V. Why it works: every output token can pull information from every input token in O(1) sequential steps. Pre-attention (RNNs) needed O(n) sequential steps, which is why long contexts were hard. See Transformer for the full architecture.

A loose category for neural models that ingest or produce audio (speech, music, environmental sound) as their primary modality. Three sub-flavors a co-op will meet: (1) Automatic Speech Recognition (ASR) / Speech-to-Text (STT) — audio in, text out (Whisper, Parakeet, Canary, Distil-Whisper); (2) Text-to-Speech (TTS) — text in, audio out (Kokoro, F5-TTS, CosyVoice 2, XTTS-v2, Tortoise TTS, ElevenLabs, OpenAI TTS); (3) Audio understanding — audio in, text out, more general (audio-language models like Qwen2-Audio, SALMONN). Music-specific models (MusicGen, AudioLDM, Suno, Udio) are a related but separate category. See also: Whisper (the canonical STT), Kokoro (the canonical local TTS), Multimodal AI. Practical: The 2024–2026 shift: small open audio models got good enough for production. Whisper-large-v3 matches cloud STT APIs on English. Kokoro-82M runs on a Raspberry Pi. The 80/20 on a co-op: use Whisper for STT (local, no API), Kokoro for TTS (local, no API), and only call OpenAI/Google/Amazon cloud audio when you need a feature the open models don't have (e.g. real-time streaming TTS with voice cloning, or 100+ languages). The fully-local voice agent pattern (Whisper + LLM + Kokoro, all running locally) is now a 2-day co-op project, not a 2-month one. Watch out for: streaming (Whisper doesn't stream by default; use faster-whisper for that), word-level timestamps (needed for subtitles and karaoke — use whisperx or insanely-fast-whisper), and hallucination (Whisper on silent audio will sometimes output "Thanks for watching!" — always pass no_speech_threshold=0.6 to suppress).

Automation is when technology such as AI performs specific tasks based on explicit human instructions. The human defines what needs to be done, and the AI executes it according to those predetermined parameters. Practical: "Automation" in industry often means classical RPA (robotic process automation) — scriptable, deterministic. "AI automation" or "agentic automation" is the new term and implies non-determinism. The implications for testing are very different.

Backpropagation is how neural networks learn from mistakes by working backward through the network to figure out which parts caused the error. Practical: In PyTorch you don't write backprop — loss.backward() does it. Under the hood: it walks the computation graph in reverse, applying the chain rule, and stores gradients on each parameter's .grad attribute. The optimizer then steps parameters in the opposite direction of the gradient. If you ever debug a training run, you will live in loss.backward() and optimizer.step().

The number of training examples processed together before the model updates its weights. See also: Mini-Batch, Epoch, Gradient Descent. Practical: Choose based on GPU memory. Common: 8, 16, 32, 64, 128. Larger = more stable gradients + faster wall-clock but more memory. The effective batch size is batch_size × grad_accum_steps × num_gpus — match this across runs for fair comparison.

Bayesian Networks are graphical models that represent cause-and-effect relationships between variables using probabilities, like a map showing how different factors influence each other. Practical: Mostly historical in the deep-learning era, but you will see them in: medical diagnosis, risk modeling, and any domain where interpretability and uncertainty quantification matter more than raw accuracy.

A decoding strategy for sequence generation that keeps the top-k most probable partial sequences at each step, instead of just the single most probable (greedy). Used in translation and summarization; less common for chat LLMs. Practical: For LLM APIs you almost never set beam search — you use sampling (temperature, top_p). Beam search is for tasks where you want the single best output, not creative variation.

Bias in AI occurs when a system produces results that favor or discriminate against certain groups of people. Practical: Three flavors: (1) dataset bias — training data under-represents a group; (2) algorithmic bias — model amplifies patterns; (3) evaluation bias — benchmarks don't measure the right thing. Mitigation: balanced data, fairness metrics (demographic parity, equalized odds), human review of edge cases.

Big Data is extremely large datasets, too large to be analyzed by traditional data-processing software, that can be analyzed using AI to reveal patterns and trends. Practical: In 2026, "big data" usually means datasets that don't fit on a single machine's RAM, or training corpora in the trillions of tokens. Tools: Spark (distributed dataframes), Ray (distributed compute), Dask (pandas at scale), Polars (faster pandas).

BLEU (Bilingual Evaluation Understudy) and ROUGE (Recall-Oriented Understudy for Gisting Evaluation) are n-gram overlap metrics. BLEU for machine translation, ROUGE for summarization. Both are known to be weak — they reward copying and don't understand meaning. Practical: If your manager quotes a BLEU/ROUGE number approvingly, gently suggest LLM-as-judge or human eval instead. Modern eval is moving to GPT-4-as-judge, where a strong LLM grades outputs on a rubric.

The simplest form of Imitation Learning: treat robot control as a supervised learning problem. Given (observation, expert-action) pairs from human teleoperation, train a policy π(a | o) to predict the expert's action from the observation. The "behavior cloning = supervised learning on robot data" idea. Practical: The baseline against which everything else is measured. Works surprisingly well when (1) you have lots of data (DROID has 76k trajectories), (2) the test distribution matches the train distribution, (3) the policy is expressive enough (a 7B VLA, not a 3-layer MLP). The famous failure mode: covariate shift — small errors compound because the policy encounters states the expert never visited. Fixes: DAgger (ask expert to label the policy's own states), or just collect more diverse data. See also: Imitation Learning, Diffusion Policy, VLA.

A subword tokenization algorithm. Iteratively merges the most frequent adjacent pair of bytes/characters in a corpus. Used by GPT-2, GPT-3, GPT-4, RoBERTa, and most modern LLMs. Practical: The reason "tokenization" looks weird: "Tokenization" might tokenize as ["Token", "ization"] (3 tokens) or ["Token", "iz", "ation"] depending on the tokenizer. Same word, different model, different token count → different cost. Always check token count with the model's tokenizer before committing to a prompt pattern.

When a model fine-tuned on a new task loses performance on tasks it previously did well. The new gradient updates overwrite weights that encoded the old knowledge. Practical: Why fine-tuning is risky and you should evaluate on the original benchmark after every fine-tune. Mitigations: lower learning rate, mix in old data (replay), LoRA (only a small fraction of weights change), or RLHF instead of SFT.

A Chatbot is a computer program designed to simulate conversation with humans, typically through text or voice interactions. Practical: "Chatbot" in 2026 is essentially a synonym for "LLM with a chat UI." The interesting part is no longer the chat — it's what the chat can do (tools, memory, code execution). Modern chatbots = LLMs + system prompts + tool use + retrieval.

A prompting technique where you ask the model to "think step by step" before giving the final answer. Often dramatically improves reasoning on math, logic, and multi-step tasks. Practical: Variants: Zero-shot CoT (just append "Let's think step by step"); Few-shot CoT (include examples of step-by-step reasoning); Self-consistency (sample N reasoning paths, take the majority answer); Tree of Thought (branch and backtrack). Models trained specifically for reasoning (o1, o3, DeepSeek-R1) internalize this — you don't need to prompt for it.

Also called proprietary software, Closed Source refers to software whose underlying code is restricted and not available for the public to view, modify, or use. Practical: For models, "closed" means: weights not released, only accessible via API. GPT-4, Claude 3.5/3.7/4, Gemini 1.5/2.0 are closed. The opposite: open-weight (Llama, Mistral, Qwen, DeepSeek). Closed-weight models usually lead on benchmarks; open-weight models are catching up and are essential when you can't send data to a third party (healthcare, finance, government).

Computer Vision is a field of AI that enables computers to see, identify, and understand visual information from images and videos, similar to how humans see and process this information. Practical: The classic CV stack: image → CNN backbone (ResNet, ConvNeXt) → task head (classification, detection, segmentation). In 2024–2026 most new CV is done by Vision Transformers or VLMs (vision-language models) instead of pure CNNs. The shift happened because transformers scale better and unify vision with text.

The practice of designing everything that goes into an LLM's context window — not just the user prompt, but system prompt, retrieved documents, tool outputs, conversation history, examples, and structure — to maximize the quality of the model's output. The term was coined/popularized in 2025 as a superset of "prompt engineering" that acknowledges the context is the entire input, not just the question. Practical: The 2025–2026 way to think about LLM apps. Instead of "how do I write a clever prompt," ask "what does the model need to see to answer well?" Components to engineer: system prompt (role, constraints, format), few-shot examples, retrieved documents (RAG), tool definitions, conversation memory, structured output schemas. See also: Prompt, Prompt Engineering, RAG, Function Calling.

Context Window is the amount of input (like text) that an AI system can process at one time during a task. Practical: Measured in tokens (not words or characters). Modern sizes: GPT-4 Turbo 128k, Claude 3.5/3.7/4 200k, Gemini 2.0 2M. Costs scale linearly with context length (in API pricing), and attention quality can degrade past the "effective" window — empirically, models perform worse on information buried in the middle of a very long prompt than on info at the start or end ("lost in the middle" effect). Don't assume "fits in context" = "model uses it well."

Contrastive Learning is a machine learning technique where the model learns by comparing similar and dissimilar examples to understand what makes things alike or different. Practical: The training method behind most modern embeddings (CLIP for images+text, sentence-transformers for text). Pull similar pairs together, push dissimilar pairs apart in vector space. The output: an embedding model. Used everywhere in semantic search, RAG, recommendation, deduplication.

A measure of similarity between two vectors: cos(θ) = (A · B) / (||A|| · ||B||). Range: -1 (opposite) to 1 (identical). 0 means orthogonal (unrelated). Practical: The default similarity metric for embedding search. If you remember nothing else about vector search: nearest neighbors in a vector DB are usually retrieved by cosine similarity over normalized embeddings. Other choices: dot product (faster, equivalent for normalized vectors), Euclidean distance (L2).

NVIDIA's parallel computing platform and API. Lets you run general-purpose code on the GPU. PyTorch and TensorFlow hide most of it, but torch.cuda.is_available(), model.to('cuda'), and .cuda() are everywhere in deep learning code. Practical: If torch.cuda.is_available() returns False, check: (1) NVIDIA driver installed (nvidia-smi); (2) CUDA toolkit matches PyTorch's expected version; (3) on a machine with no GPU, use device = 'cpu' or run on Colab / Lambda Labs. For Apple Silicon Macs, PyTorch has MPS backend: device = 'mps'.

Data Augmentation is a technique to artificially expand a training dataset by creating modified versions of existing data without collecting anything new. Practical: For images: random crop, flip, color jitter, MixUp, CutMix. For text: back-translation, paraphrase via LLM, synonym replacement. For tabular: SMOTE. Why it matters: in low-data regimes (which is most real projects), augmentation is the single biggest lever for model quality after data quality.

Data Mining is the process of discovering patterns and trends in large datasets using statistical methods and machine learning. Practical: Largely a synonym for "applied ML on tabular data." The classic toolkit: pandas, scikit-learn, XGBoost, LightGBM. Even in the LLM era, ~80% of enterprise data is tabular, and gradient-boosted trees still beat deep learning on structured data.

A structured collection of (input, target) pairs for supervised learning. The interface: len(ds) and ds[i] returns one example. In PyTorch: torch.utils.data.Dataset. In HuggingFace: datasets.Dataset. Practical: Three splits, always. Train (fit the model), Validation (tune hyperparameters, early stopping), Test (final, one-time evaluation — never use for tuning). If you don't respect the test split, your reported number is lying.

A Decision Tree is a machine learning algorithm that makes predictions by asking yes/no questions, splitting data at each step based on different features until reaching a final conclusion. Practical: Rarely used alone in 2026 — almost always as the building block of a gradient-boosted ensemble (XGBoost, LightGBM, CatBoost). These still win most Kaggle tabular competitions and most production fraud/credit/risk models.

Deep Learning is a subset of machine learning that uses large multi-layer neural networks to automatically learn complex patterns from data. Practical: The field has narrowed to "transformer for everything" since 2020. CNNs (vision) and RNNs (sequences) still exist but transformer variants have absorbed most use cases. The one place transformers haven't won: tiny on-device models and tabular data.

Diffusion Models are a type of generative model that creates new content like images by adding and then subtracting "noise." Practical: The architecture behind Stable Diffusion, Midjourney, DALL-E 3, Imagen, FLUX. Training: add noise step-by-step to real images, teach a network to predict the noise (the "denoiser"). Sampling: start from pure noise, denoise iteratively. Why it matters: diffusion produces the highest-quality images in 2026 and is being extended to video (Sora, Veo), audio, and 3D.

A robot learning method (Chi et al., 2023, Stanford) that represents the policy as a conditional diffusion model: given the current observation, denoise a future action sequence from random noise, just like Stable Diffusion denoises an image. Currently the strongest non-VLA approach for learning from demonstration. Practical: Why it works for robots: action sequences are smooth, multi-modal (a given observation may have several valid continuations — pick up with left or right hand?), and have temporal correlations — all things diffusion models are great at. Training: same as image diffusion, but the conditioning is a robot observation (image + proprioception) and the "image" being denoised is a chunk of future actions (e.g. next 16 timesteps). Inference: 4–10 denoising steps at 10–50 Hz. Open-source reference impl: https://diffusion-policy.cs.columbia.edu. The 2024–2025 evolution: replacing the U-Net with a transformer DDPM, and replacing the diffusion with flow matching (simpler training, same quality — this is what π0 uses for its action head). See also: Behavior Cloning, VLA, Diffusion Models.

Dimensionality Reduction is a technique for simplifying complex data by reducing the number of variables while preserving the most important information. Practical: Methods: PCA (linear, classical), t-SNE (non-linear, for 2D viz), UMAP (non-linear, faster, preserves more global structure than t-SNE — preferred in 2026). Use case: visualize high-dim embeddings, compress features, speed up downstream models. Be careful: t-SNE/UMAP visualizations are suggestive — distances in the 2D plot do not faithfully represent distances in the original space.

Running ML models on the device that collects the data, not in a remote data center. The opposite of cloud AI. The 2024–2026 inflection: small open models + Quantization + llama.cpp + Apple Silicon / Jetson / ESP32 made it economical to run a useful LLM, VLM, or TTS model locally, with sub-second latency and zero cloud dependency. The spectrum: (1) Server-grade edge: NVIDIA Jetson Orin, Apple Silicon Macs (unified memory enables 70B models in 4-bit on M3 Max), (2) Consumer edge: laptops, phones, Raspberry Pi 5, Steam Deck, in-car computers, (3) Microcontroller edge: ESP32-S3, RP2040, Arduino Portenta — only fits models in the <2M parameter range (KWS keyword spotters, simple anomaly detectors, sensor fusion). See also: Quantization, llama.cpp, Small Specialist Models, Moondream, Kokoro. Practical: The 2026 decision tree for a co-op: 1. Latency budget < 50ms? Must run on-device. Cloud round-trips are 30–200ms. 2. Privacy / regulatory? Healthcare (HIPAA), legal, EU (GDPR), defense, finance — must run on-device. 3. No reliable network? Drones, ships, remote sensors, in-flight systems — must run on-device. 4. Volume × cost > cloud bill? At >1M inferences/day, the per-query cost of a cloud API can exceed the one-time cost of a Jetson + small model in <3 months. Run on-device. 5. None of the above? Use the cloud API. Don't over-engineer. The 2026 typical local stack: Ollama for development, llama.cpp for production, whisper.cpp for STT, kokoro-onnx for TTS, ONNX Runtime Mobile for VLMs on phones. On Apple Silicon, the mlx framework (Apple's own) is increasingly competitive with llama.cpp for Mac-only deployments. On NVIDIA Jetson, TensorRT is the production runtime. On ESP32, TFLite Micro and ESP-DL are the only realistic options and you stay in the sub-2M parameter regime.

See Embeddings below.

Embeddings are numerical representations that convert complex data (like words, images, or other objects) into vectors of numbers that capture their meaning or characteristics. Practical: The workhorse of modern AI. A list of 384, 768, 1024, 1536, or 3072 floats per item. Models: text-embedding-3-small (OpenAI, 1536d), voyage-3 (1024d), BGE-large, E5-large, sentence-transformers/all-MiniLM-L6-v2 (384d, free, local). For code: voyage-code-3. Use the same model to embed queries and documents. Store in a vector DB. Search by cosine similarity.

Two halves of a sequence-to-sequence model. Encoder reads the input and produces a representation. Decoder generates the output from that representation. Practical: Original Transformer (2017) was encoder-decoder (good for translation). GPT is decoder-only (good for generation). BERT was encoder-only (good for understanding). Modern LLMs are decoder-only transformers. If you see "encoder-only" or "encoder-decoder" in 2026, think BERT/T5/FLAN-T5 — still excellent for classification and structured tasks.

Ensemble Methods are machine learning techniques that combine multiple models (often called "weak learners") to produce a single, more accurate and robust prediction than any individual model could achieve alone. Practical: Two flavors: (1) bagging — train many models on random subsets in parallel and average (Random Forest); (2) boosting — train models sequentially, each correcting the last (XGBoost, LightGBM, AdaBoost). Boosting is strictly better for tabular data in 2026. Modern twist: "LLM ensemble" = run the same prompt through N different models and majority-vote.

One full pass through the training dataset. If you have 10,000 examples and batch size 32, one epoch = ~312 steps. Practical: Typical fine-tuning: 3–10 epochs. Watch the validation loss per epoch — if it stops going down, you're overfitting. Most HuggingFace Trainer callbacks (early stopping, save best) trigger at epoch boundaries.

Ethical AI is the design, development, and deployment of artificial intelligence systems that align with human values, fairness, transparency, and societal well-being. Practical: On a co-op you will most often encounter this as: (1) a model card you have to write; (2) a review board for a new use case; (3) a feature flag for a safety filter. Read your company's AI policy on day 1.

Expert Systems are AI programs designed to mimic the decision-making abilities of human experts in specific domains by using a knowledge base of facts and a set of logical rules to draw conclusions, mainly using if-then rules. Practical: Mostly historical (1970s–90s) but the pattern survives: any rule-based system in industry (tax calculation, eligibility check, compliance) is a modern expert system. The new name is "decision engine" or "rules engine."

The business end of a robot arm — the part that actually interacts with the world. For a humanoid arm, it's the gripper (or dexterous hand); for a welding arm, it's the welding tip; for a drone, you might call the camera mount the end-effector. The robot's "fingers." Practical: In VLA code, the action space is usually defined over the end-effector pose (6D: x, y, z, roll, pitch, yaw) plus a gripper open/close signal — not raw joint angles. This is called end-effector control and is dramatically easier to learn than joint control because (1) the action space is smaller and more semantically meaningful, (2) you can use the same action representation across different robot embodiments. Inverse kinematics (IK) then converts end-effector targets to joint angles. Frameworks: PyTorch3D, CuRobo (NVIDIA), Drake (MIT). On a co-op you'll be told which one your team uses and not think about it again. See also: Proprioception, VLA.

Embodiment = the specific physical form of a robot (number of arms, types of joints, camera positions, gripper geometry, joint torque limits). Embodiment gap = the distribution shift that happens when a policy trained on one robot's body is deployed on a different robot's body. Practical: The #1 open problem in 2026 VLA research. A VLA trained on 100k trajectories from a Franka Panda 7-DoF arm in a lab will mostly fail on a UR5e with a different gripper in a different room, even for the same task. The mitigations being tried: (1) train on many embodiments (Open X-Embodiment dataset has 60+ embodiments); (2) use end-effector control instead of joint control to abstract away the body; (3) cross-embodiment pretraining with embodiment-specific adapters. For a co-op at a robotics company: when a policy "doesn't work" on a new robot, the embodiment gap is the first thing to check. See also: End-Effector, VLA, Transfer Learning.

Explainable AI (XAI) are methods and techniques that make AI systems' decisions and predictions understandable and interpretable to humans, rather than operating as opaque "black boxes." Practical: For trees: feature importance, SHAP. For neural nets: saliency maps, attention visualization, integrated gradients. For LLMs: chain-of-thought, retrieved-document citation, structured output that exposes reasoning. If your model is in healthcare, finance, or hiring, XAI is usually a regulatory requirement, not a nice-to-have.

See Few-Shot Learning.

Federated Learning is a machine learning approach where a model is trained across multiple decentralized devices or servers that hold local data, without the data ever leaving its original location. Practical: The tech behind "your iPhone learns your typing without sending keystrokes to Apple." Practical on a co-op: rare, but you'll see it in healthcare and mobile. Frameworks: Flower, TensorFlow Federated.

Few-Shot Learning is a machine learning approach where models can learn to recognize or perform new tasks with only a small number of training examples. Practical: In the LLM era, "few-shot" almost always means "few-shot prompting" — include 2–5 example input/output pairs in the prompt. Strong LLMs are surprisingly good few-shot learners, often matching fine-tuning for narrow tasks.

Fine-Tuning is the process of taking a pre-trained model and further training it on task or domain specific data. Practical: Three flavors. (1) Full fine-tuning — update all weights, expensive, needs lots of data. (2) LoRA / QLoRA — train a tiny low-rank adapter, cheap, default choice. (3) Continued pretraining — train on unlabeled domain text to teach the model a domain (medical, legal, code). After fine-tuning, evaluate on the original benchmark — catastrophic forgetting is real.

Foundation Models are large-scale AI models, often transformers, trained on vast amounts of broad, diverse data that can be adapted to perform a wide variety of downstream tasks, serving as a "foundation" for many different applications. Practical: The Stanford-coined term for what the rest of us call "a large pre-trained model." Examples: GPT-4, Claude 3.5/4, Gemini 1.5/2, Llama 3, Mistral, DeepSeek-V3. The "foundation" framing matters because the same model gets adapted many ways (chat, code, vision, voice) without retraining from scratch.

Numerical precisions used to make models smaller and faster. FP32 (32-bit float, default), FP16 (16-bit float, half memory, can overflow), BF16 (16-bit "brain float," wider exponent, no overflow — preferred for training in 2026), INT8 (8-bit integer, for inference), INT4 (4-bit, for serving, quality loss possible). Together called "quantization." Practical: When serving a model you almost always quantize. bitsandbytes, GPTQ, AWQ, and llama.cpp's Q4_K_M are the common paths. In inference APIs you don't worry about this — the provider does.

A pattern where the LLM is given a JSON schema describing external functions; the model can respond with structured arguments to call them, the system executes the call, and feeds the result back. See also: Agentic AI. Practical: This is the single most important production pattern. You define tools (get_weather(city), search_docs(query), query_database(sql)); the LLM decides when to call them and with what arguments; your code executes. OpenAI, Anthropic, and Google all have near-identical APIs. Always set tool_choice="auto" (default) unless you want to force a call. Always validate the model's arguments before executing — models do hallucinate tool inputs.

``python # OpenAI-style tool use tools = [{ "type": "function", "function": { "name": "get_weather", "description": "Get current weather for a city", "parameters": { "type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"], }, }, }] response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": "What's the weather in Boston?"}], tools=tools, ) ``

Generative AI (or GenAI) refers to AI systems that can create new content like text, images, music, code, or video. Practical: Three families by architecture: autoregressive transformers (text — GPT, Claude, Gemini, Llama), diffusion (images, video — Stable Diffusion, Sora, Midjourney), GANs (largely superseded by diffusion for images, but still used in some research). All generate token-by-token (text) or denoising-step-by-step (images).

GANs (Generative Adversarial Networks) are a type of AI architecture consisting of two neural networks - a "generator" and a "discriminator" - that compete against each other in a process to create realistic synthetic data. Practical: Once dominant for image generation (StyleGAN, BigGAN, CycleGAN). Largely superseded by diffusion models for high-quality image generation in 2023–2026. Still relevant in: data augmentation for limited data, some 3D generation, and as a research concept.

Generative Pre-Trained Transformer (GPT) is a family of large language models developed that uses the transformer architecture to generate human-like text based on input prompts. Practical: "GPT" is now used in two senses: (1) OpenAI's specific product line (GPT-3, GPT-3.5, GPT-4, GPT-4o, GPT-5); (2) any decoder-only transformer trained with next-token prediction. When a paper says "we trained a 7B GPT," they mean the second.

GPU (Graphics Processing Unit) is a specialized electronic chip originally designed to rapidly render graphics and images by performing many mathematical calculations simultaneously in parallel. Practical: The two relevant numbers: VRAM (how big a model fits — 8GB for 7B, 16GB for 13B, 24GB for 70B in FP16) and compute (TFLOPS, how fast). Common consumer: RTX 4090 (24GB). Common data center: H100 (80GB), A100 (40/80GB), B200 (Blackwell, 192GB). Apple Silicon uses unified memory — an M2 Max with 96GB can run a 70B model. Run nvidia-smi to see your GPU.

The optimization algorithm at the heart of neural network training. Update rule: θ ← θ - η · ∇L(θ), where η is the learning rate and ∇L is the gradient of the loss. Practical: Three variants: Batch GD (uses all data per step, stable but slow), Stochastic GD / SGD (one example per step, noisy but fast), Mini-batch GD (the default — 32–512 examples per step, good balance). All modern optimizers (Adam, AdamW, Lion) are variants of gradient descent with smarter step sizes.

The simplest text generation strategy: at each step, pick the single most probable next token. Fast, deterministic, but often produces repetitive or generic text. Practical: Almost never what you want for chat or creative generation. Set temperature > 0 and/or top_p < 1.0 to break out of greedy. Greedy is usually fine for structured outputs (JSON mode, function calling) where you want determinism.

The act of connecting an LLM's output to verifiable external sources — documents, databases, the live web. A "grounded" answer cites its sources; an "ungrounded" answer is whatever the model "thinks" based on training data. Practical: The standard solution to hallucination in production. RAG is the most common grounding pattern. The new pattern: tool-use with web search. A grounded answer can always be checked by a human in seconds; an ungrounded one cannot.

Hallucinations in AI refers to instances where an artificial intelligence system generates information or responses that are incorrect, misleading, or entirely fabricated but presented as factual. Practical: The single most important failure mode. Mitigation hierarchy: (1) grounding (RAG, tool use) so the model has real sources; (2) structured output to force verifiable formats; (3) self-consistency (sample multiple times, check agreement); (4) LLM-as-judge to score outputs; (5) human-in-the-loop for anything that ships. Never fully solved — design systems that tolerate hallucination rather than trying to eliminate it.

The intermediate tensor a model computes as it processes input. In a transformer, each layer produces a hidden state of shape (batch, sequence_length, hidden_dim). The final hidden state is what gets decoded into a prediction. Practical: In fine-tuning and mechanistic interpretability, "the hidden state" is what you're looking at. The output_hidden_states=True flag in HuggingFace gives you every layer's output — essential for probing, steering, and visualization.

Hierarchical Navigable Small World — the graph-based approximate nearest-neighbor (ANN) algorithm used by essentially every modern vector database. Tradeoff: blazing fast queries at the cost of some memory and inexact recall. Practical: When you set up a vector DB, you usually pick an HNSW index with parameters M (graph degree) and ef_construction (build-time search breadth). Higher = better recall, more memory, slower indexing. Default values work for most projects.

The de-facto hub for open models, datasets, and Spaces. huggingface.co/models is the closest thing the AI world has to PyPI. The transformers library by HuggingFace is the most common way to load and fine-tune models in Python. Practical: You'll spend half your time on huggingface.co. The pipeline() function is the easiest way to try any model in 3 lines of code. The Trainer API handles 90% of fine-tuning boilerplate. The datasets library makes data loading painless. Free tip: filter models by license and downloads — a model with 50 downloads from an unknown user is research code, not production.

``python from transformers import pipeline sentiment = pipeline("sentiment-analysis") sentiment("This co-op is going great!") # [{'label': 'POSITIVE', 'score': 0.9998...}] ``

Human-Centered Artificial Intelligence (HAI) is an approach to AI that prioritizes human needs, values, and well-being throughout the development and deployment of AI systems. Practical: A Stanford HAI framing. In practice, it means: design for the user, not the metric. Test with real users. Build in feedback loops. Make the system's failure modes legible to the people affected.

Human-Computer Interaction (HCI) is the process through which people operate and engage with computer systems. Practical: Every LLM product is fundamentally an HCI problem: how do users know what the system can do, how do they correct it, how do they build mental models of its behavior. Read Don Norman's The Design of Everyday Things if you want to think about this seriously.

Human-in-the-Loop refers to AI systems that include human feedback or intervention as part of their operation. Practical: Three patterns. (1) Review before action — model drafts, human approves (most common in high-stakes domains). (2) Feedback after action — model acts, human labels result (RLHF). (3) Active learning — model asks the human only when uncertain (maximizes human time). For a co-op project, "human-in-the-loop" usually means #1 + a UI for approval.

A Hyperparameter is a parameter whose value is set before the learning process of a machine learning model begins. Practical: Not learned from data — you set it. Examples: learning rate, batch size, number of layers, dropout rate. Tuned on the validation set (never the test set). Three ways to tune: (1) hand-tuning, (2) grid search, (3) Bayesian optimization (Optuna, Ray Tune). The 80/20: most projects only need to tune learning rate and a regularization coefficient. Don't waste a week sweeping layers.

The family of robot learning methods that learn a policy by watching an expert (almost always a human teleoperator) — instead of being programmed by hand or learning from reward signals. The most common approach in modern robotics because reward engineering is hard and demonstrations are easy. See also: Behavior Cloning, Diffusion Policy. Practical: Two flavors. (1) Behavior Cloning — supervised learning on (observation, action) pairs. Simple, scales with data, suffers from covariate shift. (2) Inverse RL / GAIL — recover a reward function from demonstrations, then RL against it. More robust, much more complex. In 2026 production, the choice is almost always (1) with enough data — DROID (76k trajectories), Open X-Embodiment (2M+ trajectories across 60+ robot types), BridgeData. The data-collection pipeline: a human wears a VR headset (Apple Vision Pro, Meta Quest 3) or uses a leader arm (the puppeteering arm that the robot mirrors), and the system records (camera, joint state, action) triples at 10–30 Hz. See also: Teleoperation, Behavior Cloning, VLA, Reinforcement Learning.

In artificial intelligence, Inference is when a trained AI model makes predictions or decisions on new data it hasn't seen before. Practical: Two meanings depending on context. (1) ML inference: running a trained model on new inputs — the "deployment" stage, contrasted with training. (2) LLM inference: the act of generating tokens given a prompt. LLM inference is bottlenecked by memory bandwidth (how fast you can load weights), not compute — this is why GPUs with more VRAM but slower TFLOPS can serve LLMs faster. Serving frameworks: vLLM, TGI, llama.cpp, TensorRT-LLM.

Fine-tuning a base model on (instruction, response) pairs so that it follows instructions instead of just continuing text. This is the "SFT" step in ChatGPT-style training. Practical: Datasets: OpenHermes, Alpaca, ShareGPT, FLAN. After instruction tuning, the same model goes from "fancy autocomplete" to "follows commands." This is what makes a base model into a chat model.

Interpretability refers to the degree to which humans can understand how an AI system arrives at its decisions or predictions. Practical: In 2026, interpretability is having a moment. Mechanistic interpretability (Anthropic, Neel Nanda) tries to reverse-engineer what individual neurons/circuits in a transformer compute. If you find this fascinating, read Anthropic's "Mapping the Mind of a Large Language Model" — it's accessible and profound. On a co-op you'll more likely use SHAP (for tabular) or attention visualization (for NLP) and call it a day.

An LLM API feature that constrains the model's output to be valid JSON, optionally matching a schema you provide. See also: Function Calling, Structured Output. Practical: Use this whenever you're piping LLM output into code. response_format={"type": "json_schema", "json_schema": {...}} in OpenAI, tool_use in Anthropic, responseSchema in Gemini. Without this, models can and will return malformed JSON that breaks your parser.

``python # OpenAI structured outputs response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": "Extract: 'Paris is the capital of France.'"}], response_format={ "type": "json_schema", "json_schema": { "name": "fact", "schema": { "type": "object", "properties": { "subject": {"type": "string"}, "predicate": {"type": "string"}, "object": {"type": "string"}, }, "required": ["subject", "predicate", "object"], "additionalProperties": False, }, }, }, ) fact = response.choices[0].message.parsed # Already a dict ``

k-NN is a simple, intuitive machine learning algorithm used for classification and regression. Practical: In tabular ML, k-NN is usually a baseline you beat quickly. In modern AI, k-NN is everywhere as a subroutine — the retrieval step in RAG is k-NN over embeddings. ANN libraries (FAISS, ScaNN, HNSW) are optimized k-NN.

A Knowledge Graph is a structured database that represents information as a network of interconnected entities and their relationships. Practical: Used at Google, Meta, LinkedIn, Bloomberg for entity-aware search and recommendations. Most teams don't build one — they use a service (Neo4j, Amazon Neptune, Google Knowledge Graph API). Pairing a vector DB with a knowledge graph ("hybrid search") is a common 2025–2026 pattern.

In transformer inference, the cached Key and Value tensors from previously generated tokens. Because attention for token N only depends on tokens 1..N, you can cache K/V and avoid recomputing them every step. Practical: The single biggest optimization for LLM serving. Without it, generating 1000 tokens is O(n²); with it, O(n). vLLM, TGI, and llama.cpp all implement continuous batching on top of KV caching. If you ever see "prefix caching" or "prompt caching" as a feature, that's sharing the KV cache across requests with the same prompt prefix.

A small (82M-parameter) open-weight text-to-speech (TTS) model (2025) that produces natural-sounding speech in 100+ voices across multiple languages. Notable for running in real time on CPU while being competitive in quality with much larger commercial TTS systems. Available as a HuggingFace model and through the kokoro-onnx runtime. See also: Whisper (the STT counterpart), Audio Models, TTS. Practical: If your co-op needs local TTS (voice agents, accessibility, content generation, IVR replacement), Kokoro is the 2025–2026 default. The fastest path: pip install kokoro-onnx sounddevice, download the model + voices from HuggingFace, and:

```python from kokoro_onnx import Kokoro import sounddevice as sd

kokoro = Kokoro("kokoro-v0_19.onnx", "voices.bin") samples, sample_rate = kokoro.create("Hello, this is a local TTS test.", voice="af_bella") sd.play(samples, sample_rate); sd.wait() ```

Pairs naturally with Whisper (STT) for fully local voice agents — no cloud round trip, runs on a laptop. License: Apache 2.0. The competition in 2026: F5-TTS, CosyVoice 2, XTTS-v2 (voice cloning), Tortoise TTS (slower, higher quality). Start with Kokoro unless you have a specific reason not to.

The two most popular frameworks for building LLM applications on top of raw APIs. LangChain is more general (chains, agents, RAG, tools). LlamaIndex focuses on data ingestion + RAG. Practical: As of 2025–2026, opinion has shifted: many production teams are moving off LangChain because (a) abstractions leak, (b) dependency churn, (c) raw API calls are often simpler. For a co-op, learn the raw API first, then pick up a framework if you need to ship fast. If you do use one, pin the version and don't import the whole package.

A Large Language Model is an AI system trained on massive amounts of text data to understand and generate human-like language. Practical: "Large" is vague. In 2026 it usually means ≥1B parameters. Sizes you'll see: 1B (Phi-3 mini), 3B (Phi-3 small, Llama 3.2 3B), 7B (Llama 2/3 7B, Mistral 7B), 13B (Llama 2 13B), 70B (Llama 3 70B, Mixtral 8x22B), 405B (Llama 3.1 405B), 1T+ (GPT-4 class). Larger = generally smarter but slower and more expensive. For most co-op work, 7B–70B covers everything.

Latent Space is a compressed, abstract representation where high-dimensional data (like images, text, or audio) is encoded into a lower-dimensional mathematical space that captures the essential features and patterns. Practical: Two reasons you care. (1) Embeddings live here — every embedding is a point in latent space, and "semantically similar" = "geometrically close." (2) Diffusion models denoise in latent space — Stable Diffusion operates on a 4×64×64 latent, not on the 3×512×512 image. Editing in latent space is much faster.

The step size for the optimizer. 1e-4 is the default starting point for fine-tuning LLMs. Too high = loss explodes. Too low = loss never decreases. Practical: Use a learning rate schedule with warmup (linear ramp from 0 to peak over first 1–10% of steps) and decay (cosine or linear to 0 over the rest). HuggingFace Trainer does this for you if you set lr_scheduler_type="cosine" and warmup_ratio=0.03. The 1e-4 rule breaks down at scale — for very large models, use 1e-5 or even 5e-6.

Meta's open-weight LLM family. Llama 2 (2023), Llama 3 (2024), Llama 3.1 (405B!), Llama 3.2 (with vision), Llama 3.3 (70B matching 405B). The most influential open model line. Practical: The default local model. If you ollama pull llama3.2, you get a 3B model. If you have a beefy GPU, ollama pull llama3.3:70b. License: custom but very permissive for commercial use above 700M monthly users.

The reference open-source C/C++ port of Meta's Llama inference code that has become the de facto engine for running any GGUF-format open-weight model on consumer hardware — CPU, Apple Silicon, and modest GPUs. Two entry points matter for a co-op: the CLI (llama-cli, formerly main) for one-off generation, and the server (llama-server, formerly server) for an OpenAI-compatible HTTP API. See also: Ollama (which is a friendlier wrapper around llama.cpp), GGUF, Quantization. Practical: The CLI is for batch jobs, scripted experiments, and quick smoke tests. The five commands you will type: ```bash # Download a GGUF model (HuggingFace CLI, then point llama.cpp at the file) huggingface-cli download TheBloke/Llama-2-7B-Chat-GGUF llama-2-7b-chat.Q4_K_M.gguf

# Run inference from a local GGUF (interactive REPL) llama-cli -m ./llama-2-7b-chat.Q4_K_M.gguf -p "Explain GGUF in one sentence." -n 128

# One-shot prompt with conversation template llama-cli -m model.gguf -p "[INST] Summarize this article: ... [/INST]" -n 256 --temp 0.7

# Benchmark tokens/second (no output, just throughput) llama-bench -m model.gguf -p 512 -n 128

# Quantize a HuggingFace .safetensors model to GGUF (Q4_K_M is the 2026 default) python convert.py /path/to/hf-model --outfile model-f16.gguf ./llama-quantize model-f16.gguf model-q4km.gguf Q4_K_M `` The server is what you actually put in production. It exposes an OpenAI-compatible /v1/chat/completions endpoint, so any client (Python openai SDK, LangChain, your own code) just works by changing base_url. The five flags that matter: ``bash llama-server \ -m ./model-q4km.gguf \ # model file (required) -c 8192 \ # context window in tokens --n-gpu-layers 35 \ # offload N layers to GPU (-1 = all, 0 = CPU only) -t 8 \ # CPU threads for non-GPU layers --host 0.0.0.0 --port 8080 # bind address

# From any OpenAI client, point at it: # base_url = "http://localhost:8080/v1" ``` Why it matters: vLLM is faster on a beefy H100, but llama.cpp is the only realistic option on (a) laptops, (b) Apple Silicon, (c) Raspberry Pi / Jetson, (d) anything without a top-tier NVIDIA GPU. For embedded AI on ESP32 / microcontroller-adjacent, llama.cpp is often what people mean when they say "edge inference." See also: Ollama, GGUF, Quantization, vLLM, Whisper (the same project also ports Whisper).

HuggingFace's open-source robotics library — the robotics analog of the transformers library. Pretrained policies (Diffusion Policy, ACT, OpenVLA wrappers), standardized dataset loaders (LeRobotDataset, aloha, pusht), simulation environments (Aloha sim, Isaac Sim integration), and training scripts. See also: VLA, Diffusion Policy, Behavior Cloning. Practical: If your co-op is at a robotics company, this is almost certainly already imported. from lerobot.common.policies.diffusion import DiffusionConfig and you have a state-of-the-art policy. The dataset format (Parquet + video) is the de facto interchange format for robot trajectories. The community: https://huggingface.co/lerobot. Goal: replicate the HuggingFace model hub experience for robots. See also: OpenVLA, Teleoperation, Imitation Learning.

Large Language Model Operations (LLMOps) is the practice of managing the entire lifecycle of LLM-based applications in production environments. Practical: Subset of MLOps specific to LLM apps. The new things vs. classic MLOps: prompt versioning (not just model versioning), eval pipelines (not just accuracy on a test set), retrieval monitoring (RAG quality drifts as the source docs change), cost tracking (per-token spend per feature), and rate-limit handling (LLM APIs throttle aggressively).

LoRA = Low-Rank Adaptation. Freezes the original model weights and trains a tiny pair of low-rank matrices that get added in. Reduces trainable params by 100–1000×. QLoRA = LoRA on a quantized (4-bit) base model. Trains a 70B model on a single 24GB GPU. See also: Fine-tuning, PEFT. Practical: The default fine-tuning approach in 2024–2026. Library: HuggingFace peft. The four lines you need:

``python from peft import LoraConfig, get_peft_model config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none", task_type="CAUSAL_LM") model = get_peft_model(base_model, config) ``

A Loss Function (also called a cost function or objective function) is a mathematical measure that quantifies how wrong a machine learning model's predictions are compared to the actual correct values. Practical: The loss is what you actually minimize. Common ones: MSE (regression), Cross-Entropy (classification, also LLM training), Hinge Loss (SVMs, historical), Contrastive Loss (embeddings), KL Divergence (RLHF, distillation). For LLMs, the loss is the negative log-likelihood of the next token — equivalent to cross-entropy over the vocabulary.

Machine Learning is a branch of artificial intelligence that enables computers to learn patterns and make decisions from data without being explicitly programmed with rules. Practical: In 2026 "ML" often means either (1) classical ML (XGBoost on tabular data), (2) deep learning (transformers, CNNs, etc.), or (3) the umbrella term. The most common co-op split: 60% classical ML + 40% LLM/AI work. Don't assume "ML" means "LLM."

A Markov Chain is a mathematical model that describes a sequence of events where the probability of each future event depends only on the current state, not on the history of how you got there. Practical: Mostly relevant as the conceptual ancestor of autoregressive models — an LLM is a Markov chain over tokens (with a huge state). Also: MCMC sampling, Hidden Markov Models for sequence labeling (NER, POS tagging before transformers took over).

A family of architectures (State Space Models) that compete with transformers for sequence modeling. Linear-time complexity instead of quadratic, so they handle very long contexts efficiently. Mamba (2023) and Mamba-2 (2024) are the leading variants. Practical: Promising but not yet dominant. If you see a paper mention "Mamba" or "SSM" in 2025–2026, it's likely a long-context or efficiency-focused project. Production LLMs are still transformers.

Machine Learning Operations (MLOps) is a set of practices that combines machine learning, software engineering, and DevOps to deploy, monitor, and maintain ML models reliably in production environments. Practical: The boring side of ML that decides whether your model ever makes money. Core loop: train → version → deploy → monitor → retrain. Tools: MLflow, Weights & Biases, BentoML, Ray Serve, KServe, Sagemaker, Vertex AI. The hardest part is rarely the model — it's the data versioning and the monitoring.

A tiny (~1.8B-parameter) open-weight vision-language model (VLM) designed for resource-constrained devices. Accepts an image + a text question, returns text. Notable for running in 1–2GB of RAM and <1 second per query on a Raspberry Pi or a low-end CPU, while still being useful for basic image understanding (object presence, OCR, simple counting, scene description). See also: VLM, VLA, llama.cpp (often the runtime), Quantization, Small Specialist Models. Practical: The 2025–2026 reference for "I need vision on a constrained device" — drone feeds, security cameras, IoT, mobile AR. Not as smart as GPT-4o or LLaVA-13B, but ~50× smaller and runs anywhere. Two model variants: moondream2 (the current 2025 release, trained on a richer dataset) and the older moondream1. Typical usage: ```python from PIL import Image from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("vikhyatk/moondream2", trust_remote_code=True) tokenizer = AutoTokenizer.from_pretrained("vikhyatk/moondream2") img = Image.open("photo.jpg") print(model.answer_question(img, "How many people in this image?", tokenizer)) # "3" ``` For real-time edge vision (Jetson, Pi 5, Apple Silicon) Moondream is often paired with llama.cpp (yes, the same one) or ONNX Runtime Mobile. On a co-op, reach for Moondream when "smart enough at 1.8B" beats "needs an A100 at 13B." See also: Florence-2 (Microsoft, similar size, different strengths), SmolVLM (HuggingFace, 2025), LLaVA-1.5 7B (3–4× larger but noticeably smarter).

A Model is a simplified mathematical or computational representation of a real-world system, process, or relationship that is used to make predictions or understand patterns. Practical: In 2026, "model" almost always means a neural network. The .pt or .safetensors file. Loaded via from_pretrained(). Made of parameters (weights and biases) and an architecture (the computation graph).

Model Drift occurs when a machine learning model's performance degrades over time because the real-world data it encounters has changed from the data it was originally trained on. Practical: Two kinds: data drift (the input distribution changes — new user demographics, new product names) and concept drift (the relationship between input and output changes — what counts as "fraud" evolves). Detect by tracking input distributions and per-segment accuracy over time. If you ship a model and never look at it again, it will silently rot.

An open protocol (introduced by Anthropic, late 2024) that standardizes how LLMs connect to external tools and data sources. Think of it as "USB-C for AI tools" — one protocol, many integrations. Practical: If you build agents in 2025–2026, MCP is becoming the default way to expose tools. Servers expose resources, tools, and prompts; clients (Claude Desktop, IDE plugins) consume them. If your team has internal APIs, wrapping them as an MCP server is high-leverage.

Multimodal AI refers to artificial intelligence systems that can process, understand, and generate multiple types of data modalities simultaneously—such as text, images, audio, and video. Practical: Architectures: (1) Encoder fusion — separate encoders per modality, project to shared space (CLIP, LLaVA); (2) Native multimodal — single transformer trained on all modalities from scratch (GPT-4o, Gemini 2). The frontier models in 2026 are all multimodal: text + image + audio in, any of these out. The phrase "vision-language model" is a subset of multimodal. The four modality pairs a co-op will actually build: (a) text + image (VLM: GPT-4o, Claude 4, Moondream for edge, LLaVA-13B for self-hosted), (b) text + audio (audio-language: Qwen2-Audio, SALMONN — much less mature than VLMs), (c) text + speech (Whisper STT, Kokoro TTS — the local voice agent stack), (d) image + text → action (VLA: RT-2, π0, OpenVLA). The decision rule on a co-op: pick the smallest model that meets the accuracy bar. A 1.8B Moondream on a Raspberry Pi beats a 70B LLaVA on an H100 for "count people in this camera feed" because the second one is overkill. See also: VLM, VLA, Audio Models, Whisper, Kokoro.

Natural Language Processing (NLP) is a branch of artificial intelligence focused on enabling computers to understand, interpret, and generate human language in a meaningful way. Practical: In 2026, "NLP" is almost a synonym for "LLM applications." The pre-transformer NLP (LSTMs, CRF, spaCy) is still maintained and excellent for production NER, POS tagging, and dependency parsing at 1000× the speed and 1/100th the cost of an LLM. Don't reach for GPT-4 when spacy.load("en_core_web_sm") does the job.

A Neural Network is a computational model inspired by the structure of the human brain, consisting of interconnected layers of artificial "neurons" that process and transmit information. Practical: A neural net is a function f(x; θ) composed of linear layers + non-linear activations, optimized with gradient descent. The "deep" in deep learning just means many layers. In 2026, "neural network" almost always means a transformer of some kind.

The foundational numerical computing library in Python. Every other ML library (PyTorch, TensorFlow, JAX, pandas) is built on or interoperates with NumPy. Practical: The single most important data structure is np.ndarray. Know its rules: fixed shape, fixed dtype, vectorized ops, broadcasting. np.array([1,2,3]) * 2 works because of broadcasting. A 1000-loop Python for over an array is 1000× slower than the vectorized version. Learn it well — you will use it every day.

In ML libraries, the term tensor specifically means an n-dimensional array with a single dtype living on a device (CPU or GPU). Shape is a tuple like (batch, sequence, features). PyTorch torch.Tensor, NumPy np.ndarray, TensorFlow tf.Tensor, JAX jax.Array are all the same idea. Practical: Operations you will type a thousand times: x.shape, x.dtype, x.device, x.to(device), x.unsqueeze(0), x[:, -1, :]. The convention is (batch, ..., features) — last dim is features for the linear layer.

A tool that runs open-weight LLMs locally with one command. ollama run llama3.2 gives you a chat with a 3B model in 60 seconds. Supports Llama, Mistral, Qwen, DeepSeek, Phi, Gemma, and many more. Practical: Your first stop for any local LLM work. No GPU required for the small models (CPU is slow but works). Excellent for prototyping RAG, agents, and prompt engineering before paying for API credits. Production note: Ollama is for dev. For serving, use vLLM or llama.cpp.

The company that made ChatGPT. Their API is the de facto standard that other APIs copy. Models: GPT-4o, GPT-4o-mini, o1, o1-mini, o3-mini, GPT-4.1. SDK: openai Python package. Practical: Start here on day 1 of learning LLM APIs. The API patterns transfer to Anthropic, Google, etc. with minimal changes. The openai package also works against OpenAI-compatible servers (Ollama, vLLM, Together, Groq) by changing base_url.

A 7B-parameter open-weight Vision-Language-Action model (Kim et al., 2024) that is currently the de facto research baseline for VLA work. Architecture: Llama 2 7B backbone + SigLIP vision encoder + a discretization head that maps continuous robot actions into 256-bin tokens. Trained on Open X-Embodiment. Practical: The reason it matters: it's the first serious open VLA. License: Apache 2.0 (the original "Open" was ODC-BY, but the official openvla/openvla-7b weights are Apache 2.0 as of late 2024). Inference: a single A100 (or 4090 with quantization). Fine-tuning: LoRA on your own data with a few hundred trajectories and an afternoon. The successor direction in 2025–2026 is OpenVLA-OFT (with action chunking, time horizons, and better fine-tuning) and π0-style flow-matching heads. If you write a robotics paper in 2026 and don't compare against OpenVLA, reviewers will ask why. Repo: https://github.com/openvla/openvla. See also: VLA, LeRobot, Diffusion Policy, Fine-tuning.

An Open-Weight Model is an AI model whose core components are publicly released, allowing anyone to download it. Practical: Necessary when you can't send data to a third party. Top open-weight families in 2026: Llama (Meta), Mistral / Mixtral (Mistral AI), Qwen (Alibaba), DeepSeek (DeepSeek AI), Phi (Microsoft), Gemma (Google). The gap to closed-weight (GPT-4, Claude 4) is small but real — maybe 6–12 months on most benchmarks.

Open Source refers to software where its original design, or "blueprint," is made freely available for anyone to see and use. Practical: "Open source" for models is ambiguous. Some are fully open (code + weights + data + paper): OLMo, Pythia, BLOOM. Some are open-weight only (code private, weights public): Llama, Mistral. Some are "open" in marketing only. Always check the actual license — Llama's "open" license has commercial restrictions above 700M MAU.

An Optimization Algorithm is a method that helps a machine learning model get better by adjusting its settings to make fewer mistakes. Practical: In 2026, "optimization algorithm" almost always means the optimizer (SGD, Adam, AdamW, Lion). Choose AdamW for transformers. The "hyperparameter" people forget to tune: weight decay (default 0.01) and gradient clipping (default 1.0).

Overfitting happens when a model memorizes the training data too closely, including mistakes and random patterns. Practical: Symptom: training loss goes down, validation loss goes up. Three cures. (1) More data (always the best). (2) Regularization: weight decay, dropout, data augmentation. (3) Early stopping: save the checkpoint with the best validation loss. The 80/20 of regularization in 2026: dropout 0.1, weight decay 0.01, early stopping with patience 3.

In robotics: the robot's sense of its own body — the joint angles, joint velocities, joint torques, end-effector pose, gripper state, and (for mobile robots) base pose and velocity. The robot's "self-awareness" of where its body is in space, without using cameras. See also: End-Effector, VLA. Practical: In VLA code, the input to the model is usually [image(s), language_instruction, proprioceptive_state]. The proprio state is a vector of ~7–50 numbers (7 for a single 7-DoF arm, 50+ for a humanoid). Always normalize the proprio vector (per-dimension mean/std computed on the training set) before feeding it to the model — robot datasets have wildly different joint conventions. Frameworks: gymnasium, robomimic, lerobot. If your policy is "jittery" or "asymmetric," check the proprio normalization first. See also: Teleoperation, Diffusion Policy, End-Effector.

A Parameter is an internal variable within a machine learning model that is learned and adjusted during the training phase. Practical: In transformers, parameters come in three flavors: weights (the matrices — most of the params), biases (the vectors — usually small fraction), and embeddings (the lookup tables). Total parameter count is the headline number (7B, 70B) but the useful info is the breakdown (e.g. Llama 3 70B has ~64B attention/MLP params and ~6B embedding params).

Parameter-Efficient Fine-Tuning. The umbrella term for all the methods that fine-tune only a small fraction of a model's parameters. Most famous example: LoRA. Others: prefix tuning, prompt tuning, IA³, AdaLoRA, DoRA. Practical: HuggingFace peft library is the standard. Default to LoRA unless you have a reason not to. In production, PEFT also makes model serving cleaner — you swap a tiny adapter file instead of re-deploying a 70B model.

The standard "is my LLM confused" metric. Perplexity = exp(cross_entropy_loss). Lower = better. Interpretation: it's the average number of equally-likely choices the model thinks it has at each step. Practical: Use it to compare two checkpoints of the same model on the same data. Don't compare perplexity across models or tokenizers — it's not normalized. The training loss curve dropping is the most important signal during training; validation perplexity rising = overfitting.

Predictive Analytics is the practice of using data, statistical methods, and machine learning models to forecast future outcomes or trends. Practical: The bread-and-butter of business ML: churn prediction, demand forecasting, fraud detection, lead scoring. Usually gradient-boosted trees on tabular features. LLM usage is growing (LLMs for feature engineering, "forecasting" via in-context time series) but XGBoost is still king here.

The input you give to a language model — the instructions, the question, the context, the examples, all of it. See also: Context Engineering, Prompt Engineering. Practical: The "prompt" is not just the user's question. In a production LLM app, the prompt is everything in the messages array: system prompt, conversation history, retrieved documents, tool results, the user's question, and the format spec. The job of prompt engineering is to construct this well.

Prompt Engineering is the practice of carefully crafting instructions, or "prompts," to guide AI language models toward producing desired outputs. Practical: Core techniques to know. (1) Be specific — vague prompts get vague answers. (2) Show, don't tell — 2–5 examples beats paragraphs of instructions. (3) Structure output — ask for JSON, bullets, or "first think then answer." (4) Roles — "You are an expert X" usually helps. (5) Constraints — "in 3 sentences," "use only the provided context." (6) Delimiters — wrap inputs in """ or <context> tags so the model can tell prompt from data. (7) Iterate — every model, every task needs its own tuning. There's no "one prompt to rule them all."

Prompt Injection is a type of security attack that uses malicious input to trick a Large Language Model (LLM) into behaving in an unintended way. Practical: The unsolved security problem of LLMs. If untrusted text (user input, retrieved docs, web pages) goes into your prompt, an attacker can hide instructions in that text and hijack the model. Mitigations: (1) separate instructions from data with delimiters, (2) structured outputs to constrain behavior, (3) allow-list tools the model can call, (4) post-validate model output before acting on it, (5) least-privilege system prompts. There is no complete fix. Treat the LLM as a curious, literal-minded intern, not a security boundary.

The dominant deep learning framework in research and increasingly in production (2026). Developed at Meta, open source. The torch library + torchvision (vision) + torchaudio (audio) + torchtext (text) + ecosystem (torch.compile, torch.distributed, FSDP, etc.). Practical: Every model on HuggingFace runs in PyTorch. The five commands you will type every day:

``python import torch x = torch.randn(2, 3) # make a tensor x = x.to("cuda") # move to GPU y = model(x) # forward pass loss = criterion(y, target) # compute loss loss.backward() # backprop optimizer.step(); optimizer.zero_grad() # update ``

See Perplexity above.

Reducing the numerical precision of a model's weights to make it smaller and faster, usually at the cost of some quality. Common: FP16 (2× smaller), INT8 (4× smaller), INT4 (8× smaller). Practical: Three reasons you quantize. (1) It fits in VRAM — a 70B model in FP16 needs 140GB; in INT4 it needs ~40GB. (2) It runs faster — especially on consumer GPUs. (3) It costs less to serve. Tools: bitsandbytes (training), GPTQ / AWQ (inference), llama.cpp's Q4_K_M and Q5_K_M (CPU + Apple Silicon). Quality loss is usually 1–3% on benchmarks; often imperceptible in chat.

Retrieval-Augmented Generation (RAG) is a technique that helps language models generate higher-quality outputs by allowing them to look up external, up-to-date information first. Practical: The most common production LLM pattern. The pipeline: 1. Chunk your documents (typically 200–1000 tokens, with overlap). 2. Embed each chunk with an embedding model. 3. Store the embeddings in a vector DB (FAISS, Pinecone, Weaviate, Qdrant, Chroma, pgvector). 4. Retrieve: at query time, embed the query, find top-k most similar chunks by cosine similarity. 5. Re-rank (optional, often a big quality win): use a cross-encoder to re-score the top candidates. 6. Generate: stuff the chunks into the LLM prompt and ask the question.

Reason + Act. A prompting pattern where the LLM alternates between "thinking" (a chain-of-thought step) and "acting" (calling a tool or producing a final answer). The original agent pattern. Practical: The conceptual ancestor of every modern agent. In code: a loop that calls the LLM, parses the response, executes any tool calls, appends results, and repeats until the model stops. Modern agents add planning, memory, and reflection on top of this basic loop.

A Reasoning Model is a type of AI system designed to solve complex problems by generating a logical, step-by-step sequence of thought. Practical: The 2024–2026 category. OpenAI o1, o3, DeepSeek-R1, Claude 3.7 with extended thinking, Gemini 2.0 Thinking. These models "think" before answering — they generate chains of thought internally, sometimes very long ones, then produce a final answer. Great for math, code, planning. Slower and more expensive than non-reasoning models. Use them when the task genuinely requires multi-step reasoning; don't use them for "what's 2+2."

Any technique that prevents a model from overfitting. Includes weight decay (penalize large weights in the loss), dropout (randomly zero out neurons during training), data augmentation, early stopping, label smoothing. Practical: If your training loss is way below your validation loss, you need more regularization. Default values that work in 2026: dropout 0.1, weight decay 0.01, label smoothing 0.1 (for classification). For LLMs, you usually don't add dropout during fine-tuning.

Reinforcement Learning is a type of machine learning where an AI agent improves its performance through trial and error by taking actions within a specific setting. Practical: The 2024–2026 hotness is RLHF (RL from Human Feedback) and its variants: DPO, ORPO, GRPO. These align chat models using pairwise preferences ("A is better than B"). The pipeline: (1) SFT on demonstrations, (2) train a reward model on preferences, (3) PPO/DPO/GRPO to optimize the LM against the reward. OpenAI's o1 was trained with a variant. Most co-op work won't train from scratch but you may fine-tune with DPO on preference data.

Responsible AI refers to the frameworks, principles, and practices that guide the ethical and safe development and deployment of artificial intelligence systems. Practical: On the job: (1) read the model card of every model you use; (2) log inputs and outputs for audit; (3) understand the data your model was trained on (copyright, PII, consent); (4) have a rollback plan; (5) think about who is harmed when the model is wrong. This is increasingly a legal requirement (EU AI Act, US Executive Orders).

Robotics is the field that combines engineering and computer science, and now often artificial intelligence, to design and build machines capable of performing physical tasks. Practical: Three eras of "AI + robots." Era 1 (pre-2022): classical robotics — hand-engineered controllers, SLAM, motion planning (ROS, MoveIt). Era 2 (2022–2023): learned policies — Diffusion Policy, ACT, behavior cloning on small task-specific datasets. Era 3 (2024–2026): generalist VLAs — RT-2, OpenVLA, π0, Helix, GR00T that pretrain on internet-scale vision-language data then fine-tune on robot trajectories. The 2026 frontier: humanoid robots (Figure 02, Tesla Optimus, 1X Neo, Unitree H1, Agility Digit) running VLAs at 50 Hz. On a co-op: know ROS 2, Isaac Sim (NVIDIA), MuJoCo, LeRobot (HuggingFace), and the DROID / Open X-Embodiment / Bridge datasets. The hardware you must respect: joint torque limits, control loop frequency (typically 50–1000 Hz), latency from camera to action (must be < 50 ms for reactive control). Reading: https://arxiv.org/abs/2408.12929 (OpenVLA paper), https://www.physicalintelligence.company/blog/pi0 (π0 announcement). See also: VLA, Diffusion Policy, Imitation Learning, Teleoperation, Proprioception, End-Effector, Embodiment Gap.

In LLM inference, the strategy for picking the next token from the probability distribution. Greedy is one extreme (always the argmax). Full random sampling is the other. Real systems use temperature and top_p to control the trade-off. Practical: See Temperature and Top-p.

Self-Supervised Learning is a training method where an AI model teaches itself by creating its own puzzles from raw data and then trying to solve them. Practical: The dominant pretraining paradigm. The puzzle: predict the next token (GPT), predict masked tokens (BERT), predict image patches (MAE), predict the next video frame. The label is free because it comes from the data itself. This is why you can pretrain on the entire internet.

Semantic Analysis is the process of understanding the meaning of language by examining the relationship between words, phrases, and symbols. Practical: Two flavors. (1) Linguistics — formal meaning representation (lambda calculus, AMR, predicate logic). Mostly academic. (2) Engineering — extracting meaning from text via embeddings or LLMs (entity extraction, sentiment, intent classification). Practical engineering wins. Don't conflate the two.

Scaling Laws are predictable mathematical relationships that describe how AI model performance improves as factors like model size, training data, and computing power increase. Practical: The Kaplan (2020) and Chinchilla (2022) scaling laws. The Chinchilla rule of thumb: for optimal compute, train a model on ~20 tokens per parameter. So a 7B model should see ~140B tokens; a 70B model should see ~1.4T tokens. Modern frontier models deviate from this (more inference compute, RL post-training) but the principle — bigger models need proportionally more data — still holds.

A tokenizer library (Google) that learns subword tokenization directly from raw text, without pre-tokenization. Used by T5, Llama, Mistral, Gemma, and most multilingual models. Alternative to BPE. Practical: If you load a Llama tokenizer, you load a SentencePiece model under the hood (with BPE as the algorithm). The defining property: treats input as a byte stream, language-agnostic. Good for code, multilingual text, and any input where whitespace isn't reliable.

The 2024–2026 counter-trend to "bigger is better": highly capable task-specific models under ~3B parameters that match or beat much larger general models on a narrow task. Examples: Moondream 1.8B (vision Q&A), Kokoro 82M (TTS), Whisper tiny/base (STT), Phi-3 mini 3.8B (reasoning), Gemma 2 2B (general), SmolLM2 1.7B (general), Florence-2 (vision), Parakeet (STT), All-MiniLM-L6-v2 22M (embeddings). See also: Moondream, Kokoro, Whisper, Quantization, llama.cpp, Edge AI (where these all deploy). Practical: The 2026 co-op rule: don't reach for GPT-4o when a 1B model does the job. The tradeoffs: - Cost: a 1B model on a 4090 = ~free at inference; the same query to GPT-4o = $0.01–0.10. At 1M queries/day, that's $10K–100K/month saved. - Latency: a small local model = 20–50ms first token; GPT-4o = 300–800ms. Matters for voice agents, IDEs, anything interactive. - Privacy: small local = data never leaves the device. Mandatory for healthcare, legal, government, finance, EU compliance. - Reliability: small local = no API rate limit, no outage, no price change, no model deprecation. When NOT to use them: tasks that need broad world knowledge (use a large LLM), complex multi-step reasoning (use a reasoning model), code generation at scale (use a strong LLM + IDE). When to use them: well-scoped tasks with clear input/output, high-volume automation, on-device privacy, real-time latency. The 2026 playbook: prototype with the small model, ship with the small model, only escalate to a frontier model when the small model's failure rate is unacceptable for the use case.

Stochastic Gradient Descent. The original optimizer. θ ← θ - η · ∇L(θ_batch). Where Adam adds momentum and per-parameter learning rates, plain SGD does not. Practical: Still used for fine-tuning ResNets and some other vision models. For transformers, AdamW is strictly better in practice. You'll see SGD in older code, in some RL code, and in research papers that need reproducibility.

A string that, when generated by the LLM, causes it to stop generating. Defaults are usually "\n", but you can set custom ones (e.g. "</answer>", "STOP", "}" for JSON). Practical: Always set a stop sequence for structured output. If you ask for JSON and don't set stop=["}"], the model will keep generating JSON forever (or until max_tokens). Critical for cost control.

Returning LLM output token-by-token as it's generated, instead of waiting for the full response. Reduces time-to-first-token (TTFT) from seconds to milliseconds. Practical: Default for chat UIs. In OpenAI: stream=True returns an iterator. In your code, yield chunks to your frontend via SSE or WebSockets. Streaming is the difference between a chat that "feels" responsive and one that "feels" laggy.

A pattern where the LLM is constrained to produce output matching a specific schema (JSON, function call, regex). Achieved via constrained decoding (the API masks invalid tokens at each step) or post-hoc validation. Practical: Use it whenever an LLM output is consumed by code. Three implementations in 2026: (1) OpenAI Structured Outputs (best, uses constrained decoding with your JSON schema); (2) Anthropic tool use (function-calling-as-schema); (3) Instructor / Outlines / Guidance (libraries that wrap any LLM). Always prefer this over "ask for JSON and hope."

Supervised Learning is a machine learning approach where models are trained on labeled data—input examples paired with correct output answers. Practical: The workhorse paradigm. Includes classification, regression, and instruction tuning. Requires labeled data — usually the bottleneck. Active research on cheaper labeling: weak supervision (Snorkel), programmatic labeling, LLM-as-labeler.

Synthetic Data is artificially generated information created by algorithms or simulations rather than collected from real-world events or observations. Practical: Two flavors. (1) Data augmentation — generate variations of real examples (text paraphrases, image augmentations). Safe, standard. (2) Fully synthetic — generate training data from scratch using an LLM or simulation. Powerful but risky: models trained on their own outputs can model collapse — quality drops over generations. The 2024 result on model collapse is the reason to be cautious. Practical safe use: synthetic data for minority classes in imbalanced datasets.

A special message at the start of the conversation that sets the model's role, constraints, tone, and behavior. Distinct from the user prompt. Practical: The single highest-leverage piece of text in any LLM app. A good system prompt includes: (1) role/persona, (2) task description, (3) constraints (length, format, tone, what to avoid), (4) few-shot examples, (5) output format. OpenAI's "markdown formatter" prompt in their docs is a clean example. Anthropic recommends keeping it short and putting the dynamic content in user messages. Never put untrusted user input in the system prompt.

A sampling parameter that reshapes the probability distribution over next tokens. T=0 is greedy (always the most likely). T=1 is the model's natural distribution. T>1 flattens (more random). 0<T<1 sharpens (more focused). Practical: Defaults by use case. (1) Coding, factual Q&A, extraction: 0 or 0.2. (2) Chat, general assistance: 0.7 (the OpenAI default). (3) Creative writing, brainstorming: 0.9–1.2. (4) Never go above 2.0 in practice. Almost always set temperature; if you don't, you're at the API's default which may be 1.0.

Driving a robot from a distance — the human's actions (joystick, VR controller, leader arm, hand-tracking) become the robot's actions in real time, often while recording the trajectory for later training. The dominant way robot training data is collected in 2024–2026. See also: Imitation Learning, Behavior Cloning, VLA. Practical: Three setups you'll see. (1) Leader–follower arm: a cheap "leader" arm that mimics the geometry of the real "follower" arm; the human moves the leader, the follower mirrors at 100+ Hz. Cheap (~$5k), requires the lab to have a matching pair. (2) VR teleop: the human wears a Meta Quest 3 or Apple Vision Pro; the headset's hand-tracking plus controller pose becomes the end-effector target. The 2024–2026 default for new data-collection setups because it requires no robot-specific hardware. (3) Phone / tablet teleop: the human moves a phone in 3D; the camera pose becomes the end-effector. The cheapest option, used in ALOHA and Mobile ALOHA. All three produce a stream of (camera, proprio, action) triples at 10–30 Hz that become training data for Behavior Cloning or Diffusion Policy. The unsolved problem: teleop tax — collecting one hour of good data costs $50–500 in human time, and you need hundreds to thousands of hours per task. See also: Proprioception, Imitation Learning, OpenVLA.

A Tensor is essentially a container for numbers organized in multiple dimensions, like a more advanced version of a spreadsheet. Practical: A tensor is just an n-dimensional array with a dtype and a device. In PyTorch: torch.Tensor. Convention: shape (batch, ...other_dims..., features). The output of a transformer is a tensor of shape (batch, sequence_length, vocab_size) — the logits over the next token at each position.

Term Frequency – Inverse Document Frequency. The classic (pre-embedding) way to convert text to a vector. Words that appear a lot in a document but rarely across the corpus get high scores. Practical: Still useful for: keyword search, baseline RAG (hybrid search with vector + BM25), quick text features. BM25 is the modern form. Pairing BM25 with vector search is a common 2025–2026 RAG pattern (called "hybrid search") because each catches what the other misses.

The audio synthesis task: text in, audio out. The 2024–2026 quality bar is "natural conversation" — prosody, emotion, voice cloning, real-time streaming — and the open-source models have nearly closed the gap with commercial TTS (ElevenLabs, Google Cloud TTS, OpenAI TTS). The 2026 open leaders: Kokoro (82M, Apache 2.0, runs on CPU in real time, the 80/20 default), CosyVoice 2 (Alibaba, voice cloning, multilingual), F5-TTS (flow-matching, very natural), XTTS-v2 (Coqui, voice cloning from 6 seconds of reference audio), Tortoise TTS (slower but high quality). See also: Whisper (the STT counterpart), Kokoro, Audio Models. Practical: The decision tree on a co-op: 1. Need general TTS in 5 minutes? → pip install kokoro-onnx, Kokoro's defaults. 2. Need voice cloning (3–30 seconds of reference audio)? → XTTS-v2 or CosyVoice 2. 3. Need real-time streaming TTS over a phone call? → Either self-host XTTS-v2 on a GPU (10–50ms latency achievable), or use OpenAI TTS / ElevenLabs API and pay per character. 4. Need 100+ languages? → MMS-TTS (Meta, 1000+ languages, weaker quality) or Google Cloud TTS (best polyglot, paid). Two gotchas the docs don't tell you: (a) TTS latency is the first audio byte time, not the full audio time — Kokoro streams the first 100ms in ~80ms, which is what matters for voice agents; (b) voice cloning models retain accents and cadence of the reference speaker but do not clone emotional tone unless you provide a reference with the right emotion. For a voice agent, the answer is usually: Kokoro for the default voice + XTTS-v2 for the personalized customer-facing voice.

Tokenization is the process of breaking down text into smaller units called tokens—which can be words, parts of words, or even individual characters—that AI language models can process. Practical: Models don't see text — they see tokens (integer IDs). A "token" is roughly 4 characters of English, or ¾ of a word. Tokenizers you will meet: BPE (GPT-2, GPT-3, GPT-4), WordPiece (BERT), SentencePiece (Llama, Mistral, T5), Tiktoken (OpenAI's fast BPE). Always use the model's own tokenizer for prompts — using a different tokenizer is a silent bug. Three things to remember: (1) cost is per token, (2) context window is in tokens, (3) rare characters and code can tokenize inefficiently (Korean can be 3× more tokens per character than English).

A sampling strategy: at each step, keep only the smallest set of tokens whose cumulative probability is ≥ p, then sample from that. top_p=0.9 is a common default. Practical: Pair with temperature, not instead of. (1) Coding, factual: top_p=0.1, temperature=0. (2) Chat: top_p=0.95, temperature=0.7. (3) Creative: top_p=0.98, temperature=1.0. Anthropic recommends only adjusting temperature, not top-p. OpenAI recommends both. Pick a convention and stick to it.

See Function Calling / Tool Use.

Traditional AI refers to earlier approaches to artificial intelligence that relied on explicitly programmed rules, logic, and human-defined knowledge rather than learning from data. Practical: Also called symbolic AI or GOFAI (Good Old-Fashioned AI). Includes expert systems, search (A*, minimax), planning (STRIPS, PDDL), constraint satisfaction. Still the right tool for: chess engines, theorem provers, scheduling, configuration problems, anything where you need guaranteed correctness. Hybrid systems that combine symbolic reasoning with neural networks are an active research area (e.g. AlphaProof, neurosymbolic AI).

Training Data is the collection of examples—such as text, images, audio, or other information—used to teach machine learning models how to perform specific tasks. Practical: The single most important determinant of model quality. Three things to check. (1) What is it? — check the data card. (2) Is it licensed? — training on scraped data is a legal landmine. (3) What's missing? — every dataset has gaps (languages, demographics, time periods) that become model blind spots.

Transfer Learning is a machine learning technique where a model trained on one task is reused as the starting point for a different but related task. Practical: The reason fine-tuning works at all. The base model has learned general language/visual understanding; you specialize it for your task. The base model is the ceiling — if it can't do your task in-context, fine-tuning won't help unless you also change the architecture.

A Transformer is a neural network architecture that revolutionized AI by using a mechanism called "attention" to process and understand relationships between all parts of input data simultaneously, rather than sequentially. Practical: The architecture of 2020–2026. A transformer is a stack of identical blocks, each containing: (1) Multi-head self-attention (tokens talk to each other), (2) Feed-forward MLP (per-token computation), (3) Residual connections + LayerNorm. Both encoder and decoder variants use the same building block. The original paper: https://arxiv.org/abs/1706.03762. After this, read "The Illustrated Transformer" by Jay Alammar.

The Turing Test, proposed by mathematician Alan Turing in 1950, is a measure of a machine's ability to exhibit intelligent behavior indistinguishable from a human. Practical: Largely considered "solved" for chat (GPT-4 passes a naive Turing test) but "not meaningful" for measuring intelligence. In 2026, the field has moved on to specific capability benchmarks (MMLU, HumanEval, SWE-bench, Chatbot Arena). Mention the Turing Test to show you know the history; don't use it for anything practical.

Unsupervised Learning is a machine learning approach where models are trained on data without labeled answers or predefined categories, tasked with finding patterns and structure on their own. Practical: The pretraining paradigm (self-supervised learning is a specific kind of unsupervised). Also: clustering (K-means, DBSCAN, HDBSCAN), dimensionality reduction (PCA, UMAP, t-SNE), anomaly detection (isolation forest, autoencoders). K-means on embeddings is a quick way to discover themes in a corpus.

See Dataset above and the Validation and Test Sets entry.

A held-out portion of your data used to evaluate the model. Validation set: used during training to tune hyperparameters, pick the best checkpoint, do early stopping. Test set: used exactly once, at the end, to report the final number. Practical: Common splits: 80/10/10 or 70/15/15. Critical rule: never look at the test set during development. Never train on the test set. Never tune hyperparameters on the test set. If you violate this, every number you report is biased upward. The test set is a witness you call once. If your dataset is small, use cross-validation (5-fold) instead of a single split.

The current best-in-class open-source LLM serving framework. Invented PagedAttention, which dramatically improves throughput by managing the KV cache like virtual memory. Practical: If you serve open-weight LLMs at scale, vLLM is the default. Compatible with HuggingFace models, OpenAI-compatible API, supports continuous batching, prefix caching, speculative decoding, LoRA adapters at runtime. Alternative: TGI (HuggingFace), TensorRT-LLM (NVIDIA, fastest on H100), SGLang (newer, very fast).

A Vector Database is a specialized type of database designed to store and efficiently search through high-dimensional numerical representations (vectors) of data like text, images, or audio. Practical: The substrate of RAG. Options in 2026: Pinecone (managed, easy), Weaviate (open source, hybrid search), Qdrant (Rust, fast, open source), Chroma (Python-native, easy), pgvector (Postgres extension, "good enough"), Milvus (distributed, scale). The actual ANN algorithm inside all of them is usually HNSW. For a co-op project: start with Chroma or pgvector; graduate to Weaviate/Qdrant when you need scale.

A Vision Transformer (ViT) is an adaptation of the transformer architecture, originally designed for language, to process and analyze images. Practical: Split the image into 16×16 patches, linearly project each patch to a vector, treat them as a sequence — and apply a standard transformer. The same architecture that works for text works for images. ViT is the backbone of most modern vision systems, including CLIP, DINOv2, and the visual encoders of GPT-4o / Claude / Gemini.

A model that takes both images and text as input and produces text (or sometimes other modalities) as output. Examples: GPT-4o, Claude 3.5/4, Gemini 1.5/2, LLaVA, Qwen-VL, InternVL, Pixtral. Practical: The default for "AI that sees." Architecturally: an image encoder (CLIP/ViT) + a projector + a language model. You send an image and a question; you get text back. Most modern VLMs are "any resolution" via techniques like dynamic tiling. For a co-op project, the easiest path: use GPT-4o or a local Qwen2-VL via Ollama.

A model that takes images + language instructions + the robot's current state and outputs motor commands (joint angles, end-effector pose, gripper open/close) — the model that turns a VLM into something that can do physical things, not just describe them. The "ChatGPT for robots" architecture. Practical: Architecture: take a VLM (vision encoder + LLM), drop the text-only output head, add an action head that decodes the hidden state into a sequence of robot actions. Action representations vary: RT-2 discretized actions into 256 bins per joint (treating them like tokens); π0 uses flow matching (a continuous-time generative model) to produce smooth action chunks; OpenVLA uses a 7B Llama 2 backbone with discretized actions. Key examples: RT-2 / RT-2-X (Google DeepMind, 2023), OpenVLA (2024, open-weight 7B — runs on a single A100, the default research baseline), π0 (Physical Intelligence, 2024), π0-FAST, Helix (Figure AI + PI, 2025), GR00T (NVIDIA, 2025). Training: two-stage — first pretrain as a VLM on internet data, then fine-tune on robot trajectories (image, instruction, action triples collected by human teleoperators). Why it matters: this is the first architecture where the same model that understands "pick up the red mug" from a web image can be the same model that picks up a red mug in your kitchen. On a co-op: if you're at a robotics company, you will likely be training, fine-tuning, or evaluating one of these. Frameworks to know: HuggingFace LeRobot (datasets, training, sim), OpenVLA repo, DROID dataset, Bridge dataset. Gotcha: the embodiment gap — a model trained on one robot's body often fails on a different robot's body. Generalist VLAs (π0, OpenVLA) try to bridge this with diverse training data; in 2026 it's still an open problem. See also: Diffusion Policy, Imitation Learning, Teleoperation, Proprioception, OpenVLA.

See Weights below.

Weights are the numerical parameters within a neural network that determine the strength of connections between artificial neurons and ultimately shape how the model processes information. Practical: The numbers in the matrices. "Loading the weights" = reading the .safetensors file into the model. "Fine-tuning the weights" = updating them with gradient descent. For an LLM, the "weights" file is the whole model — architecture + tokenizer + weights + config. "Distillation" is teaching a small model to mimic a big one by training it to match the big one's outputs (a kind of "soft" label).

OpenAI's open-weight speech-to-text model. 4 sizes: tiny, base, small, medium, large. Multilingual, very robust, runs locally. Practical: The default for local transcription. If you need STT in 2026, try Whisper before paying for a cloud API. Newer: Whisper-large-v3 is competitive with cloud STT services on English and most major languages. Three faster alternatives for production: faster-whisper (CTranslate2-based, 4× faster, same accuracy — the production default), insanely-fast-whisper (Flash Attention 2 + batched, fastest on a GPU), whisper.cpp (the same llama.cpp project, runs on Raspberry Pi / iOS / embedded). For word-level timestamps (subtitles, karaoke, audio editing): use whisperx (Whisper + forced alignment) or insanely-fast-whisper with --timestamp granularities word. The 2024–2026 co-op pattern: Whisper + an LLM + Kokoro = fully local voice agent. See also: Audio Models, Kokoro (the TTS counterpart), TTS, llama.cpp (also serves Whisper).

The three dominant gradient-boosted decision tree libraries. XGBoost (2014) started the modern era, LightGBM is faster on large datasets, CatBoost handles categorical features natively. Practical: For tabular data (the 80% of enterprise data that isn't text or images), these are still the best models. Always benchmark against an LLM-based feature pipeline + XGBoost. The full pipeline: features from LLM (or handcrafted) → XGBoost → eval. This combo is hard to beat in production.

"YAML Ain't Markup Language." A human-friendly data serialization format used for ML configs (HuggingFace, Weights & Biases, Hydra). The de facto standard for ML training configs. Practical: You'll write YAML configs more than you think. The killer feature: comments. The killer footgun: indentation (use 2 spaces, not tabs). Useful PyYAML pattern:

``python import yaml with open("config.yaml") as f: cfg = yaml.safe_load(f) ``

Zero-Shot Learning is the ability of an AI model to perform tasks or recognize categories it has never been explicitly trained on, using only its general knowledge and understanding. Practical: The default capability of modern LLMs. A model trained on next-token prediction can answer questions about topics it was never explicitly taught because language encodes general knowledge. Zero-shot prompting = just ask; few-shot = include examples; fine-tuning = train on examples. The progression: zero-shot → few-shot → fine-tuning, with cost/quality increasing.