Deep Learning · Beginner Glossary
Deep Learning Terms Every Beginner Should Understand
Quick summary — deep learning terms for beginners
Speak the language before you write the code. This guide explains the deep learning terms every beginner should know — from neural networks and layers to loss functions and overfitting — in plain English with examples.
In this guide you will learn:
- Core concepts — neural networks, layers, neurons, weights, activations.
- Training terms — loss, optimizer, backpropagation, epochs, batch size.
- Evaluation terms — overfitting, underfitting, bias-variance, validation.
- Glossary tracker — track which terms you've mastered.
- Tips for beginners — how to internalize these terms.
SECTION 01Core Concepts — Neural Networks, Layers, Neurons
These are the foundational words every deep learning beginner sees in every tutorial. Here's what they actually mean:
| Term | Simple Definition | Why It Matters |
|---|---|---|
| Neural Network | A stack of layers that transforms inputs into outputs | The architecture you'll build in every project |
| Layer | A group of neurons that process data together | You'll define input, hidden, and output layers |
| Neuron | A small unit that computes a weighted sum + activation | The basic building block of the network |
| Weight | A number that scales how much a neuron "cares" about an input | These are the numbers the model learns |
| Activation Function | A non-linear function applied inside neurons | Without it, deep networks are just linear models |
| Forward Pass | Running inputs through the network to get outputs | The first step of every training iteration |
Core Terms — Plain English:
• Neural Network → A model made of layers of neurons
• Layer → One step in the model's data flow
• Neuron → A small unit that does math on inputs
• Weight → How strongly one neuron influences another
• Activation → A function that adds non-linearity
• Forward Pass → Data flows from input to output
Where You'll See Them:
☐ In model definition code (nn.Module)
☐ In architecture diagrams
☐ In paper abstracts
☐ In interview questions
☐ In debugging stack traces
☐ In training loop logs
SECTION 02Training Terms — Loss, Optimizer, Backpropagation
These terms are the verbs of deep learning. They describe what the model is doing while it learns:
| Term | Simple Definition | Why It Matters |
|---|---|---|
| Loss | A number that measures how wrong the model's prediction is | Everything in training is about reducing loss |
| Optimizer | The algorithm that updates weights to reduce loss | Adam and SGD are the common ones |
| Backpropagation | The process of computing gradients backward through the network | How the model learns from its mistakes |
| Gradient | The direction and size of the update for each weight | The optimizer uses this to know which way to go |
| Epoch | One full pass over the training dataset | You'll usually run many epochs |
| Batch Size | How many samples the model looks at per update | Affects memory, speed, and training stability |
| Learning Rate | How big each weight update is | The most important hyperparameter to tune |
Training Terms — Plain English:
• Loss → "How wrong am I?"
• Optimizer → "How should I update my weights?"
• Backpropagation → "How do I compute the gradients?"
• Gradient → "Which direction is downhill?"
• Epoch → "I've seen all my data once"
• Batch Size → "How many samples per step"
• Learning Rate → "How big is each step"
Typical Training Loop:
☐ for epoch in range(num_epochs):
☐ for batch in dataloader:
☐ forward pass → predictions
☐ loss = criterion(predictions, targets)
☐ loss.backward() ← backpropagation
☐ optimizer.step() ← update weights
☐ optimizer.zero_grad()
SECTION 03Evaluation Terms — Overfitting, Bias-Variance
Evaluation terms tell you whether the model actually learned something useful — or just memorized the training data:
| Term | Simple Definition | Why It Matters |
|---|---|---|
| Overfitting | Model performs great on training data but poorly on new data | You can't ship a model that fails in production |
| Underfitting | Model performs poorly on training AND test data | Model is too simple for the problem |
| Bias | Error from wrong assumptions in the model | High bias = underfitting |
| Variance | Error from sensitivity to small changes in training data | High variance = overfitting |
| Validation Set | A portion of data held back to tune the model | Your early warning system against overfitting |
| Test Set | Data the model has never seen, used only at the end | Your honest measure of performance |
| Regularization | Techniques that discourage overfitting | Dropout, weight decay, early stopping |
Evaluation Terms — Plain English:
• Overfitting → Great on train, bad on test
• Underfitting → Bad on both train and test
• Bias → Wrong assumptions (too simple)
• Variance → Too sensitive to data noise
• Validation Set → Where you tune
• Test Set → Where you judge
• Regularization → Controls overfitting
Bias-Variance Quick Guide:
High Bias + Low Variance → Underfitting
Low Bias + High Variance → Overfitting
Low Bias + Low Variance → The goal
High Bias + High Variance → Model is broken
Signals:
□ Train loss high + test loss high → underfitting
□ Train loss low + test loss high → overfitting
□ Both low → good fit
SECTION 04Glossary Tracker
Use these templates to track which terms you've mastered:
Term Mastery Tracker:
☐ Neural Network — can explain in 1 sentence
☐ Layer — can point to one in code
☐ Neuron — can describe weighted sum
☐ Weight — can explain what is learned
☐ Activation Function — know 2 examples
☐ Forward Pass — can trace data flow
☐ Loss — can name 3 loss functions
☐ Optimizer — can name 2 optimizers
☐ Backpropagation — can explain gradient flow
☐ Epoch — can interpret training logs
☐ Batch Size — can explain trade-offs
☐ Learning Rate — can explain too high/too low
☐ Overfitting — can spot in a loss curve
☐ Underfitting — can spot in a loss curve
☐ Bias / Variance — can explain trade-off
☐ Validation Set — can describe its purpose
Weekly Review — Term Check:
Week: _____
Terms I fully understand:
1.
2.
3.
Terms I'm still shaky on:
1.
2.
3.
Terms I used in code this week:
1.
2.
3.
Next week's focus terms:
1.
2.
3.
Concept Map — How Terms Connect:
Input
↓
Layer (neurons + weights + activations)
↓
Forward Pass → Prediction
↓
Loss (how wrong?)
↓
Backpropagation (gradients)
↓
Optimizer (update weights)
↓
Repeat over epochs
↓
Evaluate on validation + test set
↓
Check for overfitting / underfitting
If you can draw this, you understand the terms.
SECTION 05Tips for Beginners
Here are tips to internalize deep learning terms instead of just memorizing them:
- Say each term out loud in one sentence — if you can't, you don't know it yet.
- Connect each term to code — find where it lives in a PyTorch or TensorFlow example.
- Draw the training loop — forward pass, loss, backpropagation, optimizer step.
- Read one paper abstract a week — you'll start recognizing the vocabulary.
- Teach a friend one term a day — explaining forces clarity.
- Build a small project — terms become real when you use them in a model.
SECTION 06Interview Q&A — Deep Learning Terms
Q1What is a neural network in one sentence?
A neural network is a model made of layers of neurons that transforms input data into predictions, learning from its mistakes through training.
Q2What is the difference between loss and gradient?
Loss is a single number that measures how wrong the model is. A gradient is a vector that tells the optimizer which direction to change each weight to reduce that loss.
Q3What is backpropagation?
Backpropagation is the algorithm that computes gradients by moving backward through the network — from the loss output to each weight. It's how the model learns.
Q4What does overfitting mean?
Overfitting means the model performs very well on training data but poorly on unseen data. It has memorized patterns instead of learning general rules.
Q5What is the difference between an epoch and a batch?
An epoch is one full pass over the entire training dataset. A batch is a small subset of the data processed in one update step. An epoch contains many batches.
SECTION 07Test yourself — Deep Learning Terms quiz
Five questions. No sign-up.
0 / 5Pick an answer to see why it is right or wrong.
SECTION 08Frequently asked questions
Do I need to know all these terms before starting deep learning?
No — but knowing them makes every tutorial, paper, and code example easier to follow. You can learn them alongside your first project.
What's the most important term to learn first?
Start with "neural network" and "layer." Once you understand the architecture, other terms make sense in context.
Do I need to memorize the math behind backpropagation?
Not at the beginning. Understand the concept — computing gradients backward — and you can use frameworks like PyTorch without manual math.
What's the difference between overfitting and underfitting?
Overfitting: great on training data, bad on new data. Underfitting: bad on both. Both are fixed by different techniques — regularization for overfitting, more capacity or training for underfitting.
How can I make these terms stick?
Use them. Build a small model, read training logs, and explain each term to a friend. Terms stick when they're used in context.
SECTION 09Related reads
Classroom & online · Noida
Your deep learning journey starts now
Our Deep Learning Training Course is designed to help you build real, job-ready models — with skills, projects, and interview prep that get you hired.
₹15,500 · full programme- Complete deep learning roadmap
- Skills & real projects
- Mock interviews
- Weekday & weekend batches