Sequence classification in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple sequence classification model using PyTorch's nn.Module.

PyTorch

import torch.nn as nn

class SequenceClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.rnn = nn.LSTM(input_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, [1])

    def forward(self, x):
        _, (hidden, _) = self.rnn(x)
        out = self.fc(hidden[-1])
        return out

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

Abatch_size

Bhidden_dim

Cinput_dim

Doutput_dim

Attempts:

3 left

💡 Hint

Common Mistakes

Using hidden_dim instead of output_dim for the linear layer output size.

Confusing input_dim with output_dim.

The final linear layer should map from the hidden dimension to the output dimension, which represents the number of classes.

2fill in blank

medium

Complete the code to apply a softmax activation to the model output for classification probabilities.

PyTorch

import torch.nn.functional as F

outputs = model(inputs)
probabilities = F.[1](outputs, dim=1)

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

Asigmoid

Btanh

Csoftmax

Drelu

Attempts:

3 left

💡 Hint

Common Mistakes

Using sigmoid instead of softmax for multi-class outputs.

Forgetting to specify the dimension for softmax.

Softmax converts raw model outputs (logits) into probabilities that sum to 1 across classes.

3fill in blank

hard

Fix the error in the training loop by completing the missing optimizer step.

PyTorch

for inputs, labels in dataloader:
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    [1]

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

Aoptimizer.step()

Bmodel.step()

Closs.step()

Dcriterion.step()

Attempts:

3 left

💡 Hint

Common Mistakes

Calling step() on loss or model instead of optimizer.

Forgetting to call optimizer.step() causing no training progress.

After computing gradients with loss.backward(), optimizer.step() updates the model parameters.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps each word to its length only if the length is greater than 3.

PyTorch

words = ['apple', 'cat', 'banana', 'dog']
lengths = {word: [1] for word in words if [2]

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

Alen(word)

Blen(word) > 3

Cword > 3

Dword.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using word > 3 which compares string to int and causes error.

Using word.length which is not valid in Python.

We map each word to its length using len(word), and filter words with length greater than 3 using len(word) > 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each word in words to its uppercase form only if the word length is less than 5.

PyTorch

words = ['apple', 'cat', 'banana', 'dog']
result = { [1]: [2] for [3] in words if len([3]) < 5 }

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

Aword

Bword.upper()

Dwords

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'words' instead of 'word' in the for loop.

Using the wrong variable name causing NameError.

We use 'word' as the key, 'word.upper()' as the value, and iterate with 'for word in words'.

Practice

1. What is the main goal of sequence classification in PyTorch?

easy

A. To assign a label to the entire input sequence

B. To predict the next item in the sequence

C. To label each item in the sequence separately

D. To generate a new sequence from the input

Solution

1. Step 1: Understand sequence classification

   Sequence classification means giving one label to the whole sequence, not to individual items.

2. Step 2: Compare options

   Only To assign a label to the entire input sequence describes labeling the entire sequence, which matches the goal of sequence classification.

3. Final Answer:

   To assign a label to the entire input sequence -> Option A

4. Quick Check:

   Sequence classification = label whole sequence [OK]

Hint: Sequence classification labels the whole sequence, not parts [OK]

Common Mistakes:

• Confusing sequence classification with sequence labeling
• Thinking it predicts next sequence item
• Assuming it generates new sequences

2. Which PyTorch module is commonly used to process sequences step-by-step for classification?

easy

A. torch.nn.Conv2d

B. torch.nn.Linear

C. torch.nn.RNN

D. torch.nn.BatchNorm1d

Solution

1. Step 1: Identify sequence processing modules

   RNN (Recurrent Neural Network) modules process sequences step-by-step, capturing order.

2. Step 2: Match options to sequence processing

   Only torch.nn.RNN is designed for sequential data; others serve different purposes.

3. Final Answer:

   torch.nn.RNN -> Option C

4. Quick Check:

   RNN processes sequences stepwise [OK]

Hint: RNN modules handle sequences stepwise in PyTorch [OK]

Common Mistakes:

• Choosing Linear which is for fixed-size input
• Selecting Conv2d meant for images
• Picking BatchNorm which normalizes features

3. Given this PyTorch code snippet for sequence classification, what is the shape of the output tensor?

rnn = torch.nn.RNN(input_size=10, hidden_size=20, batch_first=True)
inputs = torch.randn(5, 7, 10)  # batch=5, seq_len=7, features=10
output, hn = rnn(inputs)
final_output = hn.squeeze(0)

medium

A. [5, 20]

B. [5, 7, 20]

C. [7, 20]

D. [5, 10]

Solution

1. Step 1: Understand RNN output shapes

   Output shape is (batch, seq_len, hidden_size) = (5,7,20). hn shape is (num_layers, batch, hidden_size) = (1,5,20).

2. Step 2: Analyze final_output shape

   hn.squeeze(0) removes the first dimension (num_layers), resulting in (5,20).

3. Final Answer:

   [5, 20] -> Option A

4. Quick Check:

   hn.squeeze(0) shape = [batch, hidden_size] = [5, 20] [OK]

Hint: Squeeze removes layer dim; output shape is batch x hidden size [OK]

Common Mistakes:

• Confusing output and hn shapes
• Not squeezing the layer dimension
• Mixing sequence length with batch size

4. Identify the error in this PyTorch sequence classification model code:

class SeqClassifier(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.rnn = torch.nn.RNN(10, 20, batch_first=True)
        self.fc = torch.nn.Linear(10, 2)
    def forward(self, x):
        out, hn = self.rnn(x)
        out = self.fc(hn.squeeze(0))
        return out

medium

A. The forward method should return hn, not out

B. The RNN input size should be 2, not 10

C. The squeeze(0) should be applied to out, not hn

D. The Linear layer input size should be 20, not 10

Solution

1. Step 1: Check Linear layer input size

   The RNN hidden size is 20, so hn has shape (batch, 20). The Linear layer expects input size 10, which is incorrect.

2. Step 2: Correct Linear input size

   Linear layer input size must match hidden size 20 to process hn correctly.

3. Final Answer:

   The Linear layer input size should be 20, not 10 -> Option D

4. Quick Check:

   Linear input size = hidden size = 20 [OK]

Hint: Linear input size must match RNN hidden size [OK]

Common Mistakes:

• Mismatching Linear input size with hidden size
• Applying squeeze to wrong tensor
• Returning wrong tensor from forward

5. You want to classify sequences of varying lengths using an RNN in PyTorch. Which approach correctly handles different sequence lengths during training?

hard

A. Truncate all sequences to the shortest length without padding

B. Pad sequences to the same length and use pack_padded_sequence before RNN

C. Feed sequences directly without padding or packing

D. Use a Linear layer instead of RNN to avoid sequence length issues

Solution

1. Step 1: Understand variable-length sequence handling

   Sequences must be padded to the same length for batch processing, then packed to ignore padding during RNN.

2. Step 2: Evaluate options

   Pad sequences to the same length and use pack_padded_sequence before RNN uses padding plus pack_padded_sequence, the correct PyTorch method to handle varying lengths efficiently.

3. Final Answer:

   Pad sequences to the same length and use pack_padded_sequence before RNN -> Option B

4. Quick Check:

   Use padding + pack_padded_sequence for variable lengths [OK]

Hint: Pad then pack sequences to handle varying lengths in RNN [OK]

Common Mistakes:

• Ignoring padding and feeding raw sequences
• Truncating sequences losing data
• Replacing RNN with Linear layer incorrectly