The AI glossary: 30 terms in 60 seconds: study notes

 

0.10 The AI glossary: 30 terms in 60 seconds: study notes

Learn AI by Story

Thirty core AI words fall into five groups: data, model, training, network and generative. Learn the groups and each word has a place to stick.

1. The idea in one sentence

AI vocabulary is easier when you sort it by where each word sits in the pipeline: data goes in, a model is trained, a network is the usual model, and generative systems produce new content.

2. The story from the video

Zoya is new to AI and the words feel like a foreign language. The video gives thirty terms in five groups, one line each, then she reads a sentence full of jargon (the transformer was fine-tuned on a labelled dataset, then tested to avoid overfitting) and it makes sense.

3. The full glossary (30 terms)

Group 1: Data words

Term	Precise definition	Plain English
Dataset	A structured collection of examples used to build or test a model	A pile of examples
Feature	A measurable property used as model input (for example, a house's area)	One input column
Label	The correct answer attached to an example in supervised learning	The right answer
Training set	The portion of data used to fit the model	Data it learns from
Test set	Data held back and used only to measure final performance	The final exam
Bias	Systematic skew in data or results that disadvantages some outcomes or groups (also, a separate technical term: a constant offset inside a model)	Unfair or lopsided tendency

Group 2: Model words

Term	Precise definition	Plain English
Model	The learned function mapping inputs to outputs, produced by training	What the AI learned
Algorithm	The step-by-step procedure used to train a model	The learning recipe
Parameter	A number inside a model that training adjusts	A learned dial
Weights	The parameters that scale how strongly one input affects a neuron	How much each input matters
Architecture	The structure and layout of a model's components	The blueprint
Inference	Running a trained model to get a prediction on new input	Using the model

Group 3: Training words

Term	Precise definition	Plain English
Loss	A number measuring how wrong the model's predictions are	The error score
Epoch	One complete pass through the training data	One full lap of the data
Gradient descent	An algorithm that adjusts parameters in the direction that reduces loss	Walking downhill on the error
Overfitting	Fitting the training data so closely that performance on new data drops	Memorizing, not learning
Underfitting	A model too simple or undertrained to capture the pattern	Learning too little
Hyperparameter	A setting chosen by people before training (learning rate, number of layers)	A knob you set yourself

Group 4: Network words

Term	Precise definition	Plain English
Neuron (node)	A small unit that takes weighted inputs, adds them and applies a function	A tiny calculator
Layer	A group of neurons that process data at the same stage	A row of calculators
Neural network	A model made of layers of connected neurons	Stacked layers that learn
Embedding	A list of numbers representing the meaning of a word, image or item	Meaning as numbers
Token	A piece of text (a word, part of a word or symbol) that a language model reads	A chunk of text
Transformer	A neural network architecture built on attention, introduced in 2017 and used in most modern language models	The design behind modern chatbots

Group 5: Generative words

Term	Precise definition	Plain English
LLM (large language model)	A very large neural network trained on huge text to predict the next token	A giant text predictor
Prompt	The input instruction or context given to a generative model	What you ask it
Hallucination	A fluent but false or invented output	A confident wrong answer
Fine-tuning	Further training of a pre-trained model on a smaller, specific dataset	Specializing a model
RAG (retrieval-augmented generation)	Fetching relevant documents and giving them to the model along with the prompt	Letting it look things up
Agent	A system in which a model plans and uses tools to carry out multi-step tasks	AI that acts, not just answers

4. How the words fit together: one pipeline

1. Collect a dataset and split it into a training set and a test set.
2. Choose the features (inputs) and, for supervised tasks, the labels (answers).
3. Choose a model architecture (for example, a neural network) and an algorithm for training it. Set the hyperparameters.
4. Train: for each epoch, make predictions, measure the loss, and use gradient descent to update the parameters (weights).
5. Watch for overfitting (training score great, test score poor) and underfitting (both poor).
6. Test on the test set; check for bias.
7. Deploy: running the trained model on new input is inference.
8. For language systems: text is split into tokens, converted into embeddings, and processed by a transformer; a prompt triggers an output; RAG or fine-tuning can adapt it; an agent adds tools and multi-step planning; and hallucinations are the main reliability risk.

5. Everything the video skipped

• More terms you will meet soon: activation function (the nonlinearity inside a neuron), backpropagation (how the loss is traced back to each weight), learning rate (the step size in gradient descent), batch (a small group of examples processed together), validation set (a third slice used to tune choices), regularization (techniques that discourage overfitting), accuracy, precision and recall (ways to score a classifier), context window (how much text a model can read at once), temperature (a setting that changes how random the output is), multimodal (handling text, images, audio together), and benchmark (a standard test).
• Two meanings of bias. In fairness, bias is unfair skew. In a neural network, a bias is a learned constant added to a neuron's sum. Context tells you which is meant.
• Parameters versus hyperparameters. Parameters are learned by the algorithm; hyperparameters are chosen by you.
• Training versus inference. Training is expensive and happens first; inference is cheaper and happens every time someone uses the model.
• Model versus algorithm. The algorithm is the process; the model is the result. Same algorithm on different data gives a different model.
• Loss versus accuracy. Loss is what training minimizes; accuracy is what people report. They are related but not the same.
• Fine-tuning versus RAG. Fine-tuning changes the model's weights; RAG leaves the weights alone and supplies information at question time. RAG is better for fresh facts; fine-tuning is better for style or specialized behaviour.
• Agents are new and imperfect. They chain steps, so errors can compound; human review is advised for important actions.
• Connects to: 0.02 (AI, ML, DL, GenAI), 0.05 (kinds of learning), 0.08 (myths), and the later modules on training, neural networks and transformers.

6. Worked example: the vocabulary on one tiny task (illustrative)

Goal: predict whether a student passes, from hours studied.

Hours studied (feature)	Passed (label)
1	No
2	No
4	Yes
5	Yes
6	Yes
3	Yes

1. Dataset: 6 rows. Training set: first 4 rows; test set: last 2 rows.
2. Model: a simple rule with one weight and one threshold (a parameter pair).
3. Training: try a threshold of 3 hours. On the training rows it gets 1 hour no, 2 hours no, 4 yes, 5 yes: 4 of 4 right, so loss is 0.
4. Test: the test rows are 6 hours (yes) and 3 hours (yes). The rule says 3 hours is a pass, 6 is a pass: both right.
5. Inference: a new student with 2.5 hours gets predicted no.
6. A bigger, noisier real dataset would show where overfitting (too-fancy rule) and underfitting (a rule that always says yes) happen.

7. Quick comparison tables

Pair	Difference
Training set vs test set	Learn from one, judge on the other
Overfitting vs underfitting	Memorizes vs learns too little
Parameter vs hyperparameter	Learned by the algorithm vs set by you
Training vs inference	Building the model vs using it
Fine-tuning vs RAG	Changes weights vs supplies documents at question time

8. Common mistakes and myths

• Testing on data the model trained on, which hides overfitting.
• Believing a bigger model is always better; data and fit matter too.
• Treating model and algorithm as the same thing.
• Thinking tokens are always whole words; they are often word pieces.
• Assuming an LLM looks facts up; by default it predicts text from patterns.
• Calling any chatbot an agent; an agent plans and uses tools.

9. Real-life uses of this vocabulary

• Reading AI news or product pages with confidence.
• Talking to data teams: ask for the test set results and the data's coverage.
• Choosing between fine-tuning and RAG for a company chatbot.
• Spotting overfitting claims such as perfect training accuracy.

10. Self-check questions

1. What is a label? The correct answer attached to an example.
2. What is the difference between a training set and a test set? Training teaches the model; the test set measures it on unseen data.
3. Parameter or hyperparameter: the learning rate? Hyperparameter.
4. What does gradient descent do? Adjusts parameters step by step to reduce the loss.
5. Which is worse for new data: overfitting or underfitting? Both fail on new data; overfitting looks great on training data but poor on test data.
6. What is an epoch? One full pass through the training data.
7. What is an embedding? A list of numbers that represents meaning.
8. Define inference. Using a trained model to predict on new input.
9. When would you choose RAG over fine-tuning? When the model must use fresh or private documents without retraining.
10. Translate this sentence: the transformer was fine-tuned on a labelled dataset, then tested to avoid overfitting. A modern language-model design was specialized using examples with answers, then checked on unseen data to make sure it had not just memorized.

11. Key takeaways and go deeper

• Thirty words, five groups: data, model, training, network, generative.
• Most confusion comes from mixing up pairs such as training and test, parameter and hyperparameter, model and algorithm.
• Go deeper: read about activation functions, backpropagation, learning rate, validation sets and regularization.
• Next roadmap ID: 1.01, Vectors: lists of numbers that point somewhere (module 1, math in pictures).

Learn AI by Story: one concept, one story, every day.