What is
Deep Learning?

AI, machine learning, and deep learning are not the same thing.

Artificial intelligence is the broad field of making systems perform tasks associated with intelligence. Machine learning learns patterns or mappings from data. Deep learning is a class of machine learning models based on neural networks with multiple processing layers.

Example: A shopping site can use hand-written recommendations (rules), a decision tree trained on purchase history (ML), or a neural network that learns from customers' browsing sequences and product embeddings (DL).

Imagine predicting delivery cost.

You operate a local delivery service. Longer trips typically cost more. Suppose you observe several trips with distance and actual cost. You want a model that can predict the cost of a new trip.

For our teaching example, use the following illustrative data (not real market prices):

We suspect a linear relationship: a fixed base fee plus an additional amount per kilometre. In real systems we would also consider traffic, weather, demand, vehicle type, and other factors.

One equation is your first model.

Read it aloud: predicted cost = (cost per kilometre × distance) + base fee. The letter x is an input, w and b are adjustable parameters, and ŷ is the predicted outcome.

For a 4 km trip:

Interactive: change the parameters

Move the sliders. The plotted line and prediction update from the actual equation ŷ = wx + b.

How does a model actually learn?

Training means changing parameters to reduce a numerical objective computed from training examples. A typical gradient-based process consists of five recurring steps:

How do we measure “wrong”?

Suppose the actual delivery cost is ₹100 but our model predicts ₹90. The signed error is 90 − 100 = −10. If we average signed errors, positive and negative errors can cancel. A common regression loss is mean squared error (MSE).

Plain English: predict every example, subtract its true target, square each difference, and take the average.

For three errors of −10, +5 and +5:

The squared loss has units of currency squared in this example. The root mean squared error (RMSE) restores the original units. MSE is particularly sensitive to large errors; it is not universally the best loss.

Gradient descent is controlled trial and improvement.

A gradient tells us the local direction in which loss increases most rapidly. To decrease the loss, subtract a multiple of that gradient.

Derive one complete gradient step

For a single example with input x = 4, target y = 50, and current w = 8, b = 10:

Interactive: change the learning rate and watch the updates

This simulator minimizes the actual function L(w) = (w − 3)². Its gradient is 2(w − 3), so the precise update is w ← w − η·2(w − 3).

What is backpropagation?

When a network has many layers, computing each parameter gradient independently would be wasteful. Backpropagation efficiently applies the chain rule through the computational graph in reverse, reusing intermediate derivatives.

For our single-example squared error, the pieces are dL/dŷ = 2(ŷ−y) and dŷ/dw = x. Multiplying gives dL/dw = 2(ŷ−y)x. In deeper networks, this multiplication continues backward through every differentiable layer.

Implement training from scratch with NumPy.

We create a tiny, noiseless dataset with y = 20x + 20, intentionally start with incorrect parameters, and optimize them using full-batch gradient descent. Every line has a purpose.

import numpy as np

# Create a reproducible dataset: 1 km costs 40, 3 km costs 80, etc.
# Float64 gives us predictable numerical precision for this tiny experiment.
x = np.array([1., 3., 5., 7.], dtype=np.float64)
y = np.array([40., 80., 120., 160.], dtype=np.float64)

# The model starts out NOT knowing the correct weight and bias.
w = 0.0
b = 0.0

# The learning rate controls how large a parameter update we take.
learning_rate = 0.01
num_epochs = 10000
n = len(x)

for epoch in range(num_epochs):
    # FORWARD PASS: calculate a price prediction for each distance.
    prediction = w * x + b

    # ERROR: positive means overprediction, negative underprediction.
    error = prediction - y

    # LOSS: a single number measuring average squared error.
    loss = np.mean(error ** 2)

    # GRADIENTS: exact derivatives of the mean squared error.
    # Multiplying by x applies the chain rule to the weight.
    dw = (2.0 / n) * np.sum(error * x)
    db = (2.0 / n) * np.sum(error)

    # PARAMETER UPDATE: move against the loss gradient.
    w -= learning_rate * dw
    b -= learning_rate * db

    if epoch % 2000 == 0:
        print(f"Epoch {epoch:5d} | MSE: {loss:.6f}")

print(f"Learned weight: {w:.4f}")  # Approximately 20
print(f"Learned bias:   {b:.4f}")  # Approximately 20

# INFERENCE: use learned parameters for an unseen 4 km trip.
new_distance = 4.0
new_price = w * new_distance + b
print(f"Predicted cost for 4 km: ₹{new_price:.2f}")  # ~₹100

Why each part exists

Build the same model with PyTorch.

PyTorch replaces manual gradient formulas with automatic differentiation. We will use nn.Linear to represent the equation, MSELoss to measure error and SGD to update parameters.

import torch
from torch import nn

# Ensure repeatable parameter initialization where supported.
torch.manual_seed(42)

# Each example has one input feature: delivery distance.
# The shape is (4 samples, 1 feature).
X = torch.tensor([[1.], [3.], [5.], [7.]])
y = torch.tensor([[40.], [80.], [120.], [160.]])

# A linear layer learns one weight and one bias.
# Under the hood it computes a transformed input + bias.
model = nn.Linear(in_features=1, out_features=1)

# MSE is suitable for this numerical regression demonstration.
loss_function = nn.MSELoss()

# SGD updates the learnable parameters using computed gradients.
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(10000):
    model.train()  # Training mode (important for some layer types).

    predictions = model(X)             # 1. Forward pass
    loss = loss_function(predictions, y) # 2. Calculate loss

    optimizer.zero_grad()               # 3. Clear old gradients
    loss.backward()                     # 4. Autograd gradients
    optimizer.step()                     # 5. Update parameters

    if epoch % 2000 == 0:
        print(f"Epoch {epoch:5d} | MSE: {loss.item():.6f}")

# Switch to evaluation mode before predicting on new inputs.
model.eval()
with torch.no_grad():
    new_trip = torch.tensor([[4.]])
    predicted_price = model(new_trip).item()

print("Learned weight:", model.weight.item())
print("Learned bias:", model.bias.item())
print(f"Predicted 4 km cost: ₹{predicted_price:.2f}")

Install PyTorch using the environment-specific instructions in the official PyTorch installation selector ↗. This webpage displays code you can copy; Python execution itself happens in your Python environment, not inside the browser.

When simple learning does not work as expected.

Neural networks become valuable when we want to learn more complex nonlinear relationships, representations and dependencies. But architecture is only one part of quality: problem framing, data quality, evaluation and operational constraints matter too.

Hands-on practice and checkpoints.

Tick each task after you can complete it independently. The checkmarks are stored only in your browser.

Explain, don't just memorize.

Practice answering each question out loud, then reveal the model answer.

Go back to official documentation.

Our explanations are original teaching material. Use the following first-party references to validate behavior and explore the full APIs.