Extending Recurrent Neural Networks for Time Series Classification with PyTorch

Introduction

In this lesson, we will explore how to extend Recurrent Neural Networks (RNNs) for time series classification tasks using PyTorch . Time series classification involves predicting categorical labels based on sequential data. We will use a dataset containing monthly airline passenger numbers to demonstrate the process of loading and preparing data, building an RNN classification model, and evaluating its performance. By the end of this lesson, you will have a solid understanding of how to apply RNNs to classify time series data.

Loading and Preparing Data for Classification

Data Preparation for Classification

Next, we prepare the data specifically for classification by converting the labels to a one-hot encoded format. Python import torch # Convert labels to one-hot encoded format y_classification = torch.nn.functional.one_hot(torch.tensor(y), num_classes=2) import torch # Convert labels to one-hot encoded format y_classification = torch.nn.functional.one_hot(torch.tensor(y), num_classes=2) Here, we convert the binary labels to a one-hot encoded format using torch.nn.functional.one_hot, which is necessary for training the classification model.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Python

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler

# Load dataset
df = pd.read_csv('AirPassengers.csv')

# Ensure the column name matches
df.columns = ['Month', 'Passengers']

# Generate labels BEFORE scaling
df['Label'] = (df['Passengers'].diff().shift(-1) > 0).astype(int)  # Create binary labels: 1 if next month's passengers increase, else 0

# Normalize the data
scaler = MinMaxScaler(feature_range=(0, 1))
df['Passengers'] = scaler.fit_transform(df['Passengers'].values.reshape(-1, 1))

# Create input sequences
def create_sequences(data, labels, seq_length):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i + seq_length])
        y.append(labels[i + seq_length])  # Correct alignment
    return np.array(X), np.array(y)

seq_length = 10
X, y = create_sequences(df['Passengers'].values, df['Label'].values, seq_length)

Python

import torch

# Convert labels to one-hot encoded format
y_classification = torch.nn.functional.one_hot(torch.tensor(y), num_classes=2)

Python

import torch.nn as nn

class RNNClassificationModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNNClassificationModel, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.dropout = nn.Dropout(0.2)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, _ = self.rnn(x)
        out = self.dropout(out[:, -1, :])  # Use the last output of the sequence
        out = self.fc(out)
        return out

# Define model parameters
input_size = 1
hidden_size = 20
output_size = 2

# Instantiate the model
model_classification = RNNClassificationModel(input_size, hidden_size, output_size)

Python

import torch.optim as optim

# Convert data to PyTorch tensors
X_tensor = torch.tensor(X, dtype=torch.float32).unsqueeze(-1)
y_tensor = y_classification.float()

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model_classification.parameters(), lr=0.001)

# Training loop
epochs = 5
batch_size = 32

for epoch in range(epochs):
    model_classification.train()
    for i in range(0, len(X_tensor), batch_size):
        X_batch = X_tensor[i:i+batch_size]
        y_batch = y_tensor[i:i+batch_size]

        # Forward pass
        outputs = model_classification(X_batch)
        loss = criterion(outputs, y_batch)

        # Backward pass and optimization
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')

# Evaluation
model_classification.eval()
with torch.no_grad():
    y_pred_class = model_classification(X_tensor)
    y_pred_labels = torch.argmax(y_pred_class, axis=1)

# Compute accuracy
accuracy = (y_pred_labels == torch.tensor(y)).float().mean()
print("Final Model Accuracy: {:.2f}%".format(accuracy.item() * 100))

Introduction

Loading and Preparing Data for Classification

Data Preparation for Classification

Join the 1M+ learners on CodeSignal

Building the RNN Classification Model

Training and Evaluating the Classification Model

Summary