Sequence classification in PyTorch

Introduction

Sequence classification helps us teach a computer to understand and label a series of items, like words in a sentence or steps in a process.

To decide if an email is spam or not based on its words.

To recognize the sentiment (happy, sad) in a movie review.

To classify DNA sequences in biology.

To detect commands from spoken words in voice assistants.

To categorize news articles by topic from their text.

Syntax

PyTorch

import torch
import torch.nn as nn

class SequenceClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(SequenceClassifier, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)

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

The input to the model is a sequence of vectors (like word embeddings).

The RNN processes the sequence step by step, and we use the last output to classify the whole sequence.

Examples

This creates a model that takes sequences where each item has 10 features, uses 20 hidden units in the RNN, and classifies into 3 classes.

PyTorch

model = SequenceClassifier(input_size=10, hidden_size=20, num_classes=3)

Here, we pass a batch of 5 sequences, each 7 steps long, with 10 features per step. The output will have shape (5, 3) for 3 classes.

PyTorch

output = model(torch.randn(5, 7, 10))

Sample Model

This program creates a simple RNN model to classify sequences into two classes. It trains on random data for 5 steps and prints loss and accuracy.

PyTorch

import torch
import torch.nn as nn
import torch.optim as optim

# Define the model
class SequenceClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(SequenceClassifier, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)

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

# Parameters
input_size = 5
hidden_size = 10
num_classes = 2
batch_size = 4
seq_length = 6

# Create model, loss, optimizer
model = SequenceClassifier(input_size, hidden_size, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# Dummy data: batch of 4 sequences, each 6 steps, each step 5 features
inputs = torch.randn(batch_size, seq_length, input_size)
# Labels: 4 labels for the batch
labels = torch.tensor([0, 1, 0, 1])

# Training loop for 5 epochs
for epoch in range(5):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()
    _, predicted = torch.max(outputs, 1)
    accuracy = (predicted == labels).float().mean()
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}, Accuracy: {accuracy.item():.4f}")

Important Notes

Sequence length and batch size can vary depending on your data.

RNNs can be replaced with LSTM or GRU for better performance on longer sequences.

Always check that your input data shape matches the model's expected input.

Summary

Sequence classification labels whole sequences, not just single items.

RNNs process sequences step by step and help capture order information.

The last output of the RNN is used to predict the class of the entire sequence.

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