Glossary
166 terms in plain words, each linked to the lesson that explains it with an example.
- Accuracy
- The share of predictions that are correct. Misleading when one class is rare. Lesson: Measuring models honestly
- Active learning
- Letting the model pick the examples it is least sure about for people to label. Lesson: Collecting and labelling data, with SQL
- Agent
- An LLM application that decides which tools to call, in a loop, to reach a goal. Lesson: Tools and agents with human approval
- Agent loop
- The repeating cycle of an agent: the model decides, a tool runs, the result goes back to the model, until the task is done or a limit is reached. Lesson: Tools and agents with human approval
- Agent memory
- Information an agent keeps between steps or between sessions, such as past results or user preferences. Lesson: Tools and agents with human approval
- Agentic AI
- AI that works toward a goal in several steps, using tools and taking actions, with limits and human approval for risky steps. Lesson: "Generative AI and Agentic AI: the whole picture"
- Anomaly detection
- Finding rare, unusual records such as fraud or faults, often without labels. Lesson: Unsupervised learning: groups, compression and anomalies
- API (application programming interface)
- A web address and agreed format that programs use to talk to each other. Lesson: Serving a model as an API
- Artificial intelligence (AI)
- Computer systems that do tasks we associate with human intelligence, such as understanding language or recognising images. Lesson: What AI, machine learning, deep learning and generative AI are
- Attention
- The transformer step in which every token looks at the other tokens and takes in what is relevant. Lesson: Transformers and attention
- AUC (area under the ROC curve)
- A score from 0.5 (random) to 1 (perfect) for how well a model ranks positives above negatives. Lesson: Measuring models honestly
- Backpropagation
- The method that works out how much each weight contributed to the error so it can be adjusted. Lesson: Neural networks in plain words
- Bagging
- Training many models on random re-samples of the data and combining them by voting or averaging. Lesson: The main ML algorithms and when to use each
- Baseline
- The simplest reasonable approach (for example "always predict the most common class"), used to judge whether a model is worth it. Lesson: How an AI or ML project runs from idea to production
- Batch
- A group of examples processed together, in training or in serving. Lesson: Training deep networks well
- Batch normalisation
- A step inside a neural network that rescales each layer’s numbers to a steady range, which usually makes training faster and steadier. Lesson: Training deep networks well
- Batch serving
- Scoring many records on a schedule instead of one at a time on request. Lesson: Serving a model as an API
- Bias (in data)
- A systematic difference between the data and the real population that makes a model unfair or wrong for some groups. Lesson: Responsible AI: fairness, privacy, transparency and oversight
- BPE (byte-pair encoding)
- A tokenizer method that repeatedly merges the most frequent pairs of characters into new tokens. Lesson: Tokens and sampling settings
- Chain of thought
- Asking a model to work through intermediate steps before giving its final answer. Lesson: Prompt engineering that works in production
- Champion and challenger
- The current production model (champion) and a new candidate (challenger) compared on the same test. Lesson: "MLOps: versioning, pipelines and safe releases"
- Chunking
- Splitting documents into smaller passages so the right piece can be retrieved for RAG. Lesson: RAG: answering from your own documents
- Citation
- A pointer from a statement in an answer to the source passage that supports it, so a reader can check it. Lesson: RAG: answering from your own documents
- Classification
- Predicting a category, such as spam or not spam. Lesson: Classification: picking a category
- Clustering
- Grouping similar records without labels, for example customer segments. Lesson: Unsupervised learning: groups, compression and anomalies
- CNN (convolutional neural network)
- A neural network that scans small filters across an image to detect edges, shapes and objects. Lesson: Computer vision: classification, detection and segmentation
- Cold start
- The difficulty of recommending for new users or items with no history. Lesson: Recommender systems
- Computer use
- An agent controlling a computer the way a person does, by looking at the screen and clicking or typing. Lesson: Tools and agents with human approval
- Concept drift
- When the correct answer for the same inputs changes over time. Lesson: Monitoring models and AI apps in production
- Confusion matrix
- A table of correct and wrong predictions for each class. Lesson: Classification: picking a category
- Context packing
- Choosing and ordering the retrieved passages that fit in the prompt so the model gets the most useful information within its limit. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- Context window
- The maximum number of tokens a language model can read and write in one request. Lesson: Tokens and sampling settings
- Cosine similarity
- A measure of how similar two vectors are in direction; used to compare embeddings. Lesson: Embeddings and vector search
- Cross-validation
- Training and testing several times on different splits to get a more reliable score. Lesson: Measuring models honestly
- Data augmentation
- Creating extra training examples by changing existing ones, such as flipping an image. Lesson: Training deep networks well
- Data drift
- When live inputs stop looking like the training data. Lesson: Monitoring models and AI apps in production
- Data leakage
- When training uses information that will not be available at prediction time, giving falsely good results. Lesson: Feature engineering: turning raw data into model inputs
- Decision tree
- A model that makes a prediction through a series of yes/no questions about the features. Lesson: The main ML algorithms and when to use each
- Deep learning
- Machine learning with neural networks that have many layers. Lesson: Neural networks in plain words
- Deploying to cloud
- Running your AI service on rented servers so other people and systems can reach it reliably. Lesson: Production architecture for AI systems
- Diffusion model
- A generative model that creates images by gradually removing noise. Lesson: Generative models: autoencoders, GANs and diffusion
- Distillation
- Training a small model to copy a large model’s outputs so it is cheaper to run. Lesson: Speed, cost and scaling
- DPO (direct preference optimisation)
- A method to adjust an LLM using pairs of preferred and rejected answers. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- Dropout
- Randomly switching off some neurons during training to reduce overfitting. Lesson: Training deep networks well
- Durable workflow
- A multi-step process whose progress is saved, so it can resume after a crash, a restart or a long wait. Lesson: Tools and agents with human approval
- Early stopping
- Stopping training when validation results stop improving. Lesson: Training deep networks well
- Embedding
- A list of numbers that represents the meaning of a text, image or item, so similar things have similar numbers. Lesson: Embeddings and vector search
- Embedding model
- A model whose job is to turn text or other items into embeddings, not to write answers. Lesson: Embeddings and vector search
- Epoch
- One full pass through the training data. Lesson: Training deep networks well
- Epsilon-greedy
- A way to choose: most of the time pick the best option so far, and sometimes pick a random one to keep exploring. Lesson: Reinforcement learning
- Evaluation set (eval dataset)
- A fixed set of example inputs with the expected or acceptable answers, used to score an AI feature the same way every time and to check quality before every release. Lesson: Evaluating AI applications
- Excessive agency
- Giving an AI system more tools or permissions than it needs, so a mistake or attack can cause real damage. Lesson: Security for AI applications
- Feature
- One input column a model uses, such as tenure in months. Lesson: Feature engineering: turning raw data into model inputs
- Feature engineering
- Creating useful inputs from raw data, such as "days since last order". Lesson: Feature engineering: turning raw data into model inputs
- Feature store
- A shared system that serves the same feature values to training and to live predictions. Lesson: "MLOps: versioning, pipelines and safe releases"
- Federated learning
- Training a shared model across devices or organisations without moving their raw data. Lesson: Responsible AI: fairness, privacy, transparency and oversight
- Few-shot prompting
- Putting a few worked examples in the prompt to show the model what you want. Lesson: Prompt engineering that works in production
- Fine-tuning
- Further training an existing model on your own examples to change its behaviour or style. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- Fine-tuning vs prompting
- Prompting changes the instructions you send; fine-tuning changes the model itself. Try prompting (and RAG) first, and fine-tune when you need a consistent style or format. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- Function calling (tool calling)
- The model asking your application to run a named function with given inputs, as a structured request. Your code runs it and returns the result. Lesson: Calling an LLM from your application
- GAN (generative adversarial network)
- Two networks trained against each other: one generates fakes, the other tries to spot them. Lesson: Generative models: autoencoders, GANs and diffusion
- Generative AI
- AI that makes new content, such as text, images, sound or code, from a request called a prompt. Lesson: "Generative AI and Agentic AI: the whole picture"
- GGUF
- A file format for quantised models used by llama.cpp and Ollama to run LLMs on ordinary computers. Lesson: Running language models on your own machine
- GPU
- A processor with thousands of small cores, very fast for the matrix calculations in deep learning. Lesson: From laptop to big hardware: scaling training
- Gradient boosting
- Many small decision trees built one after another, each fixing the errors of the previous ones. Often the best choice for tables. Lesson: The main ML algorithms and when to use each
- Gradient clipping
- Limiting how large a training step can be, so one huge gradient cannot throw the model off course. Lesson: Training deep networks well
- Graph neural network (GNN)
- A network that learns from connected data such as social networks or molecules by passing messages between neighbours. Lesson: Graph neural networks: learning from connections
- GraphRAG
- A form of RAG that stores facts as a network of connected entities and uses those links to answer questions that span many documents. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- Guardrails
- Checks around a model that filter inputs and outputs and enforce policy in code. Lesson: Security for AI applications
- Hallucination
- A confident but false or unsupported statement from a language model. Lesson: How large language models work
- Hallucination check
- A test that looks for claims in an answer that the source documents do not support, so unsupported statements can be caught before users see them. Lesson: Evaluating AI applications
- Handoff
- Passing a task from one agent (or from an agent to a person) together with the context needed to continue. Lesson: Tools and agents with human approval
- Human in the loop
- A design where a person reviews or approves certain steps, especially risky actions, before they happen. Lesson: Tools and agents with human approval
- Hybrid search
- Combining keyword search and meaning-based (embedding) search, then merging the results. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- Hyperparameter
- A setting chosen before training, such as tree depth or learning rate. Lesson: Improving and explaining models
- Inference
- Using a trained model to make predictions or generate output. Lesson: How an AI or ML project runs from idea to production
- KV cache
- Stored attention results for earlier tokens so an LLM does not recompute them for each new token. Lesson: From laptop to big hardware: scaling training
- Label
- The correct answer attached to a training example. Lesson: Data basics: types, features, labels and splits
- Large language model (LLM)
- A very large neural network trained on text to predict the next token, able to follow instructions and write. Lesson: How large language models work
- Latency and cost
- How long a model call takes and what it costs. They usually trade off against quality, so you measure both. Lesson: Speed, cost and scaling
- Latency budget
- The total time a request is allowed to take, split across its steps such as retrieval, model call and checks. Lesson: Monitoring models and AI apps in production
- Learning rate
- How big a step the model takes each time it adjusts its weights. Lesson: Training deep networks well
- Learning-rate schedule
- A plan for changing the learning rate during training, for example starting small, rising, then shrinking. Lesson: Training deep networks well
- Linear regression
- A model that predicts a number as a weighted sum of the inputs. Lesson: Regression: predicting a number
- LLM as judge
- Using one language model to grade the answers of another against a written scoring guide. Useful at scale, but it must be checked against human grades. Lesson: Evaluating AI applications
- Logistic regression
- A simple, fast classification model that outputs a probability. Lesson: Classification: picking a category
- LoRA (low-rank adaptation)
- Fine-tuning by training small extra weight matrices while the original model stays frozen. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- Loss
- A number that measures how wrong the model is; training tries to make it smaller. Lesson: How a model learns: loss, training and overfitting
- Machine learning (ML)
- Building programs that learn patterns from examples instead of following hand-written rules. Lesson: What AI, machine learning, deep learning and generative AI are
- MAE (mean absolute error)
- The average size of prediction errors, in the target’s units. Lesson: Regression: predicting a number
- MCP (Model Context Protocol)
- An open standard for connecting AI applications to tools and data sources. Lesson: AI frameworks and MCP: what to use in Python and .NET
- Metadata filter
- A condition on fields such as date, author or department that limits which stored items a search may return. Lesson: Embeddings and vector search
- Mixture of experts (MoE)
- A model design where a router sends each token to a few of many expert blocks, so only part of the model runs per token. Lesson: Designing a language model
- MLOps
- Practices and tools for versioning, testing, releasing and monitoring ML models. Lesson: "MLOps: versioning, pipelines and safe releases"
- Model routing
- Sending each request to a suitable model, for example a small cheap one for easy tasks and a larger one for hard tasks. Lesson: Speed, cost and scaling
- Model selection
- Choosing which model to use for a task by testing candidates on your own examples for quality, speed and cost. Lesson: Calling an LLM from your application
- Multi-agent system
- Several agents, each with its own role or tools, working together on one task. Lesson: Tools and agents with human approval
- Multimodal model
- A model that handles more than one kind of input or output, such as text and images. Lesson: Multimodal AI apps: images, documents and voice
- Named entity recognition (NER)
- Finding names of people, companies, places, dates and amounts in text. Lesson: Classification: picking a category
- Neural network
- Layers of simple units connected by weights that together learn complex patterns. Lesson: Neural networks in plain words
- Observability
- Collecting logs, traces and measurements so you can understand what a running system is doing and why it fails. Lesson: Monitoring models and AI apps in production
- ONNX
- An open model file format with fast runtimes for Python, C#, Java and more. Lesson: Speed, cost and scaling
- Overfitting
- When a model memorises training data and does worse on new data. Lesson: How a model learns: loss, training and overfitting
- PCA (principal component analysis)
- Compressing many columns into a few that keep most of the information. Lesson: Unsupervised learning: groups, compression and anomalies
- PDF parsing
- Extracting clean text, tables and structure from PDF files so they can be chunked and searched. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- Perplexity
- A score for language models: lower means the model is less surprised by real text. Lesson: Evaluating language models
- pgvector
- An extension that lets the PostgreSQL database store embeddings and search them by similarity. Lesson: Embeddings and vector search
- PII redaction
- Finding personal details such as names, emails or card numbers in text and removing or masking them before the text is stored or sent on. Lesson: Security for AI applications
- Planning (agents)
- An agent breaking a goal into smaller steps and deciding their order before or while it acts. Lesson: Tools and agents with human approval
- Precision
- Of the items the model flagged, the share that were really positive. Lesson: Measuring models honestly
- Pretraining
- The first, very large training stage where a model learns from huge amounts of general data. Lesson: How large language models work
- Prompt
- The text (instructions, context and question) sent to a language model. Lesson: Prompt engineering that works in production
- Prompt A/B test
- Running two versions of a prompt on the same cases (or on different groups of users) and comparing results to see which is better. Lesson: Evaluating AI applications
- Prompt caching
- A provider feature that reuses the processed start of a long prompt that repeats between requests, reducing time and cost. Lesson: Prompt engineering that works in production
- Prompt engineering
- Writing and testing prompts, with clear instructions, context and examples, to get reliable output from a model. Lesson: Prompt engineering that works in production
- Prompt injection
- Text that tries to override an AI system’s instructions, typed by a user or hidden in content it reads. Lesson: Security for AI applications
- PSI (population stability index)
- A drift score comparing live and training distributions; above about 0.25 means investigate. Lesson: Monitoring models and AI apps in production
- QLoRA
- LoRA fine-tuning on a base model that is compressed to 4-bit numbers, so it fits in much less memory. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- Quantisation
- Storing model weights with fewer bits (for example 4-bit) to save memory and often gain speed. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- Query rewriting
- Rewording a user question, for example filling in missing context, so that retrieval finds better passages. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- RAG (retrieval-augmented generation)
- Retrieving relevant passages from your documents and giving them to an LLM so it answers from them. Lesson: RAG: answering from your own documents
- Random forest
- Many decision trees trained on random parts of the data, with their votes combined. Lesson: The main ML algorithms and when to use each
- Rate limit
- A cap on how many requests are allowed in a period of time, set by a provider or by you to protect a service. Lesson: Speed, cost and scaling
- Re-indexing
- Rebuilding or updating the search index when documents, chunking rules or the embedding model change. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- Re-ranking
- A second, more careful scoring of retrieved passages to put the best ones first. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- Reasoning model
- An LLM trained to think through a problem internally before answering; slower but stronger on hard tasks. Lesson: Prompt engineering that works in production
- Recall
- Of all the real positives, the share the model found. Lesson: Measuring models honestly
- Recommender system
- A system that suggests items (products, films, articles) a user is likely to want. Lesson: Recommender systems
- Red teaming
- Attacking your own AI system on purpose before release to find weaknesses. Lesson: Security for AI applications
- Regression
- Predicting a number, such as a price or a delivery time. Lesson: Regression: predicting a number
- Regression test
- A saved check that confirms something that used to work still works after a change to the prompt, model or code. Lesson: Evaluating AI applications
- Regularisation
- Techniques that discourage a model from becoming too complex, to reduce overfitting. Lesson: Improving and explaining models
- Reinforcement learning (RL)
- Learning by trial and error from rewards, as in game playing and robot control. Lesson: Reinforcement learning
- Response caching
- Saving the answer to a request so that the same request later is answered instantly without calling the model again. Lesson: Speed, cost and scaling
- Retries and fallbacks
- Trying a failed call again a limited number of times, then switching to a backup (another model, a rule or a person). Lesson: Production architecture for AI systems
- Retrieval evaluation
- Measuring whether the search step finds the right passages for test questions, separately from the quality of the final answer. Lesson: Advanced RAG: chunking, hybrid search, re-ranking and evaluation
- RLHF (reinforcement learning from human feedback)
- Adjusting an LLM using human ratings of its answers. Lesson: Fine-tuning: SFT, LoRA, QLoRA and preference tuning
- RNN and LSTM
- Networks that read sequences step by step with a memory; largely replaced by transformers for text. Lesson: Text and sequences: tokens, embeddings and RNNs
- Sampling temperature
- A setting that controls randomness in generated text: low is focused, high is varied. Lesson: Tokens and sampling settings
- Sandboxing
- Running code or tools in a restricted space so that a mistake or attack cannot reach the rest of the system. Lesson: Tools and agents with human approval
- Secrets management
- Keeping API keys and passwords out of code and storing them where only the running service can read them. Lesson: Production architecture for AI systems
- Segmentation
- Labelling every pixel of an image with a class. Lesson: Computer vision: classification, detection and segmentation
- Self-supervised learning
- Learning from data that labels itself, such as predicting the next word. Lesson: What AI, machine learning, deep learning and generative AI are
- Shadow mode
- Running a new model on live traffic while only logging its answers. Lesson: "MLOps: versioning, pipelines and safe releases"
- SHAP (Shapley values)
- A method that shows how much each feature pushed one prediction up or down. Lesson: Improving and explaining models
- Skill (agent skill)
- A packaged set of instructions and files that an agent loads when it needs to do a particular kind of task. Lesson: Tools and agents with human approval
- Speculative decoding
- A small model drafts tokens and a large model checks them, making generation faster with the same output. Lesson: Running language models on your own machine
- Streaming
- Receiving a model answer piece by piece as it is generated, so users see text sooner. Lesson: Calling an LLM from your application
- Structured output
- Making an LLM return data in a fixed format such as JSON matching a schema. Lesson: Calling an LLM from your application
- Subagent
- A helper agent started by a main agent to do one part of the work, often with its own context and tools. Lesson: Tools and agents with human approval
- Supervised learning
- Learning from examples that include the correct answer. Lesson: How a model learns: loss, training and overfitting
- Synthetic data
- Data generated by scripts, simulators or models instead of collected from real people. Lesson: Collecting and labelling data, with SQL
- System prompt
- Standing instructions given to a model before the user speaks, setting its role, rules and format. Lesson: Prompt engineering that works in production
- Test set
- Data kept aside and used only once, at the end, to measure how the model does on new data. Lesson: How a model learns: loss, training and overfitting
- Time series
- Data recorded over time, such as daily sales, used for forecasting. Lesson: Time-series forecasting
- Token
- A piece of text (a word, part of a word or punctuation) that a language model reads and writes. Lesson: Tokens and sampling settings
- Token cost tracking
- Recording how many tokens each request uses and what they cost, per feature or customer, so spending stays visible. Lesson: Monitoring models and AI apps in production
- Tool design
- Choosing clear names, descriptions and inputs for the tools an agent can use, so the model picks the right one and uses it correctly. Lesson: Tools and agents with human approval
- Tracing
- Recording each step of one request (prompt, retrieval, tool calls, answer, time taken) so you can see exactly what happened. Lesson: Monitoring models and AI apps in production
- Transfer learning
- Starting from a model trained on a large dataset and adapting it to your smaller task. Lesson: Computer vision: classification, detection and segmentation
- Transformer
- The neural network design behind modern LLMs, built from attention and feed-forward layers. Lesson: Transformers and attention
- Underfitting
- When a model is too simple to capture the pattern and does badly even on training data. Lesson: How a model learns: loss, training and overfitting
- Unsupervised learning
- Finding structure in data that has no labels. Lesson: Unsupervised learning: groups, compression and anomalies
- Validation set
- Data used during development to compare models and choose settings. Lesson: How a model learns: loss, training and overfitting
- Vector database
- A database that stores embeddings and finds the most similar ones quickly. Lesson: Embeddings and vector search
- Weight
- A number inside a model that is adjusted during training. Lesson: Neural networks in plain words
No terms match these filters.