The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Time Series Forecasting Project

Next ►
►

Introduction

In this project, we will apply the concepts learned in previous modules to build a time series forecasting model using PyTorch. Time series forecasting is a crucial task in various domains such as finance, weather prediction, and inventory management. We will use a Recurrent Neural Network (RNN) to predict future values of a given time series.

Objectives

  • Understand the basics of time series data.
  • Preprocess time series data for training.
  • Build and train an RNN model for time series forecasting.
  • Evaluate the model's performance.
  • Make predictions using the trained model.

Step 1: Understanding Time Series Data

Time series data is a sequence of data points collected or recorded at specific time intervals. Examples include stock prices, temperature readings, and sales data.

Key Concepts

  • Trend: The long-term movement in the time series.
  • Seasonality: The repeating short-term cycle in the time series.
  • Noise: Random variations in the time series.

Step 2: Data Loading and Preprocessing

We will use a sample dataset for this project. Let's start by loading and preprocessing the data.

Code Example

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Load the dataset
url = 'https://example.com/time_series_data.csv'
data = pd.read_csv(url, parse_dates=['Date'], index_col='Date')

# Display the first few rows of the dataset
print(data.head())

# Plot the time series data
plt.figure(figsize=(10, 6))
plt.plot(data)
plt.title('Time Series Data')
plt.xlabel('Date')
plt.ylabel('Value')
plt.show()

Explanation

  • We load the dataset using pandas.
  • The parse_dates parameter ensures that the 'Date' column is parsed as datetime objects.
  • We plot the time series data to visualize it.

Step 3: Preparing the Data for Training

We need to convert the time series data into a format suitable for training an RNN. This involves creating sequences of data points.

Code Example

def create_sequences(data, seq_length):
    xs, ys = [], []
    for i in range(len(data) - seq_length):
        x = data[i:i+seq_length]
        y = data[i+seq_length]
        xs.append(x)
        ys.append(y)
    return np.array(xs), np.array(ys)

# Define sequence length
seq_length = 10

# Create sequences
X, y = create_sequences(data.values, seq_length)

# Split the data into training and testing sets
split = int(0.8 * len(X))
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

print(f'Training set shape: {X_train.shape}')
print(f'Testing set shape: {X_test.shape}')

Explanation

  • The create_sequences function generates sequences of length seq_length from the time series data.
  • We split the data into training and testing sets.

Step 4: Building the RNN Model

We will build an RNN model using PyTorch.

Code Example

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

class RNNModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super(RNNModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.rnn(x, h0)
        out = self.fc(out[:, -1, :])
        return out

# Define model parameters
input_size = 1
hidden_size = 50
output_size = 1
num_layers = 1

# Initialize the model, loss function, and optimizer
model = RNNModel(input_size, hidden_size, output_size, num_layers)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

Explanation

  • We define an RNN model class with an RNN layer and a fully connected layer.
  • The forward method defines the forward pass of the model.
  • We initialize the model, loss function, and optimizer.

Step 5: Training the Model

We will train the RNN model using the training data.

Code Example

# Convert data to PyTorch tensors
X_train_tensor = torch.tensor(X_train, dtype=torch.float32).unsqueeze(-1)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32).unsqueeze(-1)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32).unsqueeze(-1)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32).unsqueeze(-1)

# Training loop
num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    outputs = model(X_train_tensor)
    loss = criterion(outputs, y_train_tensor)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

Explanation

  • We convert the training and testing data to PyTorch tensors.
  • We define the training loop, which includes forward pass, loss computation, backward pass, and optimizer step.

Step 6: Evaluating the Model

We will evaluate the model's performance on the testing data.

Code Example

model.eval()
with torch.no_grad():
    predictions = model(X_test_tensor)
    test_loss = criterion(predictions, y_test_tensor)
    print(f'Test Loss: {test_loss.item():.4f}')

# Plot the predictions
plt.figure(figsize=(10, 6))
plt.plot(y_test, label='True Values')
plt.plot(predictions.numpy(), label='Predictions')
plt.title('Time Series Forecasting')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.show()

Explanation

  • We set the model to evaluation mode and make predictions on the testing data.
  • We compute the test loss and plot the true values and predictions.

Conclusion

In this project, we built a time series forecasting model using PyTorch. We covered the following steps:

  • Understanding time series data.
  • Loading and preprocessing the data.
  • Building and training an RNN model.
  • Evaluating the model's performance.

By completing this project, you have gained practical experience in applying RNNs to time series forecasting tasks. This knowledge can be extended to more complex models and datasets in real-world applications.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved