Predicting Time Series using 1D Convolutional Neural Networks with PyTorch

In this tutorial, we will walk through how to build a Convolutional 1D Neural Network using PyTorch for predicting time series data. Time series data is a sequence of data points collected at regular intervals over time, and the goal of this tutorial is to use machine learning to predict future data points in the sequence.

Step 1: Import Libraries
First, we need to import the necessary libraries. You will need to have PyTorch installed in your environment. You can install it using pip:

pip install torch torchvision

Now, import the following libraries:

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

Step 2: Generate Time Series Data
Next, we will generate some example time series data to train our model on. For this tutorial, we will use a sine wave as our time series data. Here is a simple function to generate the data:

def generate_time_series_data(num_points):
    time = np.arange(0, num_points)
    data = np.sin(0.1 * time) + np.random.normal(0, 0.1, num_points)
    return data

data = generate_time_series_data(1000)
plt.plot(data)
plt.show()

Step 3: Prepare the Data
Before we can train our model, we need to prepare the data. We will split the data into input sequences and labels. Here is a function to create input-output pairs for our model:

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

seq_length = 10
X, y = create_sequences(data, seq_length)
X = torch.from_numpy(X).float()
y = torch.from_numpy(y).float()

Step 4: Build the Convolutional 1D Neural Network
Now, we will define our Convolutional 1D Neural Network using PyTorch. The model consists of a one-dimensional convolutional layer followed by a fully connected layer. Here is the code to build the model:

class Conv1DNN(nn.Module):
    def __init__(self):
        super(Conv1DNN, self).__init__()
        self.conv1 = nn.Conv1d(in_channels=1, out_channels=16, kernel_size=3)
        self.fc1 = nn.Linear(16, 1)

    def forward(self, x):
        x = x.unsqueeze(1)
        x = self.conv1(x)
        x = nn.functional.relu(x)
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        return x

model = Conv1DNN()

Step 5: Training the Model
Next, we will train our model on the time series data we generated earlier. We will use Mean Squared Error loss and the Adam optimizer for training. Here is the code to train the model:

criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

def train_model(model, X, y, num_epochs):
    for epoch in range(num_epochs):
        outputs = model(X)
        loss = criterion(outputs, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if epoch % 10 == 0:
            print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')

train_model(model, X, y, num_epochs=100)

Step 6: Make Predictions
Finally, let’s make predictions using our trained model. We will use the model to predict the next data point in the sequence. Here is the code to make predictions:

def predict_next_point(model, data, seq_length):
    input_seq = torch.from_numpy(data[-seq_length:]).float()
    with torch.no_grad():
        pred = model(input_seq).item()
    return pred

pred = predict_next_point(model, data, seq_length)
print(f'Predicted next point: {pred}')

And that’s it! You have now built a Convolutional 1D Neural Network using PyTorch for predicting time series data. You can further optimize and tune the model parameters to improve its performance on your specific time series data. Happy coding!