{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Forecasting using spatio-temporal data with combined Graph Convolution + LSTM model" ] }, { "cell_type": "markdown", "metadata": { "nbsphinx": "hidden", "tags": [ "CloudRunner" ] }, "source": [ "
Run the latest release of this notebook:
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The dynamics of many real-world phenomena are spatio-temporal in nature. Traffic forecasting is a quintessential example of spatio-temporal problems for which we present here a deep learning framework that models speed prediction using spatio-temporal data. The task is challenging due to two main inter-linked factors: (1) the complex spatial dependency on road networks, and (2) non-linear temporal dynamics with changing road conditions.\n", "\n", "To address these challenges, here we explore a neural network architecture that learns from both the spatial road network data and time-series of historical speed changes to forecast speeds on road segments at a future time. In the following we demo how to forecast speeds on road segments through a `graph convolution` and `LSTM` hybrid model. The spatial dependency of the road networks are learnt through multiple graph convolution layers stacked over multiple LSTM, sequence to sequence model, layers that leverage the historical speeds on top of the network structure to predicts speeds in the future for each entity. \n", "\n", "The architecture of the gcn-lstm model is inpired by the paper: [T-GCN: A Temporal Graph Convolutional Network for Traffic Prediction](https://ieeexplore.ieee.org/document/8809901).\n", "\n", "The authors have made available the implementation of their model in their github [repo](https://github.com/lehaifeng/T-GCN).\n", "There has been a few differences in the architecture proposed in the paper and the implementation of the graph convolution component, these issues have been documented [here](https://github.com/lehaifeng/T-GCN/issues/18) and [here](https://github.com/lehaifeng/T-GCN/issues/14). The `GraphConvolutionLSTM` model in `StellarGraph` emulates the model as explained in the paper while giving additional flexibility of adding any number of `graph convolution` and `LSTM` layers. \n", "\n", "Concretely, the architecture of `GraphConvolutionLSTM` is as follows:\n", "\n", "1. User defined number of graph convolutional layers (Reference: [Kipf & Welling (ICLR 2017)](http://arxiv.org/abs/1609.02907)).\n", "2. User defined number of LSTM layers. The [TGCN](https://ieeexplore.ieee.org/document/8809901) uses GRU instead of LSTM. In practice there are not any remarkable differences between the two types of layers. We use LSTM as they are more frequently used.\n", "3. A Dropout and a Dense layer as they experimentally showed improvement in performance and managing over-fitting.\n", "\n", "## References: \n", "\n", "* [T-GCN: A Temporal Graph Convolutional Network for Traffic Prediction](https://ieeexplore.ieee.org/document/8809901)\n", "* [https://github.com/lehaifeng/T-GCN](https://github.com/lehaifeng/T-GCN)\n", "* [Semi-Supervised Classification with Graph Convolutional Networks](http://arxiv.org/abs/1609.02907)\n", "\n", "**Note: this method is applicable for uni-variate timeseries forecasting.**" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "nbsphinx": "hidden", "tags": [ "CloudRunner" ] }, "outputs": [], "source": [ "# install StellarGraph if running on Google Colab\n", "import sys\n", "if 'google.colab' in sys.modules:\n", " %pip install -q stellargraph[demos]==1.0.0" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "nbsphinx": "hidden", "tags": [ "VersionCheck" ] }, "outputs": [], "source": [ "# verify that we're using the correct version of StellarGraph for this notebook\n", "import stellargraph as sg\n", "\n", "try:\n", " sg.utils.validate_notebook_version(\"1.0.0\")\n", "except AttributeError:\n", " raise ValueError(\n", " f\"This notebook requires StellarGraph version 1.0.0, but a different version {sg.__version__} is installed. Please see .\"\n", " ) from None" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import os\n", "import sys\n", "import urllib.request\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.lines as mlines\n", "\n", "import tensorflow as tf\n", "from tensorflow import keras\n", "from tensorflow.keras import Sequential, Model\n", "from tensorflow.keras.layers import LSTM, Dense, Dropout, Input" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data\n", "\n", "We apply the gcn-lstm model to the **Los-loop** data. This traffic dataset\n", "contains traffic information collected from loop detectors in the highway of Los Angeles County (Jagadish\n", "et al., 2014). There are several processed versions of this dataset used by the research community working in Traffic forecasting space. \n", "\n", "This demo is based on the pre-processed version of the dataset used by the TGCN paper. It can be directly accessed from there [github repo](https://github.com/lehaifeng/T-GCN/tree/master/data). \n", "\n", "This dataset contains traffic speeds from Mar.1 to Mar.7, 2012 of 207 sensors, recorded every 5 minutes. \n", "\n", "In order to use the model, we need:\n", "\n", "* A N by N adjacency matrix, which describes the distance relationship between the N sensors,\n", "* A N by T feature matrix, which describes the (f_1, .., f_T) speed records over T timesteps for the N sensors.\n", "\n", "A couple of other references for the same data albeit different time length are as follows: \n", "\n", "* [DIFFUSION CONVOLUTIONAL RECURRENT NEURAL NETWORK: DATA-DRIVEN TRAFFIC FORECASTING](https://github.com/liyaguang/DCRNN/tree/master/data): This dataset consists of 207 sensors and collect 4 months of data ranging from Mar 1st 2012 to Jun 30th 2012 for the experiment. It has some missing values.\n", "* [ST-MetaNet: Urban Traffic Prediction from Spatio-Temporal Data Using Deep Meta Learning](https://github.com/panzheyi/ST-MetaNet/tree/master/traffic-prediction). This work uses the DCRNN pre-proccessed data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loading and pre-processing the data" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import stellargraph as sg" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This demo is based on the pre-processed version of the dataset used by the TGCN paper." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "dataset = sg.datasets.METR_LA()" ] }, { "cell_type": "markdown", "metadata": { "tags": [ "DataLoadingLinks" ] }, "source": [ "(See [the \"Loading from Pandas\" demo](../basics/loading-pandas.ipynb) for details on how data can be loaded.)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "tags": [ "DataLoading" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "No. of sensors: 207 \n", "No of timesteps: 2016\n" ] } ], "source": [ "speed_data, sensor_dist_adj = dataset.load()\n", "num_nodes = speed_data.shape[1]\n", "time_len = speed_data.shape[0]\n", "print(\"No. of sensors:\", num_nodes, \"\\nNo of timesteps:\", time_len)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Let's look at a sample of speed data.**" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
773869767541767542717447717446717445773062767620737529717816...772167769372774204769806717590717592717595772168718141769373
064.37500067.62500067.12500061.50000066.87500068.75000065.12500067.12500059.62500062.750000...45.62500065.50000064.50000066.42857166.87500059.37500069.00000059.25000069.00000061.875000
162.66666768.55555665.44444462.44444464.44444468.11111165.00000065.00000057.44444463.333333...50.66666769.87500066.66666758.55555662.00000061.11111164.44444455.88888968.44444462.875000
264.00000063.75000060.00000059.00000066.50000066.25000064.50000064.25000063.87500065.375000...44.12500069.00000056.50000059.25000068.12500062.50000065.62500061.37500069.85714362.000000
361.77777865.50000062.55555659.88888966.77777867.16666763.22222265.27777863.58333364.694444...43.41666769.33333360.44444458.61111167.41666759.88888965.30555660.13888969.57142960.444444
459.55555667.25000065.11111160.77777867.05555668.08333361.94444466.30555663.29166764.013889...42.70833369.66666764.38888957.97222266.70833357.27777864.98611158.90277869.28571458.888889
\n", "

5 rows × 207 columns

\n", "
" ], "text/plain": [ " 773869 767541 767542 717447 717446 717445 \\\n", "0 64.375000 67.625000 67.125000 61.500000 66.875000 68.750000 \n", "1 62.666667 68.555556 65.444444 62.444444 64.444444 68.111111 \n", "2 64.000000 63.750000 60.000000 59.000000 66.500000 66.250000 \n", "3 61.777778 65.500000 62.555556 59.888889 66.777778 67.166667 \n", "4 59.555556 67.250000 65.111111 60.777778 67.055556 68.083333 \n", "\n", " 773062 767620 737529 717816 ... 772167 769372 \\\n", "0 65.125000 67.125000 59.625000 62.750000 ... 45.625000 65.500000 \n", "1 65.000000 65.000000 57.444444 63.333333 ... 50.666667 69.875000 \n", "2 64.500000 64.250000 63.875000 65.375000 ... 44.125000 69.000000 \n", "3 63.222222 65.277778 63.583333 64.694444 ... 43.416667 69.333333 \n", "4 61.944444 66.305556 63.291667 64.013889 ... 42.708333 69.666667 \n", "\n", " 774204 769806 717590 717592 717595 772168 \\\n", "0 64.500000 66.428571 66.875000 59.375000 69.000000 59.250000 \n", "1 66.666667 58.555556 62.000000 61.111111 64.444444 55.888889 \n", "2 56.500000 59.250000 68.125000 62.500000 65.625000 61.375000 \n", "3 60.444444 58.611111 67.416667 59.888889 65.305556 60.138889 \n", "4 64.388889 57.972222 66.708333 57.277778 64.986111 58.902778 \n", "\n", " 718141 769373 \n", "0 69.000000 61.875000 \n", "1 68.444444 62.875000 \n", "2 69.857143 62.000000 \n", "3 69.571429 60.444444 \n", "4 69.285714 58.888889 \n", "\n", "[5 rows x 207 columns]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "speed_data.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you can see above, there are 2016 observations (timesteps) of speed records over 207 sensors. Speeds are recorded every 5 minutes. This means that, for a single hour, you will have 12 observations. Similarly, a single day will contain 288 (12x24) observations. Overall, the data consists of speeds recorded every 5 minutes over 207 for 7 days (12X24X7).\n", "\n", "### Forecasting with spatio-temporal data as a supervised learing problem \n", "\n", "Time series forecasting problem can be cast as a supervised learning problem. We can do this by using previous timesteps as input features and use the next timestep as the output to predict. Then, the spatio-temporal forecasting question can be modeled as predicting the feature value in the future, given the historical values of the feature for that entity as well as the feature values of the entities \"connected\" to the entity. For example, the speed prediction problem, the historical speeds of the sensors are the timeseries and the distance between the sensors is the indicator for connectivity or closeness of sensors." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Train/test split\n", "\n", "Just like for modeling any standard supervised learning problem, we first split the data into mutually exclusive train and test sets. However, unlike, a standard supervised learning problem, in timeseries analysis, the data is in some choronological time respecting order and the train/test happens along the timeline. Lets say, we use the first `T_t` observations for training and the remaining `T - T_t` of the total `T` observations for testing. \n", "\n", "In the following we use first 80% observations for training and the rest for testing." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def train_test_split(data, train_portion):\n", " time_len = data.shape[0]\n", " train_size = int(time_len * train_portion)\n", " train_data = np.array(data[:train_size])\n", " test_data = np.array(data[train_size:])\n", " return train_data, test_data" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "train_rate = 0.8" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train data: (1612, 207)\n", "Test data: (404, 207)\n" ] } ], "source": [ "train_data, test_data = train_test_split(speed_data, train_rate)\n", "print(\"Train data: \", train_data.shape)\n", "print(\"Test data: \", test_data.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Scaling\n", "It is generally a good practice to rescale the data from the original range so that all values are within the range of 0 and 1. Normalization can be useful and even necessary when your time series data has input values with differing scales. In the following we normalize the speed timeseries by the maximum and minimum values of speeds in the train data. \n", "\n", "Note: `MinMaxScaler` in `scikit learn` library is typically used for transforming data. However, in timeseries data since the features are distinct timesteps, so using the historical range of values in a particular timestep as the range of values in later timesteps, may not be correct. Hence, we use the maximum and the minimum of the entire range of values in the timeseries to scale and transform the train and test sets respectively." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def scale_data(train_data, test_data):\n", " max_speed = train_data.max()\n", " min_speed = train_data.min()\n", " train_scaled = (train_data - min_speed) / (max_speed - min_speed)\n", " test_scaled = (test_data - min_speed) / (max_speed - min_speed)\n", " return train_scaled, test_scaled" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "train_scaled, test_scaled = scale_data(train_data, test_data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Sequence data preparation for LSTM\n", "\n", "We first need to prepare the data to be fed into an LSTM. \n", "The LSTM model learns a function that maps a sequence of past observations as input to an output observation. As such, the sequence of observations must be transformed into multiple examples from which the LSTM can learn.\n", "\n", "To make it concrete in terms of the speed prediction problem, we choose to use 50 minutes of historical speed observations to predict the speed in future, lets say, 1 hour ahead. Hence, we would first reshape the timeseries data into windows of 10 historical observations for each segment as the input and the speed 60 minutes later is the label we are interested in predicting. We use the sliding window approach to prepare the data. This is how it works: \n", "\n", "* Starting from the beginning of the timeseries, we take the first 10 speed records as the 10 input features and the speed 12 timesteps head (60 minutes) as the speed we want to predict. \n", "* Shift the timeseries by one timestep and take the 10 observations from the current point as the input feartures and the speed one hour ahead as the output to predict. \n", "* Keep shifting by 1 timestep and picking the 10 timestep window from the current time as input feature and the speed one hour ahead of the 10th timestep as the output to predict, for the entire data.\n", "* The above steps are done for each sensor. \n", "\n", "The function below returns the above transformed timeseries data for the model to train on. The parameter `seq_len` is the size of the past window of information. The `pre_len` is how far in the future does the model need to learn to predict. \n", "\n", "For this demo: \n", "\n", "* Each training observation are 10 historical speeds (`seq_len`).\n", "* Each training prediction is the speed 60 minutes later (`pre_len`)." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "seq_len = 10\n", "pre_len = 12" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def sequence_data_preparation(seq_len, pre_len, train_data, test_data):\n", " trainX, trainY, testX, testY = [], [], [], []\n", "\n", " for i in range(len(train_data) - int(seq_len + pre_len - 1)):\n", " a = train_data[\n", " i : i + seq_len + pre_len,\n", " ]\n", " trainX.append(a[:seq_len])\n", " trainY.append(a[-1])\n", "\n", " for i in range(len(test_data) - int(seq_len + pre_len - 1)):\n", " b = test_data[\n", " i : i + seq_len + pre_len,\n", " ]\n", " testX.append(\n", " b[:seq_len,]\n", " )\n", " testY.append(b[-1])\n", "\n", " trainX = np.array(trainX)\n", " trainY = np.array(trainY)\n", " testX = np.array(testX)\n", " testY = np.array(testY)\n", "\n", " return trainX, trainY, testX, testY" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1591, 10, 207)\n", "(1591, 207)\n", "(383, 10, 207)\n", "(383, 207)\n" ] } ], "source": [ "trainX, trainY, testX, testY = sequence_data_preparation(\n", " seq_len, pre_len, train_scaled, test_scaled\n", ")\n", "print(trainX.shape)\n", "print(trainY.shape)\n", "print(testX.shape)\n", "print(testY.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## StellarGraph Graph Convolution and LSTM model" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "from stellargraph.layer import GraphConvolutionLSTM" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "gcn_lstm = GraphConvolutionLSTM(\n", " seq_len=seq_len,\n", " adj=sensor_dist_adj,\n", " gc_layers=2,\n", " gc_activations=[\"relu\", \"relu\"],\n", " lstm_layer_size=[200],\n", " lstm_activations=[\"tanh\"],\n", ")" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "x_input, x_output = gcn_lstm.in_out_tensors()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "model = Model(inputs=x_input, outputs=x_output)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "model.compile(optimizer=\"adam\", loss=\"mae\", metrics=[\"mse\"])" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "history = model.fit(\n", " trainX,\n", " trainY,\n", " epochs=100,\n", " batch_size=60,\n", " shuffle=True,\n", " verbose=0,\n", " validation_data=[testX, testY],\n", ")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"model\"\n", "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "input_1 (InputLayer) [(None, 10, 207)] 0 \n", "_________________________________________________________________\n", "fixed_adjacency_graph_convol (None, 10, 207) 43156 \n", "_________________________________________________________________\n", "fixed_adjacency_graph_convol (None, 10, 207) 43156 \n", "_________________________________________________________________\n", "lstm (LSTM) (None, 200) 326400 \n", "_________________________________________________________________\n", "dropout (Dropout) (None, 200) 0 \n", "_________________________________________________________________\n", "dense (Dense) (None, 207) 41607 \n", "=================================================================\n", "Total params: 454,319\n", "Trainable params: 368,621\n", "Non-trainable params: 85,698\n", "_________________________________________________________________\n" ] } ], "source": [ "model.summary()" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train loss: 0.05301835040235804 \n", "Test loss: 0.06069195360995771\n" ] } ], "source": [ "print(\n", " \"Train loss: \",\n", " history.history[\"loss\"][-1],\n", " \"\\nTest loss:\",\n", " history.history[\"val_loss\"][-1],\n", ")" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(history.history[\"loss\"], label=\"Training loss\")\n", "plt.plot(history.history[\"val_loss\"], label=\"Test loss\")\n", "plt.legend()\n", "plt.xlabel(\"epoch\")\n", "plt.ylabel(\"loss\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "ythat = model.predict(trainX)\n", "yhat = model.predict(testX)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Rescale values\n", "\n", "Recale the predicted values to the original value range of the timeseries." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "## Rescale values\n", "max_speed = train_data.max()\n", "min_speed = train_data.min()\n", "\n", "## actual train and test values\n", "train_rescref = np.array(trainY * max_speed)\n", "test_rescref = np.array(testY * max_speed)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "## Rescale model predicted values\n", "train_rescpred = np.array((ythat) * max_speed)\n", "test_rescpred = np.array((yhat) * max_speed)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Measuring the performance of the model\n", "\n", "To understand how well the model is performing, we compare it against a naive benchmark.\n", "\n", "1. Naive prediction: using the most recently **observed** value as the predicted value. Note, that albeit being **naive** this is a very strong baseline to beat. Especially, when speeds are recorded at a 5 minutes granularity, one does not expect many drastic changes within such a short period of time. Hence, for short-term predictions naive is a reasonable good guess." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Naive prediction benchmark (using latest observed value)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "## Naive prediction benchmark (using previous observed value)\n", "\n", "testnpred = np.array(testX).transpose(1, 0, 2)[\n", " -1\n", "] # picking the last speed of the 10 sequence for each segment in each sample\n", "testnpredc = (testnpred) * max_speed" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Total (ave) MAE for NN: 4.248436818644403\n", "Total (ave) MAE for naive prediction: 5.877064444860809\n", "Total (ave) MASE for per-segment NN/naive MAE: 0.7389886237426843\n", "...note that MASE<1 (for a given segment) means that the NN prediction is better than the naive prediction.\n" ] } ], "source": [ "## Performance measures\n", "\n", "seg_mael = []\n", "seg_masel = []\n", "seg_nmael = []\n", "\n", "for j in range(testX.shape[-1]):\n", "\n", " seg_mael.append(\n", " np.mean(np.abs(test_rescref.T[j] - test_rescpred.T[j]))\n", " ) # Mean Absolute Error for NN\n", " seg_nmael.append(\n", " np.mean(np.abs(test_rescref.T[j] - testnpredc.T[j]))\n", " ) # Mean Absolute Error for naive prediction\n", " if seg_nmael[-1] != 0:\n", " seg_masel.append(\n", " seg_mael[-1] / seg_nmael[-1]\n", " ) # Ratio of the two: Mean Absolute Scaled Error\n", " else:\n", " seg_masel.append(np.NaN)\n", "\n", "print(\"Total (ave) MAE for NN: \" + str(np.mean(np.array(seg_mael))))\n", "print(\"Total (ave) MAE for naive prediction: \" + str(np.mean(np.array(seg_nmael))))\n", "print(\n", " \"Total (ave) MASE for per-segment NN/naive MAE: \"\n", " + str(np.nanmean(np.array(seg_masel)))\n", ")\n", "print(\n", " \"...note that MASE<1 (for a given segment) means that the NN prediction is better than the naive prediction.\"\n", ")" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAEWCAYAAADcsGj7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydeZxcVZX4v6eru7qqq7d0Z9/ZTAjZCGETMQzK4JJBcEABlU1FhwGcEVAcGAWX3zCKII4rLsOisgyigqOOC0R2NYEASQiBkE53p/e9a1/e/f1xXzeVTm9VXfu738+nP11vu++89bxz7rnniFIKg8FgMBgKkbJ8C2AwGAwGw0QYJWUwGAyGgsUoKYPBYDAULEZJGQwGg6FgMUrKYDAYDAWLUVIGg8FgKFgyoqRE5Hsi8u8ZamupiPhFxGVPbxGRj2Wibbu934rIxZlqz2DIBCKiROTISZZ/QkS+Yf9ebq9fPsG6N4nITzIg0zwReUVEKmfa1jT3d5qItGap7Z0iclo22s4mItIkIu+cZPmZIvLLXMqUCUTk6yLyT9NZd0olZZ+kkIgMi8iAiDwjIp8UkdFtlVKfVEp9aZptTXjC7baalVLVSqnEdA5giv0d8rAqpd6tlLp7pm0bMsd07osU2+oSEV/SvI+JyJakaSUiLyffwyLyZRG5KxMyZBoRcQM3Al/L5X6VUp3A48DludxvNlBKHaOU2pJvObLAV4Bb8i1EGtwK/Jt9b0/KdC2pf1BK1QDL0Cfks8CP0pdvfCb6MjRozPmZNi7gU1OssxA4Pxs7H/ECZJD3AbuVUgcy3O50+CnwiTzst+TI9PMrIscDdUqp59LYVpI/0nKNUqod2A2cNdW6KQmplBpUSj0CfBC4WERWA4jIXSLyZfv3bBH5tW119YnIkyJSJiL3AkuBR2133meS3BYfFZFm4LEJXBlHiMhfRWRIRH4lIg32vg5xD4x8lYvIu4B/Az5o7+9Fe/mo+9CW60YR2W9/fd8jInX2shE5LhaRZhHpEZEbJjo3IlJnb99tt3ej3X6lfS5WJ607x7ZO59rTm0Vke5KlunbM8XxWRF4CAmNvdPtmu92Wf8i2EEauS6WI3GrL3ynaLetN2vYzItIuIm22tTHqcrKv6XdEu0f9IvK0iMwXkW+ISL+I7BaRY5PaWigiP7ePf5+IXJ207CYRedA+P8OiXS8b7WXj3RceEfmJiPTa5+RvIjJvonM/Dl8DrhWR+knW+Spw83ReHCP3mYj8m30fNInIh5KW3yUi3xWR34hIAPi7aZz765LO/WVTiPBu4M/jzL/M3r5dRK6dTPYx80YtV/sevV5E9trn+0Gxny+bvwCHi8iyCdp/r4i8YN97LSJyU9KySZ8hEfHa565fRHYBx092Euy2Pikir9n3xbdFROxlR4jIY/Yx9IjIT5Ovv7z5Xlgo+tlrSFp2rL1NhT19mWg3Z7+I/N8kxz5yfJePdx3s+/4h+14eAi6Z6nyLyEdEvz96ZZL3jc0h94WIvNV+Xgbt/29NWrZFRL4iIk8DQfR1vdQ+1mEReUNEPpG0/sh9f43o90u7iFyatLxRRB61r/3fRHsjnkpavlJE/iBaD7wqIh8YI/8W4L1THCMopSb9A5qAd44zvxn4J/v3XcCX7d//AXwPqLD/TgVkvLaA5YAC7gF8gDdpXrm9zhbgALDaXufnwE/sZacBrRPJC9w0sm7S8i3Ax+zflwGvA4cD1cDDwL1jZPuBLdc6IAIcPcF5ugf4FVBjb7sH+Ki97MfAV5LW/Wfgd/bvY4Eu4ES0BXCxfQyVScezHVgCeMfZ75nANqAeEOBoYIG97HbgEaDBlutR4D/sZe8COoBjgCrgJ/bxHpl0TXuA4wAP8BiwD7jIlvPLwOP2umW2DJ8H3Pb5fAM4M+k6hIH32Nv+B/DcRPcY+sv9UVsuly1Drb3seuDXU92v9rUcuSc/BmxJWkcBR9kyj9wLXwbumqDN04A4cBtQCWwCAsCKpHM1CJxinwvPNM59J2/e0z9LPvfj7P9vwHnjPDf32duvAboZ575n6mfkU8BzwGL72L4P3Ddm/ZeAsyY5N2vs415rH9fZ03mG0F6ZJ+1ztATYMVbWMftSwK/R9/pS+5jfZS87EjjDPoY5wBPANyY45seAjyct+xrwPfv3+9DvhKOBcrSb9ZkJ5JnOdYgBZ9vnxzvZ+QZWAX7g7fay29D33SHvX3v9/wGuS5puAPqBj9iyX2BPNya9+5rRz3w5+v38XuAI9LtjE1p5bRhz33/RXvc99vJZ9vL77b8qW/YW4Cl7mc+evtTe17Ho98mqJHnfDzw/pQ6acoWJldRzwA1JD+nIC+GL6Jf1IQ/c2LaSLvLh48xLVlK3JC1fBUTRL6/TmJmS+hNwRdKyFfZNVZ4kx+Kk5X8Fzh/nuFy2TMkX4BPYL0b0S3Nv0rKngYvs398FvjSmvVeBTUnHc9kk1+d0tEI8CShLmi/oF+kRSfNOBvbZv3+M/dJMesjHKqkfJC2/CnglaXoNMGD/PhFoHiPX54D/TroOfxxzDUOT3BeXAc8Aa6e6Pye6x9AKYBD9whpPSR2Jfuj2oxXrdJSUL2neg8C/J52re1I898n39FuYXEm9hv0yHvOMrEya91XgR2Pve6Z+Rl4B3pG0bAH2MzDe/TqN8/8N4PYxco77DKE/ZJKP6/Kxso5pWwFvG3MNrp9g3bOBFyY45o8BjyVdqxbg7fb0b7E/Lu3pMvSLedk4+5jOdXhizDYTnm/0R979Sct86PfKRErqD8Ank6Y/Avx1zDrPApfYv7cAX5zi+v0S+FTSvRMacy90od81LlvuFUnLvsybSuqDwJNj2v4+8IWk6TOAN6a6p2bik1wE9I0z/2voL5Hf2+bj9dNoqyWF5fvRWn32tKScnIV2e8ltlwPJrqWOpN9BtMU1ltm2TGPbWmT/fhyoEpETRWQ5sB74hb1sGXCN7b4YEJEB9FflwqS2Jjw/SqnHgG8B3wa6ROROEalFv5yrgG1J7f7Onj9y7MntjrePzqTfoXGmR87FMmDhmGP4NyY/jx6Z2NV2L/B/wP22G+WrI66Y6aKU2oH+6p7w/lNK/QZoZXp9Lv1KqUDS9H4mvkapnvvk+2bcfaOtsbGMbWPhOOtMxTLgF0lyvgIkOPja1QAD421s39OPi3bzDgKf5NBnc6JnKNXzMGFboiMR7xeRA7Zr7SfjyDHCz4GTRWQB2mqx0BYd6PNxR9L56EMrskXjtqSZ7DqMfa4mO98HnQ/7fuudZL9j74ux77MReZJlP0geEXm3iDxnu+QG0B9uyeetVykVT5oeOedz0O/Kid4hy4ATx7wTPgTMT1pnwvsqmbSUlOgOu0XAU2OXKaWGlVLXKKUOR3eKfVpE3jGyeIImJ5o/wpKk30vRGrwH/bValSSXizdfBNNptw19MpPbjnPwy3g69NgyjW3rAIDSkYoPos3vC9DuqmF7vRa0K7A+6a9KKXXfdI9DKfVNpdRxaAvlLcB1tkwh4JikduuUUiMviHa0y2GEJaRPC9pKSD6GGqXUe6a5/UHHp5SKKaVuVkqtAt4KbEa7GVPlC8DHmfwFcwNaoVZNsg7ALEmKGERf37ak6eRjmM65H3tPT8ZL6Os6lrFttI2zzlTPSAvw7jHXzqPsIA37Q+JI4MUJZPsZ2q25RClVh3b1yxTHM0Kq52Ey/h/6GqxRStUCH55IDqVUP/B79Nf+hWjrZeT6tQCfGHM+vEqpZybZ92TXYeyzO9n5Puh8iEgV0DjJfsfeF2PfZyPyJAfcjMojemjBz9GRdvOUUvXAb5je9etGvysneoe0AH8ec5zVSqnksPOjmfi+GiUlJSUitSKyGe2H/IlS6uVx1tksIkfaHZqD6K8Ey17cie6vSJUPi8gq+6J9EXjIfvHvQX+Rv9f+0r4R7csdoRNYLhNHsdwH/KuIHCYi1egb/YExXw5TkqSEviIiNXZH66fRX3Mj/Az9UHzI/j3CD4BP2l+kIiI++3jG+3I+BBE53t62Av1CCgOWUsqy275d3gzQWCQiZ9qbPghcKiJH2+d1JuPc/goMiw7w8IqIS0RW2x8z0+Gg+0JE/k5E1tgv1CH0B4A10cYToZR6HXgAuHqSdbag+0IunkaTN4uIW0RORSvO/5mgzemc+0uS7ukvTLHf36D7C8by7yJSJSLHoH3/D4yzzlTPyPfQ9+0yW845IvK+pOUnAE1KqYmsnBqgTykVFpET0C/96fIg8DkRmSUii9Eu5XSpQffnDIrIIvSH2mT8DP3hcy4HP4/fs2U6BkYDos6boq3pXIfk9ic63w8Bm0XkbaJDs7/I5O/osffFb4C3iMiFIlIuIh9Ef7j+eoLt3eh7oRuIi8i7gb+f9Eht7Hfew8BN9rGv5OAPyV/bsnxERCrsv+NF5OikdTah3auTMl0l9aiIDKO14w3oDr1LJ1j3KOCP6BvmWeA7SqnH7WX/Adxom3/jRiNNwL1ov38HulP6atDRhsAVwA/RXwsBtPtmhJGXSK+IPD9Ouz+2234CHRQQJv0H5Sp7/2+gLcyf2e1jy/oXe/lCki6MUmor+mv/W2jz/XXgkhT2W4t+IfajTfte3hxP81m7vedsF8gf0f1uKKV+C3wT7Yp8Hd3HCLpjOyXsG3Yz2o25D21J/BCom2YTY++L+egHdgjtDvkz+johOsJuyhs7iS+iffuTcSO603kyOtDnuA0dlv1JpdTuSdaf6tx/A92B/7r9fzIeBVaKyFh33p/t7f8E3KqU+v3YDafxjNyBtoR+bz/jz6H7GEf4EPrFOhFXAF+0t/08WvFMl5vR9+w+tGVzbwrbjtfWBvSH8f+iX6CT8Qj6XdWhlBr9mldK/QL4T7SreQj9AfPuKdqa8jokMeH5VkrtRAdV/QxtVfVz8LU6CKXU82ilPLJ9L/o5vAb9HvgMsFkp1TPB9sPod+mD9r4utGWbLlein/EO9LW7D/v9Ybf99+hhHm32Ov+J/YFku1pXofvAJmUk6s7gcOwvnB3oqMKULMlSR3Smgp8opRZPtW4WZbgcHZjzLznc51z0C/hYpVQ4V/stFkT3L+8DKvL1zIjI36ODv87Ox/7HyPKfwHyl1JReCRH5OjqY7DtTrmuUlHMRkXPQLoIq4G60mzDvN3uhUQhKylB4FIKSyie2i88NvIwe4/YbdOR0RtM0mQSzzuYT6JDSvei+w2nl0jIYDAZ0P+DDaBfyA8DX0cOPMoqxpAwGg8FQsBhLymAwGAwFS1EmLJ09e7Zavnx5vsUwGAyGomLbtm09Sqk5U69ZOBSlklq+fDlbt27NtxgGg8FQVIjIdLJ6FBTG3WcwGAyGgsUoKYPBYDAULEZJGQwGg6FgKco+qfGIxWK0trYSDpuB8YWMx+Nh8eLFVFSklNTcYDA4lJJRUq2trdTU1LB8+XJ0bltDoaGUore3l9bWVg477LB8i2MwGIqAknH3hcNhGhsbjYIqYESExsZGY+0aDIZpUzJKCjAKqggw18hgMKRCSSkpg8FgMJQWjlZSLpeL9evXs3r1as477zyCwWDabW3ZsoXNmzcD8Mgjj3DLLbdMuO7AwADf+c6bGerb2to499xz0953MqeddhpLly4lOSfj2WefTXX1eFXvJ+aSSy7hoYcemvE6JUU0CM3PzfxvqD3fR2IwFA2OVlJer5ft27ezY8cO3G433/vewbXdlFJYVsoFYTnrrLO4/vrrJ1w+VkktXLgwoy/7+vp6nn766dF9tbebl2JGCHRDqH/mf8PjVXk3GAzjkVMlJSI/FpEuEdmRNO9rIrJbRF4SkV+ISH0uZRrh1FNP5fXXX6epqYkVK1Zw0UUXsXr1alpaWvj973/PySefzIYNGzjvvPPw+/0A/O53v2PlypVs2LCBhx9+sxDoXXfdxZVXXglAZ2cn55xzDuvWrWPdunU888wzXH/99ezdu5f169dz3XXX0dTUxOrVqwEdAHLppZeyZs0ajj32WB5//PHRNt///vfzrne9i6OOOorPfOYzEx7L+eefz/333w/Aww8/zPvf//7RZUoprrvuOlavXs2aNWt44IEHRudfeeWVrFixgne+8510dXWNbrNt2zY2bdrEcccdx5lnnulcpRcYt8BpGu30QhofPwaDE8m1JXUX8K4x8/4ArFZKrQX2AJ/LsUzE43F++9vfsmbNGgBee+01rrjiCnbu3InP5+PLX/4yf/zjH3n++efZuHEjt912G+FwmI9//OM8+uijbNu2jY6OjnHbvvrqq9m0aRMvvvgizz//PMcccwy33HILRxxxBNu3b+drX/vaQet/+9vfRkR4+eWXue+++7j44otHo+G2b9/OAw88wMsvv8wDDzxAS0vLuPt8xzvewRNPPEEikeD+++/ngx/84Oiyhx9+mO3bt/Piiy/yxz/+keuuu4729nZ+8Ytf8Oqrr7Jr1y7uuecennnmGUCPP7vqqqt46KGH2LZtG5dddhk33HDDjM950WFZEOzNTFsqAeGBzLRlMJQ4OR0npZR6wq5mmTzv90mTzwGZ6ZyZBqFQiPXr1wPakvroRz9KW1sby5Yt46STTtICPfccu3bt4pRTTgEgGo1y8skns3v3bg477DCOOuooAD784Q9z5513HrKPxx57jHvuuQfQfWB1dXX09/dPKNNTTz3FVVddBcDKlStZtmwZe/bsAbTyqaurA2DVqlXs37+fJUuWHNKGy+XibW97G/fffz+hUIjkjPFPPfUUF1xwAS6Xi3nz5rFp0yb+9re/8cQTT4zOX7hwIaeffjoAr776Kjt27OCMM84AIJFIsGDBgmme4RIiPKCVS6YI9EBVQ+baMxhKlEIbzHsZusLjIYjI5cDlAEuXLs3Izkb6pMbi8/lGfyulOOOMM7jvvvsOWme87bJNZWXl6G+Xy0U8PnHF6vPPP59zzjmHm266aUb7VEpxzDHH8Oyzz86onaIn2JfZ9kIZbs9gKFEKJnBCRG4A4sBPx1uulLpTKbVRKbVxzpzclUM56aSTePrpp3n99dcBCAQC7Nmzh5UrV9LU1MTevXsBDlFiI7zjHe/gu9/9LqCtkMHBQWpqahgeHh53/VNPPZWf/lSfgj179tDc3MyKFStSlvvUU0/lc5/7HBdccMEh8x944AESiQTd3d088cQTnHDCCbz97W8fnd/e3j7aF7ZixQq6u7tHlVQsFmPnzp0py1P0ZMrVN0JoAKwMWmYGQ4lSEEpKRC4BNgMfUgVWz37OnDncddddXHDBBaxdu3bU1efxeLjzzjt573vfy4YNG5g7d+64299xxx08/vjjrFmzhuOOO45du3bR2NjIKaecwurVq7nuuusOWv+KK67AsizWrFnDBz/4Qe66666DLKjpIiJce+21zJ49+6D555xzDmvXrmXdunWcfvrpfPWrX2X+/Pmcc845HHXUUaxatYqLLrqIk08+GQC3281DDz3EZz/7WdatW8f69etH+6scg5WNPiSlI/0MBsOkSK51gt0n9Wul1Gp7+l3AbcAmpVT3dNrYuHGjGlv08JVXXuHoo4/OrLCGrFB01yrQC61/zXy7DYfDnNStZIMhXURkm1JqY77lSIVch6DfBzwLrBCRVhH5KPAtoAb4g4hsF5HvTdqIwZBrghkKPR9LpkLaDYYSJtfRfReMM/tHuZTBYEiZwLQM/NSJDEE8AuWpu3MNBqdQEH1SBkPBEgtBZPwgl4zg75p6HYPBwRglZTBMxvD4g7Qzhr8zu+0bDEWOUVIGw2QMZTnPXqBHu/wMBsO4GCVlMExEaED3G2UVBYOtWd6HwVC8GCWVQUSEa665ZnT61ltvHc34cNNNN1FVVXVQ4tZUy2cYckx/U272M7DfJJw1GCbAKKkMUllZycMPP0xPz/ihxbNnz+brX/96jqUypEVkOPv9USPEIzDYnJt9GQxFhlFSGaS8vJzLL7+c22+/fdzll112GQ888AB9fSZvW8HTvQfI4UD33tchEcvd/gyGIqHQEsxmhJsf3cmutsz2JaxaWMsX/uGYKdf753/+Z9auXTtuvafq6mouu+wy7rjjDm6++eaMymfIIEPtEMhxaHgiBt27Yf6a3O7XYChwjCWVYWpra7nooov45je/Oe7yq6++mrvvvnvCBLOGPBOPQFeeEugOtoI/SwOHDYYipSQtqelYPNnkX/7lX9iwYQOXXnrpIcvq6+u58MIL+fa3v50HyQyTYlnQ9kJ+3W7tL8Kyt4K7Kn8yGAwFhLGkskBDQwMf+MAH+NGPxs/49OlPf5rvf//7k9aDMuSBrp35z0xuxaDtedM/ZTDYGCWVJa655ppJo/zOOeccIhEziLNg6NpdOOOVIsNwYBskzEeMwZDzUh2ZwJTqKG4K7lp174G+vfmW4lC8DbDoOHCVpFfekAdMqQ6DoZiwLGh/qTAVFOgS8y3PQSycb0kMhrxhPtEMziQRg7btM64VFUtY7GqfeLjD0llVzPK5099BZBian9UWlac2/XYMhiLFWFIG5xEegv1PZ6SYYSASRykm/PNHMtCvFA9D83MweGDmbRkMRYaxpAzOYqAZul4BlZlceVMpoYwoKQCVgI6XdPTh3KOhzJWZdg2GAscoKYMziEegY0fGM0kMhydXQpG4RSRuUVmeIafFYAsEe2HBOvDWZ6ZNg6GAMe4+Q+kz1AZNT2ZcQUXiCSLxqS2yoVCGxzzFgtr9173HZE83lDxGSWWQdEtv/PKXv2TXrl1p77epqYmf/exnaW9fssRC0LpVZ3HIwuDYwWkqn6FwNgbmKh2V2PQkBE3CYkPpYpRUAWCUVIaxLOjdC/uehED2cuENBKenfPzhOLFEliyeWBBa/qJD6U2FX0MJYpRUFtiyZQunnXYa5557LitXruRDH/oQI4Omr7/+elatWsXatWu59tpreeaZZ3jkkUe47rrrWL9+PXv37uUHP/gBxx9/POvWreMf//EfCQaDAFxyySVcffXVvPWtb+Xwww/noYceGm3zySefZP369dx+++00NTVx6qmnsmHDBjZs2MAzzzwzpVzbtm1j06ZNHHfccZx55pm0t7cDsH37dk466STWrl3LOeecQ3+/Tht02mmnMTKguqenh+XLlwOwc+dOTjjhBNavX8/atWt57bXXcnPSRwj0aOuiZ48ONsgSkXiCYHR67Sumb3WlzdAB2PcE9O0zLkBDSVGagRO/vR46Xs5sm/PXwLtvmfbqL7zwAjt37mThwoWccsopPP300xx99NH84he/YPfu3YgIAwMD1NfXc9ZZZ7F582bOPfdcQCeh/fjHPw7AjTfeyI9+9COuuuoqANrb23nqqafYvXs3Z511Fueeey633HILt956K7/+9a8BCAaD/OEPf8Dj8fDaa69xwQUXjCqU8eQ68cQTueqqq/jVr37FnDlzeOCBB7jhhhv48Y9/zEUXXcR//dd/sWnTJj7/+c9z8803841vfGPC4/7e977Hpz71KT70oQ8RjUZJJLKnKA4iGtClLvy5KbHRH4imtH5fMMrs6sosSWNjxfU5GGyFOSuhek5292cw5IDSVFIFwAknnMDixYsBWL9+PU1NTZx00kl4PB4++tGPsnnzZjZv3jzutjt27ODGG29kYGAAv9/PmWeeObrs7LPPpqysjFWrVtHZ2Tnu9rFYjCuvvJLt27fjcrnYs2fPpHLV19ezY8cOzjjjDAASiQQLFixgcHCQgYEBNm3aBMDFF1/MeeedN+lxn3zyyXzlK1+htbWV97///Rx11FHTPGNpkojpgoH9+8lVkUKlFH2B1CyjYCRBKJbAW5GD0PGoHw5sharZMHclVNZkf58GQ5YoTSWVgsWTLSor3/xqdrlcxONxysvL+etf/8qf/vQnHnroIb71rW/x2GOPHbLtJZdcwi9/+UvWrVvHXXfdxZYtW8Ztd6K8i7fffjvz5s3jxRdfxLIsPB7PpHIppTjmmGN49tlnD2pncHBwwuMrLy/Hst1K4fCbaXsuvPBCTjzxRP73f/+X97znPXz/+9/n9NNPn7CdtLEsGGiC3jd05vAcMhSOE02jj6nXH2XxLG8WJJqAYA80PQ11i6DxKKjwTL2NwVBgmD6pHOL3+xkcHOQ973kPt99+Oy+++CIANTU1BxVBHB4eZsGCBcRiMX76059O2e7Y7QcHB1mwYAFlZWXce++9U7rcVqxYQXd396iSisVi7Ny5k7q6OmbNmsWTTz4JwL333jtqVS1fvpxt27YBjPaNAbzxxhscfvjhXH311bzvfe/jpZdems6pmT5KaXfWvj9D96s5V1AAPf70AhT6ghESOe8vGjlfT+iQdVMCxFBkGCWVQ4aHh9m8eTNr167lbW97G7fddhsA559/Pl/72tc49thj2bt3L1/60pc48cQTOeWUU1i5cuWU7a5duxaXy8W6deu4/fbbueKKK7j77rtZt24du3fvxufzTbq92+3moYce4rOf/Szr1q1j/fr1o8EWd999N9dddx1r165l+/btfP7znwfg2muv5bvf/S7HHnvsQSVJHnzwQVavXs369evZsWMHF110Ubqn61D8XTqdUcfLOlVQHgjFElMO4J0IyyJlN2HGUAkdsr7vzya4wlBU5LRUh4j8GNgMdCmlVtvzGoAHgOVAE/ABpdSkledMqY7iJuVrFezT0Xr5LkgI7O8L0D8DReN2lbFyfg1lZZJBqdKg3AOzj4LaRSB5lsWQM0ypjqm5C3jXmHnXA39SSh0F/MmeNhjeLP7X8peCUFDRuMXADC2haMJiINvh6NMhHtYWadNTMDx+AI7BUAjkVEkppZ4Axg6Pfx9wt/37buDsXMpkKEBiIT04tempnIWUT4eu4UhG4gc7h8ITBr3knKhfl6tvfs5krjAUJIUQ3TdPKdVu/+4A5o23kohcDlwOsHTp0nEbUkohxnVR0Ez6co5Hdb/JQHPGspRniljCojeQmYwOkbjFYChGfdUM6kxlmlC/tlh9c2HOW0zYuqFgKKjACaXfYOO+xZRSdyqlNiqlNs6Zc+ggRY/HQ29vb+F8oRoOQSlFb2/vQSHxAFgJO43Rn6G/qeAUFED3cIRM3lodQwWawijQpS3Y9pe0RWsw5JlCsKQ6RWSBUqpdRBYAafl3Fi9eTGtrK93d2cvVZpg5HgGQmoAAACAASURBVI9ndDAxSul0Pj17CjrvXCxhpR12PhHhWILBUIw6b0VG280YQwdguB1mLYeGw8FVoHIaSp5CUFKPABcDt9j/f5VOIxUVFRx22GGZlMuQTQI9OoVPZHjqdfNMtz+ClQUDvXMoXLhKCrRF2/eGrmHVeBTULYGygnK+GBxATpWUiNwHnAbMFpFW4Ato5fSgiHwU2A98IJcyGXJMNABduzNe2ylbxC2L3gxbUSMEowmGwjFqPQWsqEAPAO7aBQP7Ye4q8M3Ot0QGB5FTJaWUumCCRe/IpRyGPDCSY68AgyImo9cfJVtVNgC6hiKFr6RGiAag9W/gm6NL2LsnHyRuMGSCQnD3GUqdwQPatZdILXN4vrEsRfdwdvvK/JE4gWgcn7uIHsVANzT1wqzDoPEIKMtB0lyDYymiJ8NQdESGoXNnQQzETYf+UIx4NjqjxtAzHMHXWGSPorL0cIGhA9qqqpmfb4kMJUqRPRmGomAkpLzvDXJVPiMbdOcoTHwgGGNBnYW7vAiDEuJhaHsBqufq/qqKHGZ5NziClJ4KEXGJyNRpuQ3OJdinx9n07aWYFdRwOE44npuCjQroydBA4bzht8dX9TeR0QFlBseTkpJSSiWAZSJSQEPlDQVBIq5dey1/gVgw39LMmEyPi5qKXn+ERA5ci1nFikPXK9DyVx1kYTBkgHTcfW8AT4vII8DonaiUui1jUhmKi2AfdJROhoJo3GIox0lgExYMhGI0+krg+y/Up4stzlkBs5blWxpDkZOOktpr/5UBJsGXk7EsHVZe5H1PY+kJZCaRbKr0+iOloaRA16/q2qUjAeevgfLKqbcxGMYhZSWllLoZQESq7Wl/poUyFAHRILRvh/DEJeaLEctS9PnzEyofjCaKLxx9KgLd0PQkzF8H1Yfm3DQYpiLlcCIRWS0iLwA7gZ0isk1Ejsm8aIaCZbhDV8gtMQUFMJijsPOJyHVfWE5IxODAVl2+3gRVGFIknZjXO4FPK6WWKaWWAdcAP8isWIaCxLJ0x3jbC7qTvATpznOU3UAwRiybKS7ySd9eHVhTwMmEDYVHOkrKp5R6fGRCKbUFMPlRSp14RKfE6W/KtyRZIxCJE4zkJux8IpQia7kCC4JQv7bCi3SAtyH3pKOk3hCRfxeR5fbfjeiIP0OpEh60XyylXbm1K8spkKZLjz9a/OHokxGP6DD1wdZ8S2IoAtJRUpcBc4CHgZ8Ds+15hlJkuBOaS99FM1LfqRCIW4q+QHHlOUwZZUHHy9D9qumnMkxKSmFEIuICblBKXZ0leQyFRN8b+iXiADqHwvkW4SC6h3U4elmZ5FuU7NL3BkT9sGC9SVRrGJd0Mk68LUuyGAoFpaBzl2MUVCiWoD9YGFbUCNGERW+pW1Mj+Lu0+y/ukOM1pEQ6AzJesLNN/A8HZ5x4OGNSGfKHZUHHizrM3CG0DRRmpozOoTCzfBWUO6EabngAmp+FJSeYJLWGg0hHSXmAXuD0pHkK3UdlKGYScR1eHuzJtyQ5YygcYzhcmOH0cUvRORRhUb1DXtqxoFZUi0+Ayup8S2MoENLpk3pJKXV7luQx5ItEDFq36i9ah5CwFAf6C9OKGqFnOMKsqgqqSikLxWTEI9DynFZUntp8S2MoANLpk5qoBLyhWIlHdZ+AgxQUQOdwmEi8sAfOKqB1IIRyUgRcIqbvRzOWykB6IehPi8i3RORUEdkw8pdxyQy5IR6F1r9CZCjfkuSUYDSes6KGMyUYSdBdygN8x8OyLftgaY/NM0xNOj6E9fb/LybNUxzcR2UoBkYV1HC+JckplqVo7g0VVd729sEwNZ4KvBUOCtO24nBgGyw6Dqoa8i2NIU+kkwX977IhiCHHJGKOVFAA7UPhnFXdzRRKQXNvkKPmVpf+2KlkRhTV4o3gnZVvaQx5YNruPhH5RtLvT41ZdlcGZTJkmxGfvwMV1FA4RneBpD9KlVAsQUeBDTrOCVYcWreVZNZ9w9Sk0if19qTfF49ZtjYDshhyQSKuff0O64MCiCUsmnuLu7R913CEoXBhDTzOCVZMJzh24IeV00lFSckEvw3FgmVB2/OOi+IDUErR3BfMa62oTNHcGyzdch6TkbAVVTQw9bqGkiEVJVUmIrNEpDHpd4OINAAO6s0tUpSC9hcg2JtvSfJCjz9asIN2UyVuaYXrSEZKxsQc6PZ0KKkoqTpgG7AVqAWet6e3ATUzFURE/lVEdorIDhG5T0Q8M23TYKOUzjjt78q3JHkhGI3TNljYg3ZTZTgcL9q+tRkTC2lFZXL9OYJpR/cppZZnSwgRWQRcDaxSSoVE5EHgfOCubO3TUXS/CkMH8i1FXhgNNy9+L98htA2GqPaUOyssfYSoX0f9LTnBZE8vcQopc2U54BWRcqAKaMuzPKVB717o35dvKfJGMYabTxelYH9vEKsE+tnSIjygc01aDuyfcxAFoaSUUgeAW4FmoB0YVEr9PnkdEblcRLaKyNbu7u58iFl8DLZCz558S5E3/JHSd4mFYwm6hh3cPxPoho6XTOHEEqYglJSIzALeBxwGLAR8IvLh5HWUUncqpTYqpTbOmTMnH2IWF/4u6NiRbynyhmUpWhwSXNA5FCEYLY2gkLQYbofu3fmWwpAl0lJSIvI2EbnU/j1HRA6boRzvBPYppbqVUjF02Y+3zrBN5xLs026Qokr8k1mKIXlspnBkEtqx9Ddp17ah5EhZSYnIF4DPAp+zZ1UAP5mhHM3ASSJSJSICvAN4ZYZtOpPwEBx4HpQzXtDjEYkn6CpxN99YgpEEfQVWXTjn9OyBgZZ8S2HIMOlYUucAZ2FX5VVKtTHDEHSl1F+Ah9Bh7S/bct05kzYdSTSgQ3MtZ7+sWvtLM5pvKtoHQsSdHkTQudNRVaWdQDpZ0KNKKSUiCkBEfJkQRCn1BeALmWjLkcTCWkElnD12pJAr7WYbx1XyHRcF7S9CWQX4GvMtjCEDpGNJPSgi3wfqReTjwB+BH2ZWLENKxKP2KPzSGrCaKlYRVNrNNj3DEcKx0gy5nzbK0mOoTNHEkiBlJaWUuhXtmvs5sAL4vFLqm5kWzDBNEjE4sFUPbnQ4vYGoY4IlJkIBbYMODkkfQSXszOnOS6RcaqQTOPGfSqk/KKWuU0pdq5T6g4j8ZzaEM0zBSEZzU8KAWMKiY8jZVtQIQ6GYMzOlj8Vybs20UiIdd98Z48x790wFMaRIIq4tKAdmNB+P9sEwTkwMPhEH+kPOzUSRjINrp5UKqRQ9/CcReRlYISIvJf3tA17KnoiGQxhRUMbnDujMEn0BZweMjCUSt+h0ciaKZBJRaPmLcf0VKalE9/0M+C3wH8D1SfOHlVJ9GZXKMDGJmO3iMxYUQMJBmSVSpWsoQp23gip3OkG8JUbCdv0tPh48dfmWxpAC07aklFKDSqkm9EBelfRXLSJLsyOe4SDiEfuL0CioEQ4MhBwfLDERCp2ANmHcfpoR11/QfFMXE+l8Yv0v+v4XwIPOt/cqcEwG5TKMJRq0w8yN1TBCbyBq3HxTEIlbtPYHWdaYkeGMxY9lBxstXA/Vc/MtjWEapKyklFJrkqdFZANwRcYkMhxKeFA/WA4fqJvMcDhOa79R2NOhPxjDXR5iQZ2TB/kmoRI6ddi8Y6B+Sb6lMUzBjLOgK6WeB07MgCyG8fB3aReFUVCjBCJx9vX6HZn6KF06hyIlX7YkNRR07oDuPabMR4GTsiUlIp9OmiwDNmAKFGaHvn26qq6Ds5mPZTgcZ1+PH9PNkjoHBkIklGJ+rSffohQOfXshFoD5a02F3wIlnT6p5GSycXQf1c8zI44B0JVGu3bqooWGUXoDUVr7g+bDdwZ0DIaJxS0W1XspK5N8i1MYDHfolGILj4UK4xItNNLpk7o5G4IYbGJhXQvKRPCNYlmKtsEQPX7j8swEvYEooXiC5Q0+3OUFUfc0/4QHYf8zWlFVNeRbGkMS01ZSIvIok/idlFJnZUQiJzNSrND0P40SjMZp7guZpKkZJhhJ8GrnEItnVTGryp1vcQqDRFT3/85ZAQ0zreNqyBSpWFK3Zk0Kp6MU9L0BPa9h+p80lqXo8kfoHAob916WSFh6HNVgMMaiWV4qXMaqAqVL0Yf6dT+VywyEzjfTvgJKqT+P/BYRN/AWe/JVu+S7IR3iUeh4CQLd+ZakYBgKxzjQbwbp5oqBUIyhSIwFtV4afW7TVwXg74T9T8OCdeCtz7c0jiad6L7TgLuBJvSA3iUicrFS6onMiuYAAr3Q8aLOJGEgGI3TMRRhKGS+eXKNZenovx5/hAX1Huq9xgVILKgzvMw+CmYdBmKUdz5Ix5b9OvD3SqlXAUTkLcB9wHGZFKyksSzo2QP9+/ItSUEQiSfoGAzTHzTKKd9E4hZNPUGq3BHm13mo9VTkW6T8oiw9DCTQC/PXQIUJ38816SipihEFBaCU2iMiDr+TUyAyrMtbm9IBhGIJuobCDARjpieuwAhGE7zRHcBX6WJerVFWBHug6SmYvxpq5udbGkeRjpLaKiI/BH5iT38Y2Jo5kUoUpaC/SVtQytl9LYFInK7hCIPGrVfwBCJaWXkqXMyrqaS+qgJxqtvLiuno29qFMHcVuByuuHNEOkrqn4B/Bq62p58EvpMxiUqRaBA6XoaQc7MvW5ZiMBSjOxAhGDHh5MVGOJZgf1+Q9sEyGqvdNFa7KS9zaDTgUBsEe3X0n292vqUpedIZzBsBbgNuE5EGYLE9zzAWpWCgWfu0lTNfzLGERW8gSq8/QixhnHrFTjRh0T4YpnMozKwqN7NrKvFWODCdUDyiqxLULYE5K02oehZJJ7pvC3CWve02oEtEnlFK/WuGZStuokGdwDLYm29J8oI/HKc3EGEgFDPjnEoQS+nMFb2BKL5KF7N9ldR5K5wXvj7YooePzF8LvsZ8S1OSpKP+65RSQyLyMeAepdQXRMSUjx9hxHrq2aNr1ziIuGXRH4jR648SjjvTcnQigUiCQCRIeZnQUO2m0eemstxB1lU8rKv+GqsqK6RzNstFZAHwAeCGDMtT3Di078lYTQaAuKXoGorQNRShutJFo9Osq1Grao3pq8og6SipLwL/BzytlPqbiBwOvJZZsYoMpWBgv12bxhkWRCxh0WdXxjWZIQxj8UcS+CNBXGUwq6qSBl8FVW4HWBjxsN1Xtdi2qkwE4EwRVYSfvhs3blRbtxZI1Hs0YFtP/fmWJOsopRgKx+kLRBkKmbFNhtTwVrho8LmZ5atwRmRgeSXMWwPVc/ItySgisk0ptTHfcqRCOoEThwN3ACehs6E+C/yrUuqNmQgiIvXAD4HVdruXKaWenUmbWWV03NNrJW89ReIJegNR+vxR4qbaoCFNQrEEBwZCtA+GqPNW0OirpNpTwtZVPAIHthqraoakc4f8DPg2cI49fT46LdJMS8jfAfxOKXWuncC2aobtZQ8H9D0l7HFNvYEIATOuyZBBLAX9wRj9wRiV5WXM8rlpqHKXbm2rwdakCEDTV5Uq6SipKqXUvUnTPxGR62YihIjUAW8HLgFQSkWBwiyqNNAMXbtL1noKRrU7rz8YJWG6mgxZJhK36BgM0zkYptZbQYPPTa2nvPSyWoyMq6pfqq0qU6p+2qRS9HCkXOVvReR64H60W+6DwG9mKMdhQDfw3yKyDj3+6lNKqUDS/i8HLgdYunTpDHeXBvGItp5KsKRGwrLoD+rQ8ZApLmjIAwoYDMUYDMWocAkNPjeNvsrSs64GmiHQY0qApMC0AydEZB/6XhrvE0cppQ5PWwiRjcBzwClKqb+IyB3AkFLq38dbP+eBE/5uXfOpxCrmBqNxev1R+kNRrEmspiNf+nruhDI4jtfXXjPufAFqvBU0lqR1JboESMPhOS0BUtKBE0qpCespZyALeivQqpT6iz39EHD9DNucOZYFPa/qAIkSwbIUA6EYPSaHnqHAUcBQKMZQKIbbVTY6ULg0KggrPeB/xKoyJUAmJO3QGtGfNacDFwKbgXnptqWU6hCRFhFZYZcBeQewK932MkIspDMehwfzKkamiMYtegKRtCL0JvrSNRhyRTRh910Nhan3VjC7phJfKYy7CvXB/qdgwXoTVDEB6YSgn4RWTGcDDeiM6NdmQJargJ/akX1vAJdmoM30CPRA23admr/ICUTidNtlMUzwuKHYUUmRgVWVLuZUV1LvLfLyIYmYDqqY/RZoPCLf0hQcqQRO/D/gPKAZHXJ+M7BVKXV3JgRRSm0H8u8r7W/S0XtF/EpXSoePd/mNS89QugQjCfZHgrS7yphdo12BrmIeJNyzRxdDnb/GRP8lkYol9TFgD/Bd4FGlVEREivdNPhaloOsVnd6oSLEsRV8wSvdwxKQqMjiGaMKibUC7AhurK5ldzFGBw+26q2HxRjP41yYVJbUAOAO4APiGiDwOeEWkXClV3Om+LUtH7w2351uStEhYFj1+rZxMRgiDU0lY0DUUoXs4QkOVm7m1HiqLUVmFB6D5OVh8vAmoILXovgTwO+B3IlKJDpbwAgdE5E9KqQuzJGN2UQrat4O/M9+SpEzcsugZjtDtj5iBtwaDjbJrXfUFotT7Kphf6ym+0iFRP7Q8B0tOcryiSis8xq7E+3Pg5yJSiw6iKE46Xi46BZWwLLqNcjIYJkUB/YEYA4EY9VUVzK/zFpdlFQvpgIqlJzna9TfjGE6l1BBwTwZkyT29e2HoQL6lmDYJS9Eb0PV6jFvPYJgeCh0ROBCM0eBzM6/WUzx9VlG/Hgqz+PicDvotJEpgoEGaBPt0BvMiQClFXzBGx2CIWMIoJ4MhHRS2GzAYZU5NJXNrKoujZEiwF3pf1xkqHIgzlZRlaTdfEYSZD4ZitA+ETTl2gyFDKKUDLHr9EebXemn0uQu/enDvXqiZD5U1+ZYk56SlpETkrcDy5O2VUsXj8hvYD7FgvqWYlFAsQdtAiOFwcQdOGgyFSsKCAwMhevwRFtR7qPe68y3SJCjoflWHpjuMdDJO3AscAWwHRj7vFcXUL1XAY6HilkXHoP7KK3w7z2AofiJxi6aeIDWeKIvqvXgqCjQSMNCtK4G7ffmWJKekY0ltBFapYqw7DxAa0FEzBcZIv1P7QMgERRgMeWA4HOfVjmHm1FYyr6ayMLNXDHc4LnVSOkpqBzAfKM6Rr5GhfEtwCOFYgpb+oKmAazDkGYXur+oPRFk0y1t4LsASSXidCukoqdnALhH5KxAZmamUOitjUmWTeGTqdXKEZSk6h8N0DUcoUrvUYChJYglFU0+QOm+MRfXewglZj4fzLUHOSUdJ3ZRpIXJKgSRuDETjtPSGTNSewVDADIZi+CMxFtVX0eArAKuqzHmDelNWUkqpP2dDkJxRkd9OR8tSdAyH6R4ygREGQzGQsKC5L8hAKMaSWd78Fl10V+Vv33ki5bMtIieJyN9ExC8iURFJiEjhdfRMRFUjSH6sqXAswWtdfrqMgjIYio6hUIxXO4YZDOWxzlx12rVli5Z0Pgm+hc6E/ho6wezHgG9nUqis4iqH2gU5321vIMqezmFCMePeMxiKlbil2NcToLU/iJXrKNwKr/7Idhhp2a1KqdcBl1IqoZT6b+BdmRUry8x+S858uwlLsb8vQEtfEBNZbjCUBj3+KK91+XNbt23uKkfm70tHSQXtEu/bReSrIvKvabaTP8orYe7KrO8mErd4rctPf6D4y9AbDIaDCcUS7OkcYiicg+e7ZgFUz83+fgqQdJTLR+ztrgQCwBLgHzMpVE6oWwyzlmeteX84zmudw4SNe89gKFkSFuzrDtA1nMXQcE+dLinvUNKJ7tsvIl5ggVLq5izIlDvmrNTjpjJckbc/EKW5P2jGPhkMDkABbQNhonGLRfVeJJMuObcPFh1XMENn8kE60X3/gM7b9zt7er2IPJJpwXKCCCxYB/XLMtZk13CY/X1GQRkMTqPHH6WpN4MBFZ56XZm3vDIz7RUp6bj7bgJOAAYAlFLbgcMyKFNuEYF5q2DOCmBmX0DtgyHaBpw3ItxgMGgGQzH29QZIzFRRVc+DJSdAeQEMIM4z6SipmFJqbAKp4rcbGg63b4r0vlraBkN0DhVOyiWDwZAfhsNx9vX401NUUqa7IRZtcLSLL5l0lNROEbkQcInIUSLyX8AzGZYrP1Q1wLJTUo6i6RgK02UUlMFgsPFHEjT1BlJz/bl9sOREaChex1Q2SCd331XADejksvcB/wd8KZNC5ZXySt1ROdQGXbsgMXl4aY8/Qsdgabv4btjqvFQshtzxlY2FXYA0XYbDcZr7gixrrJoimEK0J6fxSCjE8iB5Jp3oviBaSd2QeXEKiNqFenR396swdGDcVQZDMQ70F15tKoPBUBgMhGJUDIZZVO8dfwVPve4T99TlVrAiYtpKaqoIvqIp1ZEK5ZWwYC3UL4GuVw6q5RKMxtnfGyiBzripKdUvXYMhF3QPR6gsL2N2dVJ/t8ut+55qFzoyi0QqpGJJnQy0oF18f2GmoXBjEBEXsBU4oJTanMm2Z4x3Fiw9WVtUPa8RiwRp6jFpjgwGw/Q40B+istxFjbdSJxFoOFznETVMSSoO0PnAvwGrgTuAM4AepdSfM1S+41PAKxloJzuIQN1irOVvZ3diIRHL+I4NBsP0UAivhusJLzkF5rzFKKgUmPab1k4m+zul1MXAScDrwBYRuXKmQojIYuC9wA9n2la2ea07SKdrIX3zTiZYvRyVp7IfBoOhOIh459E/5wQGat7Ci+3hmY+hchgpqXMRqUQrkwuA5cA3gV9kQI5vAJ8BaibZ9+XA5QBLly7NwC5Tp30wREuf7p9RZRUEaw8nVL0Er78Zb6AVUSZPn8Fg0EQ8cwnWLCdRUT06bzgc55X2IVYvMoES0yWVwIl70K6+3wA3K6V2ZEIAEdkMdCmltonIaROtp5S6E7gTYOPGjTn/FBkKx3il/dDajlpZHUHItwRvoNVWVvFci2cwGAoCIeKdS7B62UHKKZmOwTB13gqWNJihHdMhFUvqw+is558Crk6K+xdAKaVq05ThFOAsEXkP4AFqReQnSqkPp9lexonGLV5qGcSapHSMcrlHLStP4ADeQAtllinRYTA4AYUQqZpPsHoZVvnUymdP5zDVleXM8pm0R1MhqoAyodqW1LVTRfdt3LhRbd26NScyWZbihZb+1GtCWQk8oXa8/mZcidIe7GswOBUlLsJViwhVL8FypZZSraK8jBOWN+B1565fW0S2KaU25myHGcCEmEzB7o7h9IoWlrkI+xYTrlpEZagTr7+Z8rg/8wIaDIacY5W5CfkWE/YtQqVZ5TsWt9jeMsDG5bOocJlo4YkoKCWllNoCbMmzGKPs6wnQNjDDjBKi3QCRqvlUhPvwBppxR/oyI6DBYMgpifIqgr6lRLzzMpIANhCJ8/KBQdYvrqeszAzqHY+CUlKFRPtgiL1dmbV8Yp4GYp4GXDE/Vf5mKkOdlEICeYOh1Im56wj5lhL1zM54hog+f5RXOoY4ZqGJ+BsPo6TGoccfYVfboZF8mSJRUc3wrFUEao/A62/BEzxgwtcNhoJDiHjmEKpeQtydXQXSPhCmsryMI+dOOArHsRglNYaBYJSXWwdzUlnXclUSqDuSYM1yPME2HRGYMCU/DIZ8oqRMB0P4FmOVT5AYNgs09QQpLytj+WxfzvZZDBgllcRQOMYLLQM5HxGuysoJVS8l5FuCO9xFlb+Z8thwTmUwGJyOVVZJqHoJ4aoFaQdDzJTXu/y4ysSMoUrCKCkbfyTOC80DJBJ57CMSIeqdR9Q7j/LIAFWBZtzhnvzJYzA4gHhFDSHfEiLeuboybp55tWOYcpewoC53VlwhY5QUuuzGC839xOKTjNbNMfHKeoYq6ymLB3W/VagdUYUjn8FQ7EQrGwlVLyFW2ZBvUQ5hV9sQLhHm1nryLUrecbySCscSvNA8QCRWmArAKq8iUL+CYM1hdr9VK2VWNN9iGQxFyUhmiJBvKYmKwu37UQp2tA2yrkxorE5tkHCp4WglFU/owXShaOFH1imXm1DNckLVS6kMdlAVaMEVD+RbLIOhKLDKKkaDIZSrOFIRWRa81DrIcctnUevJTx9ZIeBYJaWUYkfbEP5wkSWDlTIivoVEqhZQEemjyt9MRbQ/31IZDAVJwuXVwRDeBRkZfJtrEpbixZYBjl/egKei+OTPBI5VUvt6AvQMF3G4twgxTyODnkbKo0N4/c1Uhrsxg4MNBohV1BKqXkrUM6foy7NHYhY72wbZsHQWUuTHkg6OVFKDoRj7ekrHVRZ31zLcsJpAPIQ30IIn2GaCLAyOJFrZSLB6GfHK+nyLklH6AzGa+4IsayzcfrRs4Ugl9XqXPyeDdXONVe4lUPcWgtXL8QYP4Am0mnIhhpKnWIIhZsobPQEW1nsdl4zWcUpqOByjP1Da0XHK5SZYcxhB31JTLsRQssykTEYxkkgo2gZCjrOmHKekBkMOsiySyoWYTBaGUsEqq7TLZCzMW2aIfDEQjLGsMd9S5BbHKalYPjNK5IukTBYVkT68flMuxFB8jJbJqJpfEJkh8kEs4by+ZscpKV+lM8M4R4hVNhCrbMAVHaYq0ExlqAsTEWgoZHSk3rKslMkoNqo9jntlO09JNfoqqXK7CBbBAN5sknDXMOw+hkDN4Xj9zSbtkqHg0GmLlhKrnJVvUQoCEVhU77x8fo5TUq4yYdXCWp5v7scy72QdEWinXfIGWvEGWhFVZAOcDSWEEPHOI1i9lERFdb6FKSgOm+2jxoGZJxynpADqq9ysXzKLl1oHiDuxj2oclMtNsPZwgtXL8ATbqAo0m9pWhpyhI/UWEvItwSo3SVXHcuTcasfWmXKkkgJo8Lk5fnkDO9uGGHJSxN9UlLkIVy8h7FtMZagTb6DFRAQasoZV5ibkW+LISL3p4C4vY+WCGubWOFdxO1ZJAfgqyzl++Sw6hsK81uknWkClOvKO6AGSkar5dkRgC+5Ib76lzkinpAAAEuBJREFUMpQIJlJvcsrKYGlDFcsbfZQ7bPDuWBytpABEdHGxOdWVtA2EaekPFkVW9FwyGhEY8+scgaFOxEQEGtIg5p5FsHqpruHk8Ei98XC5hEX1XpbMqsLrdnYk8giOV1IjlLvKWNpYxZIGL93+CC19oZLPTJEqiYpq/LNWEaw9Ak+gFW/ggAmyMEwDIeKdS9C3lIS7Jt/CFCRVbhdLGqpYUOdxvOU0FqOkxiAizK3xMLfGQyiaoGMoTOdQuPhKemQRy1VJsPYIgtXL7bRLLbgSoXyLZSgwlJQT8i0kXLXYBEOMg7u8jHm1HubXeqirMv1xE2GU1CR43S4Om+3jsNk+/JE4nUNhuoYiBCJGYQFj0i714A20UBEdyLdUhjyTcHkJ+RYTqVqAKjOvmGTc5WXMrq5kfp2HWVUVjiy9kSrmDpom1ZXlVM+p5og51YRjCXr8EXr8UfoDURKWw/tnRIh65xD1zjH9Vg4m5p5FyLfYZIYYQ11VBbOrK2msdlNTWW4UU4oUhJISkSXAPcA8dI6eO5VSd+RXqonxVLhYPKuKxbOqsCxFfzBKb0ArrGGHuwVH+q0CtUfa5UIOUGaZvr1SRdmDb0Nm8O0oXreL+qoKGn2VNPjcuMtNH9NMKAglBcSBa5RSz4tIDbBNRP6glNqVb8GmoqxMaKyupLFalwqIJSz6g1EGgjH6AlHH9mWNlgupXkZlqMuMtyoxdCbyRYSrFqJc7nyLk1c8FVopNfjczKpym6i8DFMQSkop1Q6027+HReQVYBFQ8EpqLBWustHAC4Bo3GIgFGUoFGMgGGMoHHNWOiYpGx1vVR4ZwBtoNWXui5hYRS1h32Ii3rmOHd/kqyynvqqC+qoK6rwVVLkL4jVashTc2RWR5cCxwF/GzL8cuBxg6dKlOZcrXdzlBysty1IMh+MMhmIMhLTF5ZRBxPHKeoYr6wkkIngCrXiCbaZycBGg0KVeQr7FxN21+RYnp7jKhFrvmwqpzlvhuMq4+UZUAdVRF5Fq4M/AV5RSD0+03saNG9XWrVtzJ1iWCccSDIViDIa0pTUUijsjGENZduqlVuMKLECc5tIT0VZSnbeCWlsh+dyukgp0EJFtSqmN+ZYjFQrGkhKRCuDnwE8nU1CliKfChafCxdxabW0ppQhEEwyGYgwGYwyHY/gjcQroeyIzSBmRqgVEqhZQHh3UrkBT3yrvxNx1dpTenJJ26VW5XdR4KmylVE6NpwJXWekopFKhIJSU6E+VHwGvKKVuy7c8+UZEdMh7Zflo/RjLUgxH4gyFYgyH4wyFYwRKSHHF3XUMu+sI1B6JJ3DAdgWaqMBcMRql51tSklkhvG4XtZ4Kajzl1Hr1f+O2Kw4KQkkBpwAfAV4Wke32vH9TSv0mjzIVFGVlMuoTHyFhKfy2wioVxaWzWRxOsGa5iQrMAaXo0vO6XdR4tGVUa/83YeDFS0EoKaXUU4Cxs1PEVSbUVVUclFJlxOIathXXcDiOP1KEEYUmKjCrlEqUXpXbNWoZ1XiMhVSKFISSMmSO8Swuy1IEovFRpTWiwIolOGM0KjAexhNsxRtoM4lt00InetVRenX5FiYlRKDKXa7ddZ4RpVRukrE6AKOkHEBZmdhfmW8qrpHgjDctrhhD4TiJAq5UbJV7CNYeSbD6MJPYNgVGE736lmC5KvMtzpSUlYHP/aZlVOupoNpTboIaHIpRUg4lOThjgf1RrZQiFEswFHpTaQ2HY8QLTXElJ7aN9FIZ7EAoNn9mboi6ZxV0oteyMqiuPDigodpdTplRSAabwrxzDXlBRKhyl1PlLmd+3ZulFULRhB2cEWMwVECKS4SoZ7ZOaGooeEYU0ki4d62nHJ9RSIYpMErKMCVetwuv28W82jcVVzAaT7K4Ct9VaMgtIwNjaz1aKdV6K4yFZEgLo6QMaTHW4lJKEbQtrsFQbFSBFXM4vGH6jETZ1XkrTB+SIaMYJWXICCKCr7IcX2U5C+qSBiDbeQpHlFcomsizpIaZUu56M4K01uSzM2QZo6QMWaNsnHFckXjCtrQcmhW+CDFZvw35xNxthpxSWe5ibo3rkKzwA6HoqJswYXyEeUN4M8nqiFIyVpIhnxglZcgr41lbBoPBMIL5RDIYDAZDwWKUlMFgMBgKFqOkDAaDwVCwGCVlMBgMhoLFKCmDwWAwFCxGSRkMBoOhYDFKymAwGAwFi1FSBoPBYChYjJIyGAwGQ8EiqghT0IhIN7A/33KkwWygJ99C5BhzzM7AacdcrMe7TCk1J99CpEJRKqliRUS2KqU25luOXGKO2Rk47Ziddrz5xLj7DAaDwVCwGCVlMBgMhoLFKKnccme+BcgD5pidgdOO2WnHmzdMn5TBYDD8//bOPFiOqorD348ECVuCIUAFAiZigkCxJyiCEASRRQQ0gpHtIYuoQLEoS4EsRlCgSgRZC6QeSyRKEAhEdhKwgBACvCQQASPEGIlAsURWyXL845wJ/aa6Z+Yl82Ymj/tVTdXt7tu3z+l7Tp97b/fcm2hZUk8qkUgkEi1LClKJRCKRaFlSkOoGJO0p6UVJsyWdXpDnQEmzJD0v6Q+NlrHeVNNZ0kaSJkl6VtIMSXs3Q856Iel6Sa9Leq7guCRdFvdjhqRtGy1jvalB54ND15mSHpe0VaNlrDfVdM7kGyFpkaRRjZLt00IKUnVGUi/gCmAvYDNgtKTNyvIMBc4AdjSzzYETGy5oHalFZ+As4E9mtg3wPeDKxkpZd9qBPSsc3wsYGr9jgKsaIFN3005lnV8BdjGzLYAx9IyPC9qprHPJ/i8E7m+EQJ82UpCqP9sDs83sZTP7GBgH7FeW52jgCjN7G8DMXm+wjPWmFp0N6BvpfsCrDZSv7pjZo8BbFbLsB9xozhRgLUkDGyNd91BNZzN7vGTTwBRgUEME60ZqqGeA44HbgBXdj1uSFKTqzwbAvzLb82JflmHAMEmPSZoiqWJLbQWgFp3PBQ6RNA/4C+7YPZla7klP5kjgnmYL0d1I2gA4gJ7RU25JUpBqDr3xYaCRwGjgWklrNVWi7mc00G5mg4C9gZskJfvrgUjaFQ9SpzVblgbwW+A0M1vSbEF6Kr2bLUAP5N/AhpntQbEvyzzgSTNbCLwi6SU8aD3VGBHrTi06H0mM7ZvZE5L64JN09tQhklruSY9D0pbAdcBeZvZms+VpAMOBcZLA7XlvSYvM7I7mitVzSC3Z+vMUMFTSEEmfwT8SmFCW5w68F4WkAfjw38uNFLLO1KLzXGA3AEmbAn2ANxoqZWOZABwWX/l9GVhgZvObLVR3Imkj4M/AoWb2UrPlaQRmNsTMBpvZYGA88OMUoOpL6knVGTNbJOk44D6gF3C9mT0v6RfANDObEMf2kDQLWAz8bEVuddao8yn4sOZJ+EcUbbYCT3ci6Ra8oTEg3rOdA6wMYGZX4+/d9gZmAx8ARzRH0vpRg85nA2sDV0bPYtGKPlN4DTonupk0LVIikUgkWpY03JdIJBKJliUFqUQikUi0LClIJRKJRKJlSUEqkUgkEi1LClKJRCKRaFlSkMog6cyYlXyGpA5JX1qGMgZXmzE555z2arMnZ8uVNFzSZVXyfr/C8fUljY90m6TLuyhvm6T1M9vX5Uwo2zJkdZR0rKTDMvvXr3x2bnlz4v9tXTlnvKTPV8nz1bC/DkmbVqrDLlx3DUlXSfqHpGckPS3p6OUtt4brLrWxFZVa6rmeviDpOEk/WJZzezIpSAWSdgC+CWxrZlsCu9N57rWWwcymmdkJFbIMBnIfcJJ6m9mrZrY8Swq0AUsd08yOMrNZy1FewzCzq83sxthsI6NHdyFpc6CXmVX7w/bBwK/MbGtgPQrqsMJ18v73eB3wNjDUzLbFZ/3o35Vyl4U62NiKQhv184Xr6flzWnYdM0s//6/Yt4G7Co6NAB4HpgNTgTXxQPBX4Jn4fSXyDgaei3Qv4GJ8RoYZwA9jv4DLgReBB/E/fo7Kue52cc3pUU6p3JHA3ZHeBeiI37Mh2xRgQew7CXekCcDDwCNlMrYBdwKTgb8D55TrEds/xSeJHQW8F7J3AKvGucMj32hgJvAccGHm/PeA80OXKcB6OfpuDzwRejwObJKR8Q7gAWAOcBxwcuSbAvSPfJOBS0Ou54DtM+dfHulzQ5c8PeYAAyLfcGBypNfGl2F4Hn/o/zOT7xDcJjqAa/BgVK7XBfifl0vbVwHTorzzYt9R+GzbrwBjc+qwyJZG4nY4AXip7Lob4zOZrFRg12sAD+H2OxPYr1LdR/oEYFbIMK6CDS4tg2JfGRl1Nh54IfRWjpxfwP1kepy/Me5DF0c9zwQOqlQmHpxvzZQ5kk98qMhm5+BTHeXeD7rBF4DbCbtNv7gnzRagVX7hsB3AS/haR7vE/s+Eo4+I7b74TB2rAX1i31B8ZoVODo6vI3RWpFfBH0xD8ID4AP7gWR94h/wgNQPYOdJFQeoufF2qkg69s8djfxs+X2D/HBnbgPn4g3jVcKjhRY4Z6aWOmN0OXeYC64QcDwP7Rx4D9o30RaX7UqZvX6B3pHcHbsvIOBt/+K2DP7yPjWOXACdm5Lg20juX6dgpSBXoMYf8IHUZcHak9wldBgCbxv1fOY5dCRyWo9cjwBaZ7VI99AoZtoztdsIOcuqwyJZGAu8DQ3Ku+y3g9go23xvoG+kBcY9Vpe5fBVaJ9FoVbHBpGRT7ysioy0H4qM4TwE45cj4JHBDpPlHed/jEh9bD7W5gUZkh01xg9SjnKryBUclm51AhSHWHLwBnAqc0+3nYSr803BeY2Xt4z+UYfE65P0pqAzYB5pvZU5Hvv2a2CJ8a5VpJM4Fb8cX+ytkDn7+tA3e0tXEn3Rm4xcwWm9mruAF3ImZFX8t8PRuAmwpEfwz4jaQTIv+ignwPmFnRujgPmNmbZvYhPvfaTgX5qjECf7C/EXKMxXUF+Bi4O9JP445fTj/g1nj3dgmweebYJDN718zewB9Cd8X+mWVl3QJL1wHqW6fZ5XcGbo5yJ+LDZ+BzEW4HPBV1vBuQ995pIJ3nKTxQ0jN4r2Nz8m2nnCJbAphqZq9UKyDeuXZIKq3lJeACSTPwnsoG+AO/EjOAsZIOAUq2Vs0GK/nKVDObZz6LeAdldiFpTWADM7sdwMw+MrMPcBst+dBreENgRFGZIdO9wL4xLLoPPoJQyWaXh2X1hddpwBD0ikSauy+DmS3GW0KTw6EOx40oj5OA14Ct8BbbRzl5BBxvZvd12lnHpdPN7NeSJuLzxD0m6RsFWd+vVEzO9iI6v7Pss+xSArDQoqmIz1eYZ3tj8GB0gKTBeF2U+F8mvSSzvaSsrDxdaiWrcy36CrjBzM6oku/DUnmShuAt8RFm9rak9i5cK8+WRlJct7OArSStZGZLzOx84HxJ78Xxg/GW/nZmtlDSnJClUt3vgz9s9wXOlLRFgQ1m/aGSr2TrtcguukpRmePwoeK38N7cuzHHYDUa6Qt9cHtJBKknFUjaRL6se4mt8XcPLwIDJY2IfGtGS6wf3sNaAhyKDzuUcx/wI0krx7nDJK0OPAocJKmXfLXWXctPNLN3gHcklXo1BxfIvbGZzTSzC/H3FV8E3sWHxmrl65L6S1oV2B9vGb8GrCtpbUmr4B+VlCgqfyqwi6QB8iW1R+Mt3FrpxyfLWbR14bwsBwHEfVtgZgsq5C3XYw7eMwIfTirxKPERg6S9gM/G/oeAUZLWjWP9JX0u5zp/w9+rgA9pvg8skLQevsx8LbIV2VIhZjYbHxb8ZdQH8iVSSk/mfsDrEaB2BUqy59a9fP2vDc1sEr5WVD9gjQIbzFKLrxTp8C4wT9L+IcMqklbD33GVfGgdPHBOrVLcI8C2+MrY42JfLTbbSF8Yhg+5J4LUk/qENYDfxfDQInx8/hgz+1jSQXFsVbyVszv+/uG2+Jz5XvJbs9fhXfln5E22N/AgcDvwNbylOxcfN8/jCOB6SYa/uM/jxHjALMFfxN8T6cWSpuPvOd4uOLfEVHz560HAzWY2DUA+i/lUPHC8kMnfDlwt6UNgh9JOM5sv6XRgEv4gnGhmd1a5dpaLgBsknQVM7MJ5WT6S9Cw+xFTtc952OutxHvB7SWPo3Is7D7hF0vP4Bx1zAcxsVsh6fzzAFwI/wRs3WSbi70oeNLPpId8L+NejjxXINoPOdXgp+bZUjaPw95mzJb2J2++pcWwscFeMGkwLmYiglVf3vYCbJfXD6/cyM3tH0pgcGxyYkaEWX6nEocA1IdNC4Lu4D+2Af3xgwKlm9h9J5QFyKWa2WNLdeAPo8NhX1WYr3A+ovy/siL83TQRpFvREj0HSZPyjiGnNliVLNG4m4R8XLG62PInWRNI2wMlmdmizZWkl0nBfItHNxAcp5+AfJiQSRQwAft5sIVqN1JNKJBKJRMuSelKJRCKRaFlSkEokEolEy5KCVCKRSCRalhSkEolEItGypCCVSCQSiZbl/5fqM2wIPw9hAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot violin plot of MAE for naive and NN predictions\n", "fig, ax = plt.subplots()\n", "# xl = minsl\n", "\n", "ax.violinplot(\n", " list(seg_mael), showmeans=True, showmedians=False, showextrema=False, widths=1.0\n", ")\n", "\n", "ax.violinplot(\n", " list(seg_nmael), showmeans=True, showmedians=False, showextrema=False, widths=1.0\n", ")\n", "\n", "line1 = mlines.Line2D([], [], label=\"NN\")\n", "line2 = mlines.Line2D([], [], color=\"C1\", label=\"Instantaneous\")\n", "\n", "ax.set_xlabel(\"Scaled distribution amplitude (after Gaussian convolution)\")\n", "ax.set_ylabel(\"Mean Absolute Error\")\n", "ax.set_title(\"Distribution over segments: NN pred (blue) and naive pred (orange)\")\n", "plt.legend(handles=(line1, line2), title=\"Prediction Model\", loc=2)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Plot of actual and predicted speeds on a sample sensor" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "##all test result visualization\n", "fig1 = plt.figure(figsize=(15, 8))\n", "# ax1 = fig1.add_subplot(1,1,1)\n", "a_pred = test_rescpred[:, 1]\n", "a_true = test_rescref[:, 1]\n", "plt.plot(a_pred, \"r-\", label=\"prediction\")\n", "plt.plot(a_true, \"b-\", label=\"true\")\n", "plt.xlabel(\"time\")\n", "plt.ylabel(\"speed\")\n", "plt.legend(loc=\"best\", fontsize=10)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "nbsphinx": "hidden", "tags": [ "CloudRunner" ] }, "source": [ "
Run the latest release of this notebook:
" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.5" } }, "nbformat": 4, "nbformat_minor": 4 }