Preparing Data for RNNs

Welcome back! In the previous lesson, we focused on understanding and preprocessing multivariate time series data using the Air Quality dataset. We cleaned the dataset by handling missing values, combining date and time columns, and setting the DateTime column as the index. Now, we will build on that foundation to prepare the data for Recurrent Neural Networks (RNNs). This preparation is crucial for multivariate time series forecasting, as it involves selecting relevant features, normalizing the data, structuring it into sequences suitable for RNN input, and splitting the data into training and testing sets.

Feature selection is a critical step in preparing data for RNNs. It involves choosing the most relevant features from the dataset that will be used as inputs for the model. In our case, we will focus on features that are significant for forecasting temperature, such as CO(GT), NO2(GT), PT08.S5(O3), RH, and T. By selecting these features, we ensure that the RNN model receives the most informative data for making accurate predictions.

Here's how you can select these features from the dataset:

# Select relevant features for RNN
features = ['CO(GT)', 'NO2(GT)', 'PT08.S5(O3)', 'RH', 'T']
df = df[features]

This code snippet extracts the specified features from the dataset, creating a new DataFrame that contains only the relevant columns. This step is essential for reducing the complexity of the model and improving its performance.

Normalization is a crucial step in preparing data for RNNs, as it ensures that all features are on a similar scale. This is important because RNNs are sensitive to the scale of input data, and large differences in scale can lead to inefficient training. We will use the StandardScaler from the sklearn library to normalize our data.

Here's how you can normalize the data:

from sklearn.preprocessing import StandardScaler

# Normalize the data
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

In this example, we first import the StandardScaler class from sklearn.preprocessing. We then create an instance of StandardScaler and use the fit_transform method to normalize the data. This method scales each feature to have a mean of 0 and a standard deviation of 1, ensuring that all features are on a similar scale.

Creating sequences is a key step in preparing data for RNNs. RNNs require input data to be structured as sequences, where each sequence consists of multiple time steps. In our case, we will create sequences of length 10, where each sequence contains 10 time steps of the selected features. The target variable for prediction will be the temperature (T) at the next time step.

Here's how you can create sequences for a multi-input RNN:

import numpy as np

# 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)

In this code, we define a function create_multivariate_sequences that takes the normalized data and a sequence length as input. The function iterates over the data to create sequences of the specified length, appending each sequence to the list X and the corresponding target value to the list y. The target value is the temperature at the next time step. Finally, the function returns the sequences and target values as NumPy arrays.

Once we have created the sequences, we need to reshape the data to fit the input requirements of an RNN. RNNs expect input data to be in the format (samples, timesteps, features), where "samples" is the number of sequences, "timesteps" is the length of each sequence, and "features" is the number of features in each time step.

Here's how you can reshape the data:

# Reshape input for RNN
X = X.reshape((X.shape[0], sequence_length, len(features)))  # (samples, timesteps, features)

In this example, we use the reshape method to change the shape of the input data X to the required format. The X.shape[0] represents the number of samples, sequence_length is the number of timesteps, and len(features) is the number of features. This reshaping ensures that the data is ready for input into an RNN model.

Before training an RNN, it's important to split your data into training and testing sets. For time series data, you should always split chronologically to avoid data leakage from the future into the past.

Here's how you can perform a train-test split after creating your sequences:

# Define train-test split ratio
train_size = int(0.8 * len(X))  # 80% for training, 20% for testing

# Chronological split
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

This code splits the sequences and targets into training and testing sets, preserving the temporal order of the data. The first 80% of the data is used for training, and the remaining 20% is used for testing. This approach ensures that the model is evaluated on future data it has not seen during training.

Let's walk through a complete example of preparing a dataset for RNN. We will select relevant features, normalize the data, create sequences, reshape the data, and split it into training and testing sets. Finally, we will print the shape of the processed datasets to ensure that they are correctly prepared for RNN input.

from sklearn.preprocessing import StandardScaler
import numpy as np

# Select relevant features for RNN
features = ['CO(GT)', 'NO2(GT)', 'PT08.S5(O3)', 'RH', 'T']
df = df[features]

# Normalize the data
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

# 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}")

The output of this code will display the shapes of the processed training and testing datasets, confirming that they are ready for RNN input:

X_train shape: (5544, 10, 5), y_train shape: (5544,)
X_test shape: (1387, 10, 5), y_test shape: (1387,)

This output indicates that we have 5544 training samples and 1387 testing samples, each with 10 timesteps and 5 features, and corresponding target values for temperature prediction.

In this lesson, we covered the essential steps for preparing data for RNNs. We selected relevant features, normalized the data, created sequences, reshaped the data, and performed a chronological train-test split. These steps are crucial for ensuring that the data is ready for accurate time series forecasting using RNNs. As you move on to the practice exercises, you'll have the opportunity to reinforce these concepts and gain hands-on experience with the data preparation techniques covered in this lesson. Remember, proper data preparation is key to building effective RNN models.