Artificial Intelligence Glossary — Key Terms Explained

The broad field of building systems that perform tasks we associate with human intelligence — understanding language, recognising images, making decisions, playing games. It's the umbrella term; ML and deep learning sit inside it.

A subset of AI where systems learn patterns from data instead of being explicitly programmed. You give the system examples; it learns a mapping from input to output. Spam filters, recommendation engines and fraud detection are classic examples.

A subset of ML that uses neural networks with many layers. Deep learning is what made modern image recognition, speech recognition and language models possible. "Deep" refers to the number of layers, not to the depth of understanding.

The collection of examples used to train or evaluate a model. Datasets are usually split into three: training set (the model learns from this), validation set (used to tune during development) and test set (used once at the end to estimate real-world performance).

An input variable a model uses to make predictions. In a house price model, features might be area, number of bedrooms, location and age. Good features matter more than good algorithms most of the time.

The target output in supervised learning — the "correct answer" for a training example. In spam detection, the label is "spam" or "not spam". In image classification, it's the class name.

The process of adjusting a model's parameters so its predictions get closer to the correct answers on the training data. Training is iterative — repeat millions of times and the model gradually improves.

Using a trained model to make predictions on new data. Training happens once (or periodically); inference happens constantly in production. Inference is usually much cheaper than training — but for large models, it's still substantial.

Learning from labelled examples — input-output pairs. The model learns to map inputs to known outputs. Two main types: classification (predict a category, e.g., spam/not-spam) and regression (predict a number, e.g., house price).

Learning from unlabelled data — the model finds structure on its own. Common uses: clustering (grouping similar items), dimensionality reduction (compressing data), and anomaly detection.

Learning by trial and error, guided by rewards and penalties. An agent takes actions in an environment and learns a policy that maximises long-term reward. Used in robotics, game-playing (AlphaGo) and increasingly in fine-tuning language models (RLHF).

When a model memorises the training data instead of learning general patterns. It performs great on training data and poorly on new data. Common fixes: more data, simpler models, regularisation, early stopping.

Standard ways to measure classification performance. Accuracy is the fraction of correct predictions. Precision is: of the ones the model said were positive, how many really were. Recall is: of all the actual positives, how many did it find. F1 balances precision and recall. Choose based on what matters — a spam filter favours precision; a cancer screen favours recall.

The tension between models that are too simple (high bias, underfit) and models that are too complex (high variance, overfit). Good model selection finds the middle ground where performance on new data is best.

A model made of layers of connected nodes ("neurons"). Each layer transforms its input, and learning adjusts the connection weights. A "deep" neural network has many layers — that's where the name deep learning comes from.

The algorithm that trains neural networks. It computes how much each weight contributed to the error and adjusts it to reduce that error. Repeat over many examples, and the network improves.

A neural network designed for images. Convolutional layers slide small filters across the image to detect features (edges, textures, shapes), building up from simple to complex. CNNs were the breakthrough behind modern image recognition.

A neural network designed for sequences — text, speech, time series. It processes input one step at a time, keeping a hidden state that carries information forward. Largely superseded by transformers for language, but still used in some time-series settings.

The architecture behind modern LLMs. Its key innovation is self-attention — every token can attend to every other token in the sequence, letting the model capture long-range relationships. Introduced in the 2017 paper "Attention Is All You Need", it's now the basis of GPT, Claude, Gemini, Llama and essentially every major language model.

A processor with thousands of small cores, ideal for the massively parallel computations that deep learning needs. Training and running large models on CPUs is impractical — GPUs (and increasingly TPUs) are what make modern AI feasible.

A transformer-based model trained on vast amounts of text to predict the next token. Examples: GPT-4, Claude, Gemini, Llama. LLMs can write, summarise, translate, code and answer questions — because next-token prediction, done at scale, generalises to many tasks.

The unit an LLM processes — roughly a word-fragment. "Uncodemy" might be two or three tokens; "the" is one. Pricing and context limits are counted in tokens, not words. As a rough rule: 1 token ≈ 0.75 English words.

A list of numbers representing meaning. Words, sentences or documents become vectors in a high-dimensional space, and similar meanings end up close together. Embeddings power semantic search, recommendation systems and RAG.

The maximum amount of text (in tokens) a model can consider at once. GPT-4o and Claude handle hundreds of thousands of tokens; earlier models handled a few thousand. Larger context lets you feed more documents, but every token costs compute.

The input you send to an LLM. Prompt engineering is the practice of crafting that input — giving clear instructions, examples, constraints and formats — to get better output. It's a practical skill, not a science, and small changes matter a lot.

A pattern for grounding LLMs in specific knowledge. Rather than relying on what the model learned in training, you: (1) embed your documents, (2) at query time find the most relevant chunks via semantic search, (3) pass those chunks into the prompt. The model then answers using that retrieved context — reducing hallucination and letting it reference internal or recent information.

Continuing to train a pre-trained model on your own data to specialise it. Cheaper than training from scratch, but heavier than RAG. Fine-tuning changes the model's weights; RAG doesn't. Rule of thumb: for new facts, use RAG; for new behaviour, use fine-tuning.

When an LLM confidently produces incorrect information. The model is optimised to produce plausible text, not verified facts. Common fixes: RAG for grounding, better prompts, chain-of-thought, and always verifying high-stakes output.

A training stage that aligns LLMs with human preferences. Humans rank model outputs; a reward model learns from those rankings; the LLM is tuned to maximise the reward. It's a big reason why modern models are more helpful and less toxic than their base versions.

A system that uses an LLM to take actions — call tools, query APIs, browse, write files — in pursuit of a goal. Agents chain multiple model calls with tools and observation. Powerful, but they fail in ways plain chatbots don't — evaluation and guardrails matter.

How long a model takes to produce a response. For real-time products (chat, search) latency often matters more than absolute quality. Latency depends on model size, hardware, prompt length and streaming strategy.

How you interact with most commercial AI models in production — you send a request to an endpoint (e.g., OpenAI's API) and receive a response. You don't host the model; you call it. This is why most AI product teams need little ML infrastructure and a lot of application engineering.

The set of tests that measure whether an AI system is doing its job. For LLM apps, evals usually involve a mix of automated checks and human judgment on test cases. Without evals, you cannot tell whether a prompt change improved or broke the system.

The practices for deploying and maintaining ML systems in production — versioning data and models, monitoring drift, running experiments, handling retraining. MLOps is to ML what DevOps is to software: the discipline that makes it reliable.

When a deployed model's performance degrades because the real world has changed since training. Fraud patterns shift; language shifts; customer behaviour shifts. Monitoring for drift and retraining on fresh data are part of any serious ML deployment.

A rule or check that constrains an AI system's output — blocking certain topics, enforcing formats, filtering PII, preventing dangerous tool calls. Guardrails are a practical engineering answer to the fact that models are probabilistic, not deterministic.

AI is the broadest field — any system performing intelligent tasks. ML is a subset of AI: systems that learn from data. Deep learning is a subset of ML: neural networks with many layers. Every deep learning system is ML; not every ML system is deep learning.

An embedding is a numeric vector that represents meaning. Similar meanings end up close in the vector space. This makes semantic search possible — you can find documents similar in meaning, not just matching keywords. Embeddings are also the foundation of RAG.

Use RAG when you need the model to reference specific, changing information (docs, tickets, product data). Use fine-tuning when you need the model to adopt a specific behaviour, style or specialised task pattern. RAG is cheaper, faster to set up, and updates instantly. Fine-tuning changes weights, so it's heavier and slower to iterate.

A hallucination is when an LLM produces confident but incorrect output. It happens because models are trained to produce plausible text, not verified facts. Reduce it by: giving the model high-quality context (RAG), asking for citations, prompting for step-by-step reasoning, and validating output programmatically before acting on it.

ML engineers typically train, deploy and maintain models — they work close to the model. AI engineers (in the GenAI sense) build products on top of existing models via APIs — they focus on prompting, RAG, agents and evals. The roles overlap, and the boundary is blurry in practice.

No — you can be productive with ChatGPT, Copilot or Claude knowing almost none of this vocabulary. But if you want to build AI products, evaluate them seriously, or discuss them in interviews, you need the terms in the LLMs and GenAI section at minimum.

Build something small. Write a script that calls an LLM API. Add RAG with a few of your own documents. Try fine-tuning a small open-source model. The vocabulary will stick because you'll be forced to use each term in context.

Often, yes — many "AI-powered" products are simple ML or even rules-based systems. GenAI products genuinely use LLMs. It's worth being precise: "AI" is a broad category and product marketing frequently exaggerates what's inside.

Probably "hallucination". It sounds like a bug, but it's really an inherent property of how these models generate text. Others: "embedding" (sounds abstract, is actually just a vector) and "context window" (sounds minor, is a real constraint on product design).

Our Python for AI programme covers the ML and deep learning layers in depth, and our GenAI track covers LLMs, RAG, agents and evals with hands-on projects. The blog tutorials cover most individual terms — start with "Your first RAG pipeline".