Epoch-based training in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to set the number of epochs for training.

PyTorch

num_epochs = [1]

Drag options to blanks, or click blank then click option'

A10

B'10'

Crange(10)

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string instead of an integer for epochs.

Using a range object instead of an integer.

The number of epochs should be an integer value, like 10, not a string or range.

2fill in blank

medium

Complete the code to start the training loop over epochs.

PyTorch

for epoch in [1](num_epochs):
    print(f"Epoch {epoch+1}")

Drag options to blanks, or click blank then click option'

Alen

Blist

Cenumerate

Drange

Attempts:

3 left

💡 Hint

Common Mistakes

Using len which returns an integer, not iterable.

Using list without an argument.

Using enumerate without an iterable.

We use range(num_epochs) to loop from 0 to num_epochs-1.

3fill in blank

hard

Fix the error in the training loop to correctly zero the gradients.

PyTorch

for epoch in range(num_epochs):
    optimizer.[1]()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

Drag options to blanks, or click blank then click option'

Azero_gradients

Bclear_grad

Czero_grad

Dreset_grad

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent methods like zero_gradients().

Forgetting to clear gradients causing accumulation.

In PyTorch, the correct method to clear gradients before backpropagation is zero_grad().

4fill in blank

hard

Fill both blanks to compute the loss and update the model parameters inside the epoch loop.

PyTorch

for epoch in range(num_epochs):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = [1](outputs, labels)
    loss.[2]()
    optimizer.step()

Drag options to blanks, or click blank then click option'

Acriterion

Bbackward

Cstep

Dzero_grad

Attempts:

3 left

💡 Hint

Common Mistakes

Calling step() on loss instead of optimizer.

Not calling backward() on loss.

The loss is computed by calling the criterion function, then loss.backward() computes gradients.

5fill in blank

hard

Fill all three blanks to print the epoch number, loss value, and accuracy after each epoch.

PyTorch

for epoch in range(num_epochs):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    _, predicted = torch.max(outputs, [1])
    correct = (predicted == labels).sum().item()
    accuracy = correct / labels.size([2])
    print(f"Epoch [3]: Loss={loss.item():.4f}, Accuracy={accuracy:.2%}")

Drag options to blanks, or click blank then click option'

A1

B0

Cepoch + 1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong dimension for torch.max causing errors.

Using wrong dimension for batch size causing wrong accuracy.

Printing epoch without adding 1, confusing learners.

We use dimension 1 for torch.max to get class predictions, dimension 0 for batch size, and print epoch number as epoch + 1.

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