{ "cells": [ { "cell_type": "markdown", "id": "2008dbe7-d283-4355-99d5-a56df86adb35", "metadata": {}, "source": [ "# Hyeyoung Sim: Clustering Electric Vehicle Charging Pattern with DTW and EV Charging energy demand Prediction with LSTM\n", "[Presentation](http://spatial-ecology.net/docs/source/STUDENTSPROJECTS/Proj_2022_Matera/Clustering_Electric_Vehicle_Charging_Pattern_with_DTW_and_EV_Charging_energy_demand_Prediction_with_LSTM_Hyeyoung_Sim.pdf) \n", "[Video recording](https://youtu.be/-PGvRM6hVtM)" ] }, { "cell_type": "code", "execution_count": 246, "id": "7960f670", "metadata": {}, "outputs": [], "source": [ "# !pip install dtw-python\n", "# !pip install numpy\n", "# !pip install pandas\n", "# !pip install time\n", "# !pip install datetime\n", "# !pip install openpyxl\n", "# !pip install tensorflow\n", "# !pip install seaborn\n", "# !pip install sklearn\n", "# !pip install keras\n", "# !pip install shap" ] }, { "cell_type": "code", "execution_count": 1, "id": "250514d0-79df-4fe8-b447-49575355ba92", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Importing the dtw module. When using in academic works please cite:\n", " T. Giorgino. Computing and Visualizing Dynamic Time Warping Alignments in R: The dtw Package.\n", " J. Stat. Soft., doi:10.18637/jss.v031.i07.\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-06-17 03:50:12.753342: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", "2022-06-17 03:50:12.753381: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n" ] } ], "source": [ "import time\n", "from datetime import datetime\n", "import numpy as np\n", "import dtw\n", "import pandas as pd\n", "import os\n", "\n", "import matplotlib.pyplot as plt\n", "import tensorflow as tf\n", "import seaborn as sns\n", "from sklearn.metrics import r2_score\n", "from sklearn.metrics import mean_absolute_error , mean_squared_error\n", "from sklearn.preprocessing import MinMaxScaler\n", "from sklearn.preprocessing import LabelEncoder\n", "from keras.callbacks import EarlyStopping\n", "from keras.models import load_model\n", "from keras.callbacks import ModelCheckpoint\n", "\n", "from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization\n", "from tensorflow.keras.models import Sequential" ] }, { "cell_type": "code", "execution_count": 2, "id": "020d726a-8258-4e0b-8d8b-ec300e922550", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/media/sf_LVM_shared/tmpp\n" ] } ], "source": [ "print(os.getcwd())" ] }, { "cell_type": "code", "execution_count": 3, "id": "db08cffd-e455-4f0e-a75b-2fbd30b966e0", "metadata": { "jupyter": { "source_hidden": true }, "tags": [] }, "outputs": [], "source": [ "# print(os.path.realpath('21_keco.xlsx'))\n", "# base_dir = '/media/sf_LVM_shared/tmpp'\n", "# excel_file = '21_keco.xlsx'\n", "# excel_dir = os.path.join(base_dir, excel_file)\n", "\n", "# a = pd.read_excel(excel_dir, sheet_name = '21_1')\n", "# a2 = pd.read_excel(excel_dir, sheet_name = '21_2')\n", "# a3 = pd.read_excel(excel_dir, sheet_name = '21_3')\n", "# a4 = pd.read_excel(excel_dir, sheet_name = '21_4')\n", "# a5 = pd.read_excel(excel_dir, sheet_name = '21_5')\n", "# a6 = pd.read_excel(excel_dir, sheet_name = '21_6')\n", "# a7 = pd.read_excel(excel_dir, sheet_name = '21_7')\n", "# a8 = pd.read_excel(excel_dir, sheet_name = '21_8')\n", "# a9 = pd.read_excel(excel_dir, sheet_name = '21_9')\n", "# a10 = pd.read_excel(excel_dir, sheet_name = '21_10')\n", "# a11 = pd.read_excel(excel_dir, sheet_name = '21_11')\n", "# a12 = pd.read_excel(excel_dir, sheet_name = '21_12')" ] }, { "cell_type": "code", "execution_count": 4, "id": "214c99c6-d84d-48aa-9923-6135c8fa3d41", "metadata": {}, "outputs": [], "source": [ "a1 = pd.read_table('/media/sf_LVM_shared/tmpp/18_keco.txt' , sep = \"/\")\n", "a2 = pd.read_table('/media/sf_LVM_shared/tmpp/19_keco.txt' , sep = \"/\")\n", "a3 = pd.read_table('/media/sf_LVM_shared/tmpp/20_keco.txt' , sep = \"/\")\n", "a4 = pd.read_table('/media/sf_LVM_shared/tmpp/21_keco.txt' , sep = \":\")\n", "a5 = pd.read_table('/media/sf_LVM_shared/tmpp/22_keco.txt' , sep = \"/\")" ] }, { "cell_type": "code", "execution_count": 5, "id": "14ed9f89-1a9d-4732-a559-8b2df4ea030b", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true, "source_hidden": true }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['dc', 'CNM', 'add', 'Max.vol', 'acvol', 'diffhour', 'starttm', 'endtm'], dtype='object')\n", "Index(['dc', 'CNM', 'add', 'Max.vol', 'acvol', 'diffhour', 'starttm', 'endtm'], dtype='object')\n", "Index(['dc', 'CNM', 'add', 'Max.vol', 'acvol', 'diffhour', 'starttm', 'endtm'], dtype='object')\n", "Index(['type', 'dc', 'CNM', 'add', 'Max.vol', 'acvol', 'diffhour', 'diffmin',\n", " 'starttm', 'endtm'],\n", " dtype='object')\n", "Index(['type', 'dc', 'CNM', 'add', 'Max.vol', 'acvol', 'diffhour', 'diffmin',\n", " 'starttm', 'endtm'],\n", " dtype='object')\n" ] } ], "source": [ "print(a1.columns)\n", "print(a2.columns)\n", "print(a3.columns)\n", "print(a4.columns)\n", "print(a5.columns)" ] }, { "cell_type": "code", "execution_count": 6, "id": "73df4f01-94b3-43c4-ac56-35e32841ddd1", "metadata": {}, "outputs": [], "source": [ "a1 = a1[['CNM', 'add', 'Max.vol', 'acvol', 'starttm', 'endtm']]\n", "a2 = a2[['CNM', 'add', 'Max.vol', 'acvol', 'starttm', 'endtm']]\n", "a3 = a3[['CNM', 'add', 'Max.vol', 'acvol', 'starttm', 'endtm']]\n", "a4 = a4[['CNM', 'add', 'Max.vol', 'acvol', 'starttm', 'endtm']]\n", "a5 = a5[['CNM', 'add', 'Max.vol', 'acvol', 'starttm', 'endtm']]" ] }, { "cell_type": "code", "execution_count": 7, "id": "496c2356", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(855137, 6)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c = pd.concat([a1,a2,a3,a4,a5])\n", "c.shape" ] }, { "cell_type": "code", "execution_count": 8, "id": "5a7685d6-06ae-4fe9-b562-c1612f523c2a", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true, "source_hidden": true }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "CNM object\n", "add object\n", "Max.vol int64\n", "acvol float64\n", "starttm int64\n", "endtm int64\n", "dtype: object" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c.dtypes" ] }, { "cell_type": "code", "execution_count": 11, "id": "5191a817-f779-4b3e-84c9-6457f3baa899", "metadata": {}, "outputs": [], "source": [ "c['start'] = c['starttm'].astype(str)\n", "c['end'] = c['endtm'].astype(str)" ] }, { "cell_type": "code", "execution_count": 13, "id": "9b0cdc64-8d8f-4dc6-8b6d-6b3f44aa07e7", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2018-01-01 00:17:16+09:00\n", "2 2018-01-01 00:35:24+09:00\n", "3 2018-01-01 00:59:13+09:00\n", "4 2018-01-01 01:06:31+09:00\n", "5 2018-01-01 01:24:24+09:00\n", " ... \n", "125453 2022-03-30 16:22:47+09:00\n", "125454 2022-03-30 16:32:43+09:00\n", "125455 2022-03-30 16:38:09+09:00\n", "125456 2022-03-30 16:30:22+09:00\n", "125457 2022-03-30 16:27:55+09:00\n", "Name: start, Length: 855137, dtype: datetime64[ns, Asia/Seoul]\n" ] } ], "source": [ "c['start'] = pd.to_datetime(c['start'])\n", "c['start'] = c['start'].dt.tz_localize('Asia/Seoul')\n", "print(c['start'])" ] }, { "cell_type": "code", "execution_count": 14, "id": "312dc23c-e27d-4360-b5d6-7cae3b4c6f13", "metadata": {}, "outputs": [], "source": [ "c['endsec'] =c['end'].str.slice(12,14)" ] }, { "cell_type": "code", "execution_count": 15, "id": "b5c3b0a2-882b-40a1-bf7d-23fc602c0934", "metadata": {}, "outputs": [], "source": [ "c['endsec'] = pd.to_numeric(c['endsec'], errors = 'coerce')\n", "c = c[c.endsec <=59]" ] }, { "cell_type": "code", "execution_count": 16, "id": "ad68c489-9c6a-4715-a82d-d6bf803847b7", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2018-01-01 00:54:56+09:00\n", "2 2018-01-01 01:09:26+09:00\n", "3 2018-01-01 01:22:13+09:00\n", "4 2018-01-01 01:36:11+09:00\n", "5 2018-01-01 01:35:49+09:00\n", " ... \n", "125453 2022-03-30 16:42:32+09:00\n", "125454 2022-03-30 17:13:06+09:00\n", "125455 2022-03-30 17:13:47+09:00\n", "125456 2022-03-30 17:10:22+09:00\n", "125457 2022-03-30 17:07:55+09:00\n", "Name: end, Length: 851558, dtype: datetime64[ns, Asia/Seoul]\n" ] } ], "source": [ "c['endmin'] = c['end'].str.slice(10,12) #min <=59\n", "c['endmin'] = pd.to_numeric(c['endmin'], errors = 'coerce')\n", "c = c[c.endmin <=59]\n", "\n", "c['end'] = pd.to_datetime(c['end'])\n", "c['end'] = c['end'].dt.tz_localize('Asia/Seoul')\n", "print(c['end'])" ] }, { "cell_type": "code", "execution_count": 17, "id": "51c87f62-45d6-4bfe-a118-72acc246928f", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/user/SE_data/juplab_env/lib/python3.8/site-packages/pandas/core/arrays/datetimes.py:1162: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", " warnings.warn(\n" ] } ], "source": [ "c['date_time']= c.start.dt.to_period('H')" ] }, { "cell_type": "code", "execution_count": 18, "id": "4aebcea2-f3ca-41f2-ac5b-ba76cc05fe77", "metadata": {}, "outputs": [], "source": [ "c['SIG'] = c['add'].str.slice(6,9)" ] }, { "cell_type": "code", "execution_count": 19, "id": "10fa60c9-66c7-4e31-95d6-3e238dfaa30d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "200\n", "50\n" ] } ], "source": [ "# print(c.isnull().sum())\n", "print(c['Max.vol'].max())\n", "print(c['Max.vol'].min())" ] }, { "cell_type": "code", "execution_count": 20, "id": "a0aea93f-e230-4823-90cf-8c5d023b5ce1", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "1 0 days 00:37:40\n", "2 0 days 00:34:02\n", "3 0 days 00:23:00\n", "4 0 days 00:29:40\n", "5 0 days 00:11:25\n", "Name: diff, dtype: timedelta64[ns]" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from datetime import datetime\n", "c['diff'] = (c['end'] - c['start'])\n", "c['difhour'] = c['diff'].dt.seconds\n", "c['diff'].head()" ] }, { "cell_type": "code", "execution_count": 21, "id": "0771c171-bc86-4d26-a14d-a90e3cd55c1f", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "1 2260\n", "2 2042\n", "3 1380\n", "4 1780\n", "5 685\n", "Name: difhour, dtype: int64" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c['difhour'].head()" ] }, { "cell_type": "code", "execution_count": 22, "id": "7cbecf38-1f4a-4653-877f-21c543bf5254", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ "1 0.627778\n", "2 0.567222\n", "3 0.383333\n", "4 0.494444\n", "5 0.190278\n", "Name: difhour, dtype: float64" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c['difhour'] = c['difhour']/3600\n", "c['difhour'].head()" ] }, { "cell_type": "code", "execution_count": 23, "id": "62f21b6e-31d4-4591-81b3-4f3bf2b15a90", "metadata": {}, "outputs": [], "source": [ "c['log_date'] = c['start'].dt.date\n", "c['log_hour']=c['start'].dt.hour\n", "# # print(c['start'].strftime(\"%c\"))\n", "# print(c['log_date'])\n", "# print(c['log_hour'])\n", "# # c['date_time'] = " ] }, { "cell_type": "code", "execution_count": 24, "id": "76db180a-3b5a-4e5a-beed-bd3639a79d63", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "851558\n", "850664\n" ] } ], "source": [ "c['volh'] = c['acvol']/c['difhour']\n", "c['outlier'] = np.where( c['volh']<= c['Max.vol'], 'ok', 'no')\n", "c2 = c[c['outlier'] == 'ok']\n", "print(len(c))\n", "print(len(c2))" ] }, { "cell_type": "code", "execution_count": 25, "id": "9a8c6151-9d88-4ef0-8775-717fbba62013", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "827489\n", "23.988333333333333\n", "0.08333333333333333\n" ] } ], "source": [ "# min hour/ max hour\n", "c2 = c2[(c2['difhour'] >= 0.083333)&(c2['difhour'] <= 24) ] #5/60 = 0.08333\n", "print(len(c2))\n", "print(c2['difhour'].max())\n", "print(c2['difhour'].min())" ] }, { "cell_type": "code", "execution_count": 26, "id": "017e8a84-2e59-429b-aec0-b99887765fe1", "metadata": {}, "outputs": [], "source": [ "c2['year'] = c2['start'].dt.year\n", "c2['month'] = c2['start'].dt.month\n", "c2['day'] = c2['start'].dt.day" ] }, { "cell_type": "code", "execution_count": 27, "id": "b801599f-cf6f-4a4f-8afd-bbc8a7b9b1ef", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2.018010e+07\n", "2 2.018010e+07\n", "3 2.018010e+07\n", "4 2.018010e+07\n", "5 2.018010e+07\n", "Name: dateint, dtype: float64\n" ] } ], "source": [ "c2['dateint'] = c2['year']*10000 + c2['month']*100 + c2['day'] + c2['log_hour']/24\n", "print(c2.dateint.head())" ] }, { "cell_type": "code", "execution_count": 28, "id": "9815aa41-3601-4efe-8b12-c82d9b190f41", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Index(['CNM', 'add', 'Max.vol', 'acvol', 'starttm', 'endtm', 'start', 'end',\n", " 'endsec', 'endmin', 'date_time', 'SIG', 'diff', 'difhour', 'log_date',\n", " 'log_hour', 'volh', 'outlier', 'year', 'month', 'day', 'dateint'],\n", " dtype='object')" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c2.columns" ] }, { "cell_type": "code", "execution_count": 29, "id": "a0aa4b42-57f1-4d73-97f0-da4d9a085d4d", "metadata": {}, "outputs": [], "source": [ "df= c2.drop(['add','Max.vol', 'acvol', 'starttm', 'endtm', 'end', 'diff', 'outlier'], axis=1)" ] }, { "cell_type": "code", "execution_count": 30, "id": "12e42914-8a7e-44e0-abac-017859b6ac51", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "25\n", " CNM start endsec endmin date_time \\\n", "1 볏골공원 지하공영주차장 2018-01-01 00:17:16+09:00 56.0 54 2018-01-01 00:00 \n", "2 노보텔 2018-01-01 00:35:24+09:00 26.0 9 2018-01-01 00:00 \n", "3 종묘 공영주차장 2018-01-01 00:59:13+09:00 13.0 22 2018-01-01 00:00 \n", "4 현대블루핸즈 대치북부점 2018-01-01 01:06:31+09:00 11.0 36 2018-01-01 01:00 \n", "5 노보텔 2018-01-01 01:24:24+09:00 49.0 35 2018-01-01 01:00 \n", "\n", " SIG difhour log_date log_hour volh year month day \\\n", "1 강서구 0.627778 2018-01-01 0 37.529204 2018 1 1 \n", "2 강남구 0.567222 2018-01-01 0 26.515181 2018 1 1 \n", "3 종로구 0.383333 2018-01-01 0 36.652174 2018 1 1 \n", "4 강남구 0.494444 2018-01-01 1 41.420225 2018 1 1 \n", "5 강남구 0.190278 2018-01-01 1 36.367883 2018 1 1 \n", "\n", " dateint \n", "1 2.018010e+07 \n", "2 2.018010e+07 \n", "3 2.018010e+07 \n", "4 2.018010e+07 \n", "5 2.018010e+07 \n" ] } ], "source": [ "print(len(df['SIG'].unique()))\n", "print(df.head()) #FINAL DATA" ] }, { "cell_type": "code", "execution_count": 31, "id": "31bd3a8c-6686-417d-a571-8a37a8aca8f0", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true }, "tags": [] }, "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", "
SIGdate_timevolh
0강남구2018-01-01 00:0026.515181
1강남구2018-01-01 01:0032.737450
2강남구2018-01-01 02:0028.364020
3강남구2018-01-01 05:0030.652220
4강남구2018-01-01 06:0032.791086
\n", "
" ], "text/plain": [ " SIG date_time volh\n", "0 강남구 2018-01-01 00:00 26.515181\n", "1 강남구 2018-01-01 01:00 32.737450\n", "2 강남구 2018-01-01 02:00 28.364020\n", "3 강남구 2018-01-01 05:00 30.652220\n", "4 강남구 2018-01-01 06:00 32.791086" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# df = c2.groupby([\"SIG\", \"log_date\", \"log_hour\"])['volh'].mean().reset_index()\n", "df_datetime = df.groupby([\"SIG\", \"date_time\"])['volh'].mean().reset_index()\n", "df_datetime.head()" ] }, { "cell_type": "code", "execution_count": 32, "id": "2cbd2f70-6250-48c8-9830-740bb1305030", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "25718" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "##only for gn\n", "df_datetime_gn = df_datetime[(df_datetime['SIG'] == '강남구')]\n", "len(df_datetime_gn)" ] }, { "cell_type": "markdown", "id": "7e4516fc-1201-473c-8fba-5bfc107e0cb1", "metadata": {}, "source": [ "###Daily EV charging " ] }, { "cell_type": "code", "execution_count": 35, "id": "bf2790bd-9986-4e4d-ae56-16b582fb2d34", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(['강서구', '강남구', '종로구', '광진구', '서초구', '영등포', '구로구', '강동구', '마포구',\n", " '관악구', '송파구', '은평구', '성북구', '용산구', '동대문', '노원구', '서대문', '성동구',\n", " '중구 ', '중랑구', '양천구', '동작구', '강북구', '금천구', '도봉구'], dtype=object)" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.SIG.unique()" ] }, { "cell_type": "code", "execution_count": 36, "id": "41bbb7ac-46a6-4a30-b1cd-17053ee8ba4b", "metadata": {}, "outputs": [], "source": [ "df_logdate = df.groupby([\"SIG\", \"log_date\"])['volh'].mean().reset_index()\n", "df_logdate.head()\n", "##only for gn\n", "df_logdate_gn = df_logdate[(df_logdate['SIG'] == '강남구')]\n", "dataframe= df_logdate_gn.drop(['SIG', 'log_date'], axis=1)\n", "\n", "dataset = dataframe.values\n", "dataset = dataset.astype('float32')" ] }, { "cell_type": "code", "execution_count": 37, "id": "bd033ed5-91f5-483b-8795-ac4a65a57685", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# #plotting the data\n", "# plt.figure(figsize=(16,8))\n", "# plt.title('Close Price History')\n", "plt.plot(dataframe['volh'], color='red')\n", "plt.xlabel('Date', fontsize=18)\n", "plt.ylabel('EV Charging', fontsize = 18)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 38, "id": "c8739dea-6864-405d-b37b-dcbf829e4ec8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1551, 1)\n" ] } ], "source": [ "# normalize the dataset\n", "print(dataset.shape)\n", "scaler = MinMaxScaler(feature_range=(0, 1))\n", "dataset = scaler.fit_transform(dataset)" ] }, { "cell_type": "code", "execution_count": 39, "id": "d1ee7b40-258f-4d51-ac26-ab0015cfdc6a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "len(dataset): 1551\n", "1039 512\n" ] } ], "source": [ "# split into train and test sets\n", "print('len(dataset): ',len(dataset))\n", "train_size = int(len(dataset) * 0.67)\n", "test_size = len(dataset) - train_size\n", "train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]\n", "print(len(train), len(test))" ] }, { "cell_type": "code", "execution_count": 40, "id": "d3c49ed5-57eb-410c-b7d5-7361d556214a", "metadata": {}, "outputs": [], "source": [ "# convert an array of values into a dataset matrix\n", "def create_dataset(dataset, look_back=1):\n", " dataX, dataY = [], []\n", " for i in range(len(dataset)-look_back-1):\n", " a = dataset[i:(i+look_back), 0]\n", " dataX.append(a)\n", " dataY.append(dataset[i + look_back, 0])\n", " return np.array(dataX), np.array(dataY)" ] }, { "cell_type": "code", "execution_count": 41, "id": "9563484a-9fa9-45f8-ad3e-b4b8c889921e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1037, 1, 1)\n", "trainY.shape: (1037,)\n", "testX.shape: (510, 1, 1)\n", "trainX[:5]: [0.40584978 0.32951364 0.42946067 0.386174 0.4079348 ]\n", "trainY[:5]: [0.32951364 0.42946067 0.386174 0.4079348 0.40748814]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-06-17 03:53:21.742617: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n", "2022-06-17 03:53:21.742648: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n", "2022-06-17 03:53:21.742677: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (osgeolive): /proc/driver/nvidia/version does not exist\n", "2022-06-17 03:53:21.748407: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2\n", "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "keys: dict_keys(['loss', 'val_loss'])\n", "--- Elapsed time: 227.62951803207397 seconds ---\n" ] } ], "source": [ "## Let's train the LSTM using SGD as optimizer\n", "# reshape into X=t and Y=t+1\n", "look_back = 1\n", "trainX, trainY = create_dataset(train, look_back)\n", "testX, testY = create_dataset(test, look_back)\n", "\n", "# reshape input to be [samples, time steps, features]\n", "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n", "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('testX.shape: ',testX.shape)\n", "print('trainX[:5]: ', trainX[:5,:,:].flatten())\n", "print('trainY[:5]: ', trainY[:5])\n", "\n", "\n", "# create and fit the LSTM network\n", "if 'model' in globals():\n", " print('Deleting \"model\"')\n", " del model\n", "model = Sequential()\n", "model.add(LSTM(4, input_shape=(1, look_back))) # hidden layer with 4 LSTM blocks or neurons, with time_step=1 and features=1.\n", "model.add(Dense(1)) # output layer that makes a single value prediction\n", "\n", "start_time = time.time()\n", "# Compile the model\n", "model.compile(loss='mean_squared_error', optimizer=tf.optimizers.SGD(learning_rate=0.01))\n", "\n", "# Fit the model\n", "history = model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=0, validation_data=(testX, testY))\n", "# list all data in history\n", "print('keys: ',history.history.keys())\n", "print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))" ] }, { "cell_type": "code", "execution_count": 42, "id": "34a8117b-73fe-41ee-98e9-7f63fa110ed5", "metadata": {}, "outputs": [], "source": [ "# summarize history for loss\n", "def plot_hist(history):\n", " plt.plot(history.history['loss'])\n", " plt.plot(history.history['val_loss'])\n", " plt.title('model loss')\n", " plt.ylabel('loss')\n", " plt.xlabel('epoch')\n", " plt.legend(['train','val'], loc='upper left')\n", " plt.show()\n", "\n", "# make predictions\n", "def make_preds(trainX,trainY,testX,testY):\n", " trainPredict = model.predict(trainX)\n", " testPredict = model.predict(testX)\n", " # invert predictions\n", " trainPredict = scaler.inverse_transform(trainPredict)\n", " trainY = scaler.inverse_transform([trainY])\n", " testPredict = scaler.inverse_transform(testPredict)\n", " testY = scaler.inverse_transform([testY])\n", " # calculate root mean squared error\n", " trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n", " print('Train Score: %.2f RMSE' % (trainScore))\n", " print('Train R^2: ', r2_score(trainY[0], trainPredict[:,0]))\n", " testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n", " print('Test Score: %.2f RMSE' % (testScore))\n", " print('Test R^2: ', r2_score(testY[0], testPredict[:,0]))\n", "\n", " return trainPredict, testPredict\n", "\n", "# shift train predictions for plotting\n", "def plot_preds(trainPredict,testPredict):\n", " trainPredictPlot = np.empty_like(dataset)\n", " trainPredictPlot[:, :] = np.nan\n", " trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n", " # shift test predictions for plotting\n", " testPredictPlot = np.empty_like(dataset)\n", " testPredictPlot[:, :] = np.nan\n", " testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n", " # plot baseline and predictions\n", " plt.plot(scaler.inverse_transform(dataset))\n", " plt.plot(trainPredictPlot)\n", " plt.plot(testPredictPlot)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 43, "id": "8d79b900-7194-4324-b6ea-c25623225a18", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5LElEQVR4nO3dd5hU5fnw8e89s70Xlra7dJQuyoI9IkaDJWJiAUuixmj8RaOmvZqupmmaiYbEaDRRY0SDUYk19hIRWRSVIkoVkL6d7Tv3+8dzhl2WWZiFPbvLzP25rrnmzDnPOfOcLXPP00VVMcYYY9oL9HQGjDHG9E4WIIwxxkRkAcIYY0xEFiCMMcZEZAHCGGNMRBYgjDHGRGQBwpgDJCJ/F5GfRZl2rYh89kCvY0x3sABhjDEmIgsQxhhjIrIAYeKCV7XzXRF5X0R2isg9ItJPRJ4RkWoReUFEctukP1NElopIhYi8IiKj2xw7XETe8c57GEhp915niMhi79w3RWTCfub5chFZKSJlIjJPRAZ6+0VEbhORrSJSJSIfiMg479hpIrLMy9tGEfnOfv3AjMEChIkvZwMnA4cAnweeAb4PFOD+F64BEJFDgIeA67xjTwP/EZEkEUkCHgceAPKAf3nXxTv3cOBe4GtAPvAXYJ6IJHcmoyIyDfglcB4wAFgHzPEOnwJ8xruPbC/NDu/YPcDXVDUTGAe81Jn3NaYtCxAmntyhqltUdSPwOrBAVd9V1XrgMeBwL91M4ClVfV5Vm4DfAKnAMcBRQCLwe1VtUtW5wMI273EF8BdVXaCqLap6H9DgndcZFwL3quo7qtoAfA84WkSGAE1AJjAKEFVdrqqbvPOagDEikqWq5ar6Tiff15hdLECYeLKlzXZdhNcZ3vZA3Dd2AFQ1BKwHCr1jG3X3WS7XtdkeDHzbq16qEJEKoNg7rzPa56EGV0ooVNWXgD8Cs4GtInKXiGR5Sc8GTgPWicirInJ0J9/XmF0sQBizp09xH/SAq/PHfchvBDYBhd6+sEFtttcDP1fVnDaPNFV96ADzkI6rstoIoKq3q+okYAyuqum73v6FqjoD6IurCnukk+9rzC4WIIzZ0yPA6SJykogkAt/GVRO9CcwHmoFrRCRRRL4ITGlz7t3AlSJypNeYnC4ip4tIZifz8BBwqYhM9NovfoGrElsrIpO96ycCO4F6IOS1kVwoItle1VgVEDqAn4OJcxYgjGlHVVcAFwF3ANtxDdqfV9VGVW0EvghcApTh2iv+3ebcUuByXBVQObDSS9vZPLwA/Ah4FFdqGQ7M8g5n4QJROa4aagfwa+/Yl4C1IlIFXIlryzBmv4gtGGSMMSYSK0EYY4yJyAKEMcaYiHwNECIyXURWeKNBb4hwPFlEHvaOL/D6eOM1tC1u8wiJyEQ/82qMMWZ3vrVBiEgQ+Ag3cnUDbjDR+aq6rE2arwMTVPVKEZkFfEFVZ7a7znjgcVUd7ktGjTHGRJTg47WnACtVdTWAiMwBZgDL2qSZAdzobc8F/igi0m4Q0vm0TjHQoT59+uiQIUO6INvGGBM/Fi1atF1VCyId8zNAFOIGDYVtAI7sKI2qNotIJW4w0PY2aWbiAskeROQK3NQGDBo0iNLS0q7JuTHGxAkRWdfRsV7dSC0iRwK1qrok0nFVvUtVS1S1pKAgYgA0xhizn/wMEBtx0xOEFXn7IqYRkQTczJQ72hyfhRtRaowxppv5GSAWAiNFZKg3RfIsYF67NPOAi73tc4CXwu0PIhLATWO8z/YHY4wxXc+3NgivTeFq4DkgiJu6eKmI3AyUquo83Nz1D4jISty0BbPaXOIzwPpwI/f+aGpqYsOGDdTX1+//jRwkUlJSKCoqIjExsaezYoyJETEz1UZJSYm2b6Res2YNmZmZ5Ofns/vkm7FFVdmxYwfV1dUMHTq0p7NjjDmIiMgiVS2JdKxXN1IfqPr6+pgPDgAiQn5+flyUlIwx3SemAwQQ88EhLF7u0xjTfWI+QOxTcyNUfeqejTHG7GIBQlugZgs0Vvty+YqKCv70pz91+rzTTjuNioqKrs+QMcZEyQJEQgpIEBp3+nL5jgJEc3PzXs97+umnycnJ8SVPxhgTDT+n2jg4iEBSOjTU+HL5G264gVWrVjFx4kQSExNJSUkhNzeXDz/8kI8++oizzjqL9evXU19fz7XXXssVV1wBwJAhQygtLaWmpoZTTz2V4447jjfffJPCwkKeeOIJUlNTfcmvMcaExU2AuOk/S1n2aVXkgy2N7pFUAUTf2DtmYBY/+fzYvaa55ZZbWLJkCYsXL+aVV17h9NNPZ8mSJbu6o957773k5eVRV1fH5MmTOfvss8nPz9/tGh9//DEPPfQQd999N+eddx6PPvooF110UdT5NMaY/WFVTACBoHsOtfj+VlOmTNltrMLtt9/OYYcdxlFHHcX69ev5+OOP9zhn6NChTJw4EYBJkyaxdu1a3/NpjDFxU4LY6zd9DcGmDyA9H7KLfM1Henr6ru1XXnmFF154gfnz55OWlsbUqVMjjmVITk7etR0MBqmrq/M1j8YYA1aCcCQASWnQ2PXtEJmZmVRXR+4hVVlZSW5uLmlpaXz44Ye89dZbXf7+xhizv+KmBLFPSRlQs9lVM4WrnDpSW+aCSmrOPi+bn5/Psccey7hx40hNTaVfv367jk2fPp0777yT0aNHc+ihh3LUUUcd4E0YY0zXiem5mJYvX87o0aOju0B9FZStgrzhkJLVcbpQCLYscb2f+o11gaKX6NT9GmMMcTwXU6ckeW0D+6pmaqhyg+tCzS6oGGNMjLIAERYIQmLavgfM1VW4gXWBRKjdsfe0xhhzELMA0VZSugsQGop8PNQCDZWu7SEtz5UmWmwOJ2NMbLIA0VZSBqDQWBv5eEOVCx6puZDmDWarLeu27BljTHeyANHWrnaIDqqZ6iogkOACSUKye67dATHS0G+MMW1ZgGgrmAjB5MgN1aEW1yidkuN6MIErRbQ0+jJ+whhjepoFiPaSM7x2iHalgvpKwKteCkvJcQ3WO7uusTojI6PLrmWMMQfCAkR7SemuG2tzuykv6ipcz6Wk1qkyCAQgLRfqK1y3V2OMiSE2krq9JO8bfGMNJHpTaoeaXQN1ep/W6qWw1HzYuR1qyyGjYI/L3XDDDRQXF3PVVVcBcOONN5KQkMDLL79MeXk5TU1N/OxnP2PGjBl+3pUxxnRa/ASIZ26AzR9EkdDrxRQIusWEAEJNrkSRmOaqlML6j4dTb3GBpHZHxAAyc+ZMrrvuul0B4pFHHuG5557jmmuuISsri+3bt3PUUUdx5pln2rrSxpheJX4CRNTEVR2FWgB1r0PNbkqNjqbVSMuHyg3QVOcm/Wvj8MMPZ+vWrXz66ads27aN3Nxc+vfvzze/+U1ee+01AoEAGzduZMuWLfTv39/3uzPGmGjFT4A49Zbo0+7c5j7w+45xJYYtSyC9ALILI6dPzYXKT10pol2AADj33HOZO3cumzdvZubMmTz44INs27aNRYsWkZiYyJAhQyJO822MMT3J10ZqEZkuIitEZKWI3BDheLKIPOwdXyAiQ9ocmyAi80VkqYh8ICIpfuZ1N23bIeorAd37zK2BBHe8rjziokMzZ85kzpw5zJ07l3PPPZfKykr69u1LYmIiL7/8MuvWrfPjLowx5oD4FiBEJAjMBk4FxgDni8iYdskuA8pVdQRwG3Crd24C8A/gSlUdC0wFmvzK6x4SUlzJoXEn1JdDMMm1P+xNWr7r/VRfucehsWPHUl1dTWFhIQMGDODCCy+ktLSU8ePHc//99zNq1CifbsQYY/afn1VMU4CVqroaQETmADOAZW3SzABu9LbnAn8U11J7CvC+qr4HoKrdOyueiOvOWl/lGqgz+u3Ze6m9pHQ3yK52h5unqZ0PPmhtIO/Tpw/z58+PeJmaGht0Z4zpHfysYioE1rd5vcHbFzGNqjYDlUA+cAigIvKciLwjIv8v0huIyBUiUioipdu2beva3Celu+AAUS0MhIgbE9FYAy02JsIYc/DrrQPlEoDjgAu95y+IyEntE6nqXapaoqolBQV7jkE4IOF2iGAyJKRGeU6me7apN4wxMcDPALERKG7zusjbFzGN1+6QDezAlTZeU9XtqloLPA0csT+Z2O8V85LSXONzWv6+q5faniMBaIi8BrWfYmVlQGNM7+FngFgIjBSRoSKSBMwC5rVLMw+42Ns+B3hJ3Sfdc8B4EUnzAscJ7N52EZWUlBR27Nixfx+eEoC+YyGjb+fOScro9gChquzYsYOUlO7r6GWMiX2+NVKrarOIXI37sA8C96rqUhG5GShV1XnAPcADIrISKMMFEVS1XER+hwsyCjytqk91Ng9FRUVs2LCBLm+f2JuGatfddXuLK4F0k5SUFIqKirrt/YwxsU9ipWqipKRES0tLezobsGUp/PkYmPEnOPzCrr/+8iehpQHGnd311zbGxB0RWaSqJZGO9dZG6oNX3zFu1PXqV/y5/ss/h5d/6c+1jTGmjfiZaqO7iMDQz8CaV92aEl05AV9jLWz70LV1tDRD0H59xhj/WAnCD0NPgJotsG1F1153y1K3JnaoGSpseg5jjL8sQPhh2FT3vObVrr3upsWt2ztWdu21jTGmHQsQfsgdDLlDur4dYtNiSPRWtLMAYYzxmQUIvww9Ada+0bXTbmx6DwYd5aYX3/5x113XGGMisADhl2FT3TKlbauFDkRzA2xdDgMOg/wRVoIwxvjOAoRfhn7GPa9+uWuut2Wpa5weONELEKu65rrGGNMBCxB+Se8D/cbD6r00VNdXwdPfhYr1HacJ2/Seew6XIKo/hQabFNAY4x8LEH4adgKsf9utVR3J09+Ft++CxQ/u+1qbFkNKDuQMdgECoMxKEcYY/1iA8NOwqW5ajE/e2vPY+/+C9+e4+ZpWvrjva216z5UeRFoDhLVDGGN8ZAHCT4OOdgGgfXfX8rXw1Leg+Cg45huwsRTqKjq+TkuTa4MYcJh7nTfMPVs7hDHGRxYg/JScAUWTdx8w19IMj17utr94F4w8xY2OXvNax9fZuhxaGl0DNbh1J7KLraurMcZXFiD8NvQE+HSxmwIc4LVfwYa34Yzb3IC6osluJbpVe6lm2tVAPbF1X/5wq2IyxvjKAoTfhk0F1A2aW/cmvPZrOOwCGH+OOx5MdF1iV77kJveLZNNiF0Ryh7buC3d1jZHp2o0xvY8FCL8VTnLTYyx7Av59heuFdNqvdk8zYhpUftJxm0K4gTrQ5teVPxIaKmFnNy6GZIyJKxYg/JaQBIOPgQ/+BdWb4Ox7IDlz9zTDp7nnVS/teX5LM2xe0tpAHWY9mYwxPrMA0R3Cs7ue+H0omrTn8bxhrvooUjvE9o+gua61gTosf7h7tgBhjPGJrTjTHSZd7EZWjz+34zTDp8F7c6C50ZU6wtqOoG4rZxAEk6wnkzHGN1aC6A7JmXDYLAgEO04z4iRo2gnrF+y+PzzFd7hKKSwQdCUPGwthjPGJBYjeYsjxblBd+3aITe9B//GRg4vN6mqM8ZEFiN4iJQuKpuzeDhEKwab396xeCssfAWWru3bNCWOM8ViA6E2GT3Mlhp3b3esdK121U/sG6rD8ERBqcl1kjTGmi1mA6E1GhLu7emtIdNRAHbarq6u1Qxhjup6vAUJEpovIChFZKSI3RDieLCIPe8cXiMgQb/8QEakTkcXe404/89lrDJjolhMNt0NsWgwJKdDn0Mjp+4x0z9aTyRjjA9+6uYpIEJgNnAxsABaKyDxVXdYm2WVAuaqOEJFZwK3ATO/YKlWd6Ff+eqVAEIad6AKEqitB9BsHwQ5+TWn5kJJtDdXGGF/4WYKYAqxU1dWq2gjMAWa0SzMDuM/bngucJCLiY556v+HToGazm947PMVGR8JrQ1iAMMb4wM8AUQi0XUtzg7cvYhpVbQYqgXzv2FAReVdEXhWR433MZ+8Snnaj9B5oqOq4gTosf6QFCGOML3prI/UmYJCqHg58C/iniGS1TyQiV4hIqYiUbtsWI5PWZRdCwSh411uGdG8lCHAliKqN0LjT/7wZY+KKnwFiI1Dc5nWRty9iGhFJALKBHaraoKo7AFR1EbAKOKT9G6jqXapaoqolBQUFPtxCDxl+kluqNJgEBaP3njY8J1PZav/zZYyJK34GiIXASBEZKiJJwCxgXrs084CLve1zgJdUVUWkwGvkRkSGASOB+PkEDFcz9R2z+7xMkVhPJmOMT3zrxaSqzSJyNfAcEATuVdWlInIzUKqq84B7gAdEZCVQhgsiAJ8BbhaRJiAEXKmqZX7ltdcZfAwkpELhEftOa+tTG2N84utsrqr6NPB0u30/brNdD+wxxamqPgo86mfeerWkNPjKM27d6X2mTYesQmuoNsZ0OZvuu7caeHj0afNHwA6rYjLGdK3e2ovJdEZ4LIStT22M6UIWIGJB/gior4TaHT2dE2NMDLEAEQusJ5MxxgcWIGKBrU9tjPGBBYhYkD0IAokWIIwxXcoCRCwIJnjrU1uAMMZ0HQsQsSJ/BGz/yC1TaowxXcDGQcSKgkNhxVNwSzH0Gwv9x7u1JPpPgL6j3eA7Y4zpBAsQseK46yB3CGxZAps/gPcehsa/umPJWXDpM9B/XE/m0BhzkLEAEStSsmHSxa2vQyGoWOeCxbxvwAs/gYvid/YSY0znWYCIVYEA5A11j/K18PyPYPWrMOyEns6ZMeYgYY3U8WDKFZBVBM//OLpG7PpKaG70P1/GmF7NAkQ8SEyBaT+ATYth2WN7T1u+Dm4/Av77w27JmjGm97IAES8mzIS+Y+HFn3ZcOmjcCXMuhNrtsPn97s2fMabXsQARLwJBOPkmKF8Di/6+53FVePzrsHWpW+bUFiAyJu5ZgIgnIz4LQ46HV2+Fhurdj73+W1j2OHz2JphwLuzcumcaY0xcsQART0RcKaJ2O7x5R+v+Fc/ASz+D8efBMd+APG/yv7L4WQbcGLMnCxDxpnASjDkL3vwjVG+BrR/Co5fDwIlw5u0uiOyaHdaqmYyJZxYg4tFJP4aWBtdTac75kJgKMx90z+Am/gMoswBhTDyzgXLxKH84TLoEFv7VTRN+yVOQXdh6PCkdMgfADqtiMiaeWYCIVydcD+sXwFFXwaAj9zyeN8zaIIyJcxYg4lVGX7jyjY6P5w2Dj57tvvwYY3oda4MwkeUPh53boL6qp3NijOkhFiBMZLu6ulpDtTHxytcAISLTRWSFiKwUkRsiHE8WkYe94wtEZEi744NEpEZEvuNnPk0E+TYWwph451uAEJEgMBs4FRgDnC8iY9oluwwoV9URwG3Are2O/w54xq88mr3IHeqerSeTMXHLzxLEFGClqq5W1UZgDjCjXZoZwH3e9lzgJBERABE5C1gDLPUxj6YjSWmQOdCqmIyJY34GiEJgfZvXG7x9EdOoajNQCeSLSAZwPXDT3t5ARK4QkVIRKd22bVuXZdx48ofbaGpj4lhvbaS+EbhNVWv2lkhV71LVElUtKSgo6J6cxRMbC2FMXIsqQIjItSKSJc49IvKOiJyyj9M2AsVtXhd5+yKmEZEEIBvYARwJ/EpE1gLXAd8XkaujyavpQvnD3cR+9ZU9nRNjTA+ItgTxFVWtAk4BcoEvAbfs45yFwEgRGSoiScAsYF67NPOAi73tc4CX1DleVYeo6hDg98AvVPWPUebVdJXwnExWzWRMXIo2QIj3fBrwgKoubbMvIq9N4WrgOWA58IiqLhWRm0XkTC/ZPbg2h5XAt4A9usKaHmTTfhsT16KdamORiPwXGAp8T0QygdC+TlLVp4Gn2+37cZvteuDcfVzjxijzaLpaXrirq5UgjIlH0QaIy4CJwGpVrRWRPOBS33JleofEVMgqshKEMXEq2iqmo4EVqlohIhcBP8R1STWxLn+YjYUwJk5FGyD+DNSKyGHAt4FVwP2+5cr0HnnDrIrJmDgVbYBoVlXFjXz+o6rOBjL9y5bpNfKGQ10Z1JX3dE6MMd0s2gBRLSLfw3VvfUpEAkCif9kyvYZN2mdM3Io2QMwEGnDjITbjBr392rdcmd4j3NXVJu0zJu5EFSC8oPAgkC0iZwD1qmptEPEgdwgg1lBtTByKdqqN84C3cWMWzgMWiMg5fmbM9BKJKZBdZA3VxsShaMdB/ACYrKpbAUSkAHgBN0W3iXU2aZ8xcSnaNohAODh4dnTiXHOwyx++9yqmugpY/Up35cYY002i/ZB/VkSeE5FLROQS4CnaTaFhYljecNfNtbYs8vHnvg/3z4Aty7o3X8YYX0XbSP1d4C5ggve4S1Wv9zNjphcJz+oaqZppxyp4b47bXvjX7suTMcZ3UVcTqeqjqvot7/GYn5kyvczexkK8/lsIJsLIU+D9h6G+qnvzZozxzV4DhIhUi0hVhEe1iNgnQbzIHQIS2LMnU7j0MOlSmHoDNNa0liaMMQe9vfZiUlWbTsNAQrLr6tq+oTpcejjuOsjsDwOPcNVMUy4H2etyIcaYg4D1RDLRyRu+ewmibHVr6SGzv9s35QrYvgLWvNYzeTTGdCkLECY6ed6036ru9WttSg9hY78Aafmw8O4eyaIxpmtZgDDRyR8O9ZWuu2vZanjvIZh0SWvpAdyo68O/BB8+DZUbeyyrxpiuYQHCRGfXpH2rXOkhkADHXrdnupKvgIZg0d+6NXvGmK5nAcJEJ9zVddWLrvRQcilkDdgzXe5gOGQ6LPo7NDd0axaNMV3LAoSJTs5g19X19d91XHoIm/JV2LkNls3rtuwZY7qeBQgTnYQkyC6GlgbX9hCp9BA2bJpr1LbGamMOahYgTPTyR0AwefeeS5EEAjD5q7B+AWx6v1uyZozpehYgTPRO/AGcdx9kDdx32okXQEKqlSKMOYj5GiBEZLqIrBCRlSJyQ4TjySLysHd8gYgM8fZPEZHF3uM9EfmCn/k0USqaBIeeGl3a1FyYcC68/y+o+tTffBljfOFbgBCRIDAbOBUYA5wvImPaJbsMKFfVEcBtwK3e/iVAiapOBKYDfxGRaBc3Mr3FUV93z3ceByue7dm8GGM6zc8SxBRgpaquVtVGYA4wo12aGcB93vZc4CQREVWtVdVmb38KoD7m0/il72j42quQORAemglPfQea6no6V8aYKPkZIAqB9W1eb/D2RUzjBYRKIB9ARI4UkaXAB8CVbQLGLiJyhYiUikjptm3bfLgFc8AKDoXLX4Sjr3btEXedCJuXdP469VVQtqbr82eM6VCvbaRW1QWqOhaYDHxPRFIipLlLVUtUtaSgoKD7M2mik5AMn/s5XPRvqCuDu6fBW39unddpX1ThoVkwewos/4+/eTXG7OJngNgIFLd5XeTti5jGa2PIxq13vYuqLgdqgHG+5dR0jxEnwf+9CcNPhGdvgJd/Ed15Sx+Ddf+D1Dx45Mvw7j/8zacxBvA3QCwERorIUBFJAmYB7YfWzgMu9rbPAV5SVfXOSQAQkcHAKGCtj3k13SW9D5w/BybMhDd+B5s/2Hv6xlp4/sfQbzxcvRCGTYUnroL5s7slu8bEM98ChNdmcDXwHLAceERVl4rIzSJyppfsHiBfRFYC3wLCXWGPA94TkcXAY8DXVXW7X3k13UwEpt/iSgRPXAUtezQvtXrzDqhcD6feAilZLriMOQue+z68+NPoq6mMMZ0mGiP/YCUlJVpaWtrT2TCdsewJV2X02RvhuG/uebxyA9xRAod8zg3QCwu1wJPXwTv3uxHbp/7ajd7ubjVboXwdFE/u/vc2pouIyCJVLYl0zMYWmJ4zZgaM/jy8/EsYdQb0Gbn78ed/AiicfPPu+wNB+PztkJIDb94OO7fDyTe5tbP9tu0jWPGUW/Niw0KXvyv/B/2ticzEnl7bi8nEidN+6xYamvcNCIVa96+bD0vmwjHXuCnE2xOBU37qSh/L58EfJsIDX3QzyLY0dW0ea7bBf38Ed0yC2ZPhhRuhuR6Ovsod/2R+176fMb2EBQjTszL7wed+6T5kF/7V7QuF4Nnr3QC7fU0MeNw34bolMPV7sG0FPPIl+N0YeOGmrhs38ez1rlE8uxhO+417vytfh1N+Bhn9Yf3bXfM+xvQyFiBMz5t4AQyf5r6ZV3wCix+ETe+5qqWk9H2fn10IU6+H696HCx6BohL43+/hjiNg3ZsHlrfGnbDiGZh0MXz5cZhyOeR4vbdFoHiKm7XWmBhkAcL0PBE44/du+/Gvw4s3QfFRMP6czl0nEHQN2uc/5L7lp2RD6b0HlrcVz0BTLYzrIC/FU6BiHVRvObD3MaYXsgBheofcwa49Ye3rrtH51Ftc4Nhf2YUw9guw/EloqN7/63wwF7IKYdDRkY8XH+meN1g1k4k9FiBM7zH5q26Mw/HfgoGHH/j1JsyC5rr9n56jtgxWvuACTUfdaAccBsEka4cwMcm6uZreIxDYfbzDgSqeArlD4f2HXTtHZy3/D4SaYNzZHadJSIYBEy1AmJhkJQgTu0TclB6rX92/RYuWzHVra++rNFM8BT59F5ob9y+fxvRSFiBMbJtwHqDwwb86d171Zljzumuc3ldbSPEUaGmAzbb+toktFiBMbMsfDkWT4b2HO3fe0scBja4nVdEU92zdXU2MsQBhYt+EmbB16b5njm1ryVw3g2zBoftOmzUAsgdZO4SJORYgTOwb+0UIJMB7c6JLX77WzbM0fi+N0+0VT7EAYWKOBQgT+9LzYeQpbkxDqGXf6Zc86p7HfjH69yieAtWfuhlojYkRFiBMfJgwE2o2w5pX9532g0ddu0KkSQI7UmztECb2WIAw8eGQ6ZCcve/G6q3LXXtFZ6f56DcOElJh/cL9z6MxvYwFCBMfElNg7Aw3+K1xZ8fpljwKEnCjpzsjmAiFk6wEYWKKBQgTPybMgqadbn6mSFRdO8XQz0BG385fv3iyGwvRVHdg+TSml7AAYeLHoKNdd9T3O6hm+vQdKF/T8cyt+1J8JISa3ahqY2KAzcVk4kcgABPOhTducyOlg0nuuWazm6576b8hkOiWQd0fRd7a1OvfhsHHdF2+jekhFiBMfJkwC17/LfxuNGhoz+OHXQCpOft37fQ+kDfcxkOYmGEBwsSXgkPgc7+Amq2Q2R8y+rlHZn/X7pCceWDXL57ipghXPbD1LIzpBSxAmPhz9FX+Xbt4Crz3kGvLyBvm3/t0VksTPP8TKDyi8114zd6pwj/Ohv7j4eSbejo3XcoChDFdadfEfQt7T4AIhdxSrh88Aul9XRtLQnJP5yp2rH0dVr3oHnnD3PrlMcLXXkwiMl1EVojIShG5IcLxZBF52Du+QESGePtPFpFFIvKB9zzNz3wa02X6joakzK4bD7Fzx4ENvlOFp7/tgsOoM2DnVm+mWtNlSu+FlBwYegI8/Z2YGizpW4AQkSAwGzgVGAOcLyJj2iW7DChX1RHAbcCt3v7twOdVdTxwMfCAX/k0pksFglA06cAbqsNjMmZPhns+Cy/c6EoCnb3GCz9xH2DHXgfnPQD5I+HtvxxY3kyrmq1u8OXhF8G5f4esgfDwRa53XAzwswQxBVipqqtVtRGYA8xol2YGEF5jci5wkoiIqr6rquElwJYCqSJiZWJzcCg+0k3X0VDtJu9b9gT890fwt9PgF4Vw11R4/5GOV6Cr+hQeOh8evQxyh8Bh57uuuY98ae+jwNt7/bfwvz9AyWXw2RtdN98jvwYbF8GG0i64UcO7D7ixL5MugbQ8mPVPaKiCh78EzQ09nbsD5meAKATWt3m9wdsXMY2qNgOVQH67NGcD76jqwf/TNvGhaIrrQnvbOLhtLDzyZVhwJzTXw/hzXeD49+Xwhwnw2m+gtsydpwqL7oPZR8HqV+CUn8Nlz8NZf3Y9rz58Cv52anTLpy74C7z0UzdJ4Wm/ae1RddgsVwW24E7fbj9uhFpg0d/dyPs+I92+fmNhxmzY8DY88/96NHtdoVc3UovIWFy10ykdHL8CuAJg0KBB3ZgzY/Zi8NFuevHUXDc/U2EJ9B/X2jAcCrmusG/9yX2Iv/YbOGymW4di9Ssw+Dg483a3Gl7Y0Ve5MRaPXgZ3T4PzH4q8VnZzAyz+p/twGnUGzPiTKzmEJWe66pCFf4VTfua695r9s+olqPgETr559/3jvuimXHnjNhgwEUou7ZHsdQVRVX8uLHI0cKOqfs57/T0AVf1lmzTPeWnmi0gCsBkoUFUVkSLgJeBSVf3fvt6vpKRES0ut2GwOMluWwYI/u1lmg4nuw2bSpbt/qLe1eQk8NAt2boczfgcp2e4aW5e65x0rQVtg2FS44JHIvZV2rII7JsEJ18OJ3/P19mLaQ+e7qrpvLoWEpN2PhVrgn+fB6lfhkqdg0JE9k8coiMgiVS2JeMzHAJEAfAScBGwEFgIXqOrSNmmuAsar6pUiMgv4oqqeJyI5wKvATar672jezwKEOajVlbtZZFOy9522ZivMucCteheWM9hVb/Qd454PPc3NYNuRB89zc0ZF+nDrrVRd6ei1X8OZd8DQ43suL5Ub4Pfj4bhvwkk/jpymrhzuOtH9vk6+ybUFdRT4e9DeAoRvVUyq2iwiVwPPAUHgXlVdKiI3A6WqOg+4B3hARFYCZcAs7/SrgRHAj0Uk/NM/RVW3+pVfY3pUam70aTP6wsVPumqqzP5u3ezOjgA/8go3uGvZ4zDhvM6d2xN2bof/XAsfPukC6TPXw5Wvu15j+6ulCao2up99clbnRr6/c78LWEfsZcxDaq4rPcz7huv+uuwJmPFH1/HgIOFbCaK7WQnCmE4IhWD2FEjJgstf6unc7N1Hz8ETV0N9hfu2njnAtcXMmO3aUzqrvso1Li+40wUIcGuWp+W3PrKLYdoPILtoz/NbmlwHhAET4MJ/7fv9VF1Aee4HrvNCLytN9EgJwhjTi4W7vD79HVePXhTx86FnNdTAf38Ii/4GfcfClx931WeqXgP/z9y64Ulp0V2vcqMLCov+7rqiDjkePvMdaKyF2h1tHmXu2/7K5+G8+/ecmfejZ90MwCW/j+59Rdzo6uHT2pUmZnduWdseEPclCFXlrdVlTB6SS0Kwd0R0Y7pFQzX8djQceiqcfbd/76MKHz/vqlyKJ0d3zsZF8OhXoWwNHPMNmPbD3Rvc173puvxO+5H7kN+b7Svh9d/AB/9y3+DHnOWuWXhEx+dsW+HaecrXwqm3um/84SqoB74A2z6C697vfBWXqgtQ//2hGz8x8QI4+urde6x1JBTypdSxtxJE3H8i/m/lDs6/+y2eXhIbIx+NiVq4y+vSx9x6GH7YuhzunwH/PBfuORme//HeB5CFQvDG7+GeU9xAwkuehFN+umdvrMHHwKGnu7Q12zq+3pZl8NeT3Df2yV+Fa96Fc/+29+AArl3n8pdg+Enw1LfdN//mBihb7bq3Trp4/9o/RFy316/Pd20/7/7D9Sh7+EuRBy9uXwnzZ8N9Z8LP+sJb3Tt+Je5LEKGQ8tnbXiUlIchT1xyH2BTNJp6Eu7yGe+N01d9/XQW8cgu8fRckZ8DU78O25e7bc7/xrsTSd/Tu51Rvgce+BqtfhtFnurEge2u83/YR/OkoKPkKnP6bPY+XrYF7p7vtrzwLeUM7fx+hELzyC9dzqmgy9DkE3pvjen9lDej89dqr3uwGNZbeA/WVMPhYmHghbFni2l7KVrl0BaPcYlZlq+Drb3Vp1VSPdHPtbgfSSP3wwk+4/tEPeOCyKRw/sqCLc2ZML/fQBbDiKTcT6ZgZ7jFg4v4Fi1CL+1b84k2uLn/SJa4aKN2bIGHFM+7beH2Vm/7jyCtdtcnKF+CxK1211/Rb3HnRvP+T33QNwF9fAH1GtO6v2gT3fs61NVz6zJ7BqLOWPQGP/Z9b03z052HmPw7seu01VLv7mP8nqNoAwWTXjfeQ6W7QZe5gqFgPs4+EIce6MS5dFMwtQOxDQ3MLx9/6Mof0y+QfX+29A1qM8UVDDSx51H0IrnnV1Y3nDHKBYuwX3GjwaKx5Hf77A9j0nlv/+9RbYcBhe6ar2eaCxEfPuBlQ+411jc59x8A593buw7xmK9x+OAw/sfVDu7bMzXtVuR6+PM9NntgVtixzkyZO+0Hk++oKLU2w6X3oOwqS0vc8Pn82PPd9NzHg2C90yVtagIjCna+u4pZnPuTJbxzHuMIoBisZE4tqy9y3/GVPuLr2UJObW+rYa9zgu0j17luXu8WIPn4OsopcyWD8OXv/hqsK79wHz37ffSuf/FU39Udiaufz/Oqv4OWfw1eeg37j4P4z3YjzC/8Fw07o/PV6s5ZmuPtEqNkCVy+MbmDlPliAiEJVfRPH/PIlThzVlzvOjzDHjTHxpq7CzTo7/49Qsc7NBXX0Va7nTWKqqz9/+eeuSikpE47/lus625kP+fJ1bixC+66kndG4E24/wo1ZSEqHtW/AzAdg1On7f83ebOM7ruG95Ctw+m8P+HIWIKL0y6eXc/frq3nlOycyKD/KvtXGxLqWZlg+D9683U3PkZYPIz/nRmG3NLlv/5/5bms7Q09YdB/85xq3fdadMPH8nstLd3jmBjem47Lno+863AHr5hqlrxw3lGBA+Osbq3s6K8b0HsEEN0Pp5S+7qSMKS9y624d8Dq5+G069pWeDA7juuhNmujmaYj04gGsHyRwAT17ngrRPbCR1G/2yUvjC4YU8Urqea08aSX6GrVFkzC4iMOQ49wi1HNg8SF0tEIQv3tXTueg+yZlw2q/h4QtdA/+x1/ryNlaCaOeKzwyjvinE/fPX9XRWjOm9elNwiFejz3CDBV/+pWvL8YEFiHZG9M3ks6P7cd/8tdQ2Nvd0dowxpmOn/crNbvvsDb5c3gJEBP83dRgVtU08snD9vhMbY0xPyS6Cs/7U8ZoUB8gCRASTBudRMjiXu19fQ3NLqKezY4wxHRt71oGPFO+ABYgOfO2E4WysqOPahxczd9EG1m7fSax0CTbGmGhYL6YOnDSqLzNLinl6ySaeen8TAH0ykikZnEvJkFymDM1j7MBsggGb3M8YE5tsoNw+hELKx1trKF1XRunackrXlbG+rA6AzJQEjhyazzHD8zlmRD6H9M0kYAHDGHMQsRXlDkAgIBzaP5ND+2dy4ZFuit0tVfUsWFPG/FXbeXPVDl5Y7ubSz0tPYvKQXMYOzGbMgCxGD8xiYHaKTSFujDkoWYDYD/2yUjjzsIGcedhAADZW1DF/1Q7eXLWdd9aV899lWwgXzLJTE12wGJDFiL4Zux556Uk9eAfGGLNvVsXkg50NzXy4uZplm6pY9mkVyzdVsWJzNXVNLbvS5KUnMaIgg+F9MxjllVBG9c8kJ80ChzGm+9hkfb1AKKRsrKhj1bYaVm6t2fX88dYaKmpb51Lpn5XCqAEuYIwvzGZicQ6FOalWTWWM8YW1QfQCgYBQnJdGcV4aUw/tu2u/qrK1uoEPN1fz4aYq97y5mv+t3E5TiwvefTKSOXxQDhOLczi8OIexA7PJTkvsqVsxxsQJCxA9TETol5VCv6wUTjikdbnTxuYQH26uYvH6ChZ/UsHi9RU8v6x1YfmctEQG56czJD+NwXlpbrtPGkP7ZJCblmglDmPMAbMqpoNIRW0j722o5OMt1azdsZN1O2pZu2MnG8vrCLX5NWalJDC0IIOh+S5gDCtI57CiHIrzrKrKGLO7HqtiEpHpwB+AIPBXVb2l3fFk4H5gErADmKmqa0UkH5gLTAb+rqpX+5nPg0VOWhInHFKwW0kDXGljQ7kLFmu217Jmew1rt9eycG05T7z36a4eVX0ykjh8UC5HDMrl8EE5HFaUQ2qSzcppjInMtwAhIkFgNnAysAFYKCLzVHVZm2SXAeWqOkJEZgG3AjOBeuBHwDjvYfYiKSHAsIIMhhVk7HGsvqmFlVtrWLy+gnc+KefdT1qrqoIBoV9mMv2yU+iflUL/Ns/FeWkML8ggO9XaOoyJV36WIKYAK1V1NYCIzAFmAG0DxAzgRm97LvBHERFV3Qm8ISIjfMxfXEhJDDKuMJtxhdlcdJQb6Fe2s5HF68tZvL6SjeV1bKmq56Mt1bz+8XZqGnaf4rxPRjLDCtIZXpDB8IJ0Buen0y8rmX5ZKeSnJ5EQtOm8jIlVfgaIQqDtfNkbgCM7SqOqzSJSCeQD26N5AxG5ArgCYNCgQQea37iRl57EtFH9mDaq3x7Hahqa2VxZx9rttazeXsOqrTtZta2GZ5dsorx296UNA+ICSLiRvTgvlUF5abseRblpVoVlzEHsoO7FpKp3AXeBa6Tu4ezEhIzkBEb0zWRE30xg9wBStrORDeW1bKlqYEtVPVur6t12dT3ry2p5c9V2ahtbdjunT0YyA7JTvCCSTH8vmPTNSqYwJ5UBOalkJB/Uf4bGxCw//zM3AsVtXhd5+yKl2SAiCUA2rrHa9EJ56Ul7nSJEVdmxs5FPympZX1bLJztqWe8FlA3ltSxaV7ZHKQTcdCQDc1IpzElhYE4qBRnJ5KQnkZeWRG5aIrnpSeSmJZGdmkhKYsB6YhnTTfwMEAuBkSIyFBcIZgEXtEszD7gYmA+cA7yksdLvNg6JCH0ykumTkcwRg3IjpqlvamFbdQObq+rZVFnPpxV1ux4bK+p5e00ZVfUdL/UqAulJCaQlBclITiAt2T33zXSN621LKgWZySQlBAiIIAKCEBAIiJCaFCQ5wYKNMXvjW4Dw2hSuBp7DdXO9V1WXisjNQKmqzgPuAR4QkZVAGS6IACAia4EsIElEzgJOadcDyhyEUhKDu0aUd6SxOURFbSPltU2U7WykvNY9KuuaqGtsYWdDC7WNzexsbKG2oZmq+iYWr69g89J6GpujXwEwGBDSvUCTkZJAenICWSmJ5KQl7iqx5KYlkpOWREZyAsGAEAgICQEhIEIwICQGhazURHJSE8lKTSTRGu1NDLGBciZmqCqVdU1srqpnc2U926obaAkpIYWQKqqKAi0hpa6phZ0NzexsaKG6vtltNzZTVddEeW0TFbWNey3JdCQjOYHs1EQyUxJICMquMSht/82CASEhKCQGAiQEhYRggMSAICK0hEI0h5SWkO56DqmSEHABKSEQ8J5l13USwtcJuGslBQOkJQXJ8vKRmZJIlvesqlQ3uPutqW+mpsE9mlpCBAOBXdcNtgmErvTlSojhbURAW3+2IXU/f1V3f0kJLh9JCe6RGHTXBqDt9cK/O+/3p94LxV0rfP+h3baVhIC7ZlKCkBgMeA+X37C2pcOQKs0tSnMoRHOL+7k2tYRQ2PVzSwiEf4atP+fEYGD331VAXF5UCbX5PYW8ew/nu+3vvKN97kfh/UzDJdyAV8JNDJKe7ErKfpd0bS4mExdEhJy0JHLSkhjVP+uAr9fcEqKqvpmK2kZqGpp3fUA1t6j3AQFNLSGq6puoqG2iss49V9Q1UlXXvGuJ2tb/bbcRUvfh1NQSorE5xM6GZppa3LUTg7sHgJREV0UW/iCqa2rxAkfI+8Br/bALv25qcddsDkX/5S8YcO9hep9gQEhLCpKWFCQhENgVRAJegBWBEw/tyw/PGNPl720BwpgOJAQD+2yY761UlfomF7yq65uorHNVcUERMlISXLVasqtWS08KkhAMoN439eZQiBYv8LSEwt+MW7/hh78phz+kAt63Xwm4ENgSUhqbQzR6AbCpxb1uaVOK03BRwdt2QbRdaQX34RgQ9806KK6UFRDvPVrctZtbWt+rzWV3fUv3rrxHaStcHRgOvs0t7r6bvG23z5U6mlpcUG5qUa960X1IJwRbqxvDpZfwhza7XrHHfe36Pe32c3U/6/AXgdoGrxq10ZV06xrdlwPV1lJVyDt3QE5qF/71tLIAYUwMEq8hPjUpSL+slKjPCQoEAzZ2xTjWomaMMSYiCxDGGGMisgBhjDEmIgsQxhhjIrIAYYwxJiILEMYYYyKyAGGMMSYiCxDGGGMiipm5mERkG7DuAC7RhygXKooxdt/xxe47vkRz34NVtSDSgZgJEAdKREo7mrAqltl9xxe77/hyoPdtVUzGGGMisgBhjDEmIgsQre7q6Qz0ELvv+GL3HV8O6L6tDcIYY0xEVoIwxhgTkQUIY4wxEcV9gBCR6SKyQkRWisgNPZ0fv4jIvSKyVUSWtNmXJyLPi8jH3nNuT+bRDyJSLCIvi8gyEVkqItd6+2P63kUkRUTeFpH3vPu+yds/VEQWeH/vD4vIwbdcXhREJCgi74rIk97reLnvtSLygYgsFpFSb99+/63HdYAQkSAwGzgVGAOcLyJdv7Br7/B3YHq7fTcAL6rqSOBF73WsaQa+rapjgKOAq7zfcazfewMwTVUPAyYC00XkKOBW4DZVHQGUA5f1XBZ9dS2wvM3reLlvgBNVdWKb8Q/7/bce1wECmAKsVNXVqtoIzAFm9HCefKGqrwFl7XbPAO7ztu8DzurOPHUHVd2kqu9429W4D41CYvze1anxXiZ6DwWmAXO9/TF33wAiUgScDvzVey3EwX3vxX7/rcd7gCgE1rd5vcHbFy/6qeomb3sz0K8nM+M3ERkCHA4sIA7u3atmWQxsBZ4HVgEVqtrsJYnVv/ffA/8PCHmv84mP+wb3JeC/IrJIRK7w9u3333pCV+fOHJxUVUUkZvs8i0gG8ChwnapWuS+VTqzeu6q2ABNFJAd4DBjVsznyn4icAWxV1UUiMrWHs9MTjlPVjSLSF3heRD5se7Czf+vxXoLYCBS3eV3k7YsXW0RkAID3vLWH8+MLEUnEBYcHVfXf3u64uHcAVa0AXgaOBnJEJPzFMBb/3o8FzhSRtbgq42nAH4j9+wZAVTd6z1txXwqmcAB/6/EeIBYCI70eDknALGBeD+epO80DLva2Lwae6MG8+MKrf74HWK6qv2tzKKbvXUQKvJIDIpIKnIxrf3kZOMdLFnP3rarfU9UiVR2C+39+SVUvJMbvG0BE0kUkM7wNnAIs4QD+1uN+JLWInIarswwC96rqz3s2R/4QkYeAqbjpf7cAPwEeBx4BBuGmSj9PVds3ZB/UROQ44HXgA1rrpL+Pa4eI2XsXkQm4Bskg7ovgI6p6s4gMw32zzgPeBS5S1Yaey6l/vCqm76jqGfFw3949Pua9TAD+qao/F5F89vNvPe4DhDHGmMjivYrJGGNMByxAGGOMicgChDHGmIgsQBhjjInIAoQxxpiILEAY0wuIyNTwzKPG9BYWIIwxxkRkAcKYThCRi7x1FhaLyF+8CfFqROQ2b92FF0WkwEs7UUTeEpH3ReSx8Dz8IjJCRF7w1mp4R0SGe5fPEJG5IvKhiDwobSeMMqYHWIAwJkoiMhqYCRyrqhOBFuBCIB0oVdWxwKu4UeoA9wPXq+oE3Eju8P4HgdneWg3HAOGZNg8HrsOtTTIMN6+QMT3GZnM1JnonAZOAhd6X+1TcxGch4GEvzT+Af4tINpCjqq96++8D/uXNlVOoqo8BqGo9gHe9t1V1g/d6MTAEeMP3uzKmAxYgjImeAPep6vd22ynyo3bp9nf+mrZzA7Vg/5+mh1kVkzHRexE4x5trP7zW72Dc/1F4ptALgDdUtRIoF5Hjvf1fAl71VrXbICJneddIFpG07rwJY6Jl31CMiZKqLhORH+JW7AoATcBVwE5gindsK66dAtzUynd6AWA1cKm3/0vAX0TkZu8a53bjbRgTNZvN1ZgDJCI1qprR0/kwpqtZFZMxxpiIrARhjDEmIitBGGOMicgChDHGmIgsQBhjjInIAoQxxpiILEAYY4yJ6P8Dg9/PpSTuf5AAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_hist(history)" ] }, { "cell_type": "code", "execution_count": 44, "id": "1a23242a-ffb4-4bf8-83a3-a30e281add1e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "33/33 [==============================] - 1s 3ms/step\n", "16/16 [==============================] - 0s 2ms/step\n", "Train Score: 3.57 RMSE\n", "Train R^2: 0.43751046016410977\n", "Test Score: 4.77 RMSE\n", "Test R^2: 0.43999636627656\n" ] } ], "source": [ "trainPredict, testPredict = make_preds(trainX,trainY,testX,testY)" ] }, { "cell_type": "code", "execution_count": 45, "id": "e43fd750-5e0c-4b12-bf4e-0083d3da9207", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_preds(trainPredict,testPredict)" ] }, { "cell_type": "code", "execution_count": 46, "id": "cbf467ad-b723-4415-b06e-136aa76ac0a2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1037, 1, 1)\n", "trainY.shape: (1037,)\n", "trainX[:5]: [0.40584978 0.32951364 0.42946067 0.386174 0.4079348 ]\n", "trainY[:5]: [0.32951364 0.42946067 0.386174 0.4079348 0.40748814]\n", "Deleting \"model\"\n", "keys: dict_keys(['loss', 'val_loss'])\n", "--- Elapsed time: 264.29672741889954 seconds ---\n" ] } ], "source": [ "# Let's redo it using ADAM 7;51\n", "# reshape into X=t and Y=t+1\n", "look_back = 1\n", "# our data is in the form: [samples, features]\n", "trainX, trainY = create_dataset(train, look_back)\n", "testX, testY = create_dataset(test, look_back)\n", "\n", "# 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", "# Reshape input to be [samples, time steps, features]\n", "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n", "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('trainX[:5]: ', trainX[:5,:,:].flatten())\n", "print('trainY[:5]: ', trainY[:5])\n", "\n", "# create and fit the LSTM network\n", "if 'model' in globals():\n", " print('Deleting \"model\"')\n", " del model\n", "model = Sequential()\n", "model.add(LSTM(4, input_shape=(1, look_back))) \n", "model.add(Dense(1)) \n", "\n", "start_time = time.time()\n", "# Compile the model\n", "model.compile(loss='mean_squared_error', optimizer=tf.optimizers.Adam(learning_rate=0.001))\n", "\n", "# Fit the model\n", "history = model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=0, validation_data=(testX, testY))\n", "# list all data in history\n", "print('keys: ',history.history.keys())\n", "print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))" ] }, { "cell_type": "code", "execution_count": 47, "id": "d53511fa-3159-4080-b1e7-2780ed14c98e", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_hist(history)" ] }, { "cell_type": "code", "execution_count": 48, "id": "b4b8a456-58b5-4509-a9f1-efaf19270401", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "33/33 [==============================] - 1s 4ms/step\n", "16/16 [==============================] - 0s 3ms/step\n", "Train Score: 3.43 RMSE\n", "Train R^2: 0.4824621484663243\n", "Test Score: 6.54 RMSE\n", "Test R^2: -0.05321232523693742\n" ] } ], "source": [ "trainPredict, testPredict = make_preds(trainX,trainY,testX,testY)" ] }, { "cell_type": "code", "execution_count": 49, "id": "8e728fd1-e730-4eec-88de-f54b42b0de79", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_preds(trainPredict,testPredict)" ] }, { "cell_type": "code", "execution_count": 50, "id": "9bf8a6e5-b3be-4eb6-b0aa-ecb3b07ed029", "metadata": {}, "outputs": [], "source": [ "## LSTM for Regression Using the Window Method" ] }, { "cell_type": "code", "execution_count": 51, "id": "8065d398-af9b-4824-99f8-7345bc4f03a4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1035, 3)\n", "trainY.shape: (1035,)\n", "trainX[:5]: \n", " [[0.40584978 0.32951364 0.42946067]\n", " [0.32951364 0.42946067 0.386174 ]\n", " [0.42946067 0.386174 0.4079348 ]\n", " [0.386174 0.4079348 0.40748814]\n", " [0.4079348 0.40748814 0.30990687]]\n", "trainY[:5]: \n", " [0.386174 0.4079348 0.40748814 0.30990687 0.47879067]\n" ] } ], "source": [ " # reshape into X=t and Y=t+3\n", "look_back = 3\n", "trainX, trainY = create_dataset(train, look_back)\n", "testX, testY = create_dataset(test, look_back)\n", "\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('trainX[:5]: \\n', trainX[:5])\n", "print('trainY[:5]: \\n', trainY[:5])" ] }, { "cell_type": "code", "execution_count": 52, "id": "261d3fbc-4475-47b4-b461-a2db828dbdbc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1035, 1, 3)\n", "trainY.shape: (1035,)\n", "trainX[:5]: \n", " [[[0.40584978 0.32951364 0.42946067]]\n", "\n", " [[0.32951364 0.42946067 0.386174 ]]\n", "\n", " [[0.42946067 0.386174 0.4079348 ]]\n", "\n", " [[0.386174 0.4079348 0.40748814]]\n", "\n", " [[0.4079348 0.40748814 0.30990687]]]\n", "trainY[:5]: \n", " [0.386174 0.4079348 0.40748814 0.30990687 0.47879067]\n", "Deleting \"model\"\n", "keys: dict_keys(['loss', 'val_loss'])\n", "--- Elapsed time: 247.12511897087097 seconds ---\n" ] } ], "source": [ "# reshape input to be [samples, time steps, features]\n", "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n", "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n", "\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('trainX[:5]: \\n', trainX[:5])\n", "print('trainY[:5]: \\n', trainY[:5])\n", "\n", "# create and fit the LSTM network\n", "if 'model' in globals():\n", " print('Deleting \"model\"')\n", " del model\n", "model = Sequential()\n", "model.add(LSTM(4, input_shape=(1, look_back)))\n", "model.add(Dense(1))\n", "\n", "start_time = time.time()\n", "# Compile the model\n", "model.compile(loss='mean_squared_error', optimizer='adam')\n", "\n", "# Fit the model\n", "history = model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=0, validation_data=(testX, testY))\n", "# list all data in history\n", "print('keys: ',history.history.keys())\n", "print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))" ] }, { "cell_type": "code", "execution_count": 53, "id": "22640b7e-4876-4938-b7ba-de4887f4c214", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_hist(history)" ] }, { "cell_type": "code", "execution_count": 54, "id": "23d7f551-d867-45a3-ab0a-514b9eecf7c0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "33/33 [==============================] - 1s 2ms/step\n", "16/16 [==============================] - 0s 3ms/step\n", "Train Score: 3.13 RMSE\n", "Train R^2: 0.5677213355887494\n", "Test Score: 4.50 RMSE\n", "Test R^2: 0.476461149770418\n" ] } ], "source": [ "trainPredict, testPredict = make_preds(trainX,trainY,testX,testY)" ] }, { "cell_type": "code", "execution_count": 55, "id": "88e20de3-3863-449e-8aff-26c75df8e1a8", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_preds(trainPredict,testPredict)" ] }, { "cell_type": "code", "execution_count": 56, "id": "fa0e12e9-7b96-461a-9bcf-6a578faef3c1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1035, 3, 1)\n", "trainY.shape: (1035,)\n", "trainX[:5]: \n", " [[[0.40584978]\n", " [0.32951364]\n", " [0.42946067]]\n", "\n", " [[0.32951364]\n", " [0.42946067]\n", " [0.386174 ]]\n", "\n", " [[0.42946067]\n", " [0.386174 ]\n", " [0.4079348 ]]\n", "\n", " [[0.386174 ]\n", " [0.4079348 ]\n", " [0.40748814]]\n", "\n", " [[0.4079348 ]\n", " [0.40748814]\n", " [0.30990687]]]\n", "trainY[:5]: \n", " [0.386174 0.4079348 0.40748814 0.30990687 0.47879067]\n", "Deleting \"model\"\n", "keys: dict_keys(['loss', 'val_loss'])\n", "--- Elapsed time: 351.80383682250977 seconds ---\n" ] } ], "source": [ "## LSTM for Regression with Time Steps\n", "# reshape into X=t and Y=t+1\n", "look_back = 3\n", "trainX, trainY = create_dataset(train, look_back)\n", "testX, testY = create_dataset(test, look_back)\n", "# reshape input to be [samples, time steps, features]\n", "trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n", "testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('trainX[:5]: \\n', trainX[:5])\n", "print('trainY[:5]: \\n', trainY[:5])\n", "\n", "# create and fit the LSTM network\n", "if 'model' in globals():\n", " print('Deleting \"model\"')\n", " del model\n", "model = Sequential()\n", "model.add(LSTM(4, input_shape=(look_back, 1))) # with time_step=3 and 1 feature.\n", "model.add(Dense(1))\n", "\n", "start_time = time.time()\n", "# Compile the model\n", "model.compile(loss='mean_squared_error', optimizer='adam')\n", "\n", "# Fit the model\n", "history = model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=0, validation_data=(testX, testY))\n", "# list all data in history\n", "print('keys: ',history.history.keys())\n", "print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))" ] }, { "cell_type": "code", "execution_count": 57, "id": "08d2ee35-f96f-4006-b33e-8531a8454841", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEWCAYAAACufwpNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABTJklEQVR4nO29eZhcZbXv/1lVXT13p5PuTifpBBLIABlIIBFRQFEEAwpBmeIBBQ+KnqNXcboH7rlyPf7wHqdz9CocFRUPKqNBNGoQmQdBJIFAEsgICelM3emk566e6v398e7dXV2pufbu6mF9nqeeXbWnenensr97rfWutcQYg6IoiqJ4QSDfA1AURVHGDyoqiqIoimeoqCiKoiieoaKiKIqieIaKiqIoiuIZKiqKoiiKZ6ioKEoeEJH/FpFb0tx3t4i8L9fzKMpIoKKiKIqieIaKiqIoiuIZKiqKkgDH7fQVEXlVRDpF5OciUiciD4lIu4g8KiKTo/a/WES2iEiLiDwpIidHbTtVRF5yjrsPKI75rg+KyEbn2OdE5JQsx/xJEdkpIkdEZK2IzHDWi4h8T0QaRaRNRDaJyGJn24Ui8poztn0i8uWs/mCKgoqKoqTiUuA8YD5wEfAQ8L+AWuz/n88BiMh84B7gBmfbOuAPIlIoIoXA74BfAVOA3zjnxTn2VOAO4FNANfATYK2IFGUyUBF5L/DvwBXAdGAPcK+z+XzgXc51THL2aXa2/Rz4lDGmAlgMPJ7J9ypKNCoqipKcHxpjDhlj9gHPAC8YY142xoSBB4FTnf2uBP5kjHnEGNMHfBcoAd4JnAGEgO8bY/qMMWuAF6O+43rgJ8aYF4wxA8aYO4Ee57hMuAq4wxjzkjGmB7gJeIeIzAb6gArgJECMMa8bYw44x/UBC0Wk0hhz1BjzUobfqyiDqKgoSnIORb3vjvO53Hk/A2sZAGCMiQB7gXpn2z4zvHrrnqj3xwNfclxfLSLSAsxyjsuE2DF0YK2RemPM48CtwG1Ao4jcLiKVzq6XAhcCe0TkKRF5R4bfqyiDqKgoijfsx4oDYGMYWGHYBxwA6p11LsdFvd8LfMMYUxX1KjXG3JPjGMqw7rR9AMaYHxhjlgMLsW6wrzjrXzTGrAKmYt1092f4vYoyiIqKonjD/cAHRORcEQkBX8K6sJ4Dngf6gc+JSEhEPgycHnXsT4FPi8jbnYB6mYh8QEQqMhzDPcDHRWSZE4/5v1h33W4ReZtz/hDQCYSBiBPzuUpEJjluuzYgksPfQZngqKgoigcYY7YBVwM/BA5jg/oXGWN6jTG9wIeBa4Ej2PjLb6OOXQ98EuueOgrsdPbNdAyPAl8FHsBaRycCq53NlVjxOop1kTUD33G2fRTYLSJtwKexsRlFyQrRJl2KoiiKV6iloiiKoniGioqiKIriGSoqiqIoimeoqCiKoiieUZDvAeSTmpoaM3v27HwPQ1EUZUyxYcOGw8aY2njbJrSozJ49m/Xr1+d7GIqiKGMKEdmTaJu6vxRFURTPUFFRFEVRPENFRVEURfGMCR1TiUdfXx8NDQ2Ew+F8D8VXiouLmTlzJqFQKN9DURRlHKGiEkNDQwMVFRXMnj2b4UVlxw/GGJqbm2loaGDOnDn5Ho6iKOMIdX/FEA6Hqa6uHreCAiAiVFdXj3trTFGUkUdFJQ7jWVBcJsI1Kooy8qioZENPB7TtB63wrCiKMgwVlWzo64SOQ2C872XU0tLCf/3Xf2V83IUXXkhLS4vn41EURckEX0VFRFaKyDYR2SkiN8bZXiQi9znbXxCR2c7680Rkg4hscpbvjTrmSeecG53X1GTn8ufCgnZpBjw/dSJR6e/vT3rcunXrqKqq8nw8iqIomeDb7C8RCQK3AecBDcCLIrLWGPNa1G7XAUeNMXNFZDXwLWxXvMPYrnn7RWQx8DBQH3XcVU63PNI4lw8X52hxJAJBb0994403smvXLpYtW0YoFKK4uJjJkyezdetWtm/fziWXXMLevXsJh8N8/vOf5/rrrweGSs50dHRwwQUXcNZZZ/Hcc89RX1/P73//e0pKSrwdqKIoShz8nFJ8OrDTGPMGgIjcC6wCokVlFfA15/0a4FYREWPMy1H7bAFKRKTIGNOT5PsSnSvrwMe//WELr+1vO3ZDpB/6wxDaMCQwabJwRiX/56JFCbd/85vfZPPmzWzcuJEnn3ySD3zgA2zevHlw6u8dd9zBlClT6O7u5m1vexuXXnop1dXVw86xY8cO7rnnHn76059yxRVX8MADD3D11VdnNE5FUZRs8NP9VQ/sjfrcwHBrY9g+xph+oBWojtnnUuClGEH5heP6+qoMTWNK51yIyPUisl5E1jc1NWV3ZYNf6X+g/vTTTx+WS/KDH/yApUuXcsYZZ7B371527NhxzDFz5sxh2bJlACxfvpzdu3f7Pk5FURQY5cmPIrII68Y6P2r1VcaYfSJSATwAfBT4ZbrnNMbcDtwOsGLFiqSqkNCi6O2Ew9thyglQPCndr86KsrKywfdPPvkkjz76KM8//zylpaWcc845cXNNioqKBt8Hg0G6u7t9HaOiKIqLn5bKPmBW1OeZzrq4+4hIATAJaHY+zwQeBD5mjNnlHmCM2ecs24G7sW62pOfyHDdQH/E+UF9RUUF7e3vcba2trUyePJnS0lK2bt3K3/72N8+/X1EUJRf8tFReBOaJyBzsDX818A8x+6wFrgGeBy4DHjfGGBGpAv4E3GiM+au7syMWVcaYwyISAj4IPJrsXL5cWcDRYh+mFFdXV3PmmWeyePFiSkpKqKurG9y2cuVKfvzjH3PyySezYMECzjjjDM+/X1EUJRfEr/sugIhcCHwfO0fqDmPMN0Tk68B6Y8xaESkGfgWcChwBVhtj3hCR/w3cBEQHDM4HOoGngZBzzkeBLxpjBhKdK9n4VqxYYWKbdL3++uucfPLJyS8sMgAHX4XKeiifmsZfYnSS1rUqiqLEICIbjDEr4m3zNaZijFkHrItZd3PU+zBweZzjbgFuSXDa5Qm+K+65fMGd8eVDnoqiKMpYRjPqs0HECkvEe/eXoijKWEZFJVskoJaKoihKDCoq2SIBXwL1iqIoYxkVlWyRoLq/FEVRYlBRyZaAur8URVFiUVHJllHi/iovL8/3EBRFUQZRUckWCY4KUVEURRlNjOraX6MaCfhSpuXGG29k1qxZfOYznwHga1/7GgUFBTzxxBMcPXqUvr4+brnlFlatWuX5dyuKouSKikoyHroRDm6Kv22gBwb6oDBD99O0JXDBNxNuvvLKK7nhhhsGReX+++/n4Ycf5nOf+xyVlZUcPnyYM844g4svvlj7zCuKMupQUckJ47y8u7mfeuqpNDY2sn//fpqampg8eTLTpk3jC1/4Ak8//TSBQIB9+/Zx6NAhpk2b5tn3KoqvbH8Ynv0+XPMHCOptZzyj/7rJSGJR0H4Q2g/AtKVDBSY94vLLL2fNmjUcPHiQK6+8krvuuoumpiY2bNhAKBRi9uzZcUveK8qoZfez8NZzcOQNqJ2f79EoPqKB+mzxsU/9lVdeyb333suaNWu4/PLLaW1tZerUqYRCIZ544gn27Nnj+Xcqiq90Og3xGrfkdxyK76ioZIuP5e8XLVpEe3s79fX1TJ8+nauuuor169ezZMkSfvnLX3LSSSd5/p2K4iuuqBx6Lfl+yphH3V/ZMmip+DOteNOmoQkCNTU1PP/883H36+jo8OX7FcVTBi0VFZXxjloq2eKWv/dhWrGijDs6D9vlIXV/Zc2LP4fnfpjvUaRERSVbxD/3l6KMK4yxlkqgAI7uht7OfI9obLLxbnj6u6P+QVZFJQ5pdcMM+Ov+8hs/O34qyjDCrTDQCzPfBhho3JrvEY1NOhoh3AIHXsn3SJLiq6iIyEoR2SYiO0Xkxjjbi0TkPmf7CyIy21l/nohsEJFNzvK9zvpSEfmTiGwVkS0i8s2oc10rIk0istF5fSKbMRcXF9Pc3Jz6pjuGuz8aY2hubqa4uDjfQ1EmAq7ra8677VJngGWOMdBxyL5/86n8jiUFvgXqRSQI3AacBzQAL4rIWmNMdKTuOuCoMWauiKwGvgVcCRwGLjLG7BeRxcDDQL1zzHeNMU+ISCHwmIhcYIx5yNl2nzHms7mMe+bMmTQ0NNDU1JR8x8gAtDVCYx8UNebylXmhuLiYmTNn5nsYykSg0/n/MettUFCiM8CyIdxqq3gAvPEUnPWF/I4nCX7O/jod2GmMeQNARO4FVgHRv6hVwNec92uAW0VEjDEvR+2zBSgRkSJjTBfwBIAxpldEXgI8vTOGQiHmzJmTese+MHzjTDj3Zlj2JS+HoCjjC3fmV/k0mHqSWirZ0OEIc9lUeOtv0N8DBUX5HVMC/HR/1QN7oz43MGRtHLOPMaYfaAWqY/a5FHjJGNMTvVJEqoCLgMei9xWRV0VkjYjMijcoEbleRNaLyPqU1kgyCops4LFHp/QqSlJcUSmrhamLoPH1/I5nLOK6vpZcBv3dsPfv+R1PEkZ1oF5EFmFdYp+KWV8A3AP8wLWEgD8As40xpwCPAHfGO6cx5nZjzApjzIra2tpcBmeLSepMFkVJjhtTKa2GuoVWZDpyeKCbiLiisujDNkduFMdV/BSVfUC0tTDTWRd3H0coJgHNzueZwIPAx4wxu2KOux3YYYz5vrvCGNMcZc38DFjuzWUkobAcetVSUZSkdDRCyRRbSHLqQrtOXWCZ4bq/qk+E+tNsXGWU4qeovAjME5E5TlB9NbA2Zp+1wDXO+8uAx40xxnFt/Qm40Rjz1+gDROQWrPjcELN+etTHiwH/bewiFRVFSUlnE5RPte/rFtmlBuszo+MQBEJQMtnOotu3AcJt+R5VXHwTFSdG8lnszK3XgfuNMVtE5OsicrGz28+BahHZCXwRcKcdfxaYC9wcNUV4qmO9/CuwEHgpZurw55xpxq8AnwOu9evaBiks05iKoqSi87CNp4AVl9IatVQypaMRyuus2/2Ed9tUhj3P5XtUcfG19pcxZh2wLmbdzVHvw8DlcY67BbglwWnjNi8xxtwE3JT1YLNBYyqKkprOJpi2eOhz3UK1VDKl49CQtTfzdCgotnGVBSvzO644jOpA/ahHYyqKkprOxiFLBewMsKatEBmb1SjygmupAISK4bgzRm1cRUUlFzSmoijJ6e+1iXtlU4fW1S2Evi44+mb+xjXWiLZUwMZVGreMyll0Kiq5oDEVRUlOlzOduKxmaN1UJ1ivZfDTIzJg/46upQI2rgKjcmqxikouaExFUZIzmAke7f46CRCNq6RLV7MtXBttqUxfBsWTVFTGHYXlNrt1oD/fI1GU0Ymb+BgtKoVlMHm2zgBLFzfxMdpSCQRh9tmjMq6iopILReV22afWiqLEZbDuV0z1irpFaqmky6CoTB2+fs67oWWP7VEzilBRyYXCMrvUuIqixCe67lc0UxfCkV3Q1z3yYxpruC7EWFFx4yqjzFpRUcmFQsdS0biKosSns9HmVLj/V1zqFto4QdO2/IxrLOFaKmUxolIz31Z+HmVxFRWVXBgUlfb8jkNRRituNr3E5CzrDLD06Wi095qiGGF2s+vfeGpU5fyoqORCkVoqipKUzqZjXV8AU06AYBEc0mB9SmJzVKKZ82473XgUibOKSi5oTEVRkpNIVIIFULtgVN0MRy3R2fSxjMJ8FRWVXCissEvNqleU+HQkEBUYPzPAIhF4+juw9nO2l7zXJLNUJs2EKSeOqmC9ikouuJaKioriBX7ckPKJMY6lUhN/+9SF0HEQuo6M7Li8JNwK934EHr8FXroT9r+c+phM6TiU2FIBa63seW7UxFVUVHLBjamo+0vJlV1PwLdPgN1/Tb3vWCHcCpG+xE/ZdU7DrrEaV2naDj89F3Y+Cu/7mp3l9vKvvf2OvrD9Oyb6GwJMX2onC7XuTbzPCKKikgsh11LRQL2SI01bofsI3H0FNGzI92i8IV42fTRjeQbY1nXw0/dC91H42Fo46wuwcBVsWuNt7k2nm6OSxFKpWWCXh7d79705oKKSC4GAFRZ1fym5Em61y9Jq+PWH4OCm/I7HC9wbYiL3V8U028lwLFkqkQg8+U3r8qqZC596CmafabedejX0tMLrf/Du+9wqxMlEpdYRlaat3n1vDvgqKiKyUkS2ichOEbkxzvYiEbnP2f6CiMx21p8nIhtEZJOzfG/UMcud9TtF5AcidgK8iEwRkUdEZIeznOzntQ1SqKKieEC4FYoq4Zo/2JyEX15i3StjmUTZ9C4i1lrJ1FI5unvIChpp1n0Jnvx3WPoP8PGHbKDc5fizbE2zl37p3fclKtESTekU+zceJYmkvomKiASB24ALsO1/PyIiC2N2uw44aoyZC3wP+Jaz/jBwkTFmCbaH/a+ijvkR8ElgnvNyW5/dCDxmjJkHPMZQa2J/KSrXmIqSO90tturs5OPhY7+3N9xfXgxHxnDPkUFRSXJDrFsIja+nH2SODMAdF8BD/5L7+DKlu8XGTE79KFzyXxAqGb49ELDWyu5nvPt3i1dMMh41CyaE++t0YKcx5g1jTC9wL7AqZp9VwJ3O+zXAuSIixpiXjTH7nfVbgBLHqpkOVBpj/maMMcAvgUvinOvOqPX+UlimMRUld8KtVlQAauZZYekPW2Fp3ZffsWWL67oprU68z9SF1tJvfSu9c+5+Btr358dltm0dDPTC8muPrRDgsvQfQAKw8S5vvjNe64B41C6w7q9RMIPQT1GpB6KnIzQ46+LuY4zpB1qB2F/gpcBLxpgeZ/+GBOesM8YccN4fBOJKu4hcLyLrRWR9U5MHXdMKK9T9peROuBWKq4Y+1y2Cq39rn45/efHYnHbb2QQlU2yiYyJmrrDLHY+kd85Na+zyyC5rtYwkWx6EScdB/fLE+0yqhxPPhY13ezO+jkPO3zCUfL/aBfY35IpQHhnVgXoRWYR1iX0qk+McKyauZBtjbjfGrDDGrKitTaH+6aAthRUviLZUXOpPg8v/G5p3wvaHc/+OTWvgrityP0+6JMqmj6ZuMdQtSW8qbn8PvL7WPsgN9Nqy7yNF91HY9TgsuiSxleJy6tXQts9OE8+VVDkqLqMoWO+nqOwDZkV9numsi7uPiBQAk4Bm5/NM4EHgY8aYXVH7R0XGhp3zkOMew1mOjGRrS2HFC+KJCsBx77DLNg9cYFv/BDseHrly852HkweYwd6gT/soHNiYesbbzsfs3+mMT9vPh3d4Msy0eP2PEOmHRR9Kve+CC63L72UPAvYdjan/hjCqphX7KSovAvNEZI6IFAKrgbUx+6zFBuIBLgMeN8YYEakC/gTcaIwZzAZz3FttInKGM+vrY8Dv45zrmqj1/qIthRUvCLfEF5XCUuv+8EJU3BvOSLlIOhsTTyeOZsnlECyEl36VfL/Na+zf4vTr7eeRFJUtD9qZXTNOTb1vQSGcstrmsnQ25/a96VoqFdPs7MFRMAPMN1FxYiSfBR4GXgfuN8ZsEZGvi8jFzm4/B6pFZCfwRYZmbH0WmAvcLCIbnZcr1/8M/AzYCewCHnLWfxM4T0R2AO9zPvtPobq/lByJDEBPW3xRAaish7b98bdl8h3uTXjERCUN9xfYKbEnfRBevc9mkMejpwO2PWTdT+VTrSUwUk/lnc3wxpPWSknl+nI59WpbTeDV+7L/XmPSt1REhoL1eSZJBC13jDHrgHUx626Oeh8GLo9z3C3ALQnOuR5YHGd9M3BujkPOHDemYkz6PzhFiaanzS4TisqM3C2Vlj0w0GPfdxzM7Vzp0N9rXVXpiApYF9iW38K2P8HiS4/dvu0h6OuCxZfZz9XzbKxpJNj6BzAD6bm+XOoW2oD+y7+GM/4pu3tDTzv0d6dnqYB1ge1Mc8KDj4zqQP2YoLDMdrDTtqhKtrjZ9CVV8bdPqs99WnF0IqWb++AnXSlKtMQy5xyYNCuxC2zzGmuxuTGmmnkjZ6lsedD2f5l2SmbHnXo1NG6B/S9l972DbYTTFJXaBfbftvtodt/nESoquaIthZVccUUlmaXSfSS3B5dot8hIuL/Sza9wCQRg2VXWzdQSk7PSdcQG6Rd/2O4HVlQ6m/y/gXY0wZtPw6IPZ25tLL4UCkpSx4oSfnca2fTRDM4Ay2+wXkUlV7SlsJIr3S12mSymArnFVQ5vt0+8ZVNHxlJJVUwyHqdeZZcvxyQOvr7Wxidc1xfY/uwAh312gb2+1noiMnF9uRRPskUmNz8AvV2ZH59uNr3L4N8kv8F6FZVc0ZbCSq6ktFRcUcnBBda0zd50yuugfSRExS3RksbsL5eq4+CEc2w2enTZlk1roHquLfHuMngD9fmpfMuDNn5Ttyi74xd9yMbMDmzM/NhM3V9Vx1nLKM8zwFRUckVbCiu5kraoZGmpGGNvvrULrCtlRCwVt7pumq4bl9M+avuCvPmk/dx2AHY/a62UaPdT1fEQCEGzj9OK2w/Bnr9at1u2k3BcITzwaubHdjZCoMBWck6HQNBWTlZRGeMMthRWS0XJkkFRqYq/vXKGXWZrqbQftE/LtSfZp96RiKl0NtqmVa57OF0WfMD+Hdw4xJYHAQNLLhu+X7DABs9zzVVp3AoD/fG35eL6cqmYZl2AB7MQlY5D1l0ZyOA2XbNARWXMM9hSWGMqSpaEW20RwkQ34MJS+7Sa7Qww18deMx8q6uzNyu/Cg52H7c000yf8UDGcciVs/aMN0G9eY2dd1cw7dt+aebmJysHN8F9vh9vPgYb1x27f/FsrxFNPzv47ROz4s7FUOhqhPMNSUrUn2eKceXzIVVHJFW0prORKuMVmQyd7Is0lAdKdDVS7wFoqkT7/Z00l602fitM+amt7PfVt2LfhWCvFpWYeHHkjsaWRCjfPpeUt+Nn74I9fHJo00bYf3nrezvrKlemnQNPrtnZZJqSbTR9NrRtrGsFqAzGoqOSKTilWciVR3a9oKuuzd381bYWiSfYG5cY4/I6rdDQm76OSjGlLYPoyeOFH9nOiG3v1PCuQ2RaWdEX6n561CYobfgG3vs1ODHjt94DJzfXlMu0UWzes8fXMjks3mz6a2pPsMo8uMBWVXNEpxUqupCUqOWTVH95un2BFhp58/RYV1/2VLadebZfHvROqZsXfJ9cZYG377GypSbNg5b/DJ5+wiaYPXAeP3GwrKLtP/rngBusziatEIo6oZGipTDnBBvfzOK1YRSVXCgrtLBS1VJRsSddS6WpOXBsrGU3bhqrYlk+zSz+D9cbk5v4CW2Sysh5W/GPifWrm2mW2rp62/Vas3bjPjGXwicfgwu/aro7Lr83uvLFMnmMn9GQSV+k+YkvDZCoqwZAVljxaKr7W/powaEthJRfCrVB9YvJ9JkXlqqTaN5ruo3YmlvvEPRLur3CrdUvlYqmUVMEXU/SuL5lsvyMXS8X9u7oEgnD6J+Ftn8junPEIBGDa4swslUyz6aOpXWBnteUJtVS8QMvfK7mQrvsLMg/Wu0F611IpqrAun3Yfi0pmm6OSDbkUlmzbP5QDFIuItwVip51i+8Wk2w0y02z6aGoW2AkM/b2ZH+sBKipeUFiuMRUle7pbEueouGSbAOn61l1LRcRJgPTR/ZVNNn22ZFtYMjIA7QeGxNpvpi+1VZabd6XeFzLPpo+m9iTrOjuS5nd5jIqKFxSWqaWiZMdAH/R1ZmCpNGR2/qZtNgmx6vihdRXT/HV/DYqKB+26U1Ezz8aauo5kdlxnk52RNWKi4lQ4TtcFlpP7y3mAyFNcRUXFCzSmomRLOEUvFZfCMmvNZOz+2mZdRIHg0LoRs1RGQlSyzMtwZ9Ilcn95Te1JtrvlgVfS27+jEUKlmVckAPvvjaiojGk0pqJkS7jFLlO5vyC7BMjD246dFlte52+jrg5HVEpHwP1V7cwAy7QGmPt3HClLJRiymfmZWCrlU7OL6xSW2uKSeZpW7KuoiMhKEdkmIjtF5MY424tE5D5n+wsiMttZXy0iT4hIh4jcGrV/RVR74Y0iclhEvu9su1ZEmqK2eTh9IwUaU1GyJVUxyWgm1UNrBu6v3i5o2TsUpHcpr7OzwjLN8E6XzibbSz44ApNLq463FkCmcZVBURkhSwWGyrWkUyInm2z6aGoX5K2vim+iIiJB4DbgAmAh8BERWRiz23XAUWPMXOB7wLec9WHgq8CXo3c2xrQbY5a5L2AP8NuoXe6L2v4zzy8qERpTUbJl0FJJQ1QqZ2RmqTTvAEwcS8Xx07tuKq9Jtze9FwwWlsxwBlhrAwSLbK/7kWL6Upt/kk4Sa0dTbrPnahdYoU13tpmH+GmpnA7sNMa8YYzpBe4FVsXsswq403m/BjhXRMQY02mMeRYrLnERkfnAVOAZ74eeIRpTUbIlE0ulst626U03ATJ2OrHLYAKkT8H6XLPpMyWbGWCxiY8jgduOOJ0kSLdCcbbULICBnuxL2OSAn6JSD+yN+tzgrIu7jzGmH2gF0n10WI21TKJtyUtF5FURWSMicWs7iMj1IrJeRNY3NXn0pFZYYf8BB/q8OZ8ycchUVADa07RWDm+z1Y9jkyXdJ2C/mnV1ZlFdNxeq58HRNzP7/5csR8Uv6hYBkjqu0t9rLZpc3V+Ql2D9WA7Urwbuifr8B2C2MeYU4BGGLKBhGGNuN8asMMasqK3N7of/3K7DfG3tFgYijp4Nlr9Xa0XJkIxEJcMEyKattkRIQdHw9X7X/xpJ9xfYGWCRfji6O/1j2vaNXJDepajcTixIZal4kTxak79pxX6Kyj4g2lqY6ayLu4+IFACTgOZUJxaRpUCBMWaDu84Y02yMcSOPPwOWZz/05Ly2v43/fm43HT1OyW1tKaxkS7jVFgB0H0ySMWmmXaYtKtuHnlijcW/4fkwr7u+11zTS7i9If1pxJDKyiY/RTD8ltaWSSza9S0mVdXP63W45Dn6KyovAPBGZIyKFWMtibcw+a4FrnPeXAY/HuLMS8RGGWymIyPSojxcDGdaZTp/K4hAA7WHH3NaWwkq2dLdYKyUd336F8xNPZwbYQJ/NqI4nKgWFNkDth6Uyktn0Lu604nRvoF3Ntl/LSLu/wMZVWvcmT9bMJZs+mtoF1lodYXyb82eM6ReRzwIPA0HgDmPMFhH5OrDeGLMW+DnwKxHZCRzBCg8AIrIbqAQKReQS4HxjjFth7grgwpiv/JyIXAz0O+e61q9rqyi2f7b2sGOpaEthJVvSqfvlUlRu903HUjnypnUJxQbpXcrrfBaVEaj75VJSZb8v3VyVwcTHPFkqYK2VE86Jv08u2fTR1C6AjffYKcwjOCHB14nkxph1wLqYdTdHvQ8Dlyc4dnaS854QZ91NwE3ZjjUTKgYtFVdUtKWwkiWZiApA5cz0RCW25lcs5VN9EpXDdjmS7i+wMYR03V/5FJVpTm+VA8lExbVUchSVmvn2ntS2/9hqzD4ylgP1eWPIUnHcX9pSWMmWjEVlRnr1v9wAbU0iUfHbUhlB9xdkNq3YFWU3RjWSlFVbt1uyci0dh2yFhdgJFpky9WS7zLTjZI6oqGSBKyptgzEVDdQrWRJuTa9Ei0u6CZCHt9ubV1FF/O3ldfaJOFkIs/sofGcebP9L+uPrdJ6yR9xSmef0jkk5z8daKoHQyJSRice0FMH6XLPpXeoW22UmfVw8QEUlCypLYt1f2lJYyZJwS2aWyqSZ1hpIVWKlaWtiKwXsTas/DD1tiffZ/7IViVfuTn98nU22KnIiMfOLTFoLt+2Hyum2eVY+mH6KddUlegjNpjd9PEqqYNJxcGhz7ufKABWVLDg2UO/GVNRSUTIkG/cXJLdWIhF704o388vFfRJOlgB5cJNd7nws/YZPbjb9SGaqQ2aFJfOR+BjNtFMAA4e2xN/ulaUCMG3J0L/jCKGikgVFBUEKCwJD7q9QKSDexlQ6m9Nv6KOMTfrC1lrwWlTaGmxDqKSWShpthQ86T7g9bbDnr+mN78Crw3u3jBRVx9laXmlZKnlIfIxmuhusj4mrGANPfcdWB3BFMlemLbadMfu6vTlfGqioZEllccGQpRIIeF9U8olvwK8/7N35lNGH63rKdPYXJBcVt+ZXOpZKMlE5tBlmn23dWdv/nHpsja9D4xZYeHHqfb0mELTlaFIVljRmqO5Xvpg0E0omD4919HTAb66BJ26BJVfAWTd48111i8FEoPG11Pt6RFqiIiKfF5FKsfxcRF4SkfP9HtxopqI4RFt3VK0hr8vfdxzyt4+4kn8GS7RUpX9MpZMAmWwGmDudOFGOCkCFKyoJsur7e+xT/6zT7dTXbetSl2zf/ICtNbbwkuT7+UXNvNTJfl1HrHWYT/eXyFAZfLDlZe54P7z+Bzj/Fvjw7RAq8ea7pi2xyxF0gaVrqfyjMaYNOB+YDHwU+KZvoxoDDLNUwHtLpbvF/vjTrUirjD26W+yypCr9Y4oqoChFAmTTNtvPJNm03uIq24ckUbOupq02ebJuMSy4AFreSj411RgrKrPPHhKskWbaEus6cv+u8Rjpjo+JmH6KtR52Pga3v8dm2V/1G3jn//A2HlV1vE3OPjhywfp0RcW9yguBXxljtkStm5BUFIeG8lTA+/L37lOs229DGX9kUkwymkkpOkDuewmmLkx+cxIZmlYcD/fJdtopMH+lfb9tXfx9wc4UO/IGLLks+dj9ZMZpdpksByQfzbniMW2pLRXz6w/biQ2ffALmvs/77wkEbFxlFFoqG0TkL1hReVhEKoCIf8Ma/VQcY6l43FLYFZNkT13K2CaTBl3RVM5IXP/r0BY4tCm9uEayrPqDm+0ElClzoGKavWEni6tsfsDmfpx8Uerv9YsZp9rl/pcS75PPbPpoZq6whUQXXAifePTY9gReUrfY/i4iI3PLTldUrgNuBN5mjOkCQsDHfRvVGCC+qHgYU1FLZfyTraWSrFf9xrvtzWrxpanPUz4tsaVyaLO1dgJB+3nBBdCwPv4U5EgEtjxon7RLJqd3DX5QOgUmz7ZWUyLa9oMEvckDyYUpc+CLr8OVd0Fxpb/fNW2JvTe17Pb3exzSFZV3ANuMMS0icjXwv7ENtSYsx7i/vIypRAaGZgappTJ+yUVUOhuPzR0Z6IdNv4F570+vTEr51PiTQYyx7pJpi4fWLbgAMLDj4WP33/s3awGkI2R+M+PU1KJSMX1ILPNJ+dSRScB0/x1HKK6S7hX9COhy+ph8CdgF/NK3UY0BKotDdPYO0D/gmJRexlTCUXrdfdSbcyqjj3Crza3IdKaP67qJ7QD5xhPWnbV09bHHxKO8zikDH9MxsW2ftZDrokSlbrGdzrwtjgts8wNQUOIIT56ZcZqdVOAWtowl3zkq+WDqQjsrb4TiKumKSr/T52QVcKsx5jZghOswjC7crPrBRl1exlSiXV7q/hq/ZFqixcWtOBvrAnvlHut+mv/+9M5TPhUwx96AB4P0S4bWiVjR2PX48ES6gX7Y8jtYsHKosGo+GYyrbIy/fSKKSqjEtlweoXIt6YpKu4jchJ1K/CcRCWDjKhOWY0u1lNt2wmn1GEvBMEulJffzKaOTTEu0uLgzl1qjGqmGW2Hrn2DxZelXt62YZpexwXrXTVK3aPj6BSuhvxvefHpo3ZtPQddh+72jgelLAYkfrHcTH/NRnTjfTFs86txfVwI92HyVg9jWwN/xbVRjALenStuw7o/GlsfIlWghUUtl/JK1qLilWqJEZcuDNq9p6UfSP095ggTIQ5tsb/vYopCzz7YPT9FTizc/AEWV/kyHzYbiSpsEGS+uEm6x/z8nmqUC1upsfWtE3OlpiYojJHcBk0Tkg0DYGDPBYyoxloqXPVXUUpkYZCsq8RIgX7nX1vqqPy398wzW/4oJ1h/cPDxI71JQBCe+F7Y/bGd89ffYLPCTL4JQcebX4RczTrW5OrEM5qhMQFGpc1yZiYpYeki6ZVquAP6O7dJ4BfCCiKS0d0VkpYhsE5GdInJjnO1FInKfs/0FEZntrK8WkSdEpENEbo055knnnBud19Rk5/ILt/z9YKmWwZbCHopKabVaKuOZbEUFnL4qjqVy5A1463kboM8kG9tt+Rvt/urpsOerWxL/mAUXQvsBOLARdjxiZykuHmU16macZoWy7cDw9aMl8TEfjGC5lnTbCf8rNkelEUBEaoFHgTWJDhCRIHAbcB7QALwoImuj+syDzX85aoyZKyKrgW9hXW1h4KvAYucVy1XGmPUx6xKdyxcSl7/3QlRa7HLybJ39NZ7pbsmsREs00aLyyn2AwClpzvpyCRXbci3R7q/G1wAT31IBmHe+nUm0/c+2vH5pNcw5J+Ph+0p0EmTlB4bWj5bEx3xQUWcz90cgrpJuTCXgCopDcxrHng7sNMa8YYzpBe7Fzh6LZhVwp/N+DXCuiIgxptMY8yxWXNIl7rkyOD4jhvrU+9BSONxqE7Qq69X9NV4xJjdLxS3VEonYWV8nvDu7PuSxbYXdJ9m6BKJSVg2z3m5jONsessUjg+k+m44Q05bY/z+xcZW2/VYQvepVMtaoWzwiXSDTFZU/i8jDInKtiFwL/AlIUggIgHpgb9TnBmdd3H2MMf3YhMrqNMbzC8f19dUo4UjrXCJyvYisF5H1TU1NaXxVfOLO/gJvphV3t9ibTclkdX+NV/q6IdKXg/ur3loYbz4FLXsyC9BHUz51eJb8oc02XlN1XOJj5q+0FYz7u/Nb6ysRhaW2P3usqLTus4ISnKATV6ctsYVCY/OSPCbdQP1XgNuBU5zX7caYf/FzYEm4yhizBDjbeX00k4ONMbcbY1YYY1bU1mbfRzsUDFAcCtDeEysqHpRqCbdat0hJlVoq45Vss+ldKmcABp79nv3tZVtz6xhLxQnSJzPyF1zojKEeZp2R3ff6zYxlNlgfPcV/IuaoRDNtiS1imU4jsxxIu0aAMeYBY8wXndeDaRyyD5gV9Xmmsy7uPiJSAEzCutaSjWOfs2wH7sa62bI6V65URvdU8bKlsJsUV1wFAz0j2rVNGSFyFhXH6H/zKVi4auj3lynRlYojETs7KJHry6VmHpzwHjj9+vz1eU/FjNOg+4jNrnfJdxvhfDMYrPc3rpL0FyEi7SLSFufVLiJtKc79IjBPROaISCGwGlgbs89a4Brn/WXA407mfqLxFIhIjfM+BHwQcP9CGZ3LC4YVlfQ6plJcNRTE1WD9+GOwQnFVdsdH3xzTLcsSj4o66Ou0v9ujb9r3iYL0LiLwsd95153QD+JVLJ7oolI9z5YFOuTvDLCkETZjTNalWIwx/SLyWeBhIAjcYYzZIiJfB9YbY9YCPwd+JSI7gSNY4QFARHYDlUChiFyCbRC2B1t6P+Sc81Hgp84hCc/lFxXFoajkR49jKpX1Qzec7paJbbaPR7Lp+hiNG5SfNAuOPyv7cUS3FU4VpB9L1C2yTcj2vwyLPgThNuuansj/j4IFNtbk87RiX6dtGGPWERPQN8bcHPU+jM19iXfs7ASnXZ5g/4Tn8othlkowZJ8CPI2pOGXENVg//sjV/VVUYW/+S1fn5oIqj8pVObTZzpqaenL25xstFBRZYXGTICdy4mM00xbboqDGeNthMopR6hAdG1T6Uf7emKGYyqD7qyW3cyqjj1xFBeCf/mrbz+bCMEtls42XeNUfPd/MOM12gYxERk8b4XxTt8TWaovX8sAjVFRyoLKkgLboRl1elL/vD9sZGsVVQ64RtVTGH4MxFZ8bNKWi3C0q2WgtlfHg+nKZcarN+D+ya2InPkbjBut9rFisopIDxzbqKs89oz76CVYtlfFLd4vtQZJuRWG/KJlsO0U2bYXWvamD9GOJwWD9y477S2yDromMW3naxyTIUZYKO7aoKCog3BehbyBCKBjwRlRcASmpskloiM7+Go+4cbN8EwjYGmA7H7OfE9X8GovUnmSFe//L9v9l+VQoKMz3qPJLSZVNbPVxWrFaKjkQt/5XrjGVaEslELDuEXV/jT9yKdHiNeVTbVY+jC9LJVgA00+xwfq2/er6cqlb4usMMBWVHIhb/yvXmEps/kLJZHV/jUdGk6i4zbrKasdfXawZp1lXT8tbGqR3mbbYxpl6Pej9FAcVlRwYKn/vYUvh2PyF4iq1VMYjo0lU3GnFdSnKs4xFZpxqG3Md3q6Wisu0JWAi0Pi6L6dXUcmBIfdXVAJkrnkqrlXi3nC0/tf4JNv+9H7gWifjyfXlEt20TEXF4s7w8ylYr6KSA66otPkVUwG1VMYrbime0YArKuMpSO8y5cShBnrq/rJUHQ8f/L5tl+ADKio5UBkvpjLQC/292Z803AKh0qFZKiVVOvtrvJFrLxWvqV1gpxXPXJHvkXhPIGArFoNaKi6BAKz4OEw5wZ/T+3LWCULinio5BOvDLcOfYIurrPvL39qYykjS22F92qNFVOa8C768A6pPzPdI/MHNV1FRGRE0TyUHyotc91dsUckOKJ2S3UndBl0uJZNtM6e+ruzLmyujCy9KtHhNtr/XscCpV9v/P1XH53skEwK1VHKgIBigrDAYp099DnGV2KQ4zaoff4xGURnP1C6AD/wHBIL5HsmEQEUlR4aVailyAoK55KrE+tq1/tf4I3aGn6KMI1RUcmRY+Xv3JpFLYD02pqKWyvjDtVRGQ5kWRfEYFZUcGSYqk2baZVtD9idMZKnoDLDxg7q/lHGMr6IiIitFZJuI7BSRG+NsLxKR+5ztL4jIbGd9tYg8ISIdInJr1P6lIvInEdkqIltE5JtR264VkSYR2ei8PuHntblUlkR1fyyvs1MzW7MUlUjEdqiLF1NR91d8uo7A7/4ZDr2W/jGRCBx5E3Y+Cn//KTx0I9x1BfxwOdz2dt/KVwySa9dHRRnF+Db7S0SCwG3AeUAD8KKIrDXGRP/vvw44aoyZKyKrgW8BVwJh4KvAYucVzXeNMU84fe8fE5ELjDEPOdvuM8Z81q9rikdFcYg9zc5NKBCEihnZi0pPG2COnf0F6v6KR3cL/HKVzQyWAKy6NeUhADz0FXjxZ0OfQ2V2zn7lDHjzaXjzKVhwgS9DBoZEpSjPvVQUxQf8nFJ8OrDTGPMGgIjcC6wCokVlFfA15/0a4FYREWNMJ/CsiMyNPqExpgt4wnnfKyIvATN9vIaUWPdXVE+VSTOzF5XBYpJRolJYYW+YaqkMp6cd7rrM1i+auhB2/MVaIKla6w70w+YH4MT3wtlftrkZ5XW25lV/L3x7Dmx/2GdRabHTz4M6o18Zf/jp/qoH9kZ9bnDWxd3HGNMPtALV6ZxcRKqAi4DHolZfKiKvisgaEZmV4LjrRWS9iKxvampK60KSUVEc0/0xJ1GJ4xYJBKzIqKUyRG8X3H2lLWl++S/gzBtsO9wDL6c+du/fbHxq+bUw+0xbodctolhQCCe+xwqUn8mmo6lEi6J4zJgM1ItIAXAP8APXEgL+AMw2xpwCPALcGe9YY8ztxpgVxpgVtbW1OY+lsjhEb3+EcN+AXTGp3vZuiAxkfrJEU02LqzRQ79IXhns/Am89Dx++HU6+COa+z1pz2x9OffzWdRAsghPPjb993vtt61kf262OqhItiuIxforKPiDaWpjprIu7jyMUk4DmNM59O7DDGPN9d4UxptkY0+N8/BmwPLthZ0ZlbKmWSTNtBnxHY+YnSzTVtKRK3V9g3VP3fwzeeBJW3QZLLrPry6ph5umw/c/JjzcGtv3JFtIrKo+/z7zz7TIdgcoWFRVlHOOnqLwIzBOROU5QfTWwNmaftcA1zvvLgMeNSe53EJFbsOJzQ8z66ObTFwP+NAuI4ZhGXZMcHc3GBZZoqqlb/2siM9APD1wHOx6GD/wnLPuH4dvnvx8OvOL0Ik9A4+twdHfyeElFna0V5auotKioKOMW3yKFxph+Efks8DAQBO4wxmwRka8D640xa4GfA78SkZ3AEazwACAiu4FKoFBELgHOB9qAfwW2Ai+J9YXfaoz5GfA5EbkY6HfOda1f1xbNMUUl3VyV1r0w622ZnSy266NLyWR7vonMlgfh9bVw/i3wtuuO3T5/JTz2b1YMVnw8/jm2/cnZN0UQfv5KePKb0NlsraBkvHyXbQDV123rS/V1D71fuCr+WLpbYeqi5OdVlDGKr9NPjDHrgHUx626Oeh8GLk9w7OwEp43bms4YcxNwU1YDzYEhSyU2ATLW05cG4VYbGyiMcc1ooy7YdD9UzoQzPhN/+9SToeq4FKLyENQvh8rp8be7zDsfnvx32PkILF2deL99G+D3/wyBEBSW2qnJoRLbuiDcCg/9C8w9144rGnV/KeMYndOYI8d0fyyeZKcBZ+P+cisUx06LdRt1GTP+2r2mQ2cz7Hoc3vGZxFOGRayF8dKvrKUQKhm+ve2AFYH3fjX1901fBmVTrUAlE5XnfmhzTb6wBYpjck5aG+CHK+CR/2NnqLlEIjYfSUu0KOOUMTn7azQx2Kfei1yVRE+wJVUQ6c+tT8tY5rXf2etffFny/ea/H/q74c1njt223cmPPekDqb8vEID558POx2CgL/4+R96E135vraJYQQH7Gzjzc7Dlt/DWC0Pr4yW4Kso4QkUlR46JqYAjKlnEQGKLSboM1v9qyfyc44HND0DNApiWot3t8WdZF5QrINFsXQeT50DtSel957z3Q08r7H0h/va//QgkCG//dOJznPl5qJgOD99kLRTQul/KuEdFJUfKCwsQIU4CZJYxlUSWCkzMacWtDbDnr3b6cCrXX6jYJi9uf3h48mJPu1N65cL03YcnvsfGSuLNAus6Ai//CpZcnrybYGEZnHuzdbttXmPXxauaoCjjCBWVHAkEhPLCOKVaug5b334mdLfE97VP5Ppfm39rl4svTW//+XGSF3c9DgO9cNKF6X9vUYXNuI8nKi/+3M7ueuf/SH2eU1bbGM2jX7OVANRSUcY5KioeMKz8PURNK87QWklkqUzkRl2b18CM09Lvnz7v/XYZnQi5dZ0V5llnZPbd81fC4W02fuLSF4a//wTmngd1C1OfIxCAlf9uhe65H2qFYmXco6LiAZUlIdq6YywVyDyukigpbqI26jq8wyY0Lok76zw+FXVWhLY5ojLQbxMm56/MvICjm12/4y9D6169Fzqb0rNSXI5/p81Z+ev3oXGrXaeWijJOUVHxgISWSia5Kn1h6A+nCNRPsPpfm9YAAos+lNlx81faOEZHo60R1n3UxlMypfpEqJ475AKLROC5W2H6UpjzrszO9b5/szPYnv2e/ayiooxTVFQ8oKI4RHtPlKVSMQOQzKYV97TZZbybTVGFnWk0kdxfxsCm38Ccs1MnK8Yy//2AgR2PwDa3gOR7sxvH/JWw+xno6bAuteYd8M7PZZ4vNGUOnPFP0NcJiPZSUcYtKioecIylUlBoe3Rk4v5yXVtuUD4akYlX/v7ARjiyK3VuSjymL7VTebc/BFtTFJBMxbzzbZD/zafguR/ApONg4SXZnevsL0NpjRWUVH1fFGWMohn1HnCMqEDmCZCpZgWVTJ5YlsqmNXZK78KLMz9WxForL//aupzO+kL24zjuHVYEnvq2FbqV38y+uVZxJXzoJ/6W1VeUPKOPSx5QWWwD9cMKLGcsKi12mWhW0Fit/9V+yJasz4TIgE14nHdefMstHeavtIICuXVxdBt3HdhoBf/Uj2Z/LoB574OzbsjtHIoyilFR8YCK4hD9EUO4LzK00k2ATLeDYCpLxa3/5SW/+wys+5/p739wM/zoTHjwn+DV++P3jDHGznB6+jvwk3fDf8yHOy+yCYjpsuc5aD8w1C8lG+a8GwqKoX6F7e6YC+405RXXZe9GU5QJgrq/PCC6qGRJYdCunDTL1qHqOpK6fDoMzexKVGiwpAqOvhl/Wza0HYBX7rY+/gu+lV7geesf4dAWO6vtlbvturolcOI5tknWvg12n+addlv9Cnj7P8Hfb4e7Loer1qR3U968xpZbSVWiPhmFpXDxD4f62+TCokucAH0G04gVZYKiouIBrqi0hfuZ6k7qmVRvl6170xOVdCwVL91fm34DJgKdjdZNV5XGzXffBlti/tPP2vyRXY/bLox/+zFEfgiBAph9lq2HddIHhkqYHPd2WHOdIyy/SS4s/b22UONJF1phyIVTrsjteJfCMnjf17w5l6KMc1RUPKAytvsjRCVANsCMZalPEm6BghIoKIq/vaTKCo8X5e+NgVfugZIp0H3EikUqUTEGGtbbm30gCPWn2de7vgy9nXDgVZh6UvwYyKIPWQF74BNw95Vw1f32Rh1LJAIv3WmttkwSHhVFGTVoTMUDKkuGLJVBXLdLugmQqRo3lUwGM5BZbCIRBzdB42vwrq/YHI5961Mfc3S3FaD6FcduKyyD49+RPKi++FL48E/hreessPR2DW3rPmqTCn94Kqz7sq0kfMJ7Mr4sRVHyj6+iIiIrRWSbiOwUkRvjbC8Skfuc7S+IyGxnfbWIPCEiHSJya8wxy0Vkk3PMD8TpKSwiU0TkERHZ4SyznDaUOcf0qQcorbaB4nRzVRIVk3Txsv7XK/fa6bpLV8P0U2DfS6mP2bfBLuuXZ/+9Sy6DD91uqw7ffQU0bIC1n4P/OBn+8q82afSyX1j3WkFh9t+jKEre8E1URCQI3AZcACwEPiIisRX4rgOOGmPmAt8DvuWsDwNfBb4c59Q/Aj4JzHNeK531NwKPGWPmAY85n0eEuD1VRKCyPv1pxSktlSq7zDWuMtBvW/MuWAmlU6xI7H/Zrk/Gvg3WPTc1jSKKyTjlcrjkx7D7WfjZe+0sslMuh089A//4ECz+MARDuX2Hoih5w8+YyunATmPMGwAici+wCngtap9VwNec92uAW0VEjDGdwLMiMjf6hCIyHag0xvzN+fxL4BLgIedc5zi73gk8CfyL1xcVj7iWCmSWqxJuhfKpibd7Vf9r1+O2IOLSj9jP9cvhhR9D01aYtjjxcQ3rbWwo28S/aJZeaUvPHN1traXSKbmfU1GUUYGf7q96INr30+Csi7uPMaYfaAWSTZWqd84T75x1xpgDzvuDQF28E4jI9SKyXkTWNzU1pXMdKSkrDBIQ4mTVz8pAVFqSl0P3qlGXG6Cfe5797LqzXPdWPAb67GyvXFxfsZx0Ibzjn1VQFGWcMS4D9camtsfNOjTG3G6MWWGMWVFbW+vJ94kIFcUx5e/BWirtBxP3OY8mlfvLi5bC3S22FtaSy4ZiFlNOsOdOJiqHNsNAj7eioijKuMRPUdkHRM9Tnemsi7uPiBQAk4DmFOecmeCchxz3mOsmi5Pu7R8J639hoG1/8oMjESsqyQL17syqXCyV135vxWHp6qF1IlYskomKu21mnJlfiqIoUfgpKi8C80RkjogUAquBtTH7rAWucd5fBjxuTOK6Jo57q01EznBmfX0M+H2cc10TtX5EqCgODZ9SDFEJkClcYL0dNo8jmaVSWGaTC3OxVF65F2rm2yZW0cxcYacY93bGP65hA5TVepOdrijKuMY3UXFiJJ8FHgZeB+43xmwRka+LiFt69udAtYjsBL5I1IwtEdkN/CdwrYg0RM0c+2fgZ8BOYBc2SA/wTeA8EdkBvM/5PGJYSyXW/eXchFOJSqpikuCUv6/KPlB/5E2bI7J09bHJk/XLragdeCX+sfs22PyUXJMuFUUZ9/iaUW+MWQesi1l3c9T7MBA3ddoYMzvB+vXAMdOUjDHNwLk5DDcnKosL2N8SjlnpWCptqUQlRYkWl5Kq7N1fr94PCCyJU7rEtVwa1tvWt7FjO7xdM9wVRUmLcRmozweVxSHaYi2VwlKbBJnKUhls0FWVfL9s63+5ZVnmnB2/HEt5LVQdFz+usv9lwMBMDdIripIaFRWPiBuoh/RyVfy2VPb+3VY4dnNT4lG/In5mfYNTwiU2DqMoihIHFRWPqCgO0dHTzzHzDCozEZWq5PuVTM7OUnnlHgiVwskXJd6nfjm0vnVsj5R9L0H1vNRWlKIoCioqnlFRXMBAxNDVOzB8Q1qWSotdprJUsmnU1dMOm38LJ33QZrEnIl4SpDG22KTmpyiKkiYqKh4xVKolTq5KT9uQNRKPcCsgthd6MtyWwpFI8v2iWX8H9LTC2z+VfL/pS0GCw0WlbR90HNL8FEVR0kZFxSOGyt/HyaoH21o4Ed0tUFwJgRT/HMVVgLEilQ593fDcD20Z+VTCUFgKdQuHYigw9L5e4ymKoqSHiopHJC0qCcldYKlKtLhkWv9rw522eOS7vpLe/vXLYf9LQ5bQvg0QLLQtgxVFUdJARcUjolsKD2NQVJL0VUlVTNIlk/pf/T3w1/8Hx58Js89MvT/YGWDhVjjyhv28bwNMO0V7myiKkjYqKh5RGa+nCkB5nS2vkqwDZNqWSgb1vzbeDe37bbvfdBkM1q+3/VX2v6zxFEVRMkJFxSMSur8CQaickdz9larro0u6jboG+uDZ/7QikUlb3toFUFhuLZSmrdDXpTO/FEXJCBUVj6h0RKWtO14CZIq+KulaKuk26tq0BlresrGUTOp1BYIw41QrKl60D1YUZcKhouIRxaEABQE51lIBp62wBzGVdAL1kQF45j9scH3+ysT7JaL+NDi4CfY8Z8c05YTMz6EoyoRFRcUjbKOuJKVa2g7YG34s/b3WzZSOqIRKIRBK7v567XfQvAPe9aXsqgrXL4eBXtt7pX65ViZWFCUjVFQ8pKI4FN9SmTQTIn3HlkCBoZyTdGIqIsnrf0Ui8PR3oWYBnLwqzVHHUO8E5vu7NUivKErGqKh4SGJLJUlfFdfqSCemAsnrf21/yDbbOvtLqRMpE1E5A8qn2fcaT1EUJUNUVDwkbvl7SJ6rkm4xSZdE9b+Mgae/A5Nnw+JL0ztXPNz2wqCioihKxvgqKiKyUkS2ichOEbkxzvYiEbnP2f6CiMyO2naTs36biLzfWbdARDZGvdpE5AZn29dEZF/Utgv9vLZ4JI2pgA1+xxJ2ZnKlbalUHTv7q/so/OYam1dy9pcgmGPvteXXwumfgrKa3M6jKMqEw7fOjyISBG4DzgMagBdFZK0x5rWo3a4Djhpj5orIauBbwJVO6+DVwCJgBvCoiMw3xmwDlkWdfx/wYNT5vmeM+a5f15QKG1OJIyrFlbDiH+HFn8L898O884a2uZZKuqXli6ugadvQ57degAeug/YD8L5/g2VXZzv8Ieafb1+KoigZ4qelcjqw0xjzhjGmF7gXiI0erwLudN6vAc4VEXHW32uM6THGvIntR396zLHnAruMMXt8u4IMqSguiO/+Anj//4W6xfDgp6Bt/9D6jGMqVdb9FRmAp74Nv7jA5pf841/grBuyj6UoiqJ4gJ93oHogOojQ4KyLu48xph9oBarTPHY1cE/Mus+KyKsicoeITM5t+JlTWVxAR08/kYg5dmOoBC77ha0c/MAnbBkUSL/ro0txFYTb4M6L4YlvwKIPwaee0Xa/iqKMCsbkY62IFAIXA7+JWv0j4ESse+wA8B8Jjr1eRNaLyPqmpiZPx1VZEsIY6OiN4wIDqJ0PH/hP2PNXePrbdl24BYJFVnTSoWQyYGz85JIfwaU/s+41RVGUUYBvMRVsvGNW1OeZzrp4+zSISAEwCWhO49gLgJeMMYfcFdHvReSnwB/jDcoYcztwO8CKFSvimBTZUxFVVNIt23IMyz4Cbz5tXVfHn5l+iRaX+e+Hg6/C2V+GmrkejFpRFMU7/LRUXgTmicgcx7JYDayN2WctcI3z/jLgcWObvK8FVjuzw+YA84C/Rx33EWJcXyIyPerjh4DNnl1JmiQsKhnLhd+Bmnnw209C867M+r9Xnwgf+rEKiqIooxLfRMWJkXwWeBh4HbjfGLNFRL4uIhc7u/0cqBaRncAXgRudY7cA9wOvAX8GPmOMGQAQkTLsjLLfxnzlt0Vkk4i8CrwH+IJf15YI1zrZ1JCkdTBAUbmNr3S3wO5nMrNUFEVRRjFiDYOJyYoVK8z69etT75gm3b0DXPGT53ntQBvf/PASLl8xK/kB6++AP34B5p4HV6/xbByKoih+IiIbjDFx6zj5GVOZcJQUBrnn+jP49K828JU1r3K4o5dPv/sEJFFRxuUftyXqa08a2YEqiqL4xJic/TWaKS8q4I5r38ZFS2fwrT9v5f/74+vxpxiDLYnyvq/B0tUjOkZFURS/UEvFBwoLAvy/K5dRU17IHX99k8MdPXz38qUUFqiGK4oyvlFR8YlAQLj5gwuprSji23/extGuXj7znrlUFoeYVBqisriA8qKCxK4xRVGUMYiKio+ICP98zlxqyou46bebeGbH4WHbA2ITJhfPmMRly2eycvE0ikPBuOcaiBie2dHE/ev38uLuo9RXlXBCTRkn1JYxp6acOTVlHF9dSkCE3oEI/QMR+gYMfQMRegciVBQXUF1WRDCgIqYoin/o7C8PZ38lY++RLvYe6aK1u4+2cJ9ddvdztKuXp7Y30XC0m4riAi5aOoMrVsxi6cxJiAh7j3Txm/V7WbOhgf2tYaaUFfKueTU0dfTwZlMn+1vDaY8hIFBdXsTUCvuqrShiRlUJs6vLmF1TxuzqUqpKC4cd09LVy/ZDHWw/1M7Oxg72t3RTXV5IXWUxdZXFTKssZmplEXWVxRQWBAiIIGCXwqDIdfX20907QFfvAN19A3T3DtA7EMEYgzG2cn/EGAxQGAxQU15EXWUR1eWZC2FHTz97mjvZe6QLEGorCqkpL6KmvIiyIn2OUpRcSTb7S0VlhEQlGZGI4W9vNPObDQ08tPkA4b4I86aWU1tRxPNvNANw9rxaVr9tFu87uW5YbKart5/dh7t483Anbx3pQgRCwQChoDjLAAUBoT3cR2N7D03tPTS299DYHqaxrYemjh6ifwJVpSGOry6jNBRkR2MHhzt6BreVFQaZUVXC0a4+mjuHH+cX0UJYU15ESShIUShAYTBAUShAUUGQgqBwqDXMniNdvNXcRXNnb8LzlYSC1FYUUVNe6CyLhi2rywopKQxSEgpSUhikuMAuiwoC9A0Yegci9PbbV99AhJ7+iBVDA4YhgTQYSkJBppQVUlkcIpBEGHv7I7R09dLTHxkU50zp7Y/Q3NnD4fZeDnf0EDGGqtIQk0oKqSoNUVUSoiA4dN5IxNDdN0Bnbz+dPQP09A9QVlhARXEBZUUFhIKjJ/5njKGjp59DbWEOtvZwqC1MeXEBC+oqOG5KadK/rTGG5s5eWrp6mT6pZNQ8VPQ5v6PSwmDOLnBjDD39kcGHOMF6SQKCb+51FZUEjBZRiaYt3McfXznAmg17OdrVxyXL6rlsxUzqq9KsDZYh4b4B9h7pYndzF7sPd/Jmcyd7mjvp6h1gbm058+rKmVdXwfy6CmZMKh78kfYNRGhst//BD7WGaWzvoW8gMszicG+2oaBQUlhAaShIaWGQ4sIgpaEgoTiWDUDvQGRQ/Jrawo4I9tDc0UO4L0JP/wC9/faG3tNv3Xu15UUcN6WU2TWlHDfFugKPm1IKwOGOHg532Jvt4XYrpPZ9L00dPRxJIkJeEBCYXGpv7lPKCgkFA7R0WWv1aFcvXb0Dw/adUVXCcVNKnWsoY0ZVMT19EY529XK0q4+Wrl77vrOPw509NHf00tqdoooDUFFUQFEoSHdvP119A0kfCopDASqKQ5Q7N+GBiBl6GbtMRFVJiPl1FcyfVsFJ0+xvZ3Z1KQXBAP0DEQ62hWk42s3eI100HO3mYGuYnv6BQdHuc169/RGaO3o52BYe9jeKHed85/e5oK6CiuIC9hzpYk9zJ7sPd/HWkS46eoZq8dWUF3LcFPvbOK66jBmTiukdiNAe7ndefbSH++no6ScgdtJNUUGQwmDAeR9ABAYi9vc9EDH0RwyRiKEvEqHH+X2G+yKE+wbo6bfL7r6hdd19A4N/v0klIU6oLePE2nLnVcYJteXOg6AdT1u4nzZnXC1dvTS129+vXdrfcG9/JO7fJxgQplUWM6OqmBlVJYOv+qpiFs2YRF1lcaqfTVxUVBIwGkVFGXn6BiIc6bT/WY909jo3AOui6466IYQCQmFBYOjl3GiCAUGwomifEgGEcN8ARzqtAEQv+wYMVSV2wsbk0kKqSkJUlRVSGBT2He12bor2hhgreKGgUFVayOTSEFWlhdSUD7n2asqLqHY+BwNCS5cVm5Yu+zra1TtokZQWFVBWGKSsqICyoiCFwSBdvfZm6t5U28N9dPTYm3lBQAiIEAxAMBAgGAD7ODAcg6G5o5dtB9vZ3dyJqz2FBQFqygppbO+hP0qQRKC2vIiSwuCgZT1kZQvVZUWOq7WIaZOsy3VqRRFt4X62H2xn26F2tjnLpvaewb/RrMlWlI+vtg8Yk0sL2ddihcz92x5o7SZaG0NBoaI4ZK21QiumvQNDDzHug4wx9mYdELt0/x4FAWs9FxcEKQ4FKA5ZC7c4ZC3fYscCLg4FKAkFCQYC7GvpYldjJ7uaOmhsH/IKJMK13O2/t7W2a8uLqCyx1TyMMUSirOWe/giHWsPsa+lmf2s3B1rCg3//Wy5ZzNVnHJ/Of5Fj0ORHRUlCKBgYjBGNNtrDfexvCVNaGGRyWSFlHrhLRopw3wA7GzvYerCd7YfaOdzew4yqEmZOLmHm5FJmTSlh+qSSrKfaL5tVNezzkc5eOnv6mVFVklYcrrc/QmN7mOJQkPKigoSTZEaKtnAfbzR18kZTB8bYArWVJVbkKh2xqygO5TTZZiBiONzRw76Wbt+8H2qpqKWiKIqSEcksldETjVMURVHGPCoqiqIoimeoqCiKoiieoaKiKIqieIaKiqIoiuIZKiqKoiiKZ6ioKIqiKJ6hoqIoiqJ4xoROfhSRJmBPlofXAIdT7jX+mKjXDRP32vW6JxbpXPfxxpjaeBsmtKjkgoisT5RROp6ZqNcNE/fa9bonFrlet7q/FEVRFM9QUVEURVE8Q0Ule27P9wDyxES9bpi4167XPbHI6bo1pqIoiqJ4hloqiqIoimeoqCiKoiieoaKSBSKyUkS2ichOEbkx3+PxCxG5Q0QaRWRz1LopIvKIiOxwlpPzOUY/EJFZIvKEiLwmIltE5PPO+nF97SJSLCJ/F5FXnOv+N2f9HBF5wfm93ycihfkeqx+ISFBEXhaRPzqfx/11i8huEdkkIhtFZL2zLqffuYpKhohIELgNuABYCHxERBbmd1S+8d/Ayph1NwKPGWPmAY85n8cb/cCXjDELgTOAzzj/xuP92nuA9xpjlgLLgJUicgbwLeB7xpi5wFHguvwN0Vc+D7we9XmiXPd7jDHLonJTcvqdq6hkzunATmPMG8aYXuBeYFWex+QLxpingSMxq1cBdzrv7wQuGckxjQTGmAPGmJec9+3YG0094/zajaXD+RhyXgZ4L7DGWT/urhtARGYCHwB+5nwWJsB1JyCn37mKSubUA3ujPjc46yYKdcaYA877g0BdPgfjNyIyGzgVeIEJcO2OC2gj0Ag8AuwCWowx/c4u4/X3/n3gfwIR53M1E+O6DfAXEdkgItc763L6nRd4OTplYmGMMSIybueki0g58ABwgzGmzT68WsbrtRtjBoBlIlIFPAiclN8R+Y+IfBBoNMZsEJFz8jyckeYsY8w+EZkKPCIiW6M3ZvM7V0slc/YBs6I+z3TWTRQOich0AGfZmOfx+IKIhLCCcpcx5rfO6glx7QDGmBbgCeAdQJWIuA+g4/H3fiZwsYjsxrqz3wv8P8b/dWOM2ecsG7EPEaeT4+9cRSVzXgTmOTNDCoHVwNo8j2kkWQtc47y/Bvh9HsfiC44//efA68aY/4zaNK6vXURqHQsFESkBzsPGk54ALnN2G3fXbYy5yRgz0xgzG/v/+XFjzFWM8+sWkTIRqXDfA+cDm8nxd64Z9VkgIhdifbBB4A5jzDfyOyJ/EJF7gHOwpbAPAf8H+B1wP3Actm3AFcaY2GD+mEZEzgKeATYx5GP/X9i4yri9dhE5BRuYDWIfOO83xnxdRE7APsFPAV4GrjbG9ORvpP7huL++bIz54Hi/buf6HnQ+FgB3G2O+ISLV5PA7V1FRFEVRPEPdX4qiKIpnqKgoiqIonqGioiiKoniGioqiKIriGSoqiqIoimeoqCjKGEVEznEr6irKaEFFRVEURfEMFRVF8RkRudrpU7JRRH7iFG3sEJHvOX1LHhORWmffZSLyNxF5VUQedHtZiMhcEXnU6XXykoic6Jy+XETWiMhWEblLoguUKUoeUFFRFB8RkZOBK4EzjTHLgAHgKqAMWG+MWQQ8ha1WAPBL4F+MMadgM/rd9XcBtzm9Tt4JuFVkTwVuwPb2OQFbx0pR8oZWKVYUfzkXWA686BgRJdgCfRHgPmefXwO/FZFJQJUx5iln/Z3Ab5z6TPXGmAcBjDFhAOd8fzfGNDifNwKzgWd9vypFSYCKiqL4iwB3GmNuGrZS5Ksx+2VbLym6FtUA+n9ayTPq/lIUf3kMuMzpV+H2/z4e+3/PrYD7D8CzxphW4KiInO2s/yjwlNN9skFELnHOUSQipSN5EYqSLvpUoyg+Yox5TUT+N7a7XgDoAz4DdAKnO9sasXEXsKXGf+yIxhvAx531HwV+IiJfd85x+QhehqKkjVYpVpQ8ICIdxpjyfI9DUbxG3V+KoiiKZ6iloiiKoniGWiqKoiiKZ6ioKIqiKJ6hoqIoiqJ4hoqKoiiK4hkqKoqiKIpn/P93J42D3x249QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_hist(history)" ] }, { "cell_type": "code", "execution_count": 58, "id": "347a2c53-c424-430e-887c-6c7aa0fa363f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "33/33 [==============================] - 1s 5ms/step\n", "16/16 [==============================] - 0s 4ms/step\n", "Train Score: 3.22 RMSE\n", "Train R^2: 0.5431476837424603\n", "Test Score: 4.61 RMSE\n", "Test R^2: 0.45001772422963693\n" ] } ], "source": [ "trainPredict, testPredict = make_preds(trainX,trainY,testX,testY)" ] }, { "cell_type": "code", "execution_count": 59, "id": "2620b098-abec-4ae6-a069-17c79818f316", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_preds(trainPredict,testPredict)" ] }, { "cell_type": "code", "execution_count": 60, "id": "fc7f94de-cd02-4c5a-8ea5-a04e50f987cd", "metadata": {}, "outputs": [], "source": [ "## LSTM with Memory Between Batches" ] }, { "cell_type": "code", "execution_count": 69, "id": "7eecc073-9515-4b10-9c8a-dff6a2380006", "metadata": { "tags": [] }, "outputs": [], "source": [ "# # reshape into X=t and Y=t+1\n", "# look_back = 3\n", "# trainX, trainY = create_dataset(train, look_back)\n", "# testX, testY = create_dataset(test, look_back)\n", "# # reshape input to be [samples, time steps, features]\n", "# trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n", "# testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n", "# # create and fit the LSTM network\n", "# batch_size = 1\n", "\n", "# if 'model' in globals():\n", "# print('Deleting \"model\"')\n", "# del model\n", "# model = Sequential()\n", "# model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))\n", "# model.add(Dense(1))\n", "\n", "# start_time = time.time()\n", "# model.compile(loss='mean_squared_error', optimizer='adam')\n", "# for i in range(100):\n", "# history = model.fit(trainX, trainY, epochs=50 , batch_size=batch_size, verbose=0, shuffle=False, validation_data=(testX, testY))\n", "# model.reset_states()\n", "# print('keys: ',history.history.keys())\n", "# print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))" ] }, { "cell_type": "code", "execution_count": 63, "id": "00da2235-6e49-450d-b791-d9345ecad215", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1035/1035 [==============================] - 3s 2ms/step\n", "508/508 [==============================] - 1s 2ms/step\n", "Train Score: 3.14 RMSE\n", "Train R^2: 0.5653176934509332\n", "Test Score: 7.81 RMSE\n", "Test R^2: -0.575034240837196\n" ] } ], "source": [ "# make predictions\n", "trainPredict = model.predict(trainX, batch_size=batch_size) #Now we need to specify the batch_size\n", "model.reset_states()\n", "testPredict = model.predict(testX, batch_size=batch_size)\n", "# invert predictions\n", "trainPredict = scaler.inverse_transform(trainPredict)\n", "trainY = scaler.inverse_transform([trainY])\n", "testPredict = scaler.inverse_transform(testPredict)\n", "testY = scaler.inverse_transform([testY])\n", "# calculate root mean squared error\n", "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n", "print('Train Score: %.2f RMSE' % (trainScore))\n", "print('Train R^2: ', r2_score(trainY[0], trainPredict[:,0]))\n", "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n", "print('Test Score: %.2f RMSE' % (testScore))\n", "print('Test R^2: ', r2_score(testY[0], testPredict[:,0]))" ] }, { "cell_type": "code", "execution_count": 64, "id": "269eb642-392c-44e3-a346-277af67f89f6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1035, 1, 3)\n", "trainY.shape: (1035,)\n", "trainX[:5]: [0.40584978 0.32951364 0.42946067 0.32951364 0.42946067 0.386174\n", " 0.42946067 0.386174 0.4079348 0.386174 0.4079348 0.40748814\n", " 0.4079348 0.40748814 0.30990687]\n", "trainY[:5]: [0.386174 0.4079348 0.40748814 0.30990687 0.47879067]\n", "Deleting \"model\"\n", "Epoch 1/50\n", "1025/1035 [============================>.] - ETA: 0s - loss: 0.0151\n", "Epoch 1: val_loss improved from inf to 0.01571, saving model to ./models/best_model_LSTM.h5\n", "1035/1035 [==============================] - 16s 10ms/step - loss: 0.0151 - val_loss: 0.0157\n", "Epoch 2/50\n", "1029/1035 [============================>.] - ETA: 0s - loss: 0.0095\n", "Epoch 2: val_loss improved from 0.01571 to 0.00752, saving model to ./models/best_model_LSTM.h5\n", "1035/1035 [==============================] - 10s 10ms/step - loss: 0.0094 - val_loss: 0.0075\n", "Epoch 3/50\n", "1027/1035 [============================>.] - ETA: 0s - loss: 0.0069\n", "Epoch 3: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0069 - val_loss: 0.0128\n", "Epoch 4/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0066\n", "Epoch 4: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0065 - val_loss: 0.0078\n", "Epoch 5/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0064\n", "Epoch 5: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 10ms/step - loss: 0.0064 - val_loss: 0.0090\n", "Epoch 6/50\n", "1035/1035 [==============================] - ETA: 0s - loss: 0.0065\n", "Epoch 6: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 10ms/step - loss: 0.0065 - val_loss: 0.0110\n", "Epoch 7/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0065\n", "Epoch 7: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0064 - val_loss: 0.0132\n", "Epoch 8/50\n", "1030/1035 [============================>.] - ETA: 0s - loss: 0.0064\n", "Epoch 8: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0064 - val_loss: 0.0123\n", "Epoch 9/50\n", "1032/1035 [============================>.] - ETA: 0s - loss: 0.0064\n", "Epoch 9: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 9ms/step - loss: 0.0064 - val_loss: 0.0125\n", "Epoch 10/50\n", "1031/1035 [============================>.] - ETA: 0s - loss: 0.0064\n", "Epoch 10: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0064 - val_loss: 0.0183\n", "Epoch 11/50\n", "1027/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 11: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 10ms/step - loss: 0.0063 - val_loss: 0.0151\n", "Epoch 12/50\n", "1033/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 12: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 7ms/step - loss: 0.0063 - val_loss: 0.0142\n", "Epoch 13/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 13: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 8ms/step - loss: 0.0063 - val_loss: 0.0179\n", "Epoch 14/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 14: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 11ms/step - loss: 0.0063 - val_loss: 0.0169\n", "Epoch 15/50\n", "1032/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 15: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 9ms/step - loss: 0.0063 - val_loss: 0.0164\n", "Epoch 16/50\n", "1024/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 16: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0063 - val_loss: 0.0206\n", "Epoch 17/50\n", "1033/1035 [============================>.] - ETA: 0s - loss: 0.0064\n", "Epoch 17: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0064 - val_loss: 0.0161\n", "Epoch 18/50\n", "1025/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 18: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 7ms/step - loss: 0.0062 - val_loss: 0.0206\n", "Epoch 19/50\n", "1031/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 19: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 10ms/step - loss: 0.0063 - val_loss: 0.0183\n", "Epoch 20/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 20: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0063 - val_loss: 0.0196\n", "Epoch 21/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 21: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 10ms/step - loss: 0.0063 - val_loss: 0.0182\n", "Epoch 22/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 22: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 10ms/step - loss: 0.0062 - val_loss: 0.0175\n", "Epoch 23/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 23: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 10ms/step - loss: 0.0063 - val_loss: 0.0136\n", "Epoch 24/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 24: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 9ms/step - loss: 0.0063 - val_loss: 0.0187\n", "Epoch 25/50\n", "1034/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 25: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 8ms/step - loss: 0.0062 - val_loss: 0.0211\n", "Epoch 26/50\n", "1030/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 26: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0063 - val_loss: 0.0166\n", "Epoch 27/50\n", "1032/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 27: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 9ms/step - loss: 0.0062 - val_loss: 0.0255\n", "Epoch 28/50\n", "1025/1035 [============================>.] - ETA: 0s - loss: 0.0061\n", "Epoch 28: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 9ms/step - loss: 0.0061 - val_loss: 0.0154\n", "Epoch 29/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 29: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 11ms/step - loss: 0.0063 - val_loss: 0.0157\n", "Epoch 30/50\n", "1026/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 30: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0062 - val_loss: 0.0244\n", "Epoch 31/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 31: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0062 - val_loss: 0.0157\n", "Epoch 32/50\n", "1029/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 32: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 9ms/step - loss: 0.0063 - val_loss: 0.0178\n", "Epoch 33/50\n", "1029/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 33: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0062 - val_loss: 0.0169\n", "Epoch 34/50\n", "1029/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 34: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 9ms/step - loss: 0.0063 - val_loss: 0.0251\n", "Epoch 35/50\n", "1032/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 35: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0062 - val_loss: 0.0208\n", "Epoch 36/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 36: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0062 - val_loss: 0.0138\n", "Epoch 37/50\n", "1023/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 37: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 11s 11ms/step - loss: 0.0062 - val_loss: 0.0207\n", "Epoch 38/50\n", "1028/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 38: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 10ms/step - loss: 0.0062 - val_loss: 0.0216\n", "Epoch 39/50\n", "1025/1035 [============================>.] - ETA: 0s - loss: 0.0061\n", "Epoch 39: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0062 - val_loss: 0.0233\n", "Epoch 40/50\n", "1033/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 40: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 8s 8ms/step - loss: 0.0062 - val_loss: 0.0210\n", "Epoch 41/50\n", "1035/1035 [==============================] - ETA: 0s - loss: 0.0061\n", "Epoch 41: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 8ms/step - loss: 0.0061 - val_loss: 0.0204\n", "Epoch 42/50\n", "1024/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 42: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 9ms/step - loss: 0.0062 - val_loss: 0.0178\n", "Epoch 43/50\n", "1029/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 43: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0063 - val_loss: 0.0203\n", "Epoch 44/50\n", "1032/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 44: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 6s 6ms/step - loss: 0.0063 - val_loss: 0.0227\n", "Epoch 45/50\n", "1030/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 45: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 6s 6ms/step - loss: 0.0062 - val_loss: 0.0207\n", "Epoch 46/50\n", "1033/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 46: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0062 - val_loss: 0.0220\n", "Epoch 47/50\n", "1029/1035 [============================>.] - ETA: 0s - loss: 0.0063\n", "Epoch 47: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 12s 11ms/step - loss: 0.0063 - val_loss: 0.0248\n", "Epoch 48/50\n", "1027/1035 [============================>.] - ETA: 0s - loss: 0.0061\n", "Epoch 48: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 10s 10ms/step - loss: 0.0062 - val_loss: 0.0188\n", "Epoch 49/50\n", "1030/1035 [============================>.] - ETA: 0s - loss: 0.0061\n", "Epoch 49: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 7s 7ms/step - loss: 0.0062 - val_loss: 0.0197\n", "Epoch 50/50\n", "1032/1035 [============================>.] - ETA: 0s - loss: 0.0062\n", "Epoch 50: val_loss did not improve from 0.00752\n", "1035/1035 [==============================] - 9s 9ms/step - loss: 0.0062 - val_loss: 0.0167\n", "keys: dict_keys(['loss', 'val_loss'])\n", "--- Elapsed time: 451.014142036438 seconds ---\n" ] } ], "source": [ "## Adding Early Stopping\n", "# Using Early stopping\n", "# reshape into X=t and Y=t+1\n", "look_back = 3\n", "trainX, trainY = create_dataset(train, look_back)\n", "testX, testY = create_dataset(test, look_back)\n", "\n", "# reshape input to be [samples, time steps, features]\n", "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n", "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n", "batch_size=1\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('trainX[:5]: ', trainX[:5].flatten())\n", "print('trainY[:5]: ', trainY[:5])\n", "\n", "es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=100)\n", "mc = ModelCheckpoint('./models/best_model_LSTM.h5', monitor='val_loss', mode='min', verbose=1, save_best_only=True)\n", "\n", "if 'model' in globals():\n", " print('Deleting \"model\"')\n", " del model\n", "model = Sequential()\n", "model.add(LSTM(4, batch_input_shape=(batch_size,1,look_back), stateful=True, return_sequences=True))\n", "model.add(LSTM(4, batch_input_shape=(batch_size, 1,look_back), stateful=True))\n", "model.add(Dense(1))\n", "\n", "start_time = time.time()\n", "# Compile the model\n", "model.compile(loss='mean_squared_error', optimizer='adam')\n", "\n", "# Fit the model\n", "history = model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=1, validation_data=(testX, testY),callbacks=[es, mc])\n", "# list all data in history\n", "print('keys: ',history.history.keys())\n", "print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))\n", "\n", "# load the saved model\n", "model = load_model('./models/best_model_LSTM.h5')" ] }, { "cell_type": "code", "execution_count": 65, "id": "2d18ad90-3077-4fb0-96aa-b4fc0714771a", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_hist(history)" ] }, { "cell_type": "code", "execution_count": 66, "id": "8e0328c4-c262-4399-8b59-54312b0794b5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1035/1035 [==============================] - 4s 3ms/step\n", "508/508 [==============================] - 2s 3ms/step\n", "Train Score: 3.16 RMSE\n", "Train R^2: 0.5615679306120167\n", "Test Score: 3.40 RMSE\n", "Test R^2: 0.7020410118749283\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# make predictions\n", "trainPredict = model.predict(trainX, batch_size=batch_size) #Now we need to specify the batch_size\n", "model.reset_states()\n", "testPredict = model.predict(testX, batch_size=batch_size)\n", "# invert predictions\n", "trainPredict = scaler.inverse_transform(trainPredict)\n", "trainY = scaler.inverse_transform([trainY])\n", "testPredict = scaler.inverse_transform(testPredict)\n", "testY = scaler.inverse_transform([testY])\n", "# calculate root mean squared error\n", "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n", "print('Train Score: %.2f RMSE' % (trainScore))\n", "print('Train R^2: ', r2_score(trainY[0], trainPredict[:,0]))\n", "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n", "print('Test Score: %.2f RMSE' % (testScore))\n", "print('Test R^2: ', r2_score(testY[0], testPredict[:,0]))\n", "\n", "# shift train predictions for plotting\n", "trainPredictPlot = np.empty_like(dataset)\n", "trainPredictPlot[:, :] = np.nan\n", "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n", "# shift test predictions for plotting\n", "testPredictPlot = np.empty_like(dataset)\n", "testPredictPlot[:, :] = np.nan\n", "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n", "# plot baseline and predictions\n", "plt.plot(scaler.inverse_transform(dataset))\n", "plt.plot(trainPredictPlot)\n", "plt.plot(testPredictPlot)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 67, "id": "34668111-d174-4851-8c77-19033eec86ad", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trainX.shape: (1035, 1, 3)\n", "trainY.shape: (1035,)\n", "trainX[:5]: [0.40584978 0.32951364 0.42946067 0.32951364 0.42946067 0.386174\n", " 0.42946067 0.386174 0.4079348 0.386174 0.4079348 0.40748814\n", " 0.4079348 0.40748814 0.30990687]\n", "trainY[:5]: [0.386174 0.4079348 0.40748814 0.30990687 0.47879067]\n", "Deleting \"model\"\n", "keys: dict_keys(['loss', 'val_loss'])\n", "--- Elapsed time: 319.7887361049652 seconds ---\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "1035/1035 [==============================] - 4s 3ms/step\n", "508/508 [==============================] - 2s 5ms/step\n", "Train Score: 3.35 RMSE\n", "Train R^2: 0.5055799253426811\n", "Test Score: 3.30 RMSE\n", "Test R^2: 0.7181920183273924\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Try more nodes in the LSTM\n", "# Using Early stopping\n", "\n", "# reshape into X=t and Y=t+1\n", "look_back = 3\n", "trainX, trainY = create_dataset(train, look_back)\n", "testX, testY = create_dataset(test, look_back)\n", "\n", "# reshape input to be [samples, time steps, features]\n", "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n", "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n", "print('trainX.shape: ',trainX.shape)\n", "print('trainY.shape: ',trainY.shape)\n", "print('trainX[:5]: ', trainX[:5].flatten())\n", "print('trainY[:5]: ', trainY[:5])\n", "\n", "es = EarlyStopping(monitor='val_loss', mode='min', verbose=0, patience=100)\n", "mc = ModelCheckpoint('./models/best_model_LSTM.h5', monitor='val_loss', mode='min', verbose=0, save_best_only=True)\n", "\n", "if 'model' in globals():\n", " print('Deleting \"model\"')\n", " del model\n", "model = Sequential()\n", "model.add(LSTM(8, batch_input_shape=(batch_size,1,look_back), return_sequences=True))\n", "model.add(LSTM(8, batch_input_shape=(batch_size, 1,look_back)))\n", "model.add(Dense(1))\n", "\n", "start_time = time.time()\n", "# Compile the model\n", "model.compile(loss='mean_squared_error', optimizer='adam')\n", "\n", "# Fit the model\n", "history = model.fit(trainX, trainY, epochs=50, batch_size=1, verbose=0, validation_data=(testX, testY),callbacks=[es, mc])\n", "# list all data in history\n", "print('keys: ',history.history.keys())\n", "print(\"--- Elapsed time: %s seconds ---\" % (time.time() - start_time))\n", "\n", "# load the saved model\n", "model = load_model('./models/best_model_LSTM.h5')\n", "\n", "plot_hist(history)\n", "\n", "# make predictions\n", "trainPredict = model.predict(trainX, batch_size=batch_size) #Now we need to specify the batch_size\n", "model.reset_states()\n", "testPredict = model.predict(testX, batch_size=batch_size)\n", "# invert predictions\n", "trainPredict = scaler.inverse_transform(trainPredict)\n", "trainY = scaler.inverse_transform([trainY])\n", "testPredict = scaler.inverse_transform(testPredict)\n", "testY = scaler.inverse_transform([testY])\n", "# calculate root mean squared error\n", "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n", "print('Train Score: %.2f RMSE' % (trainScore))\n", "print('Train R^2: ', r2_score(trainY[0], trainPredict[:,0]))\n", "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n", "print('Test Score: %.2f RMSE' % (testScore))\n", "print('Test R^2: ', r2_score(testY[0], testPredict[:,0]))\n", "\n", "# shift train predictions for plotting\n", "trainPredictPlot = np.empty_like(dataset)\n", "trainPredictPlot[:, :] = np.nan\n", "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n", "# shift test predictions for plotting\n", "testPredictPlot = np.empty_like(dataset)\n", "testPredictPlot[:, :] = np.nan\n", "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n", "# plot baseline and predictions\n", "plt.plot(scaler.inverse_transform(dataset))\n", "plt.plot(trainPredictPlot)\n", "plt.plot(testPredictPlot)\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": null, "id": "6eacc37b-c789-4c56-88b9-9335cbcbf309", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "8092b112-9426-43f8-913a-23751b14e4a6", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.8.10" } }, "nbformat": 4, "nbformat_minor": 5 }