Building an RNN for Multivariate Time Series | CodeSignal Learn

Building an RNN for Multivariate Time Series | CodeSignal Learn

Introduction to RNNs for Multivariate Time Series

Welcome to the next step in your journey of handling multivariate time series with Recurrent Neural Networks (RNNs). In the previous lessons, you learned how to preprocess the Air Quality dataset and prepare it for RNN input. Now, we will focus on building and training an RNN model to predict Temperature (T) using multiple features from this dataset. RNNs are particularly well-suited for time series forecasting due to their ability to capture temporal dependencies in sequential data. By the end of this lesson, you will have a solid understanding of how to construct and train an RNN model for multivariate time series forecasting.

Quick Recap of Preprocessing Steps

Before building the RNN model, it's essential to preprocess the Air Quality dataset to ensure it is suitable for input into the model. Here are the preprocessing steps you should have completed: Pythonimport pandas as pd import numpy as np from sklearn.preprocessing import StandardScaler # Load the Air Quality dataset from the URL url = "https://codesignal-staging-assets.s3.amazonaws.com/uploads/1742293523899/AirQualityUCI.csv" df = pd.read_csv(url, sep=';', decimal=',') # Replace -200 with NaN df.replace(-200, np.nan, inplace=True) # Combine 'Date' and 'Time' into a single 'DateTime' column df['DateTime'] = pd.to_datetime(df['Date'] + ' ' + df['Time'], format="%d/%m/%Y %H.%M.%S") # Drop the original 'Date' and 'Time' columns df.drop(columns=['Date', 'Time'], inplace=True) # Drop unnecessary columns df.drop(columns=['Unnamed: 15', 'Unnamed: 16'], inplace=True) # Drop rows where essential features are missing df.dropna(subset=['CO(GT)', 'NO2(GT)', 'T', 'RH'], inplace=True) # Fill missing values using forward-fill & backward-fill df.ffill(inplace=True) df.bfill(inplace=True) # Set DateTime as index df.set_index('DateTime', inplace=True) # Select relevant features for RNN features = ['CO(GT)', 'NO2(GT)', 'PT08.S5(O3)', 'RH', 'T'] df_selected = df[features] # Normalize the data scaler = StandardScaler() df_scaled = scaler.fit_transform(df_selected) # Function to create sequences for multi-input RNN def create_multivariate_sequences(data, seq_length=10): X, y = [], [] for i in range(len(data) - seq_length): X.append(data[i:i+seq_length]) # Multi-feature input y.append(data[i+seq_length, -1]) # Predicting Temperature (T) return np.array(X), np.array(y) # Define sequence length sequence_length = 10 # Create sequences X, y = create_multivariate_sequences(df_scaled, sequence_length) # Reshape input for RNN X = X.reshape((X.shape[0], sequence_length, len(features))) # (samples, timesteps, features) # Train-test split (chronological) train_size = int(0.8 * len(X)) X_train, X_test = X[:train_size], X[train_size:] y_train, y_test = y[:train_size], y[train_size:] # Print shape of the processed datasets print(f"X_train shape: {X_train.shape}, y_train shape: {y_train.shape}") print(f"X_test shape: {X_test.shape}, y_test shape: {y_test.shape}") This code splits the data so that the first 80% of the sequences are used for training, and the remaining 20% are used for testing. This preserves the temporal order of the data, which is crucial for time series forecasting.

Sign up

Join the 1M+ learners on CodeSignal

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

Building the RNN Model: Code Walkthrough

Let's walk through the code to define the RNN model. We will use TensorFlow and Keras to build the model, as they provide a high-level API for constructing neural networks. import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Input, SimpleRNN, Dense # Define an RNN model for multivariate time series model = Sequential([Input(shape=(sequence_length, len(features))), SimpleRNN(20, activation='relu'), Dense(1) # Predicting Temperature (T)]) In this code, we first import the necessary modules from TensorFlow and Keras. We then create a Sequential model, which allows us to stack layers in a linear fashion. The Input layer is added to specify the shape of the input data. The SimpleRNN layer is added with 20 units and a ReLU activation function. Finally, we add a Dense layer with a single unit to predict the temperature. The choice of activation function and the number of units in the SimpleRNN layer can be adjusted based on the complexity of the data and the desired model performance.

Compiling and Training the RNN Model

Once the model is defined, the next step is to compile and train it. Compiling the model involves specifying the optimizer and loss function, which are used to update the model's weights during training. We will use the Adam optimizer and mean squared error (MSE) as the loss function, as they are commonly used for regression tasks. # Compile model model.compile(optimizer='adam', loss='mse') # Train model history = model.fit(X_train, y_train, epochs=10, batch_size=16, verbose=1) In this code, we compile the model using the compile method, specifying the Adam optimizer and MSE loss function. We then train the model using the fit method, providing the training input data X_train and target values y_train . The epochs parameter specifies the number of times the model will iterate over the entire training dataset, while batch_size determines the number of samples processed before the model's weights are updated. The verbose parameter controls the verbosity of the training output. During training, the model learns to minimize the loss function by adjusting its weights, ultimately improving its ability to make accurate predictions.

Evaluating the Model and Summary

After training the model, it's important to evaluate its structure and performance. We can print a summary of the model to understand its architecture and the number of parameters. # Print model summary model.summary() The summary method provides a detailed overview of the model, including the layers, output shapes, and the number of parameters. This information is valuable for understanding the complexity of the model and ensuring that it is correctly configured. In summary, you have learned how to build and train an RNN model for multivariate time series forecasting. We covered the model architecture, compilation, and training process, providing you with the foundational skills needed to construct RNN models. As you move on to the practice exercises, I encourage you to apply these concepts and experiment with different parameters to deepen your understanding. Proper model building and training are key to achieving accurate time series forecasts.

Python

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Input, SimpleRNN, Dense

# Define an RNN model for multivariate time series
model = Sequential([
    Input(shape=(sequence_length, len(features))),
    SimpleRNN(20, activation='relu'),
    Dense(1)  # Predicting Temperature (T)
])