Epoch-based training in PyTorch - Model Pipeline Trace

Model Pipeline - Epoch-based training

This pipeline shows how a simple model learns step-by-step by repeating passes over the data called epochs. Each epoch helps the model improve by adjusting itself to make better predictions.

Data Flow - 5 Stages

1Data Loading

1000 rows x 10 columns→Load raw data with 10 features per example→1000 rows x 10 columns

[[0.5, 1.2, ..., 0.3], [1.1, 0.7, ..., 0.9], ...]

↓

2Preprocessing

1000 rows x 10 columns→Normalize features to range 0-1→1000 rows x 10 columns

[[0.05, 0.12, ..., 0.03], [0.11, 0.07, ..., 0.09], ...]

↓

3Train/Test Split

1000 rows x 10 columns→Split data into 800 training and 200 testing rows→Train: 800 rows x 10 columns, Test: 200 rows x 10 columns

Train example: [0.05, 0.12, ..., 0.03], Test example: [0.09, 0.15, ..., 0.07]

↓

4Model Training

800 rows x 10 columns→Feed data into model for learning→Model weights updated

Weights start random, updated each epoch

↓

5Evaluation

200 rows x 10 columns→Model predicts on test data→200 predictions

[0, 1, 0, 0, 1, ...]

Training Trace - Epoch by Epoch

Loss
0.7 | *
0.6 | *
0.5 |  *
0.4 |   *
0.3 |    *
0.2 |
    +------------
     1 2 3 4 5 Epochs

Epoch	Loss ↓	Accuracy ↑	Observation
1	0.65	0.60	Model starts learning with moderate loss and accuracy
2	0.50	0.72	Loss decreases and accuracy improves as model adjusts
3	0.40	0.80	Model continues to learn, loss drops further
4	0.32	0.85	Good progress, model is more accurate
5	0.28	0.88	Loss stabilizes, accuracy nearing high level

Prediction Trace - 4 Layers

Layer 1: Input Layer

Layer 2: Hidden Layer (ReLU activation)

Layer 3: Output Layer (Sigmoid activation)

Layer 4: Prediction Threshold

Model Quiz - 3 Questions

What happens to the loss value as epochs increase?

A It increases steadily

B It stays the same

C It decreases steadily

D It randomly jumps up and down

Key Insight

Epoch-based training helps the model learn gradually by repeatedly adjusting its parameters. Watching loss decrease and accuracy increase over epochs shows the model is improving its predictions.

Practice

1. What does one epoch represent in PyTorch training?

easy

A. One full pass through the entire training dataset

B. One batch of data processed by the model

C. One update of the model weights

D. One evaluation of the model on the test set

Solution

1. Step 1: Understand the definition of an epoch

   An epoch means the model sees every example in the training dataset once.

2. Step 2: Differentiate epoch from batch and update

   A batch is a subset of data; multiple batches make an epoch. Weight updates happen after each batch, not the whole dataset.

3. Final Answer:

   One full pass through the entire training dataset -> Option A

4. Quick Check:

   Epoch = full dataset pass [OK]

Hint: Epoch means full dataset seen once by model [OK]

Common Mistakes:

• Confusing batch with epoch
• Thinking epoch is one weight update
• Mixing test evaluation with training epoch

2. Which PyTorch code snippet correctly sets up a loop for 5 epochs?

easy

A. for epoch in range(1, 5):

B. for epoch in range(5, 10):

C. for epoch in range(0, 6):

D. for epoch in range(5):

Solution

1. Step 1: Recall Python range behavior

   range(5) generates 0,1,2,3,4 which is 5 iterations.

2. Step 2: Check other options for iteration count

   range(1,5) gives 4 iterations; range(0,6) gives 6; range(5,10) gives 5 but starts at 5, not zero.

3. Final Answer:

   for epoch in range(5): -> Option D

4. Quick Check:

   range(5) = 5 loops [OK]

Hint: range(5) loops exactly 5 times from 0 to 4 [OK]

Common Mistakes:

• Using range(1,5) which loops 4 times
• Using range(0,6) which loops 6 times
• Starting loop at 5 instead of 0

3. Given this PyTorch training loop snippet, what will be printed after 2 epochs?

for epoch in range(2):
    total_loss = 0
    for batch in dataloader:
        output = model(batch)
        loss = loss_fn(output, batch.labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1} loss: {total_loss}")

medium

A. Loss values for all batches printed

B. Loss values for epoch 1 and epoch 2 printed

C. Only loss for epoch 2 printed

D. No output printed due to error

Solution

1. Step 1: Analyze the outer loop and print statement

   The outer loop runs 2 times (epochs 0 and 1). After each epoch, it prints total_loss.

2. Step 2: Understand total_loss accumulation and printing

   total_loss sums batch losses per epoch, so print shows loss after each epoch.

3. Final Answer:

   Loss values for epoch 1 and epoch 2 printed -> Option B

4. Quick Check:

   Print inside epoch loop prints each epoch loss [OK]

Hint: Print inside epoch loop shows loss per epoch [OK]

Common Mistakes:

• Thinking only last epoch loss prints
• Confusing batch loss with epoch loss
• Assuming print causes error

4. Identify the error in this epoch-based training code snippet:

for epoch in range(3):
    for batch in dataloader:
        output = model(batch)
        loss = loss_fn(output, batch.labels)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
    print(f"Epoch {epoch+1} done")

medium

A. loss.backward() should be called after optimizer.step()

B. optimizer.step() should be called after optimizer.zero_grad()

C. optimizer.zero_grad() should be called before loss.backward()

D. No error, code is correct

Solution

1. Step 1: Recall correct order of optimizer calls

   Zero gradients before backward pass to avoid accumulating gradients.

2. Step 2: Check code order

   Code calls loss.backward() before optimizer.zero_grad(), which is wrong.

3. Final Answer:

   optimizer.zero_grad() should be called before loss.backward() -> Option C

4. Quick Check:

   Zero grads before backward [OK]

Hint: Always zero gradients before backward pass [OK]

Common Mistakes:

• Zeroing gradients after backward
• Swapping optimizer.step() and zero_grad() order
• Thinking no zero_grad needed

5. You want to train a model for 10 epochs but stop early if validation loss does not improve for 3 epochs. Which approach fits best with epoch-based training?

hard

A. After each epoch, check validation loss and stop if no improvement for 3 epochs

B. Stop training after 3 batches with no improvement

C. Train all 10 epochs regardless of validation loss

D. Check validation loss only after all 10 epochs finish

Solution

1. Step 1: Understand early stopping concept

   Early stopping monitors validation loss after each epoch to decide if training should continue.

2. Step 2: Match early stopping with epoch-based training

   Checking validation loss after each epoch and stopping if no improvement for 3 epochs fits epoch-based training.

3. Final Answer:

   After each epoch, check validation loss and stop if no improvement for 3 epochs -> Option A

4. Quick Check:

   Early stopping checks validation loss per epoch [OK]

Hint: Early stop checks validation loss after each epoch [OK]

Common Mistakes:

• Checking after batches instead of epochs
• Ignoring validation loss during training
• Waiting until all epochs finish to check