Deleted Exercise_3.ipynb, airline-passengers.csv

39c8df68 · Ahmad Said Yousf Ayad · 61e72b8e · 61e72b8e · 61e72b8e
Commit 39c8df68 authored Nov 28, 2022 by Ahmad Said Yousf Ayad
--- a/Exercise_3.ipynb
+++ b/Exercise_3.ipynb
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "4V-uGJ1u1ryh"
-      },
-      "source": [
-        "This is a problem where, given a year and a month, the task is to predict the number of international airline passengers in units of 1,000. The data ranges from January 1949 to December 1960, or 12 years, with 144 monthly observations. \n",
-        "We can phrase the problem as: given the number of passengers (in units of thousands) this month, what is the number of passengers next month?"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "KdnxaMg61ryl"
-      },
-      "source": [
-        "# Import Libraries"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Ba3Bz20P1ryl",
-        "outputId": "7fa26f19-cb0a-4752-cdaa-aa6c8e2ec8ef"
-      },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "Using TensorFlow backend.\n"
-          ]
-        }
-      ],
-      "source": [
-        "import numpy\n",
-        "import pandas\n",
-        "import matplotlib.pyplot as plt\n",
-        "from pandas import read_csv\n",
-        "import math\n",
-        "from keras.models import Sequential\n",
-        "from keras.layers import Dense\n",
-        "from keras.layers import LSTM\n",
-        "from sklearn.preprocessing import MinMaxScaler\n",
-        "from sklearn.metrics import mean_squared_error\n",
-        "\n",
-        "# fixed random seed for reproducibility\n",
-        "numpy.random.seed(7)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "dG9QCmAG1ryn"
-      },
-      "source": [
-        "We can load this dataset easily using the Pandas library. We are not interested in the date, given that each observation is separated by the same interval of one month. Therefore, when we load the dataset we can exclude the first column.\n",
-        "\n",
-        "Extract the NumPy array from the dataframe and convert the integer values to floating point values, which are more suitable for modeling with a neural network. Load and plot the dataset below."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "HltoJLSl1ryn"
-      },
-      "source": [
-        "# Load and plot dataset"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "rC7P8E6G1ryo",
-        "outputId": "4f04211a-1800-4e2a-edb8-2d84ffdc9b27"
-      },
-      "outputs": [
-        {
-          "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABBh0lEQVR4nO3dd3ykV3nw/d8ZjaRR721VVtpe7W1eN1ywMS4YbCAkphiHEifEL6HlDTg8T0h5nPAmz5MHkmDA1CUUY2yIjQPYxsa4rXe93d7m1a60qqsy6jMaTTvvH/d9j0bSjGakubVq1/fz2Y+kWzP3HNm71xxd5zrXUVprhBBCLC2O+R6AEEII+0lwF0KIJUiCuxBCLEES3IUQYgmS4C6EEEuQc74HAFBaWqrr6+vnexhCCLGoHDx4sFdrXRbrewsiuNfX13PgwIH5HoYQQiwqSqnz8b4naRkhhFiCJLgLIcQSJMFdCCGWIAnuQgixBElwF0KIJUiCuxBCLEES3IUQYgmS4C6EEDa6MOjjv491zvcwJLgLIYSdHn6thft+fIhzPSPzOg4J7kIIYaMBbwCAJ452zOs4JLgLIYSNBkfHg/t8nnQnwV0IIWw0ZAb3cz0ejncMzds4JLgLIYSNhnwBNlbl43SoeU3NJBXclVKFSqlHlVKnlFInlVJXKqWKlVLPKKXOmB+Loh5/v1KqUSl1Wil189wNXwghFpbB0QB1xVlcu66MXx7tIByen9RMsjP3rwK/0VpvAC4FTgJfAJ7VWq8FnjW/Rim1CbgL2AzcAjyolEqze+BCCLEQDY0GKchK5+2bKugc9HG+zzsv40gY3JVS+cC1wHcAtNZ+rfUAcAewx3zYHuBO8/M7gIe11mNa6yagEdht77CFEGJhGhwNkO9KpywvExjPwV9syczcVwE9wPeUUoeVUt9WSuUAFVrrTgDzY7n5+GqgNer5beY1IYRY0vzBMKOBEPlZ6eRmGmchDfuC8zKWZIK7E9gBfF1rvR3wYKZg4lAxrk1JOiml7lVKHVBKHejp6UlqsEIIsZAN+4xZekFWOnmudABGxhbuzL0NaNNa7zO/fhQj2HcppaoAzI/dUY+vjXp+DTBlyVhr/ZDWepfWeldZWcwjAIUQYlGxatzzs5zkuYyZ+9BCnblrrS8ArUqp9ealG4ETwBPAPea1e4DHzc+fAO5SSmUqpRqAtcB+W0cthBALkBXIjZn7/KZlkj0g+5PAj5RSGcA54CMYbwyPKKU+BrQA7wPQWh9XSj2C8QYQBO7TWodsH7kQQiwwkZm7azznPrKQg7vW+giwK8a3bozz+AeAB2Y/LCGEWHysypiCrHScaQ6y0tMiefiLTXaoCiGETcZz7sZiap7LycjYAs25CyGESM6QbzwtA5Drci7oUkghhBBJGBoNkpHmwJVuhNY8VzrDMnMXQojFbXA0QH6WE6WM7T75Lqfk3IUQYrEb8gUi+XaA3ExJywghxKI3ZPaVseS5nPNWCinBXQghbDI0GqBgwsw9XdIyQgix2Bk594kzd48/RGgeerpLcBdCCJsM+YIUZI3vDbVaEMxHrbsEdyHEsvNKYy8tbnsP0dBax8y5A/OSmpHgLoRYVlr7vHz4u/t58PlGW+/r9YcIhvWktIzV9ldm7kIIMae+9rtGgmHNgNfe2fRQVC93y3we2CHBXQixbJx3e/jZwTbA/tl0dEdISyTnPg/BPdmWv0IIsej9+3ONOB2K9RV5tufBh0bHe7lbxg/skJy7EELMibFgiF8cbuePLqtlVVmO7amSoahTmCyScxdCiDnW7wkQCmvWV+aR50q3/fi7wdGpOff5PI1JgrsQYlno9/oBKMrOmJOGXpPb/QJkpaeR5lBSCimEEHPFCu6F2cb5pmPBMP5g2Lb7WzN3a7YOoJQiN3N++stIcBdCLAuDZuljUXZGVImifTPqodEguZlOnGkTw+p8dYaU4C6EWBb6zeBuzNztX+gcGPVPyLdb8lzOeTmwQ4K7EGJZiM65z8VCp3vET0luxpTrefN0YIcEdyHEsjDg9eNKd+BKT4vM3O2sP+8dGaMkJ1ZwT5e0jBBCzJV+b4CibCP4ztXMvTQ3c8r1PJdT6tyFEGKuDHgDFJrB3SpXtCu4a61xe8YozZsa3GVBVQgh5tCA10+hueBpdyvewdEAgZCOm5aRUkghhJgj/V4/RTlGcM+1OS3TO2Is1pbFmLnnuZz4Q2F8gZAtr5UsCe5CiGUhOi2TnubAle6wLRfeOzIGEDfnDhe/v4wEdyHEkqe1ZmA0QFH2xIM07ErLWME9VinkfPV0l+AuhFjyhseChMKawqzx4JvnctrWPMxtpmViz9ytxduLW+suwV0IseQNeMZ3p1rsrD/vHRnDoYiUWkaL9HQfXYAzd6VUs1LqdaXUEaXUAfNasVLqGaXUGfNjUdTj71dKNSqlTiulbp6rwQshlpa9Z9189PuvEQzZ19ALJu5OtdjZGbJ3ZIzinAzSHGrK98rNRdauIZ8tr5Wsmczc36q13qa13mV+/QXgWa31WuBZ82uUUpuAu4DNwC3Ag0qpNBvHLIRYov7t2TM8d6qbPjMY2yUS3HMm9lq3s1omVkoGYEVhFgAdA6O2vFayUknL3AHsMT/fA9wZdf1hrfWY1roJaAR2p/A6Qohl4FzPCHvPuQH7zxwdiDQNi8q5Z9q7oBovuLvS0yjNzaBjcGEGdw08rZQ6qJS617xWobXuBDA/lpvXq4HWqOe2mdcmUErdq5Q6oJQ60NPTM7vRCyGWjJ++Nh427C4bHLB6uU86JcmuN5F4TcMsKwqzaOtfmMH9aq31DuBW4D6l1LXTPHZq0sl4c5h4QeuHtNa7tNa7ysrKkhyGEGIpGguG+NnBtkh+2u6Zu9XuN7olb67LiccfIhSeEp5mbLqZO0B1YdbCTMtorTvMj93ALzDSLF1KqSoA82O3+fA2oDbq6TVAh10DFkIsPc+c6KLP4+ePr64HsL3/+YDXT75r4kEakZ7uKb6ReP1BvP7QtMF9RWEW7QOjaJ36G0myEgZ3pVSOUirP+hx4O/AG8ARwj/mwe4DHzc+fAO5SSmUqpRqAtcB+uwcuhFg6Xm50U5CVzq1bqgD7N/z0ewMUTer7EilRTDHvbtW4J0rL+ALhyG8QF4Mz8UOoAH6hlLIe/2Ot9W+UUq8BjyilPga0AO8D0FofV0o9ApwAgsB9WuuL21RBCLGodA/5qC7MiqRNRmze8NMf1TTMkm9Tf5kec3dqWYK0DBgVM8UxmovNhYTBXWt9Drg0xnU3cGOc5zwAPJDy6IQQy0L38Bjl+ZmRrfp2L6gOjgambDCya+do73D8vjIWK7i39Y+ypbogpddLluxQFULMu64hHxV5LjKcDjKdDttz7v1e/4S+MmDfgR1uT+K0THXRxa91l+AuhJhXobCmd8SYuYO9JYqWAU9gQo278Tr2HJJtzdynC+5F2em40h20S3AXQiwX7pExwhrK812A0UXRzrRMIBRmeCwYIy1jz4EdvSNj5LucZDrjb8RXSrHiIpdDSnAXQsyrbnPma9W459o8cx/fnToxLWPl91PtDNnrid96INrFrnWX4C6EmFdWQ62KqJm7naWQ431lJs7cXelpZKQ5UnqtUFhzomOIygJXwsdWm7XuF4sEdyFEQv5gmFfO9jI4an+d9pSZe2a6rQuqkTePOEfgpZKWefJYB029Hj54+cqEj11RmEXviP+iHbcnwV0IEVc4rPm7Xx7nsgd+ywe+tY/vvNRk+2tYwdc6fzTP5WRkzL43kc5B4/5VBVlTvpdKZ8hgKMxXf3uGDZV53LqlMuHjqy9yd0gJ7kKIuM71jvC9l5u5tLaQwux0OucgMHUPj1GSk0G62RogN9PenHuXGdytapxoqRy198TRDs71evj029bhiNHHfbLx1r8Xp6+7BHchRFwtfV4APnXjGmqLsiNnhdqpe8gXqZQBa+YetK0PS+eQj+KcDFzpU6tZinMy6PPMrnf8t15sYlNVPjdvrkjq8TJzF0IsGK19RiCqLc6mJDeD3hF7D9EAc3dqVD481+UkENKMBe05jalr0BdZrJ2sPC+TrqGZv2GFwpozXcNcv74MszVLQqV5xoKue5ZvJjMlwV0IEVdrnxdXuoOy3ExKczNxz8HMvWvIR0VUyiTP5hYEnYM+quJUs1Tku+gZGSM8w7a/nYOjBMOauuLspJ+TneHEle6IVO/MNQnuQoi4Wvq81BRlo5SKzNztbFtr7E71U543HnxzbWoLYDHePOLM3PMzCYX1jGfTVrpqJsEdoDg7I9JFcq5JcBdCxNXaPxoJYGW5mfhD4ZQ3/URze8YIhfWEmXtupj191sE4BMTt8ceduVvpoO7hmS1ytprBvXaGwb0oJ0Nm7kKI+aW1pq3PS63Z9MrahWlnaqbbzHeXRc/czbTMsA3lkNb9K+PO3F0THpeslj4vToeK+6YRTyoLuDMlwV0IEdPgaIDhsWBkdmo1xrJzUdWaMU/IuZtpGTtm7hfMGvp4O0hnO3Nv6RuluihrwslOySjKlpm7EGKeWZUyNUVGcLdm7naWQ1oz5uhSSDt7ulsbmOIFd2vj1EwrZlr6vNQWzSwlAzJzF0IsAJMXDeciLWMF1ehTjCIzdxuCe1eC4J7pTKMoO31WOfeZ5tvBmLkP+4IEQvaUeU5HgrsQIqbWfmvR0Mi5F2WnoxT02JyWKc7JIMM5HorsrJbpHPSRnZEWKa+MpSLfNaOZ+7AvQJ/HP+NKGYDiHGOx+GKkZiS4CyFiau3zUpidHjnUwpnmoDg7w960zKQNTGDMplPt1mjpGvJRWeCadqNRWV5mpHlZMqx01eyCu/Gz9nuMxeK5bCImwV0IEVNr/+iUvHJpbmbk5CE79Hn8MU8wyrWpeVjn4GjcShlLRb6L7qHk0zKzrXEHKDJn7lbe/c6vvcz/8+NDM75PMiS4CyFiau3zTglgJbkZtm6fN842jRHcbWoe1jU0lrDXenleJj3Dye9SbU0huBebPeX7vcZmsJY+b2RR124S3IUQU4TDmvb+UWqKJ7bJLc3NtDUt0+/xRwJeNDuO2guHtZGWSWLmHgxr+pLMg7f0ecl3OSmYdLJTMorNN7I+jx+3x4/XH5rVm0QyJLgLIaboGvbhD4XnNC0TCmsGRqceXA1GWibVnHuvZ4xgWCfcaFQeKYdMLjXT0uelrmR2Adn6Wfs9/pTSO8mQ4C6EmKK936pxnzhzL8nNwOMPMepPfSFwcDSA1lAcYwac70p95t41aLwJxesrY4nsUk3yTStWuipZGU4HeZlO+rz+lNI7yZDgLoSYwkq9TM4Hl9m4kclaVJx8tinYc47qud4RAKqLpp7AFC2ySzXGzF1rzekLw5Gvg6Ewbf2js6pxtxSZG5la3EZwr5nFZqhkSHAXQkxhtRgozZ0Y3K2e5HYEd6vWO2bO3YaZ+8Hz/WRnpLG+Im/ax1knNMXqL/PLY53c/JUX2HfODUBjzwj+UJgNldPfczqR4N7npTwvk6yMqYeI2EGCuxCL1H8f6+T/PH3a1ha8lsiselI+vCTH2qWaesVMf5zXAKMzZKrVMgea+9leV5iw/0umM43C7HS6Ju1S1Vrz9efPAvBacx8Ar7cNArC1umDW4yoxO0O2pJDeSYYEdyEWqZ/sb+Hfn2vkF4fbbb93n8dPnss5YecoQGmefWmZ6WbueS4n/lCYseDscvtDvgCnLgyxa2VxUo+vyHNNmbm/cKaXk51DKAVHWgcAeKN9kOyMNBpKc2c1LjCbh3kCKeXukyHBXYhFqqnXA8CXHj9Om9kqwC69I2NTUjJgzDqt76eqz9ylGa/OHWbeGTJk1qofbhkgrGFXfVFSzyvPz6Rr0oLqN54/S2W+i9svWcGR1gG01rzePsjmFfmkJXEgdjzFOen0jIzROeRLKXefSNLBXSmVppQ6rJR60vy6WCn1jFLqjPmxKOqx9yulGpVSp5VSN8/FwIVYzsaCIToGR3nvjho08PnHjtl6/7449eeudKNPix1tf/u9flzpjpg559l0hvzuS01c+8+/Y8gX4GBzHw4F2+uSC+4V+S4uDI4fXP162yB7z7n52Fsa2F1fRO+IkUY50TnElhRSMmDk3P3BMFrPXaUMzGzm/ingZNTXXwCe1VqvBZ41v0YptQm4C9gM3AI8qJSamxUDIZap1j4vWsM1a0v56NX1vNzotrVPSbzgDkZqpsemapniGLN2gPwsq8FW8i0ITnYO0T4wyoO/O8trzf1srMqPvEkkUl2YRffwGH7zUO6953oB+IOdNWyrNd4gHjvYhi8QTinfDkz4mWdbL5+MpIK7UqoGeAfw7ajLdwB7zM/3AHdGXX9Yaz2mtW4CGoHdtoxWCAFAU6+RhllZks3KkhxgvHe5HXpH/JEUzGRl5nb9VPV7/DHLIAFWFBq15x0DozG/H4vVFuG7LzdxqKWfy+qTy7eDUc+vtdGLBozmYPkuJ0U5GWyoyiPT6eAnr7UCqS2mwsTSz4Uwc/8K8FdAdBPiCq11J4D5sdy8Xg20Rj2uzbw2gVLqXqXUAaXUgZ6enpmOW4hl7bzbyLc3lOZQZQbCzhkEwumEw5p+b+yGXmDUhc+k0VY8/d74vx1Ytd/WZqpkuEfG2FCZhwLGgmF2rkwuJRP9em3m67X2j/drT09zsKW6gJ7hMbIz0lhVNvvFVBhfQM50Oib0sbdbwuCulLod6NZaH0zynrFWGqbUammtH9Ja79Ja7yorK0vy1kIIMBZTC7LSKczOYEWBsUmnw6aZ+5AvQCisI+1pJyvPc82oRW48/d5AzMVUgIKsdPJczhktFPeO+Nm0Ip8/vXYVTodid8PMZu5A5PUmn7S0rbYQgE1VqS2mwvgCcm1xNo4U7zWdZBJSVwPvUkrdBriAfKXUD4EupVSV1rpTKVUFdJuPbwNqo55fA3TYOWghlrtmt4f6UiMdY3U9tGvmbqU34qVlyvMz8fpDjIwFk85pxzJdXh+MPHhbkjN3rXWkwufTb1vH+3bVJmw7EK2ywIVDGb8phMOatv5R3raxIvJ9K7inupgK4/9d5zIlA0nM3LXW92uta7TW9RgLpc9prT8EPAHcYz7sHuBx8/MngLuUUplKqQZgLbDf9pELsYw193qpNxfjXOlpFOdk2DZztzYoTZeWgdjb9ZMVDIUZHA1QOE1nxZqibNqTfMPy+EOMBcOU5mbgcKgZlximpzmoKjDeTHpGjIXV2qi2Bbsbisl0OrhqdcmM7htLQVY6Toea8+A++7dd+DLwiFLqY0AL8D4ArfVxpdQjwAkgCNyntZ6740aEWGZ8AaMMsr6kJnKtqmBiKV8q+jxGyiXerLo8b7zR1mzzzwOjgWlfA4xUyavn3Gitpz1JCYh0qiyJk0pKhvWbgtXQqyYq+Fbkuzj4P28ix4ZWAQ6H4j8+sJ3NK1L/LWA6MwruWuvngefNz93AjXEe9wDwQIpjE0LE0NZvlEE2mGkZwJx12rORaTwtEyfnbvViSSHvPl3rAUtNURYjY0Fzhh//cQBu8w0p3m8bybDeTCJnx05q6JVKCmqyW7ZU2XaveGSHqhCLTHQZpGVFoWtGZYPTsdIy1pFwk9mRlrHq1xPN3IGk8u7xGp3NRE1RFheGfJzr8Ux4/cVKgrsQi0xz73gZpKWqIIshXxBPip0UYbyvTKYzdgqiICudDKcjpVr3eI3Jok0uT5yO25bgnk1Yw/6mPiryM3GlL+69lxLchVhkmt3jZZAWa9NPpw15d7cn/gYmAKUUZbmZqaVlpmkaZplcnjgdq9fNdPdLxOr7frh1YEpKZjGS4C7EItPs9kQqZSzWOaEdA6lXzPR5xhIGyfL8TLqHZ/9a1sx9umqZgqx0cjOdSc7cxyK/UcyW9WbiD4bntKHXxSLBXYhFpnPAN+X0nhWFRmCyZeY+4qckQXrD2KWa2oJqdkbatKkPpRTVhVlJlUP2euLvqE1WVUEWVlFO7SLPt4MEdyEWne7hsSnH31Xku1DKnpl7orQMpL5Ltc/rnzbfbqkpSm4jU+/wGKUplEGCcb5phVnmKTN3IURMc3E6EoBnLMjIWHDK7ssMp4PS3EwupLiRKRzW9CfYOQrGzH1wNDDrTpQD3kBS+XEjuCfOubs9/sgRgKmwUjMS3IUQU3QOjnLJ3z0dOZrNTtZsuTxv6ix1RYGLjhTTMkO+AMGwTirnDiRdMfNm1zDB0HjfQfc0HSGj1RRlM+wzat2n4x4ZS2kD0/jrSXAXQsRxqnOYYV+QRw+02X7vLrO2PFbflKqCrJTb/lobmBKVFI7vUk38en0eP7d+9cXIeaSD3gAnO4dYk8TuVquCJVZ3yFfO9nK4pZ9AKEy/N5Byzh1gQ1U+RdnpkQXqxUyCuxA2s2bPT524QCAUTvDomYnM3POnBt+qQhedA6MppYSsKpZkZ+7JLKo29XoIhTU/2d9CKKz55bEO/MEw794+pRP4FPHKIbXWfPanR/nCY69HdrumUuNu+ejVDfz2s9el3PlxIZDgLoTNOs1FzQFvgH3n7E3NWLtCrYW/aFUFLjz+EEMzOHf068+f5d0PvhzJnVtplsQ59/H+MolYgblj0McLZ3p47FAb6yvy2FKdn/C541VAE39DaO0b5cKQj9NdwxxqGQCg1IaZe4bTkbBSaLGQ4C6EzToGRynNzSQ7I41fvdFp6727h8fIcDrIz5ra56SqYOblkK8193G4ZYD/7zen8IwF+epvz1CYnR5pJxxPSU4GaQ6VVFrGqnYpyk7nfz91msMtA7x3Z3XCZmDW62Q4HVNaK+xrckc+/8n+FuOxSyQo20WCuxA26xzwsbIkmxs2lPPUGxcIhe2rnOka8lGRnxkzMEZ2qc6gHLJryIdS8L2Xm/ngt/dxpnuYf3//9oRNshwORWluRlJpmbZ+L6W5GfzRZXUc7xjCoeDObYlTMmDUulcVuKa0M97f1EdhdjrrK/J44YxxkpsdaZmlRIK7EDbrGBylqsDFbVurcHv8E2aZqeoeGoukRCYbn7nPJLiPcee2alaX5XCkdYDP37KBa9YmdzJasrXurX2jVBdlc9dlxhk+164ro3wGC5ZVBa4pB5Hsb+7jsvpibt5cgbXEYMeC6lIiwV0IG2mt6Rz0UV2YxXXrylAKW/PuXcPGzD2W8rxMHCr5tEwgFMbtGaOuOJvv3HMZ//Serdx77aqkx1KR70rqtdr6vdQWZVFfmsO//uGlfPG2jUm/BsCKSVVAFwZ9nHd7ubyhmJs2VQKQkeYgz8aWvEuBBHchbOT2+PEHw1QVuMjJdFJTlMXZnhHb7t8zzczdmeagIt+V9C7V3pExtDaCdH1pDu/fXZdUHtxSV5xNa9/01TmhsKZ9YDTSLuE9O2pYW5GX9GuAUQV0YcgXSW/tN/cP7G4oZkt1PlUFLkpzM2Y09uVAgrsQNrLy3VVmlceaslwau+0J7l5/kOGxYMwySEtVQXKzaTBSMkDc3wQSqSvOYjQQivRSB+M3lx/sbeYPv7GXfo+f7mEfgZBOqTd6VUEWobCOVPLsb3KTk5HGpqp8lFL8+VvX8O4dyeXwlxP5PUYIG1k17ivM/Pea8lxePusmFNYp105bi5fxZu5gBMITnUNJ3W+6DVHJqDM7U7b0eSkz2xF89qdHePZUNwAvnOmJrAOksuOz2nyj7BgcpbLAxf6mPnbWF+NMM+amd1+xctb3Xspk5i6EjayFvyqzcmVNeS7+YNiWI/DGg/H0M/eOJDcyWTXz0/0mMB3rgGfrzNE9rzTz3Olu/sc7NpLncvLqOXfk505p5l5otTMeZdgX4Ez3CDvrimZ9v+VCgrsQNuoc9BkbYcxNQGvKjS32duTdrcqU6WbaVYVZjAXDkWPsptM1NEaaQ826J4uVR28xg/vxjkEaSnP4+DWruLyhmL1n3bT2GW921ux7NiJVQAM+Xm8fRGu4tHZuD5deCiS4C2Gj9oFRVhS4Iot7q83+KXbk3a2Ze6ymYZYVBcmfyNQ15KM0N2PW6SJXehoV+ZmR4H7qwjAbK41dp1esKqHZ7eXA+T7K81I7si7f5SQnI42OwVGOtQ0CcElN4azvt1xIcBfCRp2DvshME6AwO4PS3AxbgnuPuTu1ICv+6UXWQm4yG5m6hsdmnW+31BVn09LnZWQsyHm3lw2VRiXMlatLAHipsTflDotKKaoKs+gc8HGsbYDa4qyUjtNbLiS4C2GjzoHRSI7YstqmipmuIR/lebF3p1pmMnPvHvJNuzibjNribFr7vJy+MAwYXRUBNlbmU5idjtap5dstVhXQ0dZBLqkuTPl+y4EEdyFsEgpruobHIpUyljXlRnBP9QCP7iRm2iW5mTgdasp2/VisVgapqCvO5sKQMaMGIjN3h0NxeUMxYE9wry7M4kz3CO0Do1xSI/n2ZEhwF8Im3cPGRptYM/chX3BCPXgyog+30FpzYdA3bb4dIM2hjJ2jCc4dHQuG6PcGbEnLaA3Pnuwm19y0ZblilZGaqS1K/eCLqoIsvH6jc6Xk25MjwV0Im1g7Q2PN3GFmi6oXBn1s+dun+MxPjzA4GuB//fdJzvV62FKdeNa6onBqoy3LqQtDdA/7IjXzdszcAV4952ZDZd6ElNHbNlZQVeBix8rUyxatN0ylYKvM3JMim5iEsEnHpBp3SyS494xEFhoTOdE5iC8Q5heH23nq+AW8/hB/fFU9n7hudcLnVhVkcbi1f8r1tn4v7/7aK+xuKOYvblwDMKMGXrFYwT0Y1myomthWoLY4m73335jS/S3WG+bqstyEHSuFQWbuQtik3QzuNZPSEFUFLnIy0jg7g5l7c69RXvjQ3TtZVZbDX9+2gS+9cxOOJMoWqwpdXBj0EY5qNay15kuPH2c0EOKFMz0cOj8AxD70YybK8jLJdBphZENl4sM3Zst6w5R8e/LkLVAIm7T1eynMTp8ys1RK0VCWQ1OvJ+l7nXd7yM10ctOmCt6+uXJG41hRkEUgpHF7/JSZOfqnjnfx7KluPnJ1PXteaeabL5wDUk/LKKWoK87mTPcIG6tm1hBsJqoLs6gqcHHDhvI5e42lJuHMXSnlUkrtV0odVUodV0r9nXm9WCn1jFLqjPmxKOo59yulGpVSp5VSN8/lDyDEQtHWPxq3MqShNHdmwb3Py8qS7Fl1OqwqGN+uDxAOa/7+l8fZUJnHX9+2kbeuL6d3ZIz0NEVRdur14lZqZt0Muz3OhCs9jb3338jtl6yYs9dYapJJy4wBN2itLwW2Abcopa4AvgA8q7VeCzxrfo1SahNwF7AZuAV4UCk1++1pQtioqdfDma7hObl3W/8oNYWxK0MaSnNo6/cyFgwlda/zbi/1JdMfdRfPSvN5zW7jzaR9YJSOQR93X7mS9DQH799dBxgNyJJJ8yRy/foy3raxnDxX/M1V4uJLGNy1wUoWppt/NHAHsMe8vge40/z8DuBhrfWY1roJaAR22zloIWbr/p8f448eepV+z8zKEhPRWtPW7407c19VmkNYjzfZmk4wFKa1zxvpujhT9aXZONR4dU6j2ddmbbkxs75+fRmV+S4qC1LLt1vuvrKeb99zmS33EvZJakFVKZWmlDoCdAPPaK33ARVa604A86OVDKsGWqOe3mZem3zPe5VSB5RSB3p6elL4EYRIXmP3CH0eP1/+9Slb79vn8eMLhKmOm5YxZtPnehKnZjoHfQTDmvpZBvdMZxorS3Iiwd1ayLWqdpxpDr5x907+5vZNs7q/WBySCu5a65DWehtQA+xWSm2Z5uGxfs+bsjVPa/2Q1nqX1npXWVlyZzYKkYohX4DeET+luZn89EArrzXbd/xdW3/sShlLvRXck8i7W+mUlbNMy4BRMmh1omzsHqE4J2NCP5ZttYVcWls46/uLhW9GpZBa6wHgeYxcepdSqgrA/NhtPqwNqI16Wg3QkepAhUhVsxlY/8c7NlJdmMU/PHnCtnuPB/fYM/eCrHRKczNoSmLm3uw2UjcrZzlzB2OW3tTrIRgK09g9whqzO6VYPpKplilTShWan2cBbwNOAU8A95gPuwd43Pz8CeAupVSmUqoBWAvst3ncQsyYVa2yaUU+791Zwxvtg/gCyS1wJmIdShEvLQNGaiaZipkWt4dMpyOlGvTVZTkEQpqWPi9ne0ZYXS7BfblJps69CthjVrw4gEe01k8qpfYCjyilPga0AO8D0FofV0o9ApwAgsB9Wmt7/gUJkYKmXg9KGaV76ypyCWsjB75pReqbb9oHRsl3OcmfpmKkoTSH504lXl9qdhtlkKlUslj59dea++j3BlhdNvsUj1icEgZ3rfUxYHuM624g5t5irfUDwAMpj04IGzX1eqguzMKVnhapHDnTPWxLcDdq3KdPozSU5tI70saQLzDlTaBjYJTfv9nDH+2q5bzbQ11xasHYmqn/5o0LwHiwF8uH7FAVy0ZzrydStVJfmk2aQ9nSZx2MtEyiunTrtZt7PRM6G3YP+3j/t17lvNtLx8AoLX1erl2bWpFBviudivxMXm50AxLclyPpLSOWBa0156KCu1EumM2ZrtSDu1HjPjptvh2IpEai8+6D3gAf/s5+eobHuH59Gf/+XCO+QJiVpamnUdaU5+IPhclKT5vSqVIsfRLcxbLg9vgZ9gUnzK7XlufyZnfqu1UHvAG8/lDCtExdSTZKTax1/8YLZznTPcI3797JNz60M9IYa2WKR9MBkQqZ1eU5tuxEFYuLBHexLFhlkA1l0cE9j/Pu5FsCxJOoDNKS6Uyjpihrwsz9TNcwa8pyuWZtGa70NL55907+5JoGdpunGKXCyruvljLIZUmCu1hQmns93PSvv+dwy9R+5KmwNg81RM/cK3IJhXWkve5sWZuOkjlObnIDsfPuiW0Gqgqy+OI7NuFKT70dkzVzlxr35UkWVMWCEQyF+fRPj3Cme4RXzrrZXpf6CT6Wpl4PToeaEICtRcYz3cOsr0y+o2E4rNnX1MfjR9p5qbGXtv5RHCr+7tRoq0pzePR8f+Q81ZY+L9eum5sd2ltqCti8Ip/r1ssO8OVIgrtYML72u7McaR0gPc2+KhZLc6+HupJsnGnjv6yuLstFKWa8qPr3T57g+680k5ORxnXry3j/7jp2NxRTkJW4K2JDaQ4jY0F6RsbQGsaC4ZR2ok4n35XOf//FNXNyb7HwSXAXC0Jj9wj/9twZ7ty2gt4Rv+3BvanXMyElA0aP8Lri7Bm/1gtv9nD1mhK+/eHLyMqYWfrEqtZp6vFEerXX2bB4KsRkknMXC8LTJy4QCmv++raNrCk3ml5ZqYtU+YNhzvaMsDbGYRJry3M5M4OKmbFgiGa3hx11RTMO7BAV3Hs9nLehQZgQ8UhwFwvCy429bKjMozzfxeryXLz+EJ2DPlvu3dg9QiCkY+5EXVOeR1Ovh0AonNS9mno9hPXsNwWtKMwiw+mgqddDS58XhzKOkBPCbhLcxbzzBUK81tzPW9aUAuPVHXalZk52DgGwKcYZnxsq8wiEdKQ9biJWft5qXzBTaQ5FfUk258zgbgV7Iewmf6vEvDvQ3I8/GObqtUZwX11upCnsCu4nOodwpTtoKJ0627Zm89YbQCJnukdwKFiVQiMuqzvkebdX8u1izkhwF/PupcZe0tMUu+uNjTtluZnku5yR4+FSdbJziPUVeaTF2KW5qjSHDKeDEx3JBffG7mHqirNTqkNfVZbLebeHZrdnziplhJDgLubdy429bK8rIifTKN5SShmLqjbM3LXWnOgcitv50ZnmYH1FHieSnbl3jbBmlikZS0Op0Wt9wBtIufujEPFIcBfzqt/j542OwUi+3WJVzKTqwpCPAW+AjVXx2/puqsrnZOdwwuqcQChMU6+HtRWp7fhcFdUUTGbuYq5IcBdJe6N9kH3n3Lbe86XGXrSGq2ME994RPwNef0r3t9Itm6YJ7hur8ujz+OkaGov5/V+/3sl5t1G6GAxr1qbYPrchKrhLzl3MFQnuIinBUJhP/Ogg/++jx2y972OH2qjIz+RSsxuixSo1THVR1Voo3TDdzH1FwYTHRmvq9fCJHx3iEz88xMlOox5+tpUyluKcDPJdRgpKZu5irkhwF0n51RsXaO0zDpLw+oMzfv6QL0Brn3dC6qM96vSh6LYAMN7JMNXgfqJziJUl2eRmxt+MvcEskYyVd//B3maUMr73L0+dNsZWnlqeXClFQ1kuxTkZ5E1zLJ8QqZD2AyIhrTXfeP4saQ5FKKw50zXCpbWFM7rHn/7gIHvPucnLdHLzlkr+6T1b+elrrQD84WW1Ux5fU5RNdkZa0iWKYJxo9LlHjvKld26OzPxPdAyxsXL6Y/TyXenUFmdNqZgZGQvyswNtvOvSFQyNBvjd6R5qirLIzkj9n83tW6toHxhN+T5CxCPBXST04pleTnQO8WfXreYbvz/Lm13DMw7uJy8McVl9EStLcnj0YBv+YJj9TX1ct64sZjfFNIdia3UBR1oHkn6NQ+f7efFML5/+6WF+/omr+dXrnTS7vXzoipUJn2ssqk4M7o8dbGNkLMhHrm6gJCeDm/7v71kfo4XBbPzJtatsuY8Q8UhwFwl94/dnqcjP5FM3ruW7LzdxZoapkgGvnwFvgJs3V/Lxa1axqiyHf/6NkeL4uzs2x33etrpCvvtSE75AKKm68vYBo13BG+1D/OXPjvL0iQtc3lDMPVfVJ3zuxqp8nj7RhdcfJDvDSTis2fNKM9tqC9lmvpH96ONXUJQtaRSxOEjOXUzrWNsAr5x187G3NJCVkcbqslze7JrZ0XTn3cZhGFZlyCeuW81f3LiW3fXF3LChPO7zttcWEgjppGvQ2/tHyc5I4w921vDE0Q6KsjP42gd3kJ6W+K/55hUFaA3HzdTMme4RzvV6uCsqZbRzZRGr5OALsUjIzF1M6xu/P0uey8n7d9cBsK4il9ea+mZ0D+ukonqzBFApxWdvWgc3Tf+8bbXGYR1HWgbYkcTBHR0Do1QXZvG379pMptPBBy6vozQ3M6kxXlprVMwcbR3gsvpijrQaJ0FdZsNxd0LMB5m5i7iaej38+o0L3H3FykhVx7qKPDoGfQz7Aknfp2XSzD1ZlQUuKvNdHG0bSOrxHYOjrCjMIjfTyQPv3srmFQWJn2Qqz3NRXZjFYTPHf6R1gHyXc0oPeCEWCwnuIq6HXjhHepqDj1zdELm2zlxQnEnevdntparANat+LNtqC5NeVG3vN4L7bG2rLeRIi/Fah1sGuLS2EEeMfjRCLAYS3EVM4bDm8SPt3LltBWV546mNdebW+zcvJJ93P+/2zHon5ra6Qs67vfR5pt+p6guEcHv8SR1SHfe1agtpHxilxe3lza5hts+wIkiIhUSCu4ipfWAUrz805ZDq2qJsXOkO3pzBuaPn+7zUzzK9YVWqHE0we7dqxlcUumb1OmC8kQD856vNhPX410IsRhLcRUzWztDJJw45HEbHxmSPpvOMBekZHmNl6exm7lurC3AoIrnweDqs4F4w+5n7lhUFpDlUZHPVpTWFs76XEPNNgruIKRLcY5T+ravI49SFxF0UYbwMcuUsW9vmZDpZU57LiY7BaR9nBffqFNIyWRlpbKjMY8gXpK44m5IkK22EWIgSBnelVK1S6ndKqZNKqeNKqU+Z14uVUs8opc6YH4uinnO/UqpRKXVaKXXzXP4AYm6c7RmhJCeDopyMKd+7rL6YnuExTiWRdx8/BHr2DbI2mi15p9PeP4pDQUX+7NMyMJ4G2ib5drHIJTNzDwKf01pvBK4A7lNKbQK+ADyrtV4LPGt+jfm9u4DNwC3Ag0qp2R9bI+ZFY/dIpHnXZDduLEcpePp4V8L7nO8zZ+4pBPcNlfm0D4wyODpefnn6wjAf3/Mat3zlBfzBMO0DPirzXUltWJqOFdRn2l5BiIUm4b8ErXWn1vqQ+fkwcBKoBu4A9pgP2wPcaX5+B/Cw1npMa90ENAK7bR63MA16A/SOjDE0g7rzRLTWNPaMsDpO3/LyPBfbawt55uSFhPc67/ZQkmL3Q6tr42nzN4Uf7TvPLV99gRfe7OXUhWFeeLOHjoHUyiAt160vY0ddITdtrEj5XkLMpxlNc5RS9cB2YB9QobXuBOMNALD2kVcDrVFPazOvTb7XvUqpA0qpAz09PbMYunjuVBeX/v3T7Ppfv+WSv32a/TPcORqP22P0gpm8mBrt7ZsreaN9KJLrjqe515tyz3Krq+OpC0ZrgP/ce54tKwp46QtvpSg7ncePdtBuU3Avz3Px8z+/mjrpsy4WuaSDu1IqF3gM+LTWerpmH7F2fUxZedNaP6S13qW13lVWVpbsMESUZ050kZfp5B/u2Eyey8nD+1tsuW+8SploN20yZra/PTkxNXOiY4i//+UJrvqnZ9n6pad4tck96zJIS0V+JoXZ6ZzsHI7k+m/dWkl5notbt1bx2xNddA6OprSYKsRSk1RwV0qlYwT2H2mtf25e7lJKVZnfrwK6zettQHSD7hqgw57himgvNfZy5eoS7r6yntsvWcGv37jAyNjMDtI42zPCx/ccoD9qk5B1dunqsvhBeXVZLqvKcibk3c/2jPCu/3iJH756ni3VBbxvVy0fvbqBj1+TWntbpRQbKvM4dWGIV872AkTOXH3XpSsYDYQIhLQtM3chlopkqmUU8B3gpNb6X6O+9QRwj/n5PcDjUdfvUkplKqUagLXAfvuGLMDIZbf2jfKWtUaQ+4Od1YwGQvzq9c4Z3edrv2vktye7+N4rzZFrjd0jZKWnJawZf/umSl49547k+39/uodgWPPUZ67loQ/v4m/euYn/efsmNq2Y/rCMZGyozOf0hWFePNNLQVZ6pG/M7vpiKs0KmeoUNjAJsdQkM3O/GrgbuEEpdcT8cxvwZeAmpdQZjP5+XwbQWh8HHgFOAL8B7tNah+Zk9MvYS43GDNY6WHpHXRENpTk8drAt6Xv0DI/x5NFO0hyKH+xtjhyf19g9wurynIR9Vd62sZxgWPPim8ZY9p5zU1ecPeEAaLtsrMrD6zfevK5aXUKaOTaHQ/HOS6sAZOYuRJRkqmVe0lorrfUlWutt5p9faa3dWusbtdZrzY99Uc95QGu9Wmu9Xmv967n9EZanlxt7qSpwsSqqje57d1Szr6mPVrP8MJGf7G/BHwrz5fdsZcAb4OH9xjr42e6RmJuXJtteV0RhdjrPneomFNbsO+fmylUls/+hprHBXFT1+kORNzTLn1y7is/dtI51KR5cLcRSIjtUF6FQWPPKWTdXrynFyJoZ7txuFCX9+o3EqRl/MMwPXz3PdevKeN+uWi6rL+JbL57j848eo2PQN+1iqiXNobhuXRnPn+7meMcgQ74gV66em+C+riIP60d9y6TgXp7n4pM3rpUOjkJEkeC+gGmtY27xP9ExxIA3MCXI1RRls6osh71n3Qnv/eSxDrqHx/hj8wi6P79+DZ2DPp481sF7dlRz9xX1SY3xhg3luD1+vvnCOYA5C+5ZGWk0lORQXZiVcmmlEMuBnMS0gL33669waW0hX3rn+DmjWmu+by5+XrVmaiC9clUJjx/pIBgK44yzW3PIF+DLvz7F5hX5XLfOKEN964ZynvzkW1hVlkN2RvJ/La5bV4ZDwX8f62RVaU7K2/+n87m3r8ehmPDbihAiNpm5L1BDvgCHWgZ45LXWyEInwL88dZrHDrVx31tXU543NZBeubqEkbEgr7fHb7T1f546Tc/IGP/47q0TUhlbqgtmFNgBCrMzIkfgXTFHs3bLOy6p4tatVXP6GkIsFRLc54jWmkAoTCAUTqp74mTH2419Yh5/iKeOG9v8f7C3mQefP8sHLq/jL9++PubzrjAXNPeei52aOdI6wA9ePc+Hr1hpW/+Ut5qHXM/VYqoQYuYkLTNH7nzwlcgBE7dfUsV/fGDHjJ7/hjnzLs3N5LGD7exaWcw//uok168v4x/u2BI3NVGam8m6ilz2nnXz59evmfC9wy39fGzPASryXHzu5thvDrPxvp01tPZ5I0FeCDH/ZOY+B1rcXo62DnDb1kpu3lzBk8c6I02vkvV6+yBVBS4+eHkdL5/t5TM/PYJC8cC7t0ZqvOO5clUJB5r78QfDkWsvnenlA9/aR26mk4fvvYL8FBp5TVae7+LL772E3EyZKwixUEhwnwMvm1vkP3vTer78nkvIzkjjm78/O6N7vNE+yJbqAt67owat4cD5fj5z01qqk9ioc+XqEkYDIY61DUSu/eOvTlJV4OKxT1xF/RxsMhJCLCwS3OfAS429VOa7WF2WQ1FOBnddVscTZufCZAz7Apzr9bC1uoC6kmyuWVvKlup8PnJ1Q1LPv7yhBKXg5UYj79495ONE5xB/sKtmwmHXQoilS4K7zcJhzSuNvRM2GH38GiMof/vFc0nd43iHsZi6tdron/KtD+/i0T+7KumDKIpyMthZVxTpM/PCGeM3iWvXSvdNIZYLCe42O9E5RL83wFvWjleOrCjM4tatVfzX4fakKmesxdQtZnB3pafhSp/ZYVbv2raC013DnDYPsyjNzWBTVeoNvIQQi4MEd5tZLWmvXj1x9+hVq0vo9wZodifu+2ItpqaSQrltaxVpDsV/HWnnxTM9XLu2TLbnC7GMSHC32UuNbtZV5FI+aaemtdHn0Pn+hPd43VxMTUVpbiZXrS7h+y830+8NcO06SckIsZwsu+B+tmeEv3r0KJ975Ch/+8TxCbs/U+UPhtnf5OaqSbN2gLXlueRlOjnUEj+4a63559+c4lyPh8sbilMej3WQhVJwzdqpYxJCLF3LLrj/69Nv8l+HO3j1nJvvv9LMj/fZczQdGDNuXyDMFaumBmaHQ7GtrpBDLQMxnxsIhfnLnx3jwefP8v7ddZGGXqm4eUslGU4HW1YUUJIrVTJCLCfLKrh3DIzym+MX+MjV9bz8hRu4vKGY77zUNGGzTyoOnjda2u9cGXvWvb2uiNMXhqYchecZC/LxPQd47FAbn3nbOv7x3VviNv2aiXxXOg/cuYXP37Ih5XsJIRaXZRXcf/jqebTWfOiKlQD82fWr6Rz08cTRmR3x+uKZHm75ygu82TVx1+lrzf3Ul2THXQjdUVdIWMMxsy0BGIH9A996lRfP9PDl92zlU29ba2vXw/ftqo0cxSeEWD6WTXD3BUL8ZH8LN22qoLbY6Ad+/boyNlTm8c3fnyUcTr6510MvnOPUhWHu/s6+yKlHWmsOnu9nV338XPn2WmNR9WDUouqzp7o52jbIV+7azl2762bzowkhxBTLJrg/caSDfm+Ae6Jy2Uop/uy61ZzpHuFF80zSRDoHR3mpsZfbL6nCFwjzoe/sY8Dr51yvhz6Pn10ri+I+tyA7nTXluRMWVY+0DJDpdHDrlspZ/2xCCDHZkgvuv369k30x2t3+aN951pbnTmlLe+vWSvJcTp5MMjXzi8PtaA1/+fb1fPePd9Ha5+Xfnm3kYLMRsKebuYORmjncOhD5TeFIaz9bqwuS3n0qhBDJWFIRpbXPy5//+BB/9NCr/PH39nOuZwQwdnwebRvkA5fXTclnZzrTuGljBU+f6CIQmn5hVWvNYwfbuKy+iPrSHHauLOYPd9Xyn6828/PDbRRlp7O6bPqmXFetLmXAG+BY+yD+YJg3OobYZlNfdSGEsCyp4P7T11pRwCdvWMOh8/3c/Z39DPsCPPxaC5lOB+82D5Ce7NatVQyOBhKePXq0bZCzPR7eu6Mmcu2zN60jPc3Bq+f62LmyOOFiqHUs3XOnujl1YQh/MMy2usKZ/qhCCDGtJRPcA6Ewjxxo5a3ry/nc29fzvY/spnNwlPt//jr/dbiDd2ytojA7I+Zzr1lbSk5GGr9+o3Pa1/jPvedxpTu47ZLxo97K81386bWrAdhVHz/fbinKyWB7XRG/O9XNEbNqRmbuQgi7LZng/typbrqHx3i/WXGyc2UR9711DU8e62RkLMj7L49fieJKT+PGjRU8dbyLYJzUTFOvh18cbuODl6+cctDFvdeu4t5rV8X9zWCyGzaU83r7IE8f76I0NzOpHu1CCDETSya4/2R/C5X5Lq5fP95D5S9uXMv2ukK2VhdMW8UCcNvWSvo8fvY19UWuecaCjPpDAPzbs2fIcDr4s+tWT3luVkYaf33bRirypx5YHcsN5nF0LzX2sq220Na6diGEgCVyhuozJ7r4/Zs9fPKGtRN2dqanOfjZn16JPxROIhdeTk5GGo8faefqNaVorbnroVdp7ffywcvrePxIOx+/ZpUth11sqMyjqsBF56CPbbWpNQgTQohYFv3Mfe9ZN/f9+BCXVBdw77WrpnzfmeYgOyPxe1hWRhq3ba3iV69fYNQf4lDLAK+3D1KcncHXfncWV3oafxrj/rOhlIocJr2tNnGeXgghZmpRz9zfaB/kT35wgJXF2Xz/I7tTPqD5vTtr+NnBNp46foGXGnvJyUjjl598S+TwDDubb31gdx1t/aPsWFlo2z2FEMKyqIN7VYGLa9aW8qV3bqYoJ3YlzEzsri+mpiiLPXubOdk5xHt21JCT6eTySRuf7LCluoAffHS37fcVQghIIi2jlPquUqpbKfVG1LVipdQzSqkz5seiqO/dr5RqVEqdVkrdPFcDB2Mm/fUP7aSyILmFzEQcDsV7dtRwuGUAXyDMB6TXixBikUom5/594JZJ174APKu1Xgs8a36NUmoTcBew2XzOg0qpmR3+Oc/eu8MoZ9xaXZDyaUhCCDFfEqZltNYvKKXqJ12+A7je/HwP8DzwefP6w1rrMaBJKdUI7Ab22jTeObeyJIcv3raRS2oksAshFq/Z5twrtNadAFrrTqVUuXm9Gng16nFt5rUplFL3AvcC1NUtrPTHn9hUFSOEEPPF7lLIWMXkMRula60f0lrv0lrvKiuTw5uFEMJOsw3uXUqpKgDzY7d5vQ2ojXpcDTCzY46EEEKkbLbB/QngHvPze4DHo67fpZTKVEo1AGuB/akNUQghxEwlzLkrpX6CsXhaqpRqA74EfBl4RCn1MaAFeB+A1vq4UuoR4AQQBO7TWofmaOxCCCHiSKZa5v1xvnVjnMc/ADyQyqCEEEKkZtH3lhFCCDGVBHchhFiCJLgLIcQSpLSOWYZ+cQehVA9wPoVblAK9Ng1nLi2WccLiGetiGScsnrEulnGCjHWl1jrmRqEFEdxTpZQ6oLXeNd/jSGSxjBMWz1gXyzhh8Yx1sYwTZKzTkbSMEEIsQRLchRBiCVoqwf2h+R5AkhbLOGHxjHWxjBMWz1gXyzhBxhrXksi5CyGEmGipzNyFEEJEkeAuhBBL0KIO7kqpW8yzWhuVUl+Y7/FYlFK1SqnfKaVOKqWOK6U+ZV6Pe/bsfFNKpSmlDiulnjS/XpBjVUoVKqUeVUqdMv/7XrkQx6qU+oz5//4NpdRPlFKuhTLOhXwucpJj/Rfz//8xpdQvlFKF8z3WWOOM+t5fKqW0Uqr0Yo5z0QZ382zWrwG3ApuA95tnuC4EQeBzWuuNwBXAfebYYp49u0B8CjgZ9fVCHetXgd9orTcAl2KMeUGNVSlVDfwFsEtrvQVIwzhbeKGM8/ssnnORv8/UsT4DbNFaXwK8CdwP8z7WWONEKVUL3ITRPde6dlHGuWiDO8bZrI1a63Naaz/wMMYZrvNOa92ptT5kfj6MEYCqMca3x3zYHuDOeRngJEqpGuAdwLejLi+4sSql8oFrge8AaK39WusBFuBYMTquZimlnEA2xqE1C2KcWusXgL5Jl+ONLXIusta6CbDORb4oYo1Va/201jpofvkqxqFA8zrWOP9NAf4v8FdMPJHuooxzMQf3aqA16uu457XOJ/Nw8e3APiadPQuUT/PUi+krGH8Bw1HXFuJYVwE9wPfMFNK3lVI5LLCxaq3bgf+NMVvrBAa11k+zwMY5SbyxLfR/Zx8Ffm1+vqDGqpR6F9CutT466VsXZZyLObgnfV7rfFFK5QKPAZ/WWg/N93hiUUrdDnRrrQ/O91iS4AR2AF/XWm8HPCycdFGEma++A2gAVgA5SqkPze+oZm3B/jtTSn0RIwX6I+tSjIfNy1iVUtnAF4G/ifXtGNdsH+diDu4L+rxWpVQ6RmD/kdb65+bleGfPzqergXcppZoxUls3KKV+yMIcaxvQprXeZ379KEawX2hjfRvQpLXu0VoHgJ8DV7HwxhltUZ2LrJS6B7gd+KAe36yzkMa6GuPN/aj5b6sGOKSUquQijXMxB/fXgLVKqQalVAbGAsUT8zwmAJRSCiMvfFJr/a9R34p39uy80Vrfr7Wu0VrXY/w3fE5r/SEW5lgvAK1KqfXmpRsxjnRcaGNtAa5QSmWbfxduxFh3WWjjjLZozkVWSt0CfB54l9baG/WtBTNWrfXrWutyrXW9+W+rDdhh/h2+OOPUWi/aP8BtGKvlZ4Evzvd4osb1Foxfs44BR8w/twElGJUIZ8yPxfM91knjvh540vx8QY4V2AYcMP/b/hdQtBDHCvwdcAp4A/hPIHOhjBP4CcZaQAAj6HxsurFhpBfOAqeBWxfAWBsxctbWv61vzPdYY41z0vebgdKLOU5pPyCEEEvQYk7LCCGEiEOCuxBCLEES3IUQYgmS4C6EEEuQBHchhFiCJLgLIcQSJMFdCCGWoP8f97b3OE0jbnAAAAAASUVORK5CYII=\n",
-            "text/plain": [
-              "<Figure size 432x288 with 1 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          },
-          "output_type": "display_data"
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "[[112.]\n",
-            " [118.]\n",
-            " [132.]\n",
-            " [129.]]\n"
-          ]
-        }
-      ],
-      "source": [
-        "# load the dataset\n",
-        "dataframe = pandas.read_csv('airline-passengers.csv', usecols=[1], engine='python')\n",
-        "dataset = dataframe.values\n",
-        "dataset = dataset.astype('float32')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "KdbWrABl1ryo"
-      },
-      "source": [
-        "# Normalize the dataset \n",
-        "LSTMs are sensitive to the scale of the input data, specifically when the sigmoid (default) or tanh activation functions are used. It can be a good practice to rescale the data to the range of 0-to-1, also called normalizing. We can easily normalize the dataset using the MinMaxScaler preprocessing class from the scikit-learn library"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "jZbPSRFZ1ryp"
-      },
-      "outputs": [],
-      "source": [
-        "# normalize the dataset\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "GUat4bYY1ryp"
-      },
-      "source": [
-        "# Create training and test sets\n",
-        "After we model our data and estimate the performance of our model on the training dataset, we need to get an idea of the accuracy of the model on new unseen data. For a normal classification or regression problem, we would do this using cross validation.\n",
-        "\n",
-        "With time series data, the sequence of values is important. A simple method that we can use is to split the ordered dataset into train and test datasets. Calculate the index of the split point and separate the first part of the data into the training datasets with 67% of the observations that we can use to train our model, leaving the remaining 33% for testing."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "FHn50t7l1ryq"
-      },
-      "outputs": [],
-      "source": [
-        "# split into train and test sets\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "TzJrt8321ryq"
-      },
-      "source": [
-        "Write a simple function to convert our single column of data into a two-column dataset: the first column containing this month's (t) passenger count and the second column containing next month's (t+1) passenger count, to be predicted.\n",
-        "\n",
-        "The function takes two arguments: the \"dataset\" and the \"look_back\", which is the number of previous time steps to use as input variables to predict the next time period. The function will then create a dataset where X is the number of passengers at a given time, t, and Y is the number of passengers at the next time. t + 1. Otherwise, expressed as Y(t) = X(t+1).\n",
-        "\n",
-        "PS: the syntax \"look_back=1\" means that the default argument value value of \"look_back\" is one. The function (algorithm) should still account for look_back value different than 1.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "g9SvM9YF1ryq"
-      },
-      "outputs": [],
-      "source": [
-        "# convert an array of values into a dataset matrix\n",
-        "def create_dataset(dataset, look_back=1):\n",
-        "    dataX, dataY = [], []\n",
-        "\n",
-        "         #take a look at the effect of this function on the first rows of the dataset \n",
-        "    return numpy.array(dataX), numpy.array(dataY)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "5qre5s5b1ryr"
-      },
-      "source": [
-        "Compare the first 5 rows to the original dataset sample listed in the previous section, can you see the X=t and Y=t+1 pattern? \n",
-        "Use the function to prepare the train and test datasets for our model."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Yt5cLUxR1ryr"
-      },
-      "outputs": [],
-      "source": [
-        "# reshape into X=t and Y=t+1\n",
-        "look_back = 1\n",
-        "trainX, trainY = \n",
-        "testX, testY = "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "Li-v8Ou01ryr"
-      },
-      "source": [
-        "The LSTM network expects the input data (X) to be provided with a specific array structure in the form of: [samples, time steps, features].\n",
-        "Currently, our data is in the form: [samples, features] and we are framing the problem as one time step for each sample. You can transform the prepared train and test input data into the expected structure using numpy.reshape() as follows:\n",
-        "        "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Z22S98RD1ryr"
-      },
-      "outputs": [],
-      "source": [
-        "# reshape input to be [samples, time steps, features]\n",
-        "trainX = \n",
-        "testX = "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "Qia44Bwj1rys"
-      },
-      "source": [
-        "# Create an LSTM network\n",
-        "The sequential network has a visible layer with 1 input, a hidden layer with 4 LSTM blocks or neurons, and an output layer that makes a single value prediction. The default sigmoid activation function can be used for the LSTM blocks. The network is trained for 100 epochs and a batch size of 1 is used. For the loss function the mean squared error is a reasonable choice and the adam optimizer can be used."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "CbXqjN9h1rys",
-        "outputId": "be409f6f-462d-4d35-afc7-5c87f534f858"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Epoch 1/100\n",
-            " - 0s - loss: 0.0410\n",
-            "Epoch 2/100\n",
-            " - 0s - loss: 0.0197\n",
-            "Epoch 3/100\n",
-            " - 0s - loss: 0.0141\n",
-            "Epoch 4/100\n",
-            " - 0s - loss: 0.0127\n",
-            "Epoch 5/100\n",
-            " - 0s - loss: 0.0117\n",
-            "Epoch 6/100\n",
-            " - 0s - loss: 0.0106\n",
-            "Epoch 7/100\n",
-            " - 0s - loss: 0.0096\n",
-            "Epoch 8/100\n",
-            " - 0s - loss: 0.0087\n",
-            "Epoch 9/100\n",
-            " - 0s - loss: 0.0076\n",
-            "Epoch 10/100\n",
-            " - 0s - loss: 0.0065\n",
-            "Epoch 11/100\n",
-            " - 0s - loss: 0.0057\n",
-            "Epoch 12/100\n",
-            " - 0s - loss: 0.0048\n",
-            "Epoch 13/100\n",
-            " - 0s - loss: 0.0041\n",
-            "Epoch 14/100\n",
-            " - 0s - loss: 0.0035\n",
-            "Epoch 15/100\n",
-            " - 0s - loss: 0.0030\n",
-            "Epoch 16/100\n",
-            " - 0s - loss: 0.0027\n",
-            "Epoch 17/100\n",
-            " - 0s - loss: 0.0025\n",
-            "Epoch 18/100\n",
-            " - 0s - loss: 0.0023\n",
-            "Epoch 19/100\n",
-            " - 0s - loss: 0.0022\n",
-            "Epoch 20/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 21/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 22/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 23/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 24/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 25/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 26/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 27/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 28/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 29/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 30/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 31/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 32/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 33/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 34/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 35/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 36/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 37/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 38/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 39/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 40/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 41/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 42/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 43/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 44/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 45/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 46/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 47/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 48/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 49/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 50/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 51/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 52/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 53/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 54/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 55/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 56/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 57/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 58/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 59/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 60/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 61/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 62/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 63/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 64/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 65/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 66/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 67/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 68/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 69/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 70/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 71/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 72/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 73/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 74/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 75/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 76/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 77/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 78/100\n",
-            " - 0s - loss: 0.0019\n",
-            "Epoch 79/100\n",
-            " - 0s - loss: 0.0022\n",
-            "Epoch 80/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 81/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 82/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 83/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 84/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 85/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 86/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 87/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 88/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 89/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 90/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 91/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 92/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 93/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 94/100\n",
-            " - 0s - loss: 0.0021\n",
-            "Epoch 95/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 96/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 97/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 98/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 99/100\n",
-            " - 0s - loss: 0.0020\n",
-            "Epoch 100/100\n",
-            " - 0s - loss: 0.0020\n"
-          ]
-        },
-        {
-          "data": {
-            "text/plain": [
-              "<keras.callbacks.callbacks.History at 0x2576945aa88>"
-            ]
-          },
-          "execution_count": 8,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "# create and fit the LSTM network\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "ze34NlHE1rys"
-      },
-      "source": [
-        "Once the model is fit, we can estimate the performance of the model on the train and test datasets. "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "GbFY2Hi71ryt"
-      },
-      "source": [
-        "# Make predictions\n",
-        "Note that you must invert the scale of predictions before calculating error scores to ensure that performance is reported in the same units as the original data (thousands of passengers per month)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "_N8JHPHF1ryt"
-      },
-      "outputs": [],
-      "source": [
-        "# make predictions\n",
-        "trainPredict = \n",
-        "testPredict = \n",
-        "# invert/rescale predictions\n",
-        "trainPredict = \n",
-        "trainY = \n",
-        "testPredict = \n",
-        "testY = "
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "PnJUobMi1ryt"
-      },
-      "source": [
-        "# Evaluate performance\n",
-        "\n",
-        "Use the root mean squared error to measure the performance in the training and test datasets."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Uw71vVXv1ryt",
-        "outputId": "a5716f57-f2ca-4760-ad60-25ce92f26db4"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Score: 22.93 RMSE\n",
-            "Test Score: 47.60 RMSE\n"
-          ]
-        }
-      ],
-      "source": [
-        "# calculate root mean squared error\n",
-        "trainScore = \n",
-        "print('Train Score: %.2f RMSE' % (trainScore))\n",
-        "testScore = \n",
-        "print('Test Score: %.2f RMSE' % (testScore))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "dtcVPKOg1ryt"
-      },
-      "source": [
-        "Finally, generate predictions using the model for both the train and test dataset to get a visual indication of the performance of the model.\n",
-        "Because of how the dataset was prepared, you must shift the predictions so that they align on the x-axis with the original dataset. "
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "vd3Go0TI1ryu"
-      },
-      "outputs": [],
-      "source": [
-        "# shift train predictions for plotting\n",
-        "trainPredictPlot = numpy.empty_like(dataset)\n",
-        "trainPredictPlot[:, :] = numpy.nan\n",
-        "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
-        "# shift test predictions for plotting\n",
-        "testPredictPlot = numpy.empty_like(dataset)\n",
-        "testPredictPlot[:, :] = numpy.nan\n",
-        "testPredictPlot[len(trainPredict)+(look_back*2):len(dataset), :] = testPredict"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "mRWio1o-1ryu"
-      },
-      "source": [
-        "# Plot  the training and test results per month\n",
-        "Once prepared, the data is plotted, showing the original dataset in blue, the predictions for the training dataset in green, and the predictions on the unseen test dataset in red."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "QgFW6UwS1ryu",
-        "outputId": "bf52c590-cf87-479c-c7a0-ed237b7c9dc9"
-      },
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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\n",
-            "text/plain": [
-              "<Figure size 432x288 with 1 Axes>"
-            ]
-          },
-          "metadata": {
-            "needs_background": "light"
-          },
-          "output_type": "display_data"
-        }
-      ],
-      "source": [
-        "# plot baseline and predictions\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "Now test the performance for different values of look_back"
-      ],
-      "metadata": {
-        "id": "9LNZSck-9rLj"
-      }
-    }
-  ],
-  "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.9"
-    },
-    "colab": {
-      "provenance": [],
-      "collapsed_sections": []
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}
\ No newline at end of file
-%% Cell type:markdown id: tags:
-
-This is a problem where, given a year and a month, the task is to predict the number of international airline passengers in units of 1,000. The data ranges from January 1949 to December 1960, or 12 years, with 144 monthly observations.
-We can phrase the problem as: given the number of passengers (in units of thousands) this month, what is the number of passengers next month?
-
-%% Cell type:markdown id: tags:
-
-# Import Libraries
-
-%% Cell type:code id: tags:
-
-``` python
-import numpy
-import pandas
-import matplotlib.pyplot as plt
-from pandas import read_csv
-import math
-from keras.models import Sequential
-from keras.layers import Dense
-from keras.layers import LSTM
-from sklearn.preprocessing import MinMaxScaler
-from sklearn.metrics import mean_squared_error
-
-# fixed random seed for reproducibility
-numpy.random.seed(7)
-```
-
-%% Output
-
-    Using TensorFlow backend.
-
-%% Cell type:markdown id: tags:
-
-We can load this dataset easily using the Pandas library. We are not interested in the date, given that each observation is separated by the same interval of one month. Therefore, when we load the dataset we can exclude the first column.
-
-Extract the NumPy array from the dataframe and convert the integer values to floating point values, which are more suitable for modeling with a neural network. Load and plot the dataset below.
-
-%% Cell type:markdown id: tags:
-
-# Load and plot dataset
-
-%% Cell type:code id: tags:
-
-``` python
-# load the dataset
-dataframe = pandas.read_csv('airline-passengers.csv', usecols=[1], engine='python')
-dataset = dataframe.values
-dataset = dataset.astype('float32')
-```
-
-%% Output
-
-
-
-    [[112.]
-     [118.]
-     [132.]
-     [129.]]
-
-%% Cell type:markdown id: tags:
-
-# Normalize the dataset
-LSTMs are sensitive to the scale of the input data, specifically when the sigmoid (default) or tanh activation functions are used. It can be a good practice to rescale the data to the range of 0-to-1, also called normalizing. We can easily normalize the dataset using the MinMaxScaler preprocessing class from the scikit-learn library
-
-%% Cell type:code id: tags:
-
-``` python
-# normalize the dataset
-```
-
-%% Cell type:markdown id: tags:
-
-# Create training and test sets
-After we model our data and estimate the performance of our model on the training dataset, we need to get an idea of the accuracy of the model on new unseen data. For a normal classification or regression problem, we would do this using cross validation.
-
-With time series data, the sequence of values is important. A simple method that we can use is to split the ordered dataset into train and test datasets. Calculate the index of the split point and separate the first part of the data into the training datasets with 67% of the observations that we can use to train our model, leaving the remaining 33% for testing.
-
-%% Cell type:code id: tags:
-
-``` python
-# split into train and test sets
-
-```
-
-%% Cell type:markdown id: tags:
-
-Write a simple function to convert our single column of data into a two-column dataset: the first column containing this month's (t) passenger count and the second column containing next month's (t+1) passenger count, to be predicted.
-
-The function takes two arguments: the "dataset" and the "look_back", which is the number of previous time steps to use as input variables to predict the next time period. The function will then create a dataset where X is the number of passengers at a given time, t, and Y is the number of passengers at the next time. t + 1. Otherwise, expressed as Y(t) = X(t+1).
-
-PS: the syntax "look_back=1" means that the default argument value value of "look_back" is one. The function (algorithm) should still account for look_back value different than 1.
-
-%% Cell type:code id: tags:
-
-``` python
-# convert an array of values into a dataset matrix
-def create_dataset(dataset, look_back=1):
-    dataX, dataY = [], []
-
-         #take a look at the effect of this function on the first rows of the dataset
-    return numpy.array(dataX), numpy.array(dataY)
-```
-
-%% Cell type:markdown id: tags:
-
-Compare the first 5 rows to the original dataset sample listed in the previous section, can you see the X=t and Y=t+1 pattern?
-Use the function to prepare the train and test datasets for our model.
-
-%% Cell type:code id: tags:
-
-``` python
-# reshape into X=t and Y=t+1
-look_back = 1
-trainX, trainY =
-testX, testY =
-```
-
-%% Cell type:markdown id: tags:
-
-The LSTM network expects the input data (X) to be provided with a specific array structure in the form of: [samples, time steps, features].
-Currently, our data is in the form: [samples, features] and we are framing the problem as one time step for each sample. You can transform the prepared train and test input data into the expected structure using numpy.reshape() as follows:
-
-
-%% Cell type:code id: tags:
-
-``` python
-# reshape input to be [samples, time steps, features]
-trainX =
-testX =
-```
-
-%% Cell type:markdown id: tags:
-
-# Create an LSTM network
-The sequential network has a visible layer with 1 input, a hidden layer with 4 LSTM blocks or neurons, and an output layer that makes a single value prediction. The default sigmoid activation function can be used for the LSTM blocks. The network is trained for 100 epochs and a batch size of 1 is used. For the loss function the mean squared error is a reasonable choice and the adam optimizer can be used.
-
-%% Cell type:code id: tags:
-
-``` python
-# create and fit the LSTM network
-```
-
-%% Output
-
-    Epoch 1/100
-     - 0s - loss: 0.0410
-    Epoch 2/100
-     - 0s - loss: 0.0197
-    Epoch 3/100
-     - 0s - loss: 0.0141
-    Epoch 4/100
-     - 0s - loss: 0.0127
-    Epoch 5/100
-     - 0s - loss: 0.0117
-    Epoch 6/100
-     - 0s - loss: 0.0106
-    Epoch 7/100
-     - 0s - loss: 0.0096
-    Epoch 8/100
-     - 0s - loss: 0.0087
-    Epoch 9/100
-     - 0s - loss: 0.0076
-    Epoch 10/100
-     - 0s - loss: 0.0065
-    Epoch 11/100
-     - 0s - loss: 0.0057
-    Epoch 12/100
-     - 0s - loss: 0.0048
-    Epoch 13/100
-     - 0s - loss: 0.0041
-    Epoch 14/100
-     - 0s - loss: 0.0035
-    Epoch 15/100
-     - 0s - loss: 0.0030
-    Epoch 16/100
-     - 0s - loss: 0.0027
-    Epoch 17/100
-     - 0s - loss: 0.0025
-    Epoch 18/100
-     - 0s - loss: 0.0023
-    Epoch 19/100
-     - 0s - loss: 0.0022
-    Epoch 20/100
-     - 0s - loss: 0.0021
-    Epoch 21/100
-     - 0s - loss: 0.0021
-    Epoch 22/100
-     - 0s - loss: 0.0021
-    Epoch 23/100
-     - 0s - loss: 0.0021
-    Epoch 24/100
-     - 0s - loss: 0.0020
-    Epoch 25/100
-     - 0s - loss: 0.0020
-    Epoch 26/100
-     - 0s - loss: 0.0021
-    Epoch 27/100
-     - 0s - loss: 0.0020
-    Epoch 28/100
-     - 0s - loss: 0.0020
-    Epoch 29/100
-     - 0s - loss: 0.0020
-    Epoch 30/100
-     - 0s - loss: 0.0021
-    Epoch 31/100
-     - 0s - loss: 0.0020
-    Epoch 32/100
-     - 0s - loss: 0.0020
-    Epoch 33/100
-     - 0s - loss: 0.0021
-    Epoch 34/100
-     - 0s - loss: 0.0021
-    Epoch 35/100
-     - 0s - loss: 0.0021
-    Epoch 36/100
-     - 0s - loss: 0.0020
-    Epoch 37/100
-     - 0s - loss: 0.0021
-    Epoch 38/100
-     - 0s - loss: 0.0020
-    Epoch 39/100
-     - 0s - loss: 0.0021
-    Epoch 40/100
-     - 0s - loss: 0.0020
-    Epoch 41/100
-     - 0s - loss: 0.0020
-    Epoch 42/100
-     - 0s - loss: 0.0020
-    Epoch 43/100
-     - 0s - loss: 0.0021
-    Epoch 44/100
-     - 0s - loss: 0.0020
-    Epoch 45/100
-     - 0s - loss: 0.0021
-    Epoch 46/100
-     - 0s - loss: 0.0020
-    Epoch 47/100
-     - 0s - loss: 0.0020
-    Epoch 48/100
-     - 0s - loss: 0.0020
-    Epoch 49/100
-     - 0s - loss: 0.0020
-    Epoch 50/100
-     - 0s - loss: 0.0020
-    Epoch 51/100
-     - 0s - loss: 0.0020
-    Epoch 52/100
-     - 0s - loss: 0.0020
-    Epoch 53/100
-     - 0s - loss: 0.0020
-    Epoch 54/100
-     - 0s - loss: 0.0020
-    Epoch 55/100
-     - 0s - loss: 0.0021
-    Epoch 56/100
-     - 0s - loss: 0.0020
-    Epoch 57/100
-     - 0s - loss: 0.0020
-    Epoch 58/100
-     - 0s - loss: 0.0020
-    Epoch 59/100
-     - 0s - loss: 0.0020
-    Epoch 60/100
-     - 0s - loss: 0.0020
-    Epoch 61/100
-     - 0s - loss: 0.0021
-    Epoch 62/100
-     - 0s - loss: 0.0020
-    Epoch 63/100
-     - 0s - loss: 0.0020
-    Epoch 64/100
-     - 0s - loss: 0.0020
-    Epoch 65/100
-     - 0s - loss: 0.0020
-    Epoch 66/100
-     - 0s - loss: 0.0020
-    Epoch 67/100
-     - 0s - loss: 0.0020
-    Epoch 68/100
-     - 0s - loss: 0.0021
-    Epoch 69/100
-     - 0s - loss: 0.0020
-    Epoch 70/100
-     - 0s - loss: 0.0021
-    Epoch 71/100
-     - 0s - loss: 0.0020
-    Epoch 72/100
-     - 0s - loss: 0.0020
-    Epoch 73/100
-     - 0s - loss: 0.0020
-    Epoch 74/100
-     - 0s - loss: 0.0021
-    Epoch 75/100
-     - 0s - loss: 0.0021
-    Epoch 76/100
-     - 0s - loss: 0.0020
-    Epoch 77/100
-     - 0s - loss: 0.0021
-    Epoch 78/100
-     - 0s - loss: 0.0019
-    Epoch 79/100
-     - 0s - loss: 0.0022
-    Epoch 80/100
-     - 0s - loss: 0.0020
-    Epoch 81/100
-     - 0s - loss: 0.0020
-    Epoch 82/100
-     - 0s - loss: 0.0020
-    Epoch 83/100
-     - 0s - loss: 0.0020
-    Epoch 84/100
-     - 0s - loss: 0.0020
-    Epoch 85/100
-     - 0s - loss: 0.0021
-    Epoch 86/100
-     - 0s - loss: 0.0021
-    Epoch 87/100
-     - 0s - loss: 0.0020
-    Epoch 88/100
-     - 0s - loss: 0.0020
-    Epoch 89/100
-     - 0s - loss: 0.0020
-    Epoch 90/100
-     - 0s - loss: 0.0020
-    Epoch 91/100
-     - 0s - loss: 0.0020
-    Epoch 92/100
-     - 0s - loss: 0.0020
-    Epoch 93/100
-     - 0s - loss: 0.0021
-    Epoch 94/100
-     - 0s - loss: 0.0021
-    Epoch 95/100
-     - 0s - loss: 0.0020
-    Epoch 96/100
-     - 0s - loss: 0.0020
-    Epoch 97/100
-     - 0s - loss: 0.0020
-    Epoch 98/100
-     - 0s - loss: 0.0020
-    Epoch 99/100
-     - 0s - loss: 0.0020
-    Epoch 100/100
-     - 0s - loss: 0.0020
-
-    <keras.callbacks.callbacks.History at 0x2576945aa88>
-
-%% Cell type:markdown id: tags:
-
-Once the model is fit, we can estimate the performance of the model on the train and test datasets.
-
-%% Cell type:markdown id: tags:
-
-# Make predictions
-Note that you must invert the scale of predictions before calculating error scores to ensure that performance is reported in the same units as the original data (thousands of passengers per month).
-
-%% Cell type:code id: tags:
-
-``` python
-# make predictions
-trainPredict =
-testPredict =
-# invert/rescale predictions
-trainPredict =
-trainY =
-testPredict =
-testY =
-```
-
-%% Cell type:markdown id: tags:
-
-# Evaluate performance
-
-Use the root mean squared error to measure the performance in the training and test datasets.
-
-%% Cell type:code id: tags:
-
-``` python
-# calculate root mean squared error
-trainScore =
-print('Train Score: %.2f RMSE' % (trainScore))
-testScore =
-print('Test Score: %.2f RMSE' % (testScore))
-```
-
-%% Output
-
-    Train Score: 22.93 RMSE
-    Test Score: 47.60 RMSE
-
-%% Cell type:markdown id: tags:
-
-Finally, generate predictions using the model for both the train and test dataset to get a visual indication of the performance of the model.
-Because of how the dataset was prepared, you must shift the predictions so that they align on the x-axis with the original dataset.
-
-%% Cell type:code id: tags:
-
-``` python
-# shift train predictions for plotting
-trainPredictPlot = numpy.empty_like(dataset)
-trainPredictPlot[:, :] = numpy.nan
-trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict
-# shift test predictions for plotting
-testPredictPlot = numpy.empty_like(dataset)
-testPredictPlot[:, :] = numpy.nan
-testPredictPlot[len(trainPredict)+(look_back*2):len(dataset), :] = testPredict
-```
-
-%% Cell type:markdown id: tags:
-
-# Plot  the training and test results per month
-Once prepared, the data is plotted, showing the original dataset in blue, the predictions for the training dataset in green, and the predictions on the unseen test dataset in red.
-
-%% Cell type:code id: tags:
-
-``` python
-# plot baseline and predictions
-```
-
-%% Output
-
-
-
-%% Cell type:markdown id: tags:
-
-Now test the performance for different values of look_back
--- a/airline-passengers.csv
+++ b/airline-passengers.csv
-"Month","Passengers"
-"1949-01",112
-"1949-02",118
-"1949-03",132
-"1949-04",129
-"1949-05",121
-"1949-06",135
-"1949-07",148
-"1949-08",148
-"1949-09",136
-"1949-10",119
-"1949-11",104
-"1949-12",118
-"1950-01",115
-"1950-02",126
-"1950-03",141
-"1950-04",135
-"1950-05",125
-"1950-06",149
-"1950-07",170
-"1950-08",170
-"1950-09",158
-"1950-10",133
-"1950-11",114
-"1950-12",140
-"1951-01",145
-"1951-02",150
-"1951-03",178
-"1951-04",163
-"1951-05",172
-"1951-06",178
-"1951-07",199
-"1951-08",199
-"1951-09",184
-"1951-10",162
-"1951-11",146
-"1951-12",166
-"1952-01",171
-"1952-02",180
-"1952-03",193
-"1952-04",181
-"1952-05",183
-"1952-06",218
-"1952-07",230
-"1952-08",242
-"1952-09",209
-"1952-10",191
-"1952-11",172
-"1952-12",194
-"1953-01",196
-"1953-02",196
-"1953-03",236
-"1953-04",235
-"1953-05",229
-"1953-06",243
-"1953-07",264
-"1953-08",272
-"1953-09",237
-"1953-10",211
-"1953-11",180
-"1953-12",201
-"1954-01",204
-"1954-02",188
-"1954-03",235
-"1954-04",227
-"1954-05",234
-"1954-06",264
-"1954-07",302
-"1954-08",293
-"1954-09",259
-"1954-10",229
-"1954-11",203
-"1954-12",229
-"1955-01",242
-"1955-02",233
-"1955-03",267
-"1955-04",269
-"1955-05",270
-"1955-06",315
-"1955-07",364
-"1955-08",347
-"1955-09",312
-"1955-10",274
-"1955-11",237
-"1955-12",278
-"1956-01",284
-"1956-02",277
-"1956-03",317
-"1956-04",313
-"1956-05",318
-"1956-06",374
-"1956-07",413
-"1956-08",405
-"1956-09",355
-"1956-10",306
-"1956-11",271
-"1956-12",306
-"1957-01",315
-"1957-02",301
-"1957-03",356
-"1957-04",348
-"1957-05",355
-"1957-06",422
-"1957-07",465
-"1957-08",467
-"1957-09",404
-"1957-10",347
-"1957-11",305
-"1957-12",336
-"1958-01",340
-"1958-02",318
-"1958-03",362
-"1958-04",348
-"1958-05",363
-"1958-06",435
-"1958-07",491
-"1958-08",505
-"1958-09",404
-"1958-10",359
-"1958-11",310
-"1958-12",337
-"1959-01",360
-"1959-02",342
-"1959-03",406
-"1959-04",396
-"1959-05",420
-"1959-06",472
-"1959-07",548
-"1959-08",559
-"1959-09",463
-"1959-10",407
-"1959-11",362
-"1959-12",405
-"1960-01",417
-"1960-02",391
-"1960-03",419
-"1960-04",461
-"1960-05",472
-"1960-06",535
-"1960-07",622
-"1960-08",606
-"1960-09",508
-"1960-10",461
-"1960-11",390
-"1960-12",432