What Is Deep Learning? Simple Explanation (2026)

# tiny_neural_network.py — a neural network without any framework
# Shows the core idea: predict, measure error, adjust, repeat.

import numpy as np

# 1. Some example data: 3 students, 2 features each
#    (hours studied, hours slept)
X = np.array([
    [5, 7],
    [2, 9],
    [8, 5],
])

# 2. The "correct answers" (passed = 1, failed = 0)
y = np.array([1, 0, 1])

# 3. A single neuron with 2 weights and 1 bias (randomly initialised)
weights = np.array([0.1, 0.1])
bias = 0.0

# 4. Train the neuron for 1000 iterations
for epoch in range(1000):
    # Forward pass: prediction
    z = X @ weights + bias
    y_pred = 1 / (1 + np.exp(-z))  # sigmoid

    # Loss: how far off are we?
    loss = ((y_pred - y) ** 2).mean()

    # Gradients: which direction should we adjust?
    dz = (y_pred - y) * y_pred * (1 - y_pred)
    dw = X.T @ dz / len(X)
    db = dz.mean()

    # Update: take a small step in the right direction
    weights -= 0.1 * dw
    bias -= 0.1 * db

print("weights:", weights)
print("bias:", bias)
print("predictions:", y_pred.round(2))


# What this code shows in simple terms:
# - A "neuron" is just a weighted sum + a squashing function.
# - A "network" is many of these stacked together.
# - "Training" is adjusting weights to reduce error.
# - "Depth" means more layers doing this in sequence.
#
# What this code hides (all the engineering):
# - Automatic differentiation (handled by PyTorch).
# - GPU acceleration.
# - Regularisation, batching, optimisers.

# learning_loop.py — the same idea, written the way it appears in real code
# This is the shape of every deep learning training loop, no matter the model.

import torch
import torch.nn as nn

# Data: 3 examples, 2 features
X = torch.tensor([[5.0, 7.0], [2.0, 9.0], [8.0, 5.0]])
y = torch.tensor([[1.0], [0.0], [1.0]])

# Model: one linear layer, then a sigmoid
model = nn.Sequential(
    nn.Linear(2, 1),
    nn.Sigmoid(),
)

# Optimiser: how the model updates its weights
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# Loss: how we measure error
loss_fn = nn.BCELoss()

for epoch in range(1000):
    optimizer.zero_grad()       # 1. clear old gradients
    y_pred = model(X)           # 2. forward pass
    loss = loss_fn(y_pred, y)   # 3. compute error
    loss.backward()             # 4. backward pass (autograd)
    optimizer.step()            # 5. update weights

print("predictions:", model(X).detach().round().tolist())


# Why this matters:
# - This is the exact loop you write for every PyTorch model.
# - The only thing that changes is what's inside the model.
# - CNN, RNN, transformer — same loop.
#
# What interviewers expect you to know:
# - The order of zero_grad → forward → backward → step.
# - Why .backward() computes gradients automatically.
# - What lr controls.

# what_a_model_learns.py — inspecting the weights after training
# This shows what a "trained model" actually is: numbers.

# Before training, weights are random. After training, they reflect
# patterns in the data. Below is illustrative output.

"""
weights:
tensor([[ 1.83],
        [-0.74]])
bias:
tensor([-2.11])
"""

# Interpretation (in plain terms):
# - "Hours studied" has a large positive weight (1.83):
#   more study → more likely to pass.
# - "Hours slept" has a negative weight (-0.74):
#   in this tiny dataset, more sleep correlated with failing,
#   which is probably noise, not a real pattern.
# - Bias shifts the baseline up or down.

# What this teaches:
# - A trained model is not a "brain". It is a set of numbers
#   that happen to fit patterns in the data.
# - Small datasets can produce silly patterns (like sleep
#   being negative). Real deep learning uses huge datasets.
# - Interpretability is hard, especially in deep networks.

# Why this matters for understanding DL:
# - Deep learning is statistical fitting at scale.
# - The "learning" is optimisation, not comprehension.
# - That is why it can be accurate and unreliable at once.