{ "cells": [ { "metadata": {}, "cell_type": "markdown", "source": [ "\n", " \"Open\n", "" ], "id": "f1d1d10f246e102d" }, { "metadata": {}, "cell_type": "markdown", "source": [ "# Recurrent Neural Networks (RNN)\n", "\n", "## Limitations of MLP with Sequential Data\n", "\n", "The MLPs we saw in block 2 treat each sample independently: they have no memory of previous inputs. This is appropriate when samples are unrelated to each other, but in a time series the order and temporal context are essential for making good predictions.\n", "\n", "As discussed earlier, the window has a fixed size and the model cannot learn dependencies longer than the defined window. Moreover, it treats all values in the window symmetrically, without considering that more recent values tend to be more relevant.\n", "\n", "## RNN Overview\n", "\n", "A recurrent neural network (RNN) solves this problem by introducing the concept of a **hidden state** $h_t$: a vector that acts as memory and is passed from one time step to the next. At each step $t$, the network combines the current input $x_t$ with the previous hidden state $h_{t-1}$ to produce a new output and update the hidden state.\n", "\n", "![RNN](../../_static/03/RNN-unrolled.png \"RNN Desplegada\")\n", "\n", "## Types of Problems Solvable with RNNs\n", "\n", "One of the strengths of recurrent networks is their flexibility in handling different input/output configurations:\n", "\n", "- **One-to-one:** a single input produces a single output. Equivalent to a standard MLP, no recurrence is used.\n", "\n", "- **One-to-many:** a single input produces a sequence of outputs. Example: generating a text description from an image.\n", "\n", "- **Many-to-one:** a sequence of inputs produces a single output. Example: sentiment classification of a text, or predicting the next value in a time series from a window of past values.\n", "\n", "- **Many-to-many (equal length):** a sequence of inputs produces a sequence of outputs of the same length. Example: part-of-speech tagging in NLP.\n", "\n", "- **Many-to-many (different length):** a sequence of inputs produces a sequence of outputs of different length. Example: machine translation. This configuration is also known as **sequence-to-sequence (seq2seq)**.\n", "\n", "In this course we will focus on the **many-to-one** configuration, which is the most common in time series forecasting: the model receives a window of past values and predicts the next value.\n", "\n", "## RNN Architecture\n", "\n", "Its formulation is as follows:\n", "\n", "$$h_t = \\tanh(W_h \\cdot h_{t-1} + W_x \\cdot x_t + b),$$\n", "\n", "$$\\hat{y}_t = W_y \\cdot h_t + b_y,$$\n", "\n", "where $W_h$, $W_x$, and $W_y$ are the weight matrices and $b$ the biases. The weights are shared across all time steps, which allows the network to generalise regardless of the sequence length.\n", "\n", "![RNN interna](../../_static/03/RNN.png \"RNN Interior\")\n", "\n", "### Backpropagation Through Time\n", "\n", "Training an RNN follows the same principle as an MLP: forward pass, loss calculation, backward pass, and weight update. The difference here is that the backward pass propagates through the time steps, hence the name **Backpropagation Through Time (BPTT)**.\n", "\n", "### Gradient Problem\n", "\n", "The vanishing gradient is the main limitation of simple RNNs. During BPTT, gradients are successively multiplied across time steps. Since the values of the $\\tanh$ function are bounded between $(-1, 1)$, successive multiplications cause the gradient to approach zero rapidly, preventing the network from learning long-term dependencies.\n", "\n", "In practice, a simple RNN struggles to learn relationships between events separated by more than 10–20 time steps.\n", "\n", "See the PowerPoint presentation for more details.\n", "\n" ], "id": "5856b6fbca3f7333" }, { "metadata": {}, "cell_type": "markdown", "source": [ "## Example with PyTorch\n", "\n", "We continue using the **Air Passengers** dataset to compare the results with the ARIMA model from the previous section.\n" ], "id": "c5595f5480d0cba9" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:22:59.931121100Z", "start_time": "2026-04-21T11:22:53.530089800Z" } }, "cell_type": "code", "source": [ "# Importacio de les llibreries necessaries\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "import matplotlib.pyplot as plt\n", "import statsmodels.api as sm\n", "import pandas as pd\n", "from sklearn.preprocessing import MinMaxScaler\n", "from sklearn.metrics import mean_absolute_error\n" ], "id": "a2c6835a5b16c4ab", "outputs": [], "execution_count": 1 }, { "metadata": {}, "cell_type": "markdown", "source": "First, we will prepare the data to be fed into the network. Although it may seem counterintuitive, we still need to define a time window over which the network will operate. In our case, given our knowledge of the data, we will set it to 12; this can be considered as an additional hyperparameter of the method.", "id": "d7d4c67d3e814881" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:00.788993500Z", "start_time": "2026-04-21T11:22:59.931121100Z" } }, "cell_type": "code", "source": [ "# Càrrega del dataset\n", "data = sm.datasets.get_rdataset(\"AirPassengers\", \"datasets\").data\n", "data.columns = ['time', 'passengers']\n", "data.index = pd.date_range(start='1949-01', periods=len(data), freq='ME')\n", "series = data['passengers'].values.astype(float)\n", "\n", "# Normalització entre 0 i 1\n", "scaler = MinMaxScaler()\n", "series_scaled = scaler.fit_transform(series.reshape(-1, 1)).flatten()\n", "\n", "# Divisió train/test seqüencial (80/20)\n", "train_size = int(len(series_scaled) * 0.8)\n", "train = series_scaled[:train_size]\n", "test = series_scaled[train_size:]" ], "id": "8603283f0ef27721", "outputs": [], "execution_count": 2 }, { "metadata": {}, "cell_type": "markdown", "source": "We will use a custom function to transform the time series into input-output pairs suitable for training the network. For each time step $t$, the function takes the previous `window_size` observations as input and the value at $t$ as the target.", "id": "a000ba52ee6ab118" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:00.833127600Z", "start_time": "2026-04-21T11:23:00.820503800Z" } }, "cell_type": "code", "source": [ "def create_sequences(data, window_size):\n", " X, y = [], []\n", " for i in range(window_size, len(data)):\n", " X.append(data[i-window_size:i])\n", " y.append(data[i])\n", " return np.array(X), np.array(y)\n", "\n", "WINDOW_SIZE = 12\n", "\n", "X_train, y_train = create_sequences(train, WINDOW_SIZE)\n", "X_test, y_test = create_sequences(np.concatenate([train[-WINDOW_SIZE:], test]),\n", " WINDOW_SIZE)" ], "id": "4f2b55c6f0e4f9fc", "outputs": [], "execution_count": 3 }, { "metadata": {}, "cell_type": "markdown", "source": "When we create the sequences using the `create_sequences` function, we obtain an array of shape `[batch, seq_len]`, i.e. 2D. However, the PyTorch module we will use (`nn.RNN`) expects three-dimensional tensors of shape `[batch, seq_len, features]`, where `features` is the number of input variables. Since in this example we work with a single variable (the number of passengers), `features=1`, but PyTorch requires this dimension to exist explicitly. We can use the `unsqueeze(-1)` function, which adds this dimension at the end, transforming `[batch, seq_len]` into `[batch, seq_len, 1]`. If we were working with multiple variables, such as temperature, salinity, and pressure simultaneously, this last dimension would be greater than 1 and `unsqueeze` would not be needed.", "id": "9c1360d995538dea" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:00.928288500Z", "start_time": "2026-04-21T11:23:00.833127600Z" } }, "cell_type": "code", "source": [ "# Conversió a tensors (RNN espera shape: [batch, seq_len, features])\n", "X_train = torch.tensor(X_train, dtype=torch.float32).unsqueeze(-1)\n", "X_test = torch.tensor(X_test, dtype=torch.float32).unsqueeze(-1)\n", "y_train = torch.tensor(y_train, dtype=torch.float32)\n", "y_test = torch.tensor(y_test, dtype=torch.float32)" ], "id": "61e1b1ce4a41c547", "outputs": [], "execution_count": 4 }, { "metadata": {}, "cell_type": "markdown", "source": "To better understand how the data is structured after applying the sliding window, let's inspect the first two samples of the training set:", "id": "24b3daf10cddd6f5" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:01.051471800Z", "start_time": "2026-04-21T11:23:00.964056600Z" } }, "cell_type": "code", "source": [ "print(X_train.shape)\n", "print(X_train[0,:,0])\n", "print(X_train[1,:,0])" ], "id": "7db085dc6f35c8fb", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([103, 12, 1])\n", "tensor([0.0154, 0.0270, 0.0541, 0.0483, 0.0328, 0.0598, 0.0849, 0.0849, 0.0618,\n", " 0.0290, 0.0000, 0.0270])\n", "tensor([0.0270, 0.0541, 0.0483, 0.0328, 0.0598, 0.0849, 0.0849, 0.0618, 0.0290,\n", " 0.0000, 0.0270, 0.0212])\n" ] } ], "execution_count": 5 }, { "metadata": {}, "cell_type": "markdown", "source": [ "Now we need to define the model. In this case we cannot use the `nn.Sequential` module, we need a more complex construction. Instead, we must define the network using object-oriented programming.\n", "\n", "We will define a class, in this case `RNNModel`, which has two methods:\n", "\n", "- `__init__`: here we define the components (layers) that our network will have. In this case, an `nn.RNN` module called `self.rnn` and a linear output layer called `self.fc`.\n", "- `forward`: here we define how the layers defined in `__init__` are connected.\n", "\n", "The `nn.RNN` module contains all the logic of a recurrent neural network. Its most relevant parameters are:\n", "\n", "- `input_size`: number of input variables at each time step. In our example this is 1 (a single variable).\n", "- `hidden_size`: dimension of the hidden state vector $h_t$. Controls the model's capacity to learn complex representations.\n", "- `num_layers`: number of stacked RNN layers. A value of 1 is sufficient for most simple cases.\n", "- `batch_first`: if `True`, the input tensor is expected with shape `[batch, seq_len, features]`. If `False` (default), the expected shape is `[seq_len, batch, features]`. It is recommended to use `batch_first=True` for consistency with the rest of PyTorch.\n", "- `nonlinearity`: activation function of the hidden state. The default is `'tanh'`, but `'relu'` is also accepted." ], "id": "296c4cd16ac0f4b8" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:01.060483Z", "start_time": "2026-04-21T11:23:01.052479200Z" } }, "cell_type": "code", "source": [ "class RNNModel(nn.Module):\n", " def __init__(self, input_size=1, hidden_size=32, num_layers=1):\n", " super(RNNModel, self).__init__()\n", " self.rnn = nn.RNN(\n", " input_size=input_size,\n", " hidden_size=hidden_size,\n", " num_layers=num_layers,\n", " batch_first=True\n", " )\n", " self.fc = nn.Linear(hidden_size, 1)\n", "\n", " def forward(self, x):\n", " out, _ = self.rnn(x)\n", " out = self.fc(out[:, -1, :]) # agafem l'últim pas temporal i el processam per una capa tipus MLP\n", " return out.squeeze()\n", "\n" ], "id": "a6754d81c7462bcc", "outputs": [], "execution_count": 6 }, { "metadata": {}, "cell_type": "markdown", "source": "Now we will create a model that has a 32-dimensional hidden state and later, without doing any training, we will make a prediction to see the result:", "id": "f2b2a8ae82790172" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:01.104290100Z", "start_time": "2026-04-21T11:23:01.061484800Z" } }, "cell_type": "code", "source": [ "model = RNNModel(hidden_size=32)\n", "out = model(X_train)\n", "print(out.shape)" ], "id": "903f61b28bcc61d8", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([103])\n" ] } ], "execution_count": 7 }, { "metadata": {}, "cell_type": "markdown", "source": "The training is very similar to what we already know, here we will hardly notice any changes:", "id": "ec8ba822d4b5b6cb" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:06.321253700Z", "start_time": "2026-04-21T11:23:01.108300400Z" } }, "cell_type": "code", "source": [ "criterion = nn.MSELoss() # En aquest cas la funció de pèrdua és de regressió\n", "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n", "\n", "epochs = 1000\n", "for epoch in range(epochs):\n", " model.train()\n", " y_pred = model(X_train)\n", " loss = criterion(y_pred, y_train)\n", "\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " if (epoch + 1) % 50 == 0:\n", " print(f\"Epoch {epoch+1}/{epochs} - Loss: {loss.item():.6f}\")" ], "id": "a30d0684481e094a", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 50/1000 - Loss: 0.014425\n", "Epoch 100/1000 - Loss: 0.005034\n", "Epoch 150/1000 - Loss: 0.004174\n", "Epoch 200/1000 - Loss: 0.003429\n", "Epoch 250/1000 - Loss: 0.002825\n", "Epoch 300/1000 - Loss: 0.002546\n", "Epoch 350/1000 - Loss: 0.002256\n", "Epoch 400/1000 - Loss: 0.002571\n", "Epoch 450/1000 - Loss: 0.002035\n", "Epoch 500/1000 - Loss: 0.001877\n", "Epoch 550/1000 - Loss: 0.005245\n", "Epoch 600/1000 - Loss: 0.001848\n", "Epoch 650/1000 - Loss: 0.001739\n", "Epoch 700/1000 - Loss: 0.001648\n", "Epoch 750/1000 - Loss: 0.001557\n", "Epoch 800/1000 - Loss: 0.001455\n", "Epoch 850/1000 - Loss: 0.001642\n", "Epoch 900/1000 - Loss: 0.001570\n", "Epoch 950/1000 - Loss: 0.001511\n", "Epoch 1000/1000 - Loss: 0.001447\n" ] } ], "execution_count": 8 }, { "metadata": {}, "cell_type": "markdown", "source": "We will separate the evaluation to simplify the code blocks. In this case we will calculate the three metrics and show the network prediction graphically:", "id": "7db84887d0e5d065" }, { "metadata": { "ExecuteTime": { "end_time": "2026-04-21T11:23:06.625698100Z", "start_time": "2026-04-21T11:23:06.356163Z" } }, "cell_type": "code", "source": [ "model.eval()\n", "with torch.no_grad():\n", " predictions_scaled = model(X_test).numpy()\n", "\n", "# Desnormalització\n", "predictions = scaler.inverse_transform(predictions_scaled.reshape(-1, 1))\n", "y_test_real = scaler.inverse_transform(y_test.numpy().reshape(-1, 1))\n", "\n", "mae = mean_absolute_error(y_test_real, predictions)\n", "rmse = np.sqrt(np.mean((y_test_real - predictions) ** 2))\n", "mape = np.mean(np.abs((y_test_real - predictions) / y_test_real)) * 100\n", "\n", "print(f\"MAE: {mae:.2f}\")\n", "print(f\"RMSE: {rmse:.2f}\")\n", "print(f\"MAPE: {mape:.2f}%\")\n", "\n", "# Visualització\n", "test_index = data.index[train_size:]\n", "plt.figure(figsize=(12, 4))\n", "plt.plot(data.index[:train_size], series[:train_size], label='Train')\n", "plt.plot(test_index, y_test_real, label='Test')\n", "plt.plot(test_index, predictions, label='Predicció RNN', linestyle='--')\n", "plt.legend()\n", "plt.title('Predicció RNN - Air Passengers')\n", "plt.tight_layout()\n", "plt.show()" ], "id": "e6102e1dcfa87dad", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MAE: 28.96\n", "RMSE: 37.22\n", "MAPE: 6.35%\n" ] }, { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data", "jetTransient": { "display_id": null } } ], "execution_count": 9 }, { "metadata": {}, "cell_type": "markdown", "source": "Although the RNN improves upon ARIMA, it still struggles to capture long-term seasonality due to the vanishing gradient problem. In the next section we will see how the LSTM solves this limitation.", "id": "f99a56a5e9f85168" }, { "metadata": {}, "cell_type": "markdown", "source": [ "## Exercise\n", "\n", "Download a monthly sea surface temperature (SST) time series for the Mediterranean Sea from [surftemp.net](https://surftemp.net/timeseries/index.html) in CSV format. Choose a geographic area of your choice.\n", "\n", "Once the data is loaded:\n", "\n", "- Visualise the series and identify the trend and seasonality.\n", "- Prepare the data using a sliding window and sequential train/test split.\n", "- Train an RNN with PyTorch to predict the SST of the following month.\n", "- Evaluate the model with MAE, RMSE, and MAPE and visualise the predictions.\n", "\n", "\n", "[Sample data](link)" ], "id": "42a344fc588a99b4" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.6" } }, "nbformat": 4, "nbformat_minor": 5 }