AI & ML Quick Path

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
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