Books › AI Foundations: from zero

Every word in one place

By Kapil Kumar Gupta

A to F

• Accuracy (3): how many guesses were right out of all guesses. It can fool you when the thing you look for is rare.
• Activation (4): the "decide" step in a neuron that lets networks learn curves, not just straight lines.
• Agent (11): an AI that plans a job and uses tools to do it in several steps.
• AI, artificial intelligence (2): a computer system doing a job that normally needs human judgement.
• Alignment (8): nudging a model towards what people want: helpful, honest and safe.
• API (1): the agreed way for one program to ask another for something. Think "service counter".
• App (1): a program made for people to use.
• Attention (6): a way for each word to look at the other words and weigh how much each matters.
• Backpropagation (4): passing the blame for a mistake backwards through a network, to work out which weights to change.
• Bias (nudge) (4): a number that makes a neuron easier or harder to convince.
• Bias (unfairness) (9): results that are systematically worse for some people or cases.
• Chatbot (0): a program you talk to in everyday language.
• Chunk (10): a small piece of a document, about one idea.
• Cloud (1): computers you rent from a provider over the internet.
• Context window (7): how much text a model can look at at once, counted in tokens.
• Coordinator (orchestrator) (11): the program that runs an agent's loop and passes messages between parts.
• Data (1): information stored in a form a computer can use.
• Data leakage (3): exam information sneaking into the study pile, which makes scores meaningless.
• Database (1): an organised place where information is stored.
• Decoder (6): the part of a model that writes text one word at a time.
• Deep learning (4): machine learning with many layers of tiny deciders.
• DPO (8): a simpler way to learn from people's rankings of answers.
• Embedding (5): a list of numbers that stands for the meaning of a piece of text.
• Encoder (6): the part of a model that reads and understands text.
• Epoch (4): one full pass through the study examples.
• Fail closed (11): when a check cannot be done, stop instead of going ahead.
• Fine-tuning (8): training a model a little more for a special style or job.

G to P

• Generative AI (2): AI that creates new content, such as text, pictures or code.
• Guardrail (11): a limit or check that keeps an AI from doing something it should not.
• Hallucination (9): an answer that sounds right but is made up.
• Hardware (1): the physical parts of a computer.
• Hybrid search (10): using meaning-based and keyword search together.
• Inference (8): using a trained model to answer. Nothing is learned.
• Knowledge cut-off (9): the date after which a model learned nothing new.
• Label (3): the right answer attached to an example.
• Language model (7): a model that has learned which words tend to follow which, and writes by choosing the next word.
• Layer (4): a row of neurons in a network.
• Learning rate (4): how big each adjustment step is during training.
• Loss (4): a number saying how wrong a network's answer was.
• Machine learning (3): a way of building AI by letting the computer learn patterns from examples.
• MCP (11): a standard way for AI apps to connect to tools.
• Memory, for agents (11): notes stored outside the model and put back in front of it when needed.
• Metadata (5): extra details attached to an entry, used for filtering and explaining.
• Model (0): the part of an AI system that has learned something from examples.
• Neuron (4): one tiny voter that adds up weighted clues and decides how loudly to speak.
• Overfitting (3): learning the study examples too closely, so it fails on new ones.
• Parameters (7): the adjustable numbers inside a model.
• Precision (3): when the model says "yes", how often it is right.
• Pre-training (8): the first, huge stage where a model learns by guessing the next word.
• Prompt (8): the instruction and details you give a model.
• Prompt injection (9): a hidden instruction slipped into text the model reads.

R to Z

• RAG (10): look up the right pages first, then write the answer from them.
• Recall (3): out of all the real cases, how many the model caught.
• Re-ranking (10): a second, more careful sort of the first search results.
• Release gate (12): a rule that decides whether a change may go live, based on tests.
• RLHF (8): adjusting a model using people's rankings of its answers.
• Router (12): a part that sends each request to the best model for it.
• Server (1): a computer that answers requests from other computers.
• Similarity search (5): finding the stored vectors closest to a new one.
• Software (1): the instructions that tell a computer what to do.
• Supervised learning (3): learning from examples that come with the right answers.
• Temperature (7): a dial that controls how adventurous a model's word choice is.
• TF-IDF (5): an older way to score words by how often they appear in a document compared with all documents.
• Token (5): a small piece of text, often a word or part of a word.
• Tool (11): something an AI is allowed to use, such as a calculator or an order system.
• Top-k and top-p (7): two ways to limit the choice to the likeliest words.
• Trace (12): a written history of each step, so people can see what happened.
• Training (3): showing a model examples so it can learn.
• Transformer (6): a design for language models built from stacked blocks of attention and small thinking steps.
• Underfitting (3): a model that is too simple and misses the pattern.
• Unsupervised learning (3): learning without answers, by finding groups in the data.
• Vector (5): a list of numbers.
• Vector database (5): a store built to hold vectors and search them by closeness.
• Weight (4): how much say one clue has in a neuron. Most of what a network learns is weights.

Added in the deep dives (Level 2)

• Baseline (A): the simplest thing that could work, used as a yardstick.
• Compute-bound, memory-bound (E): limited by arithmetic speed; limited by how fast data can be read from memory.
• Contextual embedding (C): an embedding that changes with the words around it.
• Cosine similarity (C): a score of how much two arrows point the same way, from near 0 (unrelated) to 1 (the same direction).
• Cross-entropy (B): a loss for choosing between classes that punishes confident mistakes.
• Cross-validation (A): testing by rotating which part of the data is held out.
• Drift (data drift, concept drift) (A): the inputs or the right answers changing over time until a once-good model gets worse.
• EDA, exploratory data analysis (A): looking at the data, with counts and charts, before building anything.
• Feature, feature engineering (A): one clue the model sees; choosing and shaping those clues.
• Gradient (B): how much the loss changes if one weight is increased a little.
• Head (D): one attention process. A transformer runs several side by side.
• Hyperparameter (A): a setting you choose before learning, such as the size of a network.
• Index, approximate nearest neighbour search (C): a structure built in advance so a search can skip most of the data, finding very close matches fast.
• KV cache (E): the store of keys and values for earlier tokens, so they are not rebuilt at every step.
• Logits (E): the raw scores for every possible next token.
• Mask (D): blocking a word from looking at words that come after it.
• MLOps (A): the practices for running the machine learning workflow reliably.
• Normalisation (D): rescaling numbers into a sensible range.
• Optimiser (B): the rule for turning gradients into weight updates, such as Adam.
• Position code (D): numbers added to a word to tell the model where it sits.
• Prefill, decode (E): reading the prompt all at once; writing one token at a time.
• Query, key, value (D): the question a word asks, the label it offers, and the content it carries.
• Quantisation (E): storing a model's numbers with fewer bytes.
• Shortcut, residual connection (D): adding a part's input back to its result so nothing is lost.
• Softmax (D, E): a recipe that turns a list of scores into shares that add up to 100%.
• Speculative decoding (E): a small model drafts several tokens and the big model checks them in one pass.
• Target leakage (A): a clue that secretly contains the answer but will not exist when the model is used.
• Time to first token (E): the wait before the first word of an answer appears.

Where next

Back to the contents, or on to the main book, From One Call to a Platform.