Introduction
The world of AI and machine learning comes with a lot of jargon. Don’t worry – this glossary breaks down essential terms in plain English. Each term below is defined in a beginner-friendly way, often with an example or analogy. Use this as a handy reference whenever you encounter an unfamiliar concept in this blog series (or anywhere in your AI/ML learning journey).
Artificial Intelligence (AI):
A broad field of computer science focused on creating systems that exhibit intelligence similar to human intelligence. This includes any technique that enables computers to solve problems or perform tasks that normally require human cognition (such as understanding language, recognizing images, learning from experience, or making decisions). AI is the overarching concept – think of it as the goal of making machines smart. (For a detailed intro to AI, see “What is Artificial Intelligence?”)
Machine Learning (ML):
A subset of AI that refers to algorithms and techniques that allow computers to learn from data. Instead of being explicitly programmed with specific instructions for every scenario, an ML system figures out patterns in data and uses those patterns to make predictions or decisions. In other words, the machine improves at a task with experience. For example, a machine learning program can learn to filter spam emails by studying a large dataset of emails labeled “spam” or “not spam.” (For more on ML basics, see “What is Machine Learning?”)
Deep Learning:
A specialized subset of machine learning that uses neural networks with many layers (hence “deep”) to learn complex patterns from data. Deep learning has driven many recent AI breakthroughs, especially in areas like image recognition, speech recognition, and natural language processing. These deep neural networks loosely mimic the structure of the human brain’s neural connections. The key feature is that with enough layers and data, deep learning models can automatically learn representations of the data at multiple levels of abstraction (for example, in image recognition, early layers might learn edges, later layers learn object parts, and deepest layers assemble those into full objects). Deep learning is basically an advanced form of ML – all deep learning is machine learning, but not all ML is deep learning. (this post touches on deep learning in the AI vs. Machine Learning and Deep Learning section.)
Neural Network:
A computational model inspired by the human brain’s network of neurons. A neural network is composed of layers of interconnected nodes (also called neurons). Each neuron takes input data, performs a simple calculation (a weighted sum with an activation function), and passes the result to the next layer. A basic neural network has an input layer (which receives the data), one or more hidden layers (which transform the data), and an output layer (which produces the result, like a prediction). Neural networks can approximate very complex functions, which is why they’re at the core of deep learning. Training a neural network involves adjusting the weights of all these connections so that the network’s output gets closer to the desired output. This training is often done through a process called backpropagation (see Post 7 for how backpropagation works to train neural nets). In practical terms, neural networks power things like handwriting recognition, face recognition, and language translation in modern AI systems.
Dataset (Training Set & Test Set):
In machine learning, a dataset is the collection of data you use to train and evaluate your models. Typically, we split data into a training set and a test set (and often also a validation set). The training set is the portion of data that the model learns from – the algorithm adjusts itself based on this data’s patterns. The test set is kept separate and not shown to the model during training; it’s used after training to evaluate how well the model generalizes to new, unseen data. For example, if you have 1,000 labeled examples, you might use 800 for training and reserve 200 for testing. After training on the 800 examples, you check the model’s accuracy on the 200 test examples. This practice helps detect overfitting (when a model performs well on training data but poorly on new data). (We demonstrated a training/test split in Post 8 when building our first ML model.)
Algorithm vs. Model:
In machine learning, an algorithm is the learning process or recipe, while a model is the result of that learning process. The algorithm is the procedure that examines data and adjusts parameters; the model is the final set of parameters and structure that can make predictions. Think of the algorithm as the method (like the act of training) and the model as the output (like the trained program you can use). For example, “linear regression” is a machine learning algorithm. When you apply the linear regression algorithm to some training data, you get a specific linear equation (with learned coefficients) – that equation is the trained model, which you can then use to predict new values. In short: you choose an algorithm, feed it data, it produces a model.
Feature & Label:
In supervised learning, a feature is an individual measurable property or input variable, and a label (or target) is the output variable you’re trying to predict. Features are sometimes also called predictors or independent variables, while labels are the dependent variable or outcome. For instance, if we’re predicting house prices: features might be the house’s size, number of bedrooms, location, etc., and the label is the price. In a customer churn prediction example: features could be things like customer age, usage frequency, last login date, etc., and the label is a binary indicator of whether the customer churned (yes or no). Good feature selection and engineering (deciding which features to use or how to represent them) is crucial for building effective models. (When we built a simple model in Post 8, we had features like petal length, petal width of an iris flower, and the label was the species name.)
Supervised Learning vs. Unsupervised Learning:
These are two broad categories of ML approaches. Supervised learning uses labeled data – the training data includes the answers, and the goal is for the model to learn to predict those answers on new data. Unsupervised learning uses unlabeled data – the model tries to find patterns or structure without any explicit correct answers given. We didicated Supervised vs. Unsupervised Learning post to explaining these in detail. In a nutshell, use supervised learning if you have example input-output pairs (like predicting a known outcome), and use unsupervised learning if you want to explore data without predefined categories (like clustering or anomaly detection).
Overfitting & Underfitting:
These terms describe common problems in model training. Overfitting happens when a model learns the training data too well, including its noise and quirks, to the point that it doesn’t generalize to new data. An overfit model might have very high accuracy on training data but perform poorly on test data. It’s like a student who memorized practice test answers without understanding the material – they ace the practice test but fail the real exam. Underfitting is the opposite: the model is too simple or hasn’t learned enough from the data, so it performs poorly on training data and new data alike. That’s like a student who didn’t learn the material well enough even for the practice test. The goal is to find a “just right” fit – not too simple, not too complex (think of the Goldilocks principle). Techniques to avoid overfitting include using more data, simplifying the model, or using regularization (constraints). Checking performance on a validation/test set helps detect overfitting. (In our Post 8 example, we split data into train/test to guard against overfitting. If our model had scored perfectly on training data but badly on test data, that would indicate overfitting.)
(This glossary covers the most common terms you’ll encounter in our blog series. Feel free to revisit it whenever you need a refresher on a term. As you continue through the posts – from setting up your Python environment to building models and beyond – you’ll see these terms in context, which will further solidify your understanding.)
