From d85422f8463e01fb3fb072b7b104a52d871d1c93 Mon Sep 17 00:00:00 2001 From: Miguel Xochicale Date: Sat, 30 Sep 2023 03:35:32 +0100 Subject: [PATCH] just rename models as models/example-models/ (#15) --- dependencies/ve.yml | 3 +- rtt4ssa/models/README.md | 11 +- ...meseries_classification_from_scratch.ipynb | 54 +- ...imeseries_transformer_classification.ipynb | 979 ++++++++++++++ ...imeseries_transformer_classification.ipynb | 1167 ----------------- 5 files changed, 1013 insertions(+), 1201 deletions(-) rename rtt4ssa/models/{transformer-model => example-models}/timeseries_classification_from_scratch.ipynb (99%) create mode 100644 rtt4ssa/models/example-models/timeseries_transformer_classification.ipynb delete mode 100644 rtt4ssa/models/transformer-model/timeseries_transformer_classification.ipynb diff --git a/dependencies/ve.yml b/dependencies/ve.yml index a33e8f2..d257738 100644 --- a/dependencies/ve.yml +++ b/dependencies/ve.yml @@ -26,10 +26,11 @@ dependencies: - matplotlib - numpy - jupyter + #- jupyter_contrib_nbextensions #>>> jupyter nbextensions_configurator enable + - notebook - pandas - seaborn - scikit-image - - notebook - thread6 - pydot - scikit-learn diff --git a/rtt4ssa/models/README.md b/rtt4ssa/models/README.md index ca95c74..71c2fab 100644 --- a/rtt4ssa/models/README.md +++ b/rtt4ssa/models/README.md @@ -1,4 +1,13 @@ # Models -* Transformer models +## Running notebooks +``` +cd $HOME/repositories/rtt4ssa/rtt4ssa/models +export PYTHONPATH="${PYTHONPATH}:$HOME/repositories/rtt4ssa" +mamba activate rtt4ssaVE && jupyter notebook --browser=firefox +``` + +## Content +* Example models +* Transformer-based models diff --git a/rtt4ssa/models/transformer-model/timeseries_classification_from_scratch.ipynb b/rtt4ssa/models/example-models/timeseries_classification_from_scratch.ipynb similarity index 99% rename from rtt4ssa/models/transformer-model/timeseries_classification_from_scratch.ipynb rename to rtt4ssa/models/example-models/timeseries_classification_from_scratch.ipynb index d123dd7..9deaf41 100644 --- a/rtt4ssa/models/transformer-model/timeseries_classification_from_scratch.ipynb +++ b/rtt4ssa/models/example-models/timeseries_classification_from_scratch.ipynb @@ -43,21 +43,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "metadata": { "id": "vSMYnBXvh8zq" }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-09 07:59:07.703295: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2023-08-09 07:59:07.752323: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - } - ], + "outputs": [], "source": [ "from tensorflow import keras\n", "import numpy as np\n", @@ -104,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "id": "q4WhCJC0h8zu" }, @@ -137,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -196,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "id": "WxQZPakth8zw" }, @@ -325,7 +315,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "id": "8RKhPnTmh8zy" }, @@ -361,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "id": "0pNBqQ-Gh8zz" }, @@ -393,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "id": "yq23pCEXh8zz" }, @@ -416,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "id": "IP3XNJXth8z0" }, @@ -444,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "id": "xqc5-9deh8z0" }, @@ -477,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -492,16 +482,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "2023-08-09 07:59:39.743405: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:39.839564: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:39.839929: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:39.843192: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:39.843559: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:39.843807: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:40.445007: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:40.445267: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:40.445411: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 07:59:40.445534: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 6202 MB memory: -> device: 0, name: NVIDIA RTX A2000 8GB Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6\n" + "2023-09-30 03:15:35.125892: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.160165: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.160437: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.165051: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.165365: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.165562: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.763479: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.763786: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.763959: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:15:35.764107: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 6202 MB memory: -> device: 0, name: NVIDIA RTX A2000 8GB Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6\n" ] }, { @@ -518,7 +508,7 @@ "" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } diff --git a/rtt4ssa/models/example-models/timeseries_transformer_classification.ipynb b/rtt4ssa/models/example-models/timeseries_transformer_classification.ipynb new file mode 100644 index 0000000..b61c594 --- /dev/null +++ b/rtt4ssa/models/example-models/timeseries_transformer_classification.ipynb @@ -0,0 +1,979 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "iEINjF1qh0vc" + }, + "source": [ + "# Timeseries classification with a Transformer model\n", + "\n", + "**Author:** [Theodoros Ntakouris](https://github.com/ntakouris)
\n", + "**Replication:** [mxochicale](https://github.com/mxochicale/)
\n", + "**Date created:** 2021/06/25
\n", + "**Description:** This notebook demonstrates how to do timeseries classification using a Transformer model.\n", + "\n", + "**Logs:**\n", + "* MX: Fri 21 Jul 2023 # Out of Memory issue\n", + " ```\n", + " # RESOURCE_EXHAUSTED: OOM when allocating tensor with shape[64,500,4,256] and \n", + " # type float on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc\n", + " # SOLUTION > Change batch size https://github.com/tensorflow/models/issues/8487 \n", + " # OOM means out of memory. May be it is using more memory at that time. \n", + " # Decrease batch_size significantly. I set to 16, then it worked fine\n", + " # >https://stackoverflow.com/questions/49665757\n", + " ```\n", + "* MX: Sat 22 Jul 12:05:24 BST 2023 # Adds confusion matrix https://towardsdatascience.com/exploring-confusion-matrix-evolution-on-tensorboard-e66b39f4ac12\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0EmcFKhgh0vk" + }, + "source": [ + "## Introduction\n", + "\n", + "This is the Transformer architecture from\n", + "[Attention Is All You Need](https://arxiv.org/abs/1706.03762),\n", + "applied to timeseries instead of natural language.\n", + "\n", + "This example requires TensorFlow 2.4 or higher.\n", + "\n", + "## Load the dataset\n", + "\n", + "We are going to use the same dataset and preprocessing as the\n", + "[TimeSeries Classification from Scratch](https://keras.io/examples/timeseries/timeseries_classification_from_scratch)\n", + "example." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-09-30 03:29:44.451337: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2023-09-30 03:29:44.552376: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import itertools\n", + "import sklearn.metrics\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "bSpvocLzh0vl" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3601, 500), (3601,)\n", + "(1320, 500), (1320,)\n", + "x_train.shape: (3601, 500, 1), y_train.shape: (3601,)\n", + "x_test.shape: (1320, 500, 1), y_test.shape: (1320,)\n", + "n_classes: 2\n", + "(3601,)\n", + "(1320,)\n" + ] + } + ], + "source": [ + "def readucr(filename):\n", + " data = np.loadtxt(filename, delimiter=\"\\t\")\n", + " y = data[:, 0]\n", + " x = data[:, 1:]\n", + " return x, y.astype(int)\n", + "\n", + "\n", + "root_url = \"https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/\"\n", + "\n", + "x_train, y_train = readucr(root_url + \"FordA_TRAIN.tsv\")\n", + "x_test, y_test = readucr(root_url + \"FordA_TEST.tsv\")\n", + "\n", + "print(f'{x_train.shape}, {y_train.shape}')\n", + "print(f'{x_test.shape}, {y_test.shape}')\n", + "\n", + "x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], 1))\n", + "x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], 1))\n", + "\n", + "print(f'x_train.shape: {x_train.shape}, y_train.shape: {y_train.shape}')\n", + "print(f'x_test.shape: {x_test.shape}, y_test.shape: {y_test.shape}')\n", + "\n", + "n_classes = len(np.unique(y_train))\n", + "print(f'n_classes: {n_classes}')\n", + "\n", + "# Randomise samples \n", + "idx = np.random.permutation(len(x_train))\n", + "x_train = x_train[idx]\n", + "y_train = y_train[idx]\n", + "\n", + "# Rename labels \n", + "y_train[y_train == -1] = 0\n", + "y_test[y_test == -1] = 0\n", + "\n", + "print(y_train.shape)\n", + "print(y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# ## Reducing train and test data size\n", + "\n", + "# lenght_of_time_series=450 # Original size # 500\n", + "# train_size=3500 # Original size # 3601\n", + "# print(type(x_train))\n", + "# print(x_train.shape)\n", + "# x_train = np.resize(x_train, (train_size,lenght_of_time_series))\n", + "# x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], 1))\n", + "# print(x_train.shape)\n", + "\n", + "# print(y_train.shape)\n", + "# y_train = np.resize(y_train, (train_size,))\n", + "# print(y_train.shape)\n", + "\n", + "# test_size = 1200 # Original size #1320\n", + "# print(type(x_test))\n", + "# print(x_test.shape)\n", + "# x_test = np.resize(x_test, (test_size,lenght_of_time_series))\n", + "# x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], 1))\n", + "\n", + "# print(x_test.shape)\n", + "\n", + "# print(y_test.shape)\n", + "# y_test = np.resize(y_test, (test_size,))\n", + "# print(y_test.shape)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize the data\n", + "\n", + "Here we visualize one timeseries example for each class in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "idx: 700\n", + " class 0 with c_x_train.shape (1846, 500, 1)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAACPCAYAAAAyVzuDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABnhElEQVR4nO2dd3gU1d7Hv7N903svhFQg1NBChyAgICIIiHgFREAFe+V6EeuLFfQqinoVbAiKYEFpQug9hE5CAmmk92za1vP+sTuT3WT7bhKC5/M8eWBnZmfOnp2d+c6vMoQQAgqFQqFQKJQuAq+zB0ChUCgUCoViC1S8UCgUCoVC6VJQ8UKhUCgUCqVLQcULhUKhUCiULgUVLxQKhUKhULoUVLxQKBQKhULpUlDxQqFQKBQKpUtBxQuFQqFQKJQuBRUvFAqFQqFQuhRUvFA6hW7dumHBggUdciyGYfDqq692yLFuJcaMGYMxY8Z06DFVKhVeeOEFhIeHg8fjYfr06R16/K5Abm4uGIbBxo0bO3so7Uq3bt0wderUzh4G5TaFiheKUY4dO4ZXX30VNTU1nT0Uq/jrr7/+kQLlVuPrr7/Ge++9h3vvvRfffPMNnn766c4eEuUfCisSTf0tXrzYYHu5XI4XX3wRISEhkEqlGDJkCPbu3Wt038eOHcOIESPg4uKCoKAgPPHEE6ivr++Ij0XRIejsAVBuTY4dO4bXXnsNCxYsgJeXl9P3n5mZCR7Pedr5r7/+wrp164wKmKamJggE/7xTfc+ePR1+zP379yM0NBRr167t8GNTKPr4+/vju+++a7N8165d+OGHHzBhwgSD5QsWLMDWrVvx1FNPITY2Fhs3bsTkyZORmpqKESNGcNudO3cOKSkp6NGjB9asWYObN2/i/fffR1ZWFnbu3Nnun4ui5Z93Rac4HY1GA4VCAYlEYvV7xGJxO47IEFvGdTvQ2NgIFxcXiESiDj92WVmZU8WuPecW5Z+DSqWCRqMxeq67urrigQceaLN848aN8PDwwF133cUtO3XqFDZv3oz33nsPzz33HADgwQcfRGJiIl544QUcO3aM2/bf//43vL29ceDAAXh4eADQusgWL16MPXv2tBFFlPaBuo0obXj11Vfx/PPPAwCioqI4M2tubi4AbQzJ8uXL8cMPP6BXr14Qi8XYtWsXAOD999/HsGHD4OvrC6lUiqSkJGzdurXNMVrHvGzcuBEMw+Do0aN45pln4O/vD1dXV9xzzz0oLy83O94FCxZg3bp13NjYP5bWMS+vvvoqGIbBtWvX8MADD8DT0xP+/v5YuXIlCCEoKCjA3XffDQ8PDwQFBeGDDz5oc0y5XI5Vq1YhJiYGYrEY4eHheOGFFyCXyy3Ob1ZWFmbOnImgoCBIJBKEhYXhvvvuQ21trcF233//PZKSkiCVSuHj44P77rsPBQUFBtuMGTMGiYmJSEtLw6hRo+Di4oJ///vf3LrWMS/Wjnvv3r0YMWIEvLy84Obmhvj4eG6/xmBN9Kmpqbh8+TL3HRw4cAAA0NDQgGeffRbh4eEQi8WIj4/H+++/j9ZN7c2dW8Y4c+YMJk6cCD8/P0ilUkRFReGhhx4y2Mbac5I99s8//4yePXtCKpUiOTkZFy9eBAB8/vnniImJgUQiwZgxY7jfg7HvYtiwYdx41q9fb3L8+mRkZODee++Fj48PJBIJBg4ciN9//93i+9i5f//99/HFF18gOjoaYrEYgwYNwunTp9uM0Vgc1IIFC9CtWzej+1y3bh26d+8OFxcXTJgwAQUFBSCE4I033kBYWBikUinuvvtuVFVVGR3fnj170K9fP0gkEvTs2RPbtm1rs01NTQ2eeuop7vyIiYnBO++8A41GY3RMH374Ifc5r1y5YnGOWIqLi5GamooZM2YYCOKtW7eCz+djyZIl3DKJRIJFixbh+PHj3O+urq4Oe/fuxQMPPMAJF0ArdNzc3PDTTz9ZPRaKY1DLC6UNM2bMwLVr1/Djjz9i7dq18PPzA6A1w7Ls378fP/30E5YvXw4/Pz/uwvfRRx9h2rRpmDdvHhQKBTZv3oxZs2Zhx44dmDJlisVjP/744/D29saqVauQm5uLDz/8EMuXL8eWLVtMvmfp0qUoKirC3r17jZqJTTFnzhz06NEDb7/9Nv7880+8+eab8PHxweeff45x48bhnXfewQ8//IDnnnsOgwYNwqhRowBorQHTpk3DkSNHsGTJEvTo0QMXL17E2rVrce3aNfz6668mj6lQKDBx4kTI5XI8/vjjCAoKQmFhIXbs2IGamhp4enoCAN566y2sXLkSs2fPxsMPP4zy8nJ8/PHHGDVqFNLT0w2sG5WVlbjzzjtx33334YEHHkBgYKDRY1s77suXL2Pq1Kno06cPXn/9dYjFYmRnZ+Po0aMmPxdron/rrbdQX1+P1atXAwB69OgBQgimTZuG1NRULFq0CP369cPu3bvx/PPPo7CwsI2LydS51ZqysjJMmDAB/v7+eOmll+Dl5YXc3Nw2N0dbzsnDhw/j999/x7JlywAAq1evxtSpU/HCCy/g008/xWOPPYbq6mq8++67eOihh7B//36D91dXV2Py5MmYPXs25s6di59++gmPPvooRCJRG1Glz+XLlzF8+HCEhobipZdegqurK3766SdMnz4dv/zyC+655x6T72XZtGkTZDIZli5dCoZh8O6772LGjBm4ceMGhEKhxfcb44cffoBCocDjjz+OqqoqvPvuu5g9ezbGjRuHAwcO4MUXX0R2djY+/vhjPPfcc/j6668N3p+VlYU5c+bgkUcewfz587FhwwbMmjULu3btwh133AFAaykcPXo0CgsLsXTpUkRERODYsWNYsWIFiouL8eGHHxrsc8OGDWhubsaSJUsgFovh4+Nj9efZvHkzNBoN5s2bZ7A8PT0dcXFxBoIEAAYPHgxA6yoKDw/HxYsXoVKpMHDgQIPtRCIR+vXrh/T0dKvHQnEQQqEY4b333iMASE5OTpt1AAiPxyOXL19us66xsdHgtUKhIImJiWTcuHEGyyMjI8n8+fO51xs2bCAAyPjx44lGo+GWP/3004TP55Oamhqz4122bBkxdToDIKtWreJer1q1igAgS5Ys4ZapVCoSFhZGGIYhb7/9Nre8urqaSKVSg7F+9913hMfjkcOHDxscZ/369QQAOXr0qMlxpqenEwDk559/NrlNbm4u4fP55K233jJYfvHiRSIQCAyWjx49mgAg69evb7Of0aNHk9GjR9s87rVr1xIApLy83OQYTTF69GjSq1cvg2W//vorAUDefPNNg+X33nsvYRiGZGdnc8vMnVut2b59OwFATp8+bXY7a89JAEQsFhuc859//jkBQIKCgkhdXR23fMWKFW1+H+x38cEHH3DL5HI56devHwkICCAKhYIQQkhOTg4BQDZs2MBtl5KSQnr37k2am5u5ZRqNhgwbNozExsaa/Xzs/nx9fUlVVRW3/LfffiMAyB9//GEwRv1zgmX+/PkkMjKyzT79/f0Nfnvs5+7bty9RKpXc8rlz5xKRSGQw/sjISAKA/PLLL9yy2tpaEhwcTPr3788te+ONN4irqyu5du2awZheeuklwufzSX5+vsGYPDw8SFlZmdk5MUVSUhIJDg4marXaYHmvXr3anA+EEHL58mWD39fPP/9MAJBDhw612XbWrFkkKCjIrnFRbIe6jSh2MXr0aPTs2bPNcqlUyv2/uroatbW1GDlyJM6ePWvVfpcsWWLg8hk5ciTUajXy8vIcH3QrHn74Ye7/fD4fAwcOBCEEixYt4pZ7eXkhPj4eN27c4Jb9/PPP6NGjBxISElBRUcH9jRs3DgCQmppq8pisZWX37t1obGw0us22bdug0Wgwe/Zsg/0HBQUhNja2zf7FYjEWLlxo8fNaO27WqvPbb78ZmO3t5a+//gKfz8cTTzxhsPzZZ58FIaRNkKOpc6s17Dh37NgBpVJpcjtbzsmUlBQDS8+QIUMAADNnzoS7u3ub5frnBQAIBAIsXbqUey0SibB06VKUlZUhLS3N6Piqqqqwf/9+zJ49GzKZjPteKisrMXHiRGRlZaGwsNDk52OZM2cOvL29udcjR440OkZbmDVrFnfOAi2f+4EHHjAIgh8yZAgUCkWbcYaEhBhYjTw8PPDggw8iPT0dJSUlALTn5ciRI+Ht7W1wXo4fPx5qtRqHDh0y2OfMmTMNrMDWcu3aNaSlpeG+++5rkyzQ1NRkNA6PdS01NTUZ/GtqW3Y9pf2hbiOKXURFRRldvmPHDrz55ps4d+6cQRyFviAxR0REhMFr9mJcXV1t50itP5anpyckEgnnJtNfXllZyb3OysrC1atXTV5Ay8rKTB4zKioKzzzzDNasWYMffvgBI0eOxLRp07jYG3b/hBDExsYa3UdrF0BoaKhVwbnWjnvOnDn43//+h4cffhgvvfQSUlJSMGPGDNx77712ZYjl5eUhJCTE4OYPaF1K7Hp9TJ1brRk9ejRmzpyJ1157DWvXrsWYMWMwffp03H///QY3F1vOSWPnBACEh4cbXd76vAwJCYGrq6vBsri4OADamI2hQ4e2OWZ2djYIIVi5ciVWrlxp9LOWlZUhNDTU6DpTY3fGb8fR+YiJiWkzz/rzERQUhKysLFy4cMHq35O150drfvjhBwBo4zICtALXWLxac3Mzt17/X1Pb6gtlSvtCxQvFLoz9SA8fPoxp06Zh1KhR+PTTTxEcHAyhUIgNGzZg06ZNVu2Xz+cbXU5aBXY6A2PHsub4Go0GvXv3xpo1a4xu2/rC3poPPvgACxYswG+//YY9e/bgiSeewOrVq3HixAmEhYVBo9GAYRjs3LnT6Hjc3NwMXlt7wbR23FKpFIcOHUJqair+/PNP7Nq1C1u2bMG4ceOwZ88ek3PkLKz9PAzDYOvWrThx4gT++OMP7N69Gw899BA++OADnDhxAm5ubjafk6Y+W3uel6x167nnnsPEiRONbhMTE2NxP9aMkWEYo2NWq9U27dOZ86HRaHDHHXfghRdeMLqeFTss9gqETZs2IT4+HklJSW3WBQcHG7VuFRcXA9CKUnY7/eWtt2W3o7Q/VLxQjGKtpUSfX375BRKJBLt37zZ48t2wYYMzh2YUe8ZrL9HR0Th//jxSUlLsPm7v3r3Ru3dv/Oc//8GxY8cwfPhwrF+/Hm+++Saio6NBCEFUVFSbC3dHjZvH4yElJQUpKSlYs2YN/u///g8vv/wyUlNTMX78eJuOGxkZib///hsymczA+pKRkcGtd4ShQ4di6NCheOutt7Bp0ybMmzcPmzdvxsMPP9zh52RRUREaGhoMrC/Xrl0DAJOBx927dwegtajZOre24u3tbdSN1B5uWaDFqqR/vrWej+joaNTX17frZz958iSys7Px+uuvG13fr18/pKamoq6uziBo9+TJk9x6AEhMTIRAIMCZM2cwe/ZsbjuFQoFz584ZLKO0LzTmhWIU9uJrS4VdPp8PhmEMnuJyc3PNZt84C3vGay+zZ89GYWEhvvzyyzbrmpqa0NDQYPK9dXV1UKlUBst69+4NHo/HmaJnzJgBPp+P1157rc2TLCHEwIXVHuM2lvLKXrytSQVvzeTJk6FWq/HJJ58YLF+7di0YhsGdd95p8z4BrYui9fy0HmdHn5MqlQqff/4591qhUODzzz+Hv7+/0Sd+AAgICMCYMWPw+eefG32it1QqwBaio6ORkZFhsM/z58+bzSRzhKKiImzfvp17XVdXh2+//Rb9+vVDUFAQAO15efz4cezevbvN+2tqatr8XuyBtbLdf//9Rtffe++9UKvV+OKLL7hlcrkcGzZswJAhQzirpKenJ8aPH4/vv/8eMpmM2/a7775DfX09Zs2a5fBYKdZBLS8Uo7AX2pdffhn33XcfhEIh7rrrrjb+fH2mTJmCNWvWYNKkSbj//vtRVlaGdevWISYmBhcuXOiQ8T7xxBOYOHEi+Hw+7rvvvnY51r/+9S/89NNPeOSRR5Camorhw4dDrVYjIyMDP/30E3bv3t0mlZJl//79WL58OWbNmoW4uDioVCp899134PP5mDlzJgDtDebNN9/EihUrkJubi+nTp8Pd3R05OTnYvn07lixZwhXSao9xv/766zh06BCmTJmCyMhIlJWV4dNPP0VYWJhBpVFrueuuuzB27Fi8/PLLyM3NRd++fbFnzx789ttveOqppxAdHW3zPgHgm2++waeffop77rkH0dHRkMlk+PLLL+Hh4YHJkycD6PhzMiQkBO+88w5yc3MRFxeHLVu24Ny5c/jiiy/MpiuvW7cOI0aMQO/evbF48WJ0794dpaWlOH78OG7evInz5887ZXwPPfQQ1qxZg4kTJ2LRokUoKyvD+vXr0atXL9TV1TnlGPrExcVh0aJFOH36NAIDA/H111+jtLTUwPL1/PPP4/fff8fUqVOxYMECJCUloaGhARcvXsTWrVuRm5vbJg7NFtRqNbZs2YKhQ4eaPNeGDBmCWbNmYcWKFSgrK0NMTAy++eYb5Obm4quvvjLY9q233sKwYcMwevRoLFmyBDdv3sQHH3yACRMmYNKkSXaPk2IjnZDhROkivPHGGyQ0NJTweDyDtFAAZNmyZUbf89VXX5HY2FgiFotJQkIC2bBhA5earI+pVOnWaa+pqakEAElNTTU7VpVKRR5//HHi7+9PGIYxOB5MpEq3TgWeP38+cXV1bbNvY+m/CoWCvPPOO6RXr15ELBYTb29vkpSURF577TVSW1trcpw3btwgDz30EImOjiYSiYT4+PiQsWPHkr///rvNtr/88gsZMWIEcXV1Ja6uriQhIYEsW7aMZGZmmh2b/rrWabHWjHvfvn3k7rvvJiEhIUQkEpGQkBAyd+7cNqmspo5pbDwymYw8/fTTJCQkhAiFQhIbG0vee+89g7R4QsyfW605e/YsmTt3LomIiCBisZgEBASQqVOnkjNnzhhsZ+05aezYbHrue++9Z7CcPS/1U97Zz37mzBmSnJxMJBIJiYyMJJ988onRfeqnShNCyPXr18mDDz5IgoKCiFAoJKGhoWTq1Klk69atZufB1BjZz6R/7hNCyPfff0+6d+9ORCIR6devH9m9e7fJVGlrPjchxn+/kZGRZMqUKWT37t2kT58+3PwbKxMgk8nIihUrSExMDBGJRMTPz48MGzaMvP/++21SzI19TnPs2rWLACD//e9/zW7X1NREnnvuORIUFETEYjEZNGgQ2bVrl9FtDx8+TIYNG0YkEgnx9/cny5YtM0ilp7Q/DCHtEAlJoVAo/zDGjBmDiooKXLp0qbOHQqHc9tCYFwqFQqFQKF0KKl4oFAqFQqF0Kah4oVAoFAqF0qWgMS8UCoVCoVC6FNTyQqFQKBQKpUtBxQuFQqFQKJQuxW1XpE6j0aCoqAju7u4dWjKeQqFQKBSK/RBCIJPJEBISYrEJ7G0nXoqKiiw2xqNQKBQKhXJrUlBQgLCwMLPbtKt4Wb16NbZt24aMjAxIpVIMGzYM77zzDuLj402+Z+PGjVi4cKHBMrFYzLUmtwTb+K2goMCgwRaFQqFQKJRbl7q6OoSHhxs0cDVFu4qXgwcPYtmyZRg0aBBUKhX+/e9/Y8KECbhy5YrZHjkeHh7IzMzkXtvi/mG39fDwoOKFQqHc9shVahTVNCPKz/Q1lULpSlhzz29X8bJr1y6D1xs3bkRAQADS0tIwatQok+9jGIbrOEqhUCgU4xRUNWLhxtPILqvHe/f2wayB1GVO+WfQodlGtbW1AAAfHx+z29XX1yMyMhLh4eG4++67cfnyZZPbyuVy1NXVGfxRKBTKP4EP9mQiu6weALB6ZwZqm5SdPCIKpWPoMPGi0Wjw1FNPYfjw4UhMTDS5XXx8PL7++mv89ttv+P7776HRaDBs2DDcvHnT6ParV6+Gp6cn90eDdSkUyj8BlVqD1Mxy7nVVgwJ7Lpd04ogolI6jwyrsPvroo9i5cyeOHDliMYpYH6VSiR49emDu3Ll444032qyXy+WQy+Xcazbgp7a2lsa8UCiU25bTuVWYtf44PKVCzB0cgfUHr+Oe/qFYO6dfZw+tS6BWq6FUUktVRyMSiUymQdfV1cHT09Oq+3eHpEovX74cO3bswKFDh2wSLgAgFArRv39/ZGdnG10vFoshFoudMUwKhUJpN0rrmuEuEcBF5JzL7tHsCgDAqDh/jIr1w/qD13HsegUIIbTGlRkIISgpKUFNTU1nD+UfCY/HQ1RUFEQikUP7aVfxQgjB448/ju3bt+PAgQOIioqyeR9qtRoXL17E5MmT22GEFAqF0v4czirHwg2nIRXxsXZ2P4zvGejwPjNLZACAvmGeGBDpDZGAh9I6OXIqGtDd383h/QPaTCZCAImQ75T93QqwwiUgIAAuLi5U6HUgbBHZ4uJiREREODT37Speli1bhk2bNuG3336Du7s7Skq0/lhPT09IpVIAwIMPPojQ0FCsXr0aAPD6669j6NChiImJQU1NDd577z3k5eXh4Ycfbs+hUigUSrvQpFDjxa0XoNIQyJpVeOuvq0jpEeDwTTNLF6gbG+gOiZCPXiEeSM+vwaWiOqeIl9TMMjzxYzoCPST4ddlwuIm7fk1TtVrNCRdfX9/OHs4/En9/fxQVFUGlUkEoFNq9n3YN2P3ss89QW1uLMWPGIDg4mPvbsmULt01+fj6Ki4u519XV1Vi8eDF69OiByZMno66uDseOHUPPnj3bc6gUCoXSLuy4UISi2mZ4SLQ3/5yKBmSWyhzap0KlQW5FAwAgLlArVHoEa2MEMoodz7isl6uw7IezkDWrkF1Wjw/3XnN4n60hhKCqQeH0/ZqDjXFxcXHp0ONSWmDdRWq12qH9tLvbyBIHDhwweL127VqsXbu2nUZEoVAoHcvPadpMyaWjo5GeX42/r5Zh16USJATZn1CQU9EAlYbAXSxAkIcEANAjSFuV9KoTxEtqRhkaFS03l02n8vHCpASIBM553i2TNWP5D+k4lVuFeUMi8Nq0XhDwO65yB3UVdR7OmnvaVZpCoVDaieLaJpzKqQLDAPf0D8XoOH8AwPmCGof2m1WmtdzEBLpxN4ME1vJS4phVBwB261Kul47uDh9XERoVapxzcMz6vLMzE6dyqwAAP5zMxzfH85y2b8o/AypeKBQKpZ04nKXNCOoT5oUQLyniArXWkWul9Q7tN7+qEQAQ5dvSEiBBZ3kprm1GTaP97hhCCA5d09aPmdAzCMOitbEhR3TZTY5SWS/HHxeKdPvXBi6vP3gdzUrH3Ags35/Iw8pfL0HW/M9Ig87NzQXDMDh37lxnD6VDoeKFQqFQ2glWvIyK9QMATrwU1jShQa6ye78ltdpGtcFeEm6Zu0TIuZBu6OJh7KGgqgl1zSqI+Dz0DvXESN3Yj193jnj582IxFCoNEkM98Mn9AxDqJUW5TI5dlxwvsFda14xXfruE707k4YH/nYRa0yFlzP7RNDc3Y9myZfD19YWbmxtmzpyJ0tLSdj8uFS8UCsVpaDQEx69X4kBmmVUxb7czGg3harGMjNW6i7xdRfBz09alYrOF7KFYJ16CPKUGy7v5aQNRcx0QLxcLtW1cEoLdIRLwMCDCGwBwuajOKWLg+PVKAMCdicEQCXiY3j8EAJwiXn46XQB2iOdv1nKfhdJ+PP300/jjjz/w888/4+DBgygqKsKMGTPa/bhUvFAoFKfx3NbzmPvlCSzYcBpbThe0yzEKqhpxrVQGzS3+VH2luA5VDQq4ivjoH+HFLWezg645kHFUXNsEAAj2kBgsZztLOyJeLhVpb/i9QjwBAN393SAR8tCoUCOv0v79AlqX1KkcbazLkChtj7s7E4MBAAeulaFJ4ZjraMeFYoPXh6+Vm9iy8yGEQGOlwNdoNHj33XcRExMDsViMiIgIvPXWW0a3VavVWLRoEaKioiCVShEfH4+PPvrIYJsDBw5g8ODBcHV1hZeXF4YPH468PG3c0fnz5zF27Fi4u7vDw8MDSUlJOHPmjNFj1dbW4quvvsKaNWswbtw4JCUlYcOGDTh27BhOnDhhw2zYTtdP3KdQKLcEZ/Orse1sIfd61e+XMa5HAALcJWbeZRu7L5dg6XdpAID5yZF47W7TfdI6m0NZ2htncrQvhHqZNLEBbjh2vRI3yu0XAiWc5cVwbrvpYmByKhvt3vclnbUiMVQbAMznMUgI8sC5ghpcdrCGTHZZPSobFJAIeegT5gUA6BXigVAvKQprmnAipxJj4wPs2rdcpUZ2udaatXxsDD5JzcbhrAo8nhJr8j2EEDQ5KdbGFpqVahTVNIEQINhLylnjTLFixQp8+eWXWLt2LUaMGIHi4mJkZGQY3Vaj0SAsLAw///wzfH19cezYMSxZsgTBwcGYPXs2VCoVpk+fjsWLF+PHH3+EQqHAqVOnuMDvefPmoX///vjss8/A5/Nx7tw5k/VY0tLSoFQqMX78eG5ZQkICIiIicPz4cQwdOtTOGbIMFS8UCsUpfHHwBgDg3qQwZJXKcP5mLX5JK8SjY6Kdsv9GhQqv/t7SYf6b43m4s3cwhna/NYuNHckydBmxhHlrXTuFNU127VeuUqOiXhuQG+LV2m3kuOXlus6dpZ/K3SukRbzc1TfE7n2n6zKW+oZ5cWnXDMNgWLQvfk67iRPX7Rcv2WX1UGsIPCQC3JsUhk9Ss5FeUA2FSmMyxbtJqUbPV3bbdTxH+WnpUEiEfFTI5PB1FZlMIZbJZPjoo4/wySefYP78+QCA6OhojBgxwuj2QqEQr732Gvc6KioKx48fx08//YTZs2ejrq4OtbW1mDp1KqKjtb/NHj16cNvn5+fj+eefR0JCAgAgNta0+CspKYFIJIKXl5fB8sDAQK4obXtB3UYUCsVhmpVqHNSZ6BcM64Z5QyIBAFtO5zst9mX35RIU1zYj1EuKe/qHAgA2Hs11yr6dTZNCjTO51QCAEbqAVxZWcBTZKV7K6rSNaEUCHrxdDJ+Iu+vES05Fg13z3qxUo7hOa9Xp5ttSyK1niFbIOFpDhm1pwO6PJVmX0XT8RqXD+04I8kCkrwvcxQIo1QQ3KhzL7GpvFGoNGsy4y65evQq5XI6UlBSr97lu3TokJSXB398fbm5u+OKLL5Cfnw8A8PHxwYIFCzBx4kTcdddd+OijjwwKxT7zzDN4+OGHMX78eLz99tu4fv26/R+uHaGWFwqF4jBHsyvQpFQj2FOCXiEeiPJzxarfLyO3shGXi+qQGOrp8DH+vloGQFsvZXLvYGxPL8T+zDLImpVwl9hfZrw9OJlTCYVag1AvKScoWEK9HRMv7PuCPSVtntbDfbSCo16uQk2jEt6utjW/u1ndCEIAd7EAPnrvjQ3QZkldL3dMCLQIDHeD5ax4uVRYi7pmJTzs+D65fQe7g2EYxAW5Iy2vGpklMpMFAaVCPq68PtHmYzlCfbMKuZUNcBUJ4CEVorpRgbompcn2C2wrHWvZvHkznnvuOXzwwQdITk6Gu7s73nvvPZw8eZLbZsOGDXjiiSewa9cubNmyBf/5z3+wd+9eDB06FK+++iruv/9+/Pnnn9i5cydWrVqFzZs345577mlzrKCgICgUCtTU1BhYX0pLSxEUFGTTuG2FWl4oXYpymRybT+Vj39XSf3w2y63EgUyt1YXt2eMqFnAptnuvOJ42qVBpcEh3jHE9AtAj2B3d/V2hUGnw99X2T8u0lcOcy8ivjcAI0aU3l9Y1Q6nW2LzvEp1lJNizbSyRRMiHn5tWdNjjlsqt0MbKRPoZNiyMCXDj9ulIUG1GidZy01pMBHtKEe4jhYYAFwrsyxBiA6DjdcKI/TfTTNE+hmHgIhJ06B+Px0Ai5MNVLICrTrCYi7uJjY2FVCrFvn37rJqHo0ePYtiwYXjsscfQv39/xMTEGLWe9O/fHytWrMCxY8eQmJiITZs2cevi4uLw9NNPY8+ePZgxYwY2bNhg9FhJSUkQCoUGY8vMzER+fj6Sk5OtGq+9UPFC6TIo1Ro8tPE0Xtp2EYu+OYPvT+Z39pAoOk7rqqUOi25xkdyhK0C2xwni5WJhLWRyFXxcRegX5gWGYTCxl/bJ7mDmrZdRclgXrNvaZQQAfq5iiPg8aEhL4K0tsGnSwZ7Gn8hDdW4pu8SLLpso0sfQWuTjKoK3ixCEwG43TEW9HBX1CjBMS70bffqHa1Oy0/Or7do/W7iPDVpOsEK8dAZsMT6JkA+pSNutu1mhNvkwJpFI8OKLL+KFF17At99+i+vXr+PEiRP46quvjG4fGxuLM2fOYPfu3bh27RpWrlyJ06dPc+tzcnKwYsUKHD9+HHl5edizZw+ysrLQo0cPNDU1Yfny5Thw4ADy8vJw9OhRnD592iAmRh9PT08sWrQIzzzzDFJTU5GWloaFCxciOTm5XYN1ASpeKLCuB9WtwDfHcg3qNqz+6ypK62y/+FOcS12zkms0ODDSm1ue0iMQPEYbJ1FQZX/2CwBcuFkDAOgf7gUeT2sRYC07R7Ir7T6HlWoNNhzNwTNbzjntJldS24xrpfVgGGB4dFvxwuMxXHE5e1xHxbr3tM40YmHdUoXVtu+bFQCRvm0bF0brsoyu25klxVpGInxcuJu2Pv3CvQDArjYEhBBOrIXpPn+8TiA5o10CAKg1BDerG5FRXIeqBrnd+2lWaq1tEiEPEgEPPIaBmhAoVKatcCtXrsSzzz6LV155BT169MCcOXNQVlZmdNulS5dixowZmDNnDoYMGYLKyko89thj3HoXFxdkZGRg5syZiIuLw5IlS7Bs2TIsXboUfD4flZWVePDBBxEXF4fZs2fjzjvvNAgAbs3atWsxdepUzJw5E6NGjUJQUBC2bdtm5+xYD415+QeTXVaPp7ecw/XyetzTPxSv350IPu/WbFhGCMGPp7SWljemJ2Jr2k2cL6jB5lMFeHK86Wh4SvuTnl8DQoBwHykC9OqO+LiKMLCbD07lVOHvq6VYODzK7mNcuKkVrb3DWmJnkiK9IRXyUVEvR0aJjOuqbAtv78zAV0dyAAD7Msrwy6PDOBeJvbBWlz6hniZjTkK9pMirbLTLOsJaXkJMiReHLC+mxUtMgBvO5FUj287iejm6DKhoE6nWbC2c9IIaEEJsauBX2aBAs1IDhmmxSLGuqcKaJqfERZXUNXNdsItqmuEqFkAsaCvCzEEIMbC8MIzWhdSoUKFJqYZYaHx/PB4PL7/8Ml5++eU267p162Yg3sViMTZs2NDG1bN69WoA2kyg7du3Gz2OSCTCjz/+aNNnkkgkWLduHdatW2fT+xyFWl7+oTQp1Jj/9SlcLKxFo0KNH07mY/1B50WVE0JwuagWtU3O6S9ypbgO18sbtBU5+4Vg4bBuALTZLI5W/axrVuLzg9exLjXboZLt/1RYM39ShHebdWzvGkfjXs7rLC99dbVBAEAs4GOwrtAZm5ZsCwVVjfhOryFgbZMS/92X5dA4Ab2WAHH+Jrdhy/iX1tn+BM/GvLSursvCiRc7LC9sEbpIX9c261osL/aJF7auTZRf230D2gwkPo9BVYOC+4zWclP3WQPdJVxatKdLS7sERwoCAlpXT1V9y3elIQQVMtv7RynVGmh0wowdp0TI0x3D9vinfzJUvDgZWbPSKSW0axoV+Ol0ATadzMf+jFKHK0+25svDN1BY04QQTwmWj40BAHy0LwtlMsfdMBoNwcu/XsKU/x7B4Lf+xm/nCi2/yQK7L2tvfmPj/eEuEWJSYhA8JAIU1TYjLc8+HzmgDQCe9vERrN6Zgfd2Z2L6uqNOn2tAm0Xx6YFspN6GZfPZ9FljGUUTemrjUk7mVNndLFDWrORufPqWF6DFdcQWhLOFrWk3oVBrkNzdF38+oa2Z8efFYtystt/FpdEQroFh6/ou+vi7a4uSVdTbLl6KakwH7AJAqJ11ZJRqDSd4uhkRL6xF6rqDlhdT4kUs4CPaX7suo9g2scF+Z6zLiIUN2nXUdVTZoAAB4CERcnMjk9v+YMYKFLHOXcT+H4BZt1FnQAixK6C8o6DixYlsO3sTSW/+jQlrDzqk9LNKZRj93gG88MsF/Hv7RTy08QxGv5fKmaMdRanW4NvjuQCAF+9MwLMT4tA/wgsKlQZfH8l1eP+/nivEJl0wrVylwUu/XHS4rHhanjYglL0hSIR8jEvQFrOyN9uEEILlm84it7IRLiI++DwGWWX1+O9+x5++9fni0HVM/fgI3t2ViYUbTmPV75dvKwHD3hiMuW0ifF0QH+gOtYYgNdO4j94SbAfmAHdxm0qk7PlwKqfK5q7E+zK05809A0LRK8QTQ7v7QK0h+LNViXlbMNUSoDWseCmX2SZeFCoNJ3hMihc73UZFNU1QaQjEAh4C3NtWfGUtLzcqGux6QGPFS+vUcX1YV8/VEtvqybCiy5R4ueaAeFFrNKjWuYt83URwFQvAMAwUKg3kNp5zzSqdy0jP3STS/V+u6vhKv6aQK9XIKqvH1eI6VNohsDsCKl6cRE5FA577+TwUKg2ulzdgybdn7DoZFSoNHv3hLGqblAj1kiIlIQCBHmKUyeRYuOG03TcAfQ5nlaOiXgFfVxEm9w4GwzB4dLS20uKPp/Idak2v0RDO/fT0+DgMifJBk1KNd3YZL2VtDSq1BufyawAAA7u1uCbu0D3V2+uS+PVcIU7mVEEq5GPH4yPw2bwBAIANR3Mga3aOu2vXpRL831/az87e3L89noedTmhC5yw0GmL3d14vVyFPFyfRunYHy4ReWtfR7kv2fU9ZrVJg9YkLdEOAuxhylcYmC1xxbRMuFdaBYcCJYLbHzr6r9v/GWloC+Bm0BGiNveKFDVAX8XkGdVj0YQN2qxoUaFRY7wbN04t34RmJfQv1lkIs4EGh0thsnVKqNVwwcJS/afHC/kZst7w0cWPUhw3aveqAeKluVEJDCMQCPtzEAvB5DFx0Acf1NrqZ9YN1WfQtL7fKQ01xbTN3TSiqaW4Xa7SjUPHiJH5NL4SGaC/gfm5i5FY24ptjuTbv5/fzRcguq4efmwi/LR+OrxYMwqEXxmJqn2CoNARP/pjukFkbALanFwEApvUL4S6wKT0CEeolRW2T0qHurmfzq3GttB5uYgEWjuiG1+9OBMMAf10ssbs6Z0aJDA0KNdzFAq5YFgCMjveHgMcgp6LB5mwWlVqDD/ZcAwAsHxeD7v5uuKNnIKL9XdGs1Dj09M3SpFDjjR1XAAAPDY/CzidHci66tXuvOcW96Cg/nsrH4P/bh56v7MLTW87ZfJFiM3QC3MXwNdGfhRUF+zPKUNtouyhkLS/63z0LwzBcOvJhG+JejmVrK7n2DfPirDkpPbQi5kxeFReYaSsHMrTiZXRc2ywjfdhjltv4VFus19PIVECrp1QId139ENbFZA3m4l0AbY8j1uVja9zLzeomqDUEEiEPgWZ6XSUE68SGjdcKtlFl63YJ7P4yS2R2CQNCCCrrW6wu7Jy7inT1WWz8vegH67KIdNdgNSFQ3QLXBIVKwz28ifg8EJBb0vpCxYsTIITg9/NaQfDI6Gi8MCkeAPDFoRs2PdESQvDFIa3V4uGR3bkLnFjAx5rZ/dAv3At1zSq89edVu8eqUGlwIEP7ZDm1T0uPEj6PweyB4QDAZfXYA1sFNaVHADwkQsQHuWOy7ubFZnXYylldQGi/CC+DbCg3sYBLrzx+3bay4n9cKMLN6ib4uorwkC4LhmEYzNLNgX6DQXvZln4ThTVNCPWS4vmJ2nNi8aju8JAIkFVWj2PXbQ8yNYWsWYnVO69ixbaLVqf8/u/wDazYdhEV9XJoCLA9vRBv77Tt3GJvMuYyfXqGeCAhyB0KtQY7LhbZtH8AyCrTfh62G3NrWlKmrXersufUID1LXpi3C+IC3aAhwKkc28vUVzcocEbn3hzXI9DstvbGvHDdpE24jFi4dGkbXEdcppFP20wjlmhd3IutGUes1SXCx7hVh6WHzm10o6LBpmtnS+0bw3mJCXADn8egtklpEByt0VgXy9EgV0GuUoPHMAatGKQ6y0mTDdZ1QgjkurgWsZ7lhcdjOAFzK8S91DZp43tcxQKuYnNNkxIqJ8W/OMu6RMWLEyioakJORQOEfAZ39AzEjP6hCPWSoqJegZ/Tblq9n4wSGa6V1kMk4OH+IREG60QCHt6e2Rt8HoOdl0q4omC2ciqnCjK5Cn5uIvTX3fhZZg8KA4/RBlfesDOjYJ8u/iRF7+K9aKRWHPx+vsiuJ1rWHTAw0qfNOrasuK1C4PsTWoG2YFg3g5oTbNO5M3lVnJ/bXrbqvvv5wyK5Y3hKhZiiE41/XXTcugNon+bmfnkCnx+8gR9P5eP+L09YfFK6Xl6Pd3dnAgCeGBeDj+f2B6BtdphlQ7wWVzE12LjLiGXmgDAA9olCVozFmXBLDY/RipdLhdb758/q3JADWmVIDeymPcfYvkS2kJpZBg3RCrlQL+OZQCz+ugeTmkalTe7lEhM36daE2JFxxLmNzMSkxLAZR2W2xbDpixdzBHqI4eUihFpDbBJIrDst0MNwXsQCPmctyiipg0gkAo/HQ1FREWpra9HU1ITm5maTf6XVMhCVAu4CDZQKBbecUStBVAo0NTVb3Af7V1ffCI1SDqiV0CgVBuv4RLs/WUOjVftqz7+6+kYQlQJSngY8jRJCqKFWylFRW+/wvpuamlBeXg6GYUx2qrYWWufFCaQXaC90PYM9uHLPi0dG4dU/ruDLQzcwd1A4BGb83yy7L2vdNaNi/Y329kgI8sCspDBsPl2AdanZ2LhwsM1jZYNbUxIC2zwBBXtKMTY+APsyyrDpZD7+M7WnTfsuqW1GVlk9eAwwWi/Ton+4F3qHeuJiYS22nC6wucsweyNJimybipsc7YuP92fj+I1Kq2tD5FY0IC2vGjwGmD0o3GBdqJcUCUHuyCiR4VBWOe7uF2rTWFlulNcjPb8GfB6D6f0N9zGldzB+PJWPXZdK8MbdiVadG+b47ngeLhXWQSrkQ6nWoLJBgdU7M/D+rL4m3/PFwRtQqDQYFeePp++IA8Mw+P18EfZeKcVPZwrw8hTrvvurutiEnhZqrNzdLwSrd15FWl41cisauO7HlpA1K1GmiwsxVX8lwF3CfWdHr1dimoWux/VyFTJ1omtAq3NqYKQ3Np3Mxxk7MtjYWJnxPSx3RfaUCiHkM1CqtW6J1u4OU7S4jcxv3xK0a707lXUbdTNS44WFtbzY7DbSiZdwC+KFYRj0CPLA8RuVyCiRWdUTS7/LtrGqwwlB7sguq0dGiQxj4gMQFRWF4uJiFBWZtwKqNQQltc0gABgPMRqrWn6nhAAVtU3QEAAysdn4JpYmhRqVDQqIBAxyGw1FVk2jAvVyNZqqBPCUdm6fruLaZqg1BMRdjFoBD3XNStQ1qVBXzmsTMG8PDMMgLCwMfL5tNXJaQ8WLE2ArQvbTs2TMGRSB/+7PRn5VI/66VGLxggoAe3TpwBN7mTY5PzI6Gj+dKcCBzHJcK5UZLbNtDjaNc0y88TTOB4ZGYl9GGTafLsDjKbE2/ZDYeYgP8oCnnomVYRg8mByJ57dewPcn8rB4ZJTVN+yS2mYU1jSBxwB9w9teyPqHe4PPY1BaJ0dxbbNVN4HfzmkvWiNi/ds8qQHA2IQAZJTIsO9qmd3ihS2JPyzaFwGtfPxDu/vAy0WI6kYlzt+sNSrKrKWmUYGPddlRr03rhZhAN8z49Bh+P1eEFyclcO4JfeqalZyb8/FxMZzgmzMwHHuvlGLb2UK8OCnB4nek0RCDTr7mCPCQYGSsPw5eK8f29EI8fUecVZ+PtQb4uorMNusbGeuHjBIZjmSVW/ytXS6shYZorRetv3/Wune5qBbNSrVBbII5FCoN11V7vAWXEaB1Ffi5iVFc24xymdwG8cLGdljpNrLS8qLREOSx1XV9TAtLNpXZVvHCWl7Cvc2LF0BrxTt+o9LquBdzXbYBrXjZcaEYGbr9iUQiREREQKVSQa02bfXacCQH358sQ+8wT3w4p62YX7PpLK4W1+HlKT0xLsayYN14NAffnSjDxF5BeGGSYcHGrWk38dmBbIyK88equ8z/NmS62lnu7SByymTNWLntBHg8Br8vGw6pSID8qgY8s+E0+DwGWx9JhofUtmafrREKhQ4LF6CD3Ebr1q1Dt27dIJFIMGTIEJw6dcrs9j///DMSEhIgkUjQu3dv/PXXXx0xTLvhxIteaqRUxMf85G4AgPUHrlv089U2Krn0wDHxpn8I3fxcuYvjltMFNo2zuLYJ2WXasuXDjJQt1x7bHwlB7qiXq/DV4Rs27b9FxLUVGXf1DYG3ixCFNU3Yl2F9NgcbmxAf5GG0QqZUxEcPncsiXecKsMTeq1oL19TewUbXp+iyTw5eK7fbz/u3TrywRdr0EfB5SO6uc3dlOxb3si41G3XNKsQHumNmUhgGRHijX7gXFGoNtpw2Hrv0W3ohmpRqxAS4GZTzHxPvD0+pEJUNClzQa8NgipvVTaiXqyDi89DdTAYJCysqdl6y3l3G9tqxZKkZobP0HcmqsPhbu6K7ifUKaSu4wn2k8HUVQakmNrULOJlTiXq5Cv7uYvS2soM2+xRrS9wL6zYKMiK69bE1XbpU1gyFSgMBjzErjLr7aS0v1Y1Km1zA1rqNgJa4F2vFC1e0z8N4EDNrvTl/s+WcZt0WEonE6B8jEOKrEzdRKFPjrv7djG7j6+GGQpkameXNJvej/3e+uBGFMjVCfD3arAvxdUehTI30wgaz+/jyaAGGvncYQ987jA9TcyEUia06trV/V0qbUChTw83FBd4ebpBIJIgL8YW7qwvya1U4cL3W4WM4Q7gAHSBetmzZgmeeeQarVq3C2bNn0bdvX0ycONFkX4Zjx45h7ty5WLRoEdLT0zF9+nRMnz4dly5dau+h2oVKrcGVIu2PTL/6JwA8mBwJFxEfV4rrLGZCnM2vBiHaAk7Gnpb1uW8wG1R606YAr6O6DIs+oZ4GlhF9GIbBkynacvvrD91AboX1vu3zRixQLBIhH/cN1sbxsDVmrKEl3sW0dcKWhm4ltc1ciuzYBOMisX+EN7xchKhtUnKxEbZQWS9Hmm4sKSaewodxsTqWA0M1GoIjWRU4eaPSIEOpoKoR3xzTVoh9aXICF8z8wNBIANr4ktY3ckIIftDV4Ll/cITBxV7A53HjOmpF5g4rtmMC3Kwym4/vEQgBj8G10nqrn9zZ889YuXp9BnfzgYjPQ1Fts8XeO+aCjBmG4ZbbkvHCuoxSEgLMBqTqY0+6dJGFpowsrCXH2mwjtpt0mLfUrMVNKuJzwsgW6wubDRhh4XsEWlLis6yMebEk6NjrUU5Fg9VxbLsulaCiXoFADzGX6t8aVrDfsPIayYphYyn/bOG7vMpGk+L7UmEt1vytzVJU60pSPLXlHJRqDaoaFPj2eC4e/T4NL/1ywaa4NX3O6Tp6t34Anax70HNWnJ4zaHfxsmbNGixevBgLFy5Ez549sX79eri4uODrr782uv1HH32ESZMm4fnnn0ePHj3wxhtvYMCAAfjkk0/ae6h2kVvZALlKAxcRv01VSm9XEeboYir+ZyHThg3AtcaFMCrWH35uYlQ3KnHihvVZEUd1T/nGOt3qMykxCCNi/KBQafDk5nSrBJJaQ7imiX2NiBcAmDckAjxGK6Ks/XGxsQfm5kW/J4ol2Do5fcO8TIpEPo/BGF1p9/02WIlY9meUgRDtk70pd0CyzvKVll9tNmBTrlLjwa9P4YGvTmLOFycw+/PjKJM1gxCC1TuvQqHWYHiMLzdeQPv9SYQ83KhoMGhkCWitYxklMogFPMwY0NYlxga/HrbCImRNppE+ni5CDNPt39raPGwGTJSJ9F0WqYiPQVHac+SIhWKObJyOqXGz9WqsFS+EEC6WzBqXEQsbtGuteDEoUGfJbaQ770rqmq1Kyc+vMp8mrU+0jZV2axuVqGvW1kOxxm3E7r9cJrcqtb60riV93BheLiJOaFjb9JEtsjl3cIRJYd6dLdpnhYhrVqo5K2K8EVd/uI8L+DwGTUq1yZYR/92XBUK0MXP/ndsfQj6DP84XYej/7cPgt/7GK79dxs5LJdh8ugCT/3sYO1sJjdompcUu5uwDaOsHcVa8HM2usKvcQXvQruJFoVAgLS0N48ePbzkgj4fx48fj+PHjRt9z/Phxg+0BYOLEiSa3l8vlqKurM/jrSNgLYXyQu9EnroXDosAwwKFr5cguM33DZm/S+qmbphDwebhD545gg3wtQUhL2XL2BmUKhmHw9sze8JQKcf5mLd7eabnA3PXyetTLVXAR8Y3W4wC0qajsxf1bvZ4ypmhWqnFZd/M1L1606y4W1loUWuwcjDbTdwZoscrsz7C9sJo1N7Jof1f4uIqgUGlwqdD0ObvldAE3ZobRWqKmfXwUi789g78uloDPY7Dizh4GFhQ3sYA79q/phkGJ7EV5Su9geLm09V2z50a6BVEF6IsX6+Ou2Hm3xuIEtFherAnwHRGjcx2ZEV4qtYbrgG0qyJizvFjpNsosleFmdRPEAp7F35Y+nOXFSreRVrTqCtQZ+e5a71vAY6DWEKvEESsSzQXrstga98K6jPzcxEa7SbfGTSzgmk5ml1v+DvRr35iCtc6etcI6W1zbhFO6h0m2dIIxOMtLeQM0FgRidlk9NATwchEafWgS8nlcdeAcI5acerkKB3QxVY+nxGBa3xB88eBASIV8VDYooNIQ9ArxwLN3xGFkrB+UaoLlP6bjzwvFkKvUeHdXBga8sRdDV+/DS79cMGrdMfcAGhPghvhAdyjVBHuu3BoFNttVvFRUVECtViMw0PAiHhgYiJIS4xNQUlJi0/arV6+Gp6cn9xcebvpkaw/YVFFTT3ERvi5cDIWptGm5Ss0pXjZV0xKTErXVZXdfLrXqyepaaT3KZXJIhDyrrDth3i74QJet8vXRHIuN79gnmt6hnmY7Uy/QNVT85exN1FmoYnvhZi1UGoIAd3Gbst/6dPN1gZeLEAqVxuzTskZDuHowlm4yo+P8wde5OGwpgNesVOPQNe1c3WEk3oWFYRguTfesicwWpVqDT/ZnAwBev7sX9j0zGtH+riipa+bq6bw0KcFoRsY9ugyn388XcXE7dc1K/HFBK2Zap+KzdPN1gadUCKWa4FqJ+ZuTubYApmDdUmdyq6yy6HExL1ZYBNh6L8euV5oUXjkVDVCoNHAV8U3GX+i7jaypSXFId1MZFu1r1c2Zxc9NK0CsjXlhn5oDPcUWXVN8HsMFIxfVWo57YTONIqyxvHANGq1zlxRUs/Eu1gUlA0CMzjqRVWpZIFkTBzRE18CTDao2x58XikGI9kHSXMp7hI8LBDpriaVGkmy7mLhAd5MZkWxKd66RViqpGWVQqDSI8nPlLDdj4wNw5MWx+PLBgdjz9Cj8+cRIPJ4Si40LB+Oe/qFQawiWbTqLvq/twacHrnP3ic2nC/D9ibYPjzd0D6BSIR+xRjL7bjXXUZev87JixQrU1tZyfwUFtgWxOgpngjZRgwIA7k3S1rj4Nb3QqNC4VFgHuUoDH1eR2b4f+iR394W7RICKerlVsR5sX6TBUb5Wt3Ef3zMQDyZr4yde+f2S2SZd5uJdDMYd7YuYADc0KtT4xUINHLbgV1Kkt9kUaIZhuJo15uYis1SGqgYFpEK+xXF6uYi4Lsn7bOiddPx6JZqUagR5SIwGhOrDikhTZe2PXa9EmUwOPzcR7hsUge7+bvh12XA8e0ccJvcOwrr7B+DhkVFG3zsqzh/eLkJU1Ms5S8Sv6YVoVmoQF+hmUsAyDMMFnLZ2OeljTVsAY8QHusPHVYRGhZrrFG0KWbOSS4GN9LNsEegZ7IFADzEaFWqTlh02WNeUpRQAogNcIeAxkDWruBgTc7DxbOYaMRrDX5eFZq3biIt38bBOBLC1YIqsCNrNs8nyYlu6tC3BuixsPRlr4l6sycAamxAAhtE+EFlynbCZeJay1oR8HhfDc8OCkGOtfcZcRiysQDdmeWHd1xN7BRlcC33dxLijZ6BB1imfx+D9WX0xPzkSDKNtSeDnJsL6BwbgP1N6AAC+OHyjzb2Idbv3DvM0Gvc0ta9WvBy4Vm53TI0zaVfx4ufnBz6fj9JSw4t/aWkpgoKCjL4nKCjIpu3FYjE8PDwM/joSNv0uwczT59iEAHhKhSitk+NUTtvicmd0JsqBFm7S+ogEPM6iY43riIt3ifG1av8sz06Ih6+rCDfKG8wqbtbyYirehYVhGMzXCaLvjueZNbeetSLehYV1HZkLsD2piw8a2M2ba0dvjok669bWs4YiS6MLmDPGXtZl1DPA4nfJiZf8aqNP+KzPemKvIG687hIhHk+JxafzkjClT7DJYwj5PC7N+3+Hc0AIMfDjmxtbIideakxuY01bAGPweAwG66yLpixOLNamSevvm7V2mYqpsRTvAmgLm7E1Za4WmXdDNyvV3G96pIVYstbYGrBbwlbXtRDvwhKssxoUWwjaJYTo9TWyJuZFu01BVaNVVXDtES+xgdZX8i2xovaNv7uYe2Ax5/bIqWjAhZu14PMY3GkiG1EfNvvqRoX5cV6zUGgRaLG8tBYvhBAuttHac4zPY/Da3Yk49PxYbH0kGQefH4tJicGYNyQSnlIhCqqakNoqns/SA2i0vxsm9goEIcCq3y871APPGbSreBGJREhKSsK+ffu4ZRqNBvv27UNycrLR9yQnJxtsDwB79+41uX1nUtuo5J6GjEWQs4gFfC4GwZjQYONdBloR76KPvuvInHlbodLgpO4Cy8YFWIunVIgHdSnfXx/NNbpNs1LNuRAsWTQAYMaAMLiLBbhR0WAyPoEQwlkkWhcSMwYbtGsuIC+Nbe5opFKvMe7pHwoRn4dLhXW4cLMGhBB8fSQHA97ci16rdmHlr5cMXB9qDeFSpK0J3OwT5gkBj0G5TM41ltPfF1srZooVF1FjPDwyCgIegyPZFUhZcxAZJTJIhXzM6B9mcVyAecuLrcG6BvvXZTJcuGl6/4D1adL66DfrNCaMrR23tRlHaXnVkKs0CPQQmyyiZwpbxYs1sR36sJYIS26jygYF6uUqMIw2VdwS/m5iuEsE0JAWgWkO1u0aZot4sbINgVpDUCoz32Wb5S5dZeuNx3JNPjTt0FldhkX7WlWQLVov7sUc7PXRrOWFdRu1Ei8FVU0orm2GkM+0qQhtiXAfFwzs5sMVT5WK+JjFegLOGVa7Zi2hrYN19Xl2QjzEAh6OXa/Ev7462antDNrdbfTMM8/gyy+/xDfffIOrV6/i0UcfRUNDAxYuXAgAePDBB7FixQpu+yeffBK7du3CBx98gIyMDLz66qs4c+YMli9f3t5DtRk23iXUS2rxyZAtPLf3iqHQIIS0WF6sjHdhGRnrDxGfh/yqRrPpeun51WhUqOHrKrLJxM8yb2gERHwezhfUcJ9Zn8tFtVBrCPzdxRYvIIC2Z8ZM3Q9ow1HjWVhZZfWoblRCLOAhMcRy3Yy+4V5gGO1TnqkYgjRunq27APi4ijC5t/ZmuGzTWSz+9gxe33EFNY1KNCs1+O5EHp7cnM59n8euV6BMJoenVMi1LTCHRMjnXEutAwkvF9WiqkEBd7EAg6JsOy9YwrxduLRp9uL60p0JJtPkWdhA1mul9SYtTNa2BTAGe3G8YMayA+gF61phDWAZ2t0HbmIBymVyo24pa8UL+zvJsBC0y7qMhsf4WW01ZWHFS4NCbVX3Z9aCEmyhxgtLiKd1lhdWgIR4Sq1yKTMMY5PrqMAet5FOvBTWNKHBTOfmino51BoCvq7onzlmDwqHu0SgtSIbqTWk36POmqKiQEvQrrl5KJM1o7i2GQyj7fNlcl868ZJX1Wjwuzuh67PVJ8zLppgqU7AtUPZnlHGNJZuVaq6Tt7FioCxxge749qHBcJcIkNzd1yoLdnvR7keeM2cO3n//fbzyyivo168fzp07h127dnFBufn5+SgubjmRhg0bhk2bNuGLL75A3759sXXrVvz6669ITExs76HaTEvAouUL+Kg4f0iFfBTWNOGynin6enmDTTdpfVzFAgzprr2xtTYB6qN/gbW2BoU+fm5iriIvW51WH7Y4XN8wL6sv4POHdQOPAVIzy5GW19aVxo55cJSPVT8QD4mQ85OfM+I6KqppQlFtM3iMddYhlhWTe8DbRWtm/ftqGXgMsHJqT6y7fwBEfB52XirBRl33cLaX0V19g62OK2KtSq1dKOznHxrta1UNFVOsnNoTDwyNQEKQO56fGM/FMJkj3McFEiEPCpWGC+RsjbVtAYzBuqUKqprMFjrLqbA+DoNFLOBjtO5cbe06KpM1o0wmB8NYjtOx1vLCumNtdRkBgKuID4muQV+FzHL9kWJdUGiwldV4uZgXC5aXlm7S1s8zJ14sWEZUag1XKM8W8eLlIuLEiDlhwMbzBLqLzSYKANosJrYJ6+t/XGmTMJBRIkNWmba3HOsytkRLurTph8dLOgtmtL8b3MSmi9qHeEkh4mt/d/pxSidvaK+PQ+x8iGlNnzBPhHlL0ahQ44CudASbHOHnJrLYl2tId1/semqU1VWy24sOkU3Lly9HXl4e5HI5Tp48iSFDhnDrDhw4gI0bNxpsP2vWLGRmZkIul+PSpUuYPHlyRwzTLFeK6rBi20V8+Pc1bpktpnOJkM+lieq7jlirS79wL7tULFuNl61fYgw2WHeUhfRgc7DxE7+fK2pjcmUrV/bXqzBsiSg/V8xK0maGvbMzs43bixuzDUGQLfVe2sZSsC6oHnr9p6wh0EOC7xYNwaReQRiXEIAtS5OxaEQUpvQJxr8nJwAA/u+vq/j39ovcUxv7uayBNQOn5bcWL+znt/2mqA+fx+DN6b2x66lRWDY2xipxyecxXLr7NSOBeba0BTCGp1TI+fcvmXFNcTdVG9xGQEtV4z2txMsFXQGuGH83i+cAa1HKrWzgnk5bU92gwKUi7T5tSZFmYRiGs76UySwHBpdY2VGaxdpCdeyN15p4FxY27sWS5aW4thlKNYFIwLNYFbg1rOvIXMZRiY2utEfHRCPKzxVlMjneaVUCYpsutm1MnPHecsZgrSWFNU0mzxPWPcq6Y03B5zGcxemKnmg+qbO8DOluW7yiKRiG4VzRf+ri6tjrTXK0dRbEUC+pzZZGZ9Pls406iqKaJvx4Kh8/nS7gbrRsTIC1F/CJiW3jXk7oBZHawzhd0O6pnCrUGzGvVumVerfn6ZAlpUcA3MQCFNY0tXFxsFYDc75SYzx1RyzEAh5O5VYZiK8GuaolQC3O+jGzQbvG2gRYU6nXFImhnlj/ryR8vWAQBum59uYP64aJvQKhVGuDYQkBZiWFWQxa1ocN2r1aLONcBw1yFTfeETZmsDgLNnsh00i6tK1tAYzB+v7NZZOwMS+WCtS1Zkx8AAQ8Btll9QbBj+zvoI8V56m/mxg+riJoCJBloj7T0esVIET7WVr3r7IWfytbBCjVGq5BpbU3albkVNTLzdbsYQWILTE71qZLs99hpI+LzVZfdjzZZgRSsZUVh1kkQj7eukdrxf/hZD5neWhWqrlSFnMGWf/w4eMqgpfODWtKyHHixYq2EYmh2nsJW9+qsKYJN6ubwOcxDvVAaw2b9rzvqtZ1xKb7O/qw1JFQ8WIlI2L94CLio0hXXl7WrOQsL9aeVOPiW8qj51Q0QK0hXN0BWywM+kT5uaKbrwuUamK0FsvRbO0FNiHI3WgTQmuRCPmY2EtrStUP9LpZ3YjCmiYIeAwGRHrZtM9gTykWDO8GQGt9Yf28f10sRrNSg26+LmYD3FrDWl7OF9S0idVgxUCSjXFF5mAYBmvn9MMDQyPg7SLE7IFhWDWtl037CPGSIthTArWG4LzOMnAqpwpKNUGYt9Qml4kziQ/S3jiMWV5sbQtgjJZsEuPCwNY0aX08pUIM1T2l7tXLLLnABiSa8emzMAxjMe6F/b1ZqlhtDtY1Ul5v3m1UUqsrUCfgwc/VuuwuH1cRxDprbmmtaXHEBsXaJ17qzSYL5NqQxdQa9hwxa3mxUF3XGMOi/fDAUG2doyc3n0NGSR1+OJmPmkYlQr2kZnvLtYZhGO4aZew8Uao1OK1LlrAm8YB1qV7ShRac0KX8J4Z6mnU52UqfME+E+0jRpFTjo31ZnLB3xDrf0VDxYiWt3T5pedXQEK0f19ofjqdLSyDn7sslOFdQg+pGJTwkAodUNftjO2DEdcQpaieclHf30wZ6/XmhmKv5wrY16BXqCReR7T+ux0bHwEMiQGapDJtP54MQgh9PaVN6Zw0Mt8k0GRvgDlcRHw0KtcHTcqNCxZlhnfn0AgAuIgHenN4b6a9MwLv39rXrAsMVq9NZtA7pTLgjY20PAnUWnOXFmHhxINOIJcaCS8DWNOnWTOhlmDKt1hCDQorWwGYQGmvQSAjh4pIcES/WZhyxhd7CvKVWWzAYhuFcR6YaNKrUGs46Em2DFS3SV1ugrVFhvkBbHhd0bbsI5ywvZiqTt1hebHswWzm1JwZEeKG2SYk7PzqMN3ZcAQA8NjbaYuxMa8zFR50vqIFMroKXixC9rIhpZLdh3alsVd3hViQA2ALDMHh4RHcAwPqD10EIMCLGz6EH3I6GihcbYFOTt6cXcpVaB9sYRDVBZ73443wRF+A5Ks7fbDM0S7Cuo9TMsjaZTC0FtBw3B2rTB0WoblRyT52OBpN5ugjx+DhtI8jXfr+CuV+ewNn8GogEPMwcYD6ltzV8HsO5bM7m1XDLT+VUQa0hCPWSWgxG6wzYJ7Lj1yuh0RDsuay94dpa9MyZsDfunIqGNi6HjGLrA9VNwcbUZJUZf3K3J01aHzZV/UxeNSrqtZlHNY1KuEsERisSG6PF8tL2ppRXqbU4CvmMQ4GU1ooXNpU+zIreQPqwN/ViE0G7+VWNUKoJpEI+l51kDUI+jwvwvWbGMsJZXuz4Hlnxkm+mnkxLHJBtv2uxgI8NCwajf4QX2NNvZKwf5g4yXnnaHOzvwJh44ZIlov2sEkU9gt0h4DEok8lxrVSGg7oH0pQe1luDrOW+weGc25fHAC/rCth1Fah4sYGJvYLg7SJEYU0TPj90A4BWrdrCpF5BkAr5uFxUx1kY/jXUcgaIOQZH+UAq5KO0Tm4Q6HWluA4ldc2QCHkGsRr2IuDzMFVXK+GXszchV6mxSxe/Y+s86LNoRBQm9AyEQq3BCZ0Yen5CvE2mYBbWsnJcr2El94TswBjbE7bY4LHrFfjzYjEKa5rgLhZworQzCPKQwF0igFpD2mRSXLXQEsMauvu7gsdom8UZ6+3TUjTNPrdZiJcUiaEeIAT4+0opDuiy8UbF+lvt6orXxbIZs7ywjSsHRHjbZXFk8bMy5qVFvNh2k2Zv6sUmqsqyLqPu/q42x6SwhTkzzGRk5VXab3nxdxPDUyqEhhivOgvYXvtGH08XIbY+Mgyf/ysJXz44EF/NH2RXNqa5dhJsfOMoK2P3XEQCLvj75e0XUdesgreLEP3CnWsxBrQCbvtjw/HRff2weUmyQ7/nzoCKFxuQCPmYO7hFmUf5uWJKH9sKiPm7i/GMXorZ+B4BDkeRS4R87oTfd7XFdcRWxB0TFwCJ0PH6AEBLq4O/LhZj7d4s1DQqEewpsSvbgoXHY7Bu3gC8MT0R9/QPxdszemPRCONl7y3BuscOZ5VzcS+slciW4N+OpJufK/pHeEFDgMd/TAegDahz1ndmD/q+fP24F1mzkhMWjlzsJMKW3kLZRp7c2ZuVrcG6+tyZqP1tfrw/G9vStXFabMq/NcQFuoFhgIp6RRtxcUTPtecI1lteWtxGtsAWqjPlNmIDbm0tsAe0tEQxlU6u0RDk6Wq8RPrY/j0yDNOScWQksFujIVxHaVvdRix8HoOJvYJwR89Au2uWxAW6g89jUN2oNCg2mVkiQ0aJDEI+w8ULWgN7Tzmdq3UjT+sbYrMry1o8pULc3S/UZg/CrQAVLzbyREosHhoehe7+rnhreqJdAYuLRkTh/Vl9sXZOX6ybN8Ap42KL4G07exOEEBBC8NdFreqfbKPAMkdiqCfuTAyChmh9pYA2NsXRH5eQz8O/hkZi7Zx+uG9whF1PQADQP9wLHhIBahqVOFdQg9yKBmSWysBjtKbbW5V5Q1qsbxIhDwtHdOu8wehgS5nrixc2wy7USwofV/OdjS0RE2A648jeNGl9/pUcCR9XEZex4ecmtrp+B6B9Co7UCSx964tKreF6JzmaDdbebiNW7LSu4MzCWl7YAFxbYMWrqYDmkrpmKFQaCHiM2b5D5ogxU2m3skEBpZqAx8Bop+aOQqLXK+2oXsXwX9jU6/gAox3cTTEpMYjrqu0mFuDxlFjnDfY2gooXG5EI+Xjlrp7Y/+wYDLPT2sDjMbg3KQz39A+zupiZJSb3DoariI/cykYcv1GJ1Mwy5FQ0wFXEd7r74T9Te3LBfcndffHI6O5O3b8jCPg8zvryy9mb+DlN26hzZKw/vB282bYnMweE4s3piegX7oXP/zXQrvopzoa1vOgXVbxoZc0Ka+CySYwEZLKxEo5YXjwkQrw1PRFSnQVr1V09bQ7+jTdiXbhYWAtZswoeEoHVwb+m0E+VNpe1c7PKPstLuE58meqMbk+aNAvrNsouqzdaJp6NWwr3cbE7ps9c0C4bx+PvLnaokKMzYF3SrDuxrlmJH3W9xO6zIfUa0J63O54YiZVTe2LjwkFWtSn4J+K83CtKp+IqFuDu/qHYdDIfyzelc5aQB4ZGOjXFDtA+de96ahQu3KxFnzDPTr9wtOZfQyOx40Ix14gQAGYNtC34t6NhGAYPDI3kyvnfCrDBz+cKtH2dGIbhUip7O0O8mMg4qperOEuErWnSrbmzdzBGxfmjsl7BdQC2hYQgD+y+XGpgeWHdkMOsDMI0B3tjkqs0kMlVRsVVs1LNVde1pUqt/vaF1U1cGX0WQghXIdce8RLiKYGHRIC6ZhWyy+rblL53NG5Jf1zGstLY4nu2Fr9rD0bE+uGjfVk4klWBJoUaXx66AZlchbhAN4y1IfWaxcdVZLfr/J/CrXXXoTjEM3fEwcdVhKoGBcplcni5CLFoZPv8AIR8HpIivW854QJoA5gH6RX9iw9057oNU6ynZ7AHRAIeahqVyK1sBCGEa71ga0FCY7AZR61dAqzLyN406da4igV2CRegpReNfsNP9unakRRpFqmID3fdw0WZiZTjvMpGEAJ4SATwtdF6GOwphYDHQKHWcPEhLGUyOWRyFXiMfQKDYZiWoF0jGVlcxpgD1rPYwJZKx2x5Bpb8qhbLTmfTP9wLYd5S1DYpcd+XJ/DZAa1L/Zk74ux2gVPMc+vdeSh24+cmxlfzB2J4jC96h3piy5Jkuyt/dmUYRhsAPKN/KAZ188ZXCwY6zT33T0Ik4HFukbN51cjVSw+2pYqwKdgS85UNClTqBcTmVjj+xO4s2Cy9rLJ6VNTLUdOo4Aoe2ltYsjVspkyJiUJyXPCyn6vNdX/4PIZzNeW3ch2xsUyRvq52/z56mqlxkueE7zHEUwJXER9KNWnTwZrtfdXdgbgoZyHg8/CELjblfEENVBqC8T0CbQrUpdgGdRvdZvSP8MYPDw/t7GF0OgHuEqyZ06+zh9HlGRDhhbS8ahzNroBM18huUDcfp7giXUQChPtIUVDVhOyyevjqXCiO1nhxJj66TuwZJTKcuFEJpVoDtYYgPtDdbmtOa4I8JcgqqzdZi0VfvNhDuI8LcisbkV/VyFUeBoBLhVrBYa7TsSXMVSFmY5nsHTeg62Ad4IYLN2uRXSYzcG/lVGgtdrfCeQIAMweEIa+yAVtO38TwGF/83z29O73/z+0MtbxQKBSTsIUZd10uwXZdR/HRTiwhHmsk44itK+OIu8GZsDf8A5nl+POCNoPPmW7IYM7yYtxt5OhNmo17yW9luWCruNrazV6fBBOWl2almhNd9nQe14et9nylyPAYrIXOEXHkTPg8Bs9PTMCZ/4zHR/f1t6kBLMV2qHihUCgmGRDhjSg/VzQq1DhfUAMBj+EEjTOINZIKm1mqvUmxmT6dzVRdqYGtaTfx99VSMAwwTdcqwxkEsYXkTMS8OGp5YdOgW/epYtPeHcmYitfVOKmoV6BIr5bMtVIZNEQbt+RoGjProkzXiztqVKi4tgS3inihdCxUvFAoFJMwDINlY2O41w+P7G5Xkz1TcNkkOheDSq3hys0n3CLiZWA3HwzWq1A9tU8IZw1wBqzlpdSI5YUQwlml7KnFArTMo754qW1UcjEwbCdje5CK+OilczuxsUBAiyUmIdjdYddJP11w+Hld1hvQIui8XYQ21VCh3D5QuxaFQjHLvUlhSAhyx5WiOtwzINSp+47lqvhqb9C5lQ1QqDRwEfERbmNBtvbk1Wm98P6eTEhFfPx7coJT9x3E9R9qK15K6+SoaVSCz2PsSmcGWooN5lU1olGhgotIgLR8bRuObr4uDt/8B0R448LNWqTlVeOuvlqL1FW2/5UT6hUlBLtDJOChrlmFnIoGdPd3w2VdvE6sE0UkpWtBLS8UCsUiiaGemD0o3Omp8XGBbuDzGJTL5CiqaeJuevFB7rdUimnPEA98vWAQ1t0/wOYmgJbgYl6MuI3YFORuvi52t4vwcxPDz00EQlrqpbQ0VHW8WzHbT+xMXhW3jO0274x6QEJ+S9bbqRztftkO7GxHdso/DypeKBRKp+EiEnABnWfyqnHhZg0A3BIVhjuKYA+tGKpqUKBJYdg9mS2O5+h8sG4u1p1zQte4dEh3x3vasH1xLhfVoaJejuoGBdcgNjnacXEEtPSQStV1WU7X1RvqH+HllP1Tuh5UvFAolE6FfXJPy63iOoA766bXFfB0EcLLRVuMj00TZ2HFi6PBy+xN/tj1SlQ3KHBJl7njaFNYAAj0kKB3qCcIAfZdLcXxG5UgRGtVc1adKbbFyZGsClTUy3FNFyNFLS//XKh4oVAonQpbCG7b2UJklMjAMMBIB7qUd0XYjBk2EJWFbcfgaLrx6Djtzf9QVjl2XCiCWkPQM9gDoV7OcYGxqeN/XizBdl0Hb0c6zbcmMcQT/u5iNCjU+NdXpzhx1JkNGSmdCxUvFAqlUxke4wtXER8yuQoA0CfM65ZuotkeGBMvNY0KLoV8QKRjFoYBEV5w13VbX/nbZQDAPf2dF3w9pU8weAxw6Fo59l4pBY8x7JTuKDwew/X6YV1fC4bR3j//ZKh4oVAonYqXiwiLR7V0Jl82JroTR9M5sCXu2QJ9QEvqcXd/V/g4KOYEfB6m9A7mXosFPKfWqon2d8NDw1vExL1JYXZnR5liwbBu6K7rZh/uI8UMJ2e+UboW7ZIqnZubizfeeAP79+9HSUkJQkJC8MADD+Dll1+GSGT6RzhmzBgcPHjQYNnSpUuxfv369hgmhUK5RXh0TDREAh4GRHgblLD/pxDlp73R36hoKdZ3RidekpwU17Fyak9cK5XharEMn9zfH4FO7sb83MR4+LuL4e8uxrS+zhNGLBIhH38+PhLFtU0I8ZLanX1FuT1oF/GSkZEBjUaDzz//HDExMbh06RIWL16MhoYGvP/++2bfu3jxYrz++uvcaxeXW6fWA4VCaR/EAj4eGxNjecPbFNZtlF1WD42GgMdjcDCzHIBzgmoBbXftrY8MQ5NS3S6l6yVCPpaObl+rmVTER3c7i/VRbi/aRbxMmjQJkyZN4l53794dmZmZ+OyzzyyKFxcXFwQF0U6cFArln0NsoBukQj5kzSpkldXDTSLAleI68BhgbLzzeknxeAztuUO5LeiwmJfa2lr4+FiuKfDDDz/Az88PiYmJWLFiBRobGy2+h0KhULoyQj6PSxk/lVOJPZe1DSCTIr25btsUCqWFDpHg2dnZ+Pjjjy1aXe6//35ERkYiJCQEFy5cwIsvvojMzExs27bN5Hvkcjnkcjn3uq6uzuS2FAqFcqsyOMoHR7IrcCKniqvvcmdisIV3USj/TGwSLy+99BLeeecds9tcvXoVCQktvT8KCwsxadIkzJo1C4sXLzb73iVLlnD/7927N4KDg5GSkoLr168jOtq4L3X16tV47bXXbPgUFAqFcuuRHO0L7AX+vFAMAHAV8XHvwLBOHhWFcmvCELZNpxWUl5ejsrLS7Dbdu3fnMoqKioowZswYDB06FBs3bgSPZ5uXqqGhAW5ubti1axcmTpxodBtjlpfw8HDU1tbCw+OfU2KcQqF0bQghePDrU1yV4UdGR+OlO53bBJJCuZWpq6uDp6enVfdvmywv/v7+8Pe3LnissLAQY8eORVJSEjZs2GCzcAGAc+fOAQCCg02bTsViMcRi6hOmUChdG4Zh8O69ffDKb5cxMNIbD4/sbvlNFMo/FJssL9ZSWFiIMWPGIDIyEt988w34/JZ8fDaTqLCwECkpKfj2228xePBgXL9+HZs2bcLkyZPh6+uLCxcu4Omnn0ZYWFib2i/msEW5USgUCoVCuTVoN8uLtezduxfZ2dnIzs5GWJihz5bVSkqlEpmZmVw2kUgkwt9//40PP/wQDQ0NCA8Px8yZM/Gf//zHpmOz+6eBuxQKhUKhdB3Y+7Y1NpV2sbx0Jjdv3kR4eHhnD4NCoVAoFIodFBQUtDF8tOa2Ey8ajQZFRUVwd3cHwzBO3TcbDFxQUEBdUu0IneeOgc5zx0HnumOg89xxtMdcE0Igk8kQEhJiMU72tiu1yOPxLCo2R/Hw8KA/jA6AznPHQOe546Bz3THQee44nD3Xnp6eVm1Hu0pTKBQKhULpUlDxQqFQKBQKpUtBxYsNiMVirFq1itaVaWfoPHcMdJ47DjrXHQOd546js+f6tgvYpVAoFAqFcntDLS8UCoVCoVC6FFS8UCgUCoVC6VJQ8UKhUCgUCqVLQcULhUKhUCiULgUVL1aybt06dOvWDRKJBEOGDMGpU6c6e0hdjkOHDuGuu+5CSEgIGIbBr7/+arCeEIJXXnkFwcHBkEqlGD9+PLKysgy2qaqqwrx58+Dh4QEvLy8sWrQI9fX1Hfgpbm1Wr16NQYMGwd3dHQEBAZg+fToyMzMNtmlubsayZcvg6+sLNzc3zJw5E6WlpQbb5OfnY8qUKXBxcUFAQACef/55qFSqjvwotzyfffYZ+vTpwxXpSk5Oxs6dO7n1dJ7bh7fffhsMw+Cpp57iltG5dg6vvvoqGIYx+EtISODW31LzTCgW2bx5MxGJROTrr78mly9fJosXLyZeXl6ktLS0s4fWpfjrr7/Iyy+/TLZt20YAkO3btxusf/vtt4mnpyf59ddfyfnz58m0adNIVFQUaWpq4raZNGkS6du3Lzlx4gQ5fPgwiYmJIXPnzu3gT3LrMnHiRLJhwwZy6dIlcu7cOTJ58mQSERFB6uvruW0eeeQREh4eTvbt20fOnDlDhg4dSoYNG8atV6lUJDExkYwfP56kp6eTv/76i/j5+ZEVK1Z0xke6Zfn999/Jn3/+Sa5du0YyMzPJv//9byIUCsmlS5cIIXSe24NTp06Rbt26kT59+pAnn3ySW07n2jmsWrWK9OrVixQXF3N/5eXl3PpbaZ6peLGCwYMHk2XLlnGv1Wo1CQkJIatXr+7EUXVtWosXjUZDgoKCyHvvvcctq6mpIWKxmPz444+EEEKuXLlCAJDTp09z2+zcuZMwDEMKCws7bOxdibKyMgKAHDx4kBCinVOhUEh+/vlnbpurV68SAOT48eOEEK3I5PF4pKSkhNvms88+Ix4eHkQul3fsB+hieHt7k//97390ntsBmUxGYmNjyd69e8no0aM58ULn2nmsWrWK9O3b1+i6W22eqdvIAgqFAmlpaRg/fjy3jMfjYfz48Th+/Hgnjuz2IicnByUlJQbz7OnpiSFDhnDzfPz4cXh5eWHgwIHcNuPHjwePx8PJkyc7fMxdgdraWgCAj48PACAtLQ1KpdJgnhMSEhAREWEwz71790ZgYCC3zcSJE1FXV4fLly934Oi7Dmq1Gps3b0ZDQwOSk5PpPLcDy5Ytw5QpUwzmFKDntLPJyspCSEgIunfvjnnz5iE/Px/ArTfPt11jRmdTUVEBtVpt8GUAQGBgIDIyMjppVLcfJSUlAGB0ntl1JSUlCAgIMFgvEAjg4+PDbUNpQaPR4KmnnsLw4cORmJgIQDuHIpEIXl5eBtu2nmdj3wO7jtLCxYsXkZycjObmZri5uWH79u3o2bMnzp07R+fZiWzevBlnz57F6dOn26yj57TzGDJkCDZu3Ij4+HgUFxfjtddew8iRI3Hp0qVbbp6peKFQblOWLVuGS5cu4ciRI509lNuW+Ph4nDt3DrW1tdi6dSvmz5+PgwcPdvawbisKCgrw5JNPYu/evZBIJJ09nNuaO++8k/t/nz59MGTIEERGRuKnn36CVCrtxJG1hbqNLODn5wc+n98morq0tBRBQUGdNKrbD3Yuzc1zUFAQysrKDNarVCpUVVXR76IVy5cvx44dO5CamoqwsDBueVBQEBQKBWpqagy2bz3Pxr4Hdh2lBZFIhJiYGCQlJWH16tXo27cvPvroIzrPTiQtLQ1lZWUYMGAABAIBBAIBDh48iP/+978QCAQIDAykc91OeHl5IS4uDtnZ2bfcOU3FiwVEIhGSkpKwb98+bplGo8G+ffuQnJzciSO7vYiKikJQUJDBPNfV1eHkyZPcPCcnJ6OmpgZpaWncNvv374dGo8GQIUM6fMy3IoQQLF++HNu3b8f+/fsRFRVlsD4pKQlCodBgnjMzM5Gfn28wzxcvXjQQinv37oWHhwd69uzZMR+ki6LRaCCXy+k8O5GUlBRcvHgR586d4/4GDhyIefPmcf+nc90+1NfX4/r16wgODr71zmmnhv/epmzevJmIxWKyceNGcuXKFbJkyRLi5eVlEFFNsYxMJiPp6ekkPT2dACBr1qwh6enpJC8vjxCiTZX28vIiv/32G7lw4QK5++67jaZK9+/fn5w8eZIcOXKExMbG0lRpPR599FHi6elJDhw4YJDu2NjYyG3zyCOPkIiICLJ//35y5swZkpycTJKTk7n1bLrjhAkTyLlz58iuXbuIv78/TSttxUsvvUQOHjxIcnJyyIULF8hLL71EGIYhe/bsIYTQeW5P9LONCKFz7SyeffZZcuDAAZKTk0OOHj1Kxo8fT/z8/EhZWRkh5NaaZyperOTjjz8mERERRCQSkcGDB5MTJ0509pC6HKmpqQRAm7/58+cTQrTp0itXriSBgYFELBaTlJQUkpmZabCPyspKMnfuXOLm5kY8PDzIwoULiUwm64RPc2tibH4BkA0bNnDbNDU1kccee4x4e3sTFxcXcs8995Di4mKD/eTm5pI777yTSKVS4ufnR5599lmiVCo7+NPc2jz00EMkMjKSiEQi4u/vT1JSUjjhQgid5/aktXihc+0c5syZQ4KDg4lIJCKhoaFkzpw5JDs7m1t/K80zQwghzrXlUCgUCoVCobQfNOaFQqFQKBRKl4KKFwqFQqFQKF0KKl4oFAqFQqF0Kah4oVAoFAqF0qWg4oVCoVAoFEqXgooXCoVCoVAoXQoqXigUCoVCoXQpqHihUCgUCoXSpaDihUKhUCgUSpeCihcKhUKhUChdCipeKBQKhUKhdCmoeKFQKBQKhdKl+H9wP5FaGkBQYgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " class 1 with c_x_train.shape (1755, 500, 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "idx: 701\n", + " class 0 with c_x_train.shape (1846, 500, 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " class 1 with c_x_train.shape (1755, 500, 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "classes = np.unique(np.concatenate((y_train, y_test), axis=0))\n", + "\n", + "start_sample_numbers=700\n", + "end_interval=2\n", + "\n", + "for idx in range(start_sample_numbers,start_sample_numbers+end_interval):\n", + " print(f'idx: {idx}') \n", + " \n", + " for c in classes:\n", + " c_x_train = x_train[y_train == c]\n", + " print(f' class {c} with c_x_train.shape {c_x_train.shape}')\n", + " plt.figure().set_figheight(1)\n", + " plt.plot(c_x_train[idx], label=\"class \" + str(c))\n", + " plt.legend(loc=\"best\")\n", + " plt.title(f'train time series for sample number {idx}')\n", + " plt.show()\n", + " plt.close()\n", + " plt.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Qig1eolEh0vo" + }, + "source": [ + "## Build the model\n", + "\n", + "Our model processes a tensor of shape `(batch size, sequence length, features)`,\n", + "where `sequence length` is the number of time steps and `features` is each input\n", + "timeseries.\n", + "\n", + "You can replace your classification RNN layers with this one: the\n", + "inputs are fully compatible!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E9kzn8RWh0vp" + }, + "source": [ + "We include residual connections, layer normalization, and dropout.\n", + "The resulting layer can be stacked multiple times.\n", + "\n", + "The projection layers are implemented through `keras.layers.Conv1D`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "Vta2JAckh0vq" + }, + "outputs": [], + "source": [ + "def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):\n", + " # Normalization and Attention\n", + " x = layers.LayerNormalization(epsilon=1e-6)(inputs)\n", + " x = layers.MultiHeadAttention(\n", + " key_dim=head_size, num_heads=num_heads, dropout=dropout\n", + " )(x, x)\n", + " x = layers.Dropout(dropout)(x)\n", + " res = x + inputs\n", + "\n", + " # Feed Forward Part\n", + " x = layers.LayerNormalization(epsilon=1e-6)(res)\n", + " x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation=\"relu\")(x)\n", + " x = layers.Dropout(dropout)(x)\n", + " x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)\n", + " return x + res\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zIHHLcdoh0vq" + }, + "source": [ + "The main part of our model is now complete. We can stack multiple of those\n", + "`transformer_encoder` blocks and we can also proceed to add the final\n", + "Multi-Layer Perceptron classification head. Apart from a stack of `Dense`\n", + "layers, we need to reduce the output tensor of the `TransformerEncoder` part of\n", + "our model down to a vector of features for each data point in the current\n", + "batch. A common way to achieve this is to use a pooling layer. For\n", + "this example, a `GlobalAveragePooling1D` layer is sufficient." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "zxOnY6GSh0vr" + }, + "outputs": [], + "source": [ + "def build_model(\n", + " input_shape,\n", + " head_size,\n", + " num_heads,\n", + " ff_dim,\n", + " num_transformer_blocks,\n", + " mlp_units,\n", + " dropout=0,\n", + " mlp_dropout=0,\n", + " ):\n", + " \n", + " inputs = keras.Input(shape=input_shape)\n", + " x = inputs\n", + " for _ in range(num_transformer_blocks):\n", + " x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)\n", + "\n", + " x = layers.GlobalAveragePooling1D(data_format=\"channels_first\")(x)\n", + " for dim in mlp_units:\n", + " x = layers.Dense(dim, activation=\"relu\")(x)\n", + " x = layers.Dropout(mlp_dropout)(x)\n", + " outputs = layers.Dense(n_classes, activation=\"softmax\")(x)\n", + " \n", + " return keras.Model(inputs, outputs)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8FFG41R6h0vs" + }, + "source": [ + "## Setup model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "l8CubWn7h0vs" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-09-30 03:29:51.721533: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:51.755522: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:51.755800: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:51.758193: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:51.758411: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:51.758556: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:52.318629: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:52.318903: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:52.319055: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", + "2023-09-30 03:29:52.319185: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 6202 MB memory: -> device: 0, name: NVIDIA RTX A2000 8GB Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_1 (InputLayer) [(None, 500, 1)] 0 [] \n", + " \n", + " layer_normalization (LayerNorm (None, 500, 1) 2 ['input_1[0][0]'] \n", + " alization) \n", + " \n", + " multi_head_attention (MultiHea (None, 500, 1) 7169 ['layer_normalization[0][0]', \n", + " dAttention) 'layer_normalization[0][0]'] \n", + " \n", + " dropout (Dropout) (None, 500, 1) 0 ['multi_head_attention[0][0]'] \n", + " \n", + " tf.__operators__.add (TFOpLamb (None, 500, 1) 0 ['dropout[0][0]', \n", + " da) 'input_1[0][0]'] \n", + " \n", + " layer_normalization_1 (LayerNo (None, 500, 1) 2 ['tf.__operators__.add[0][0]'] \n", + " rmalization) \n", + " \n", + " conv1d (Conv1D) (None, 500, 4) 8 ['layer_normalization_1[0][0]'] \n", + " \n", + " dropout_1 (Dropout) (None, 500, 4) 0 ['conv1d[0][0]'] \n", + " \n", + " conv1d_1 (Conv1D) (None, 500, 1) 5 ['dropout_1[0][0]'] \n", + " \n", + " tf.__operators__.add_1 (TFOpLa (None, 500, 1) 0 ['conv1d_1[0][0]', \n", + " mbda) 'tf.__operators__.add[0][0]'] \n", + " \n", + " layer_normalization_2 (LayerNo (None, 500, 1) 2 ['tf.__operators__.add_1[0][0]'] \n", + " rmalization) \n", + " \n", + " multi_head_attention_1 (MultiH (None, 500, 1) 7169 ['layer_normalization_2[0][0]', \n", + " eadAttention) 'layer_normalization_2[0][0]'] \n", + " \n", + " dropout_2 (Dropout) (None, 500, 1) 0 ['multi_head_attention_1[0][0]'] \n", + " \n", + " tf.__operators__.add_2 (TFOpLa (None, 500, 1) 0 ['dropout_2[0][0]', \n", + " mbda) 'tf.__operators__.add_1[0][0]'] \n", + " \n", + " layer_normalization_3 (LayerNo (None, 500, 1) 2 ['tf.__operators__.add_2[0][0]'] \n", + " rmalization) \n", + " \n", + " conv1d_2 (Conv1D) (None, 500, 4) 8 ['layer_normalization_3[0][0]'] \n", + " \n", + " dropout_3 (Dropout) (None, 500, 4) 0 ['conv1d_2[0][0]'] \n", + " \n", + " conv1d_3 (Conv1D) (None, 500, 1) 5 ['dropout_3[0][0]'] \n", + " \n", + " tf.__operators__.add_3 (TFOpLa (None, 500, 1) 0 ['conv1d_3[0][0]', \n", + " mbda) 'tf.__operators__.add_2[0][0]'] \n", + " \n", + " global_average_pooling1d (Glob (None, 500) 0 ['tf.__operators__.add_3[0][0]'] \n", + " alAveragePooling1D) \n", + " \n", + " dense (Dense) (None, 128) 64128 ['global_average_pooling1d[0][0]'\n", + " ] \n", + " \n", + " dropout_4 (Dropout) (None, 128) 0 ['dense[0][0]'] \n", + " \n", + " dense_1 (Dense) (None, 2) 258 ['dropout_4[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 78,758\n", + "Trainable params: 78,758\n", + "Non-trainable params: 0\n", + "__________________________________________________________________________________________________\n", + "input_shape: (500, 1)\n" + ] + } + ], + "source": [ + "input_shape = x_train.shape[1:]\n", + "\n", + "# epoch_number = 2\n", + "epoch_number = 10\n", + "# epoch_number = 25\n", + "# epoch_number = 50\n", + "# epoch_number = 100\n", + "# epoch_number = 200 #Original model\n", + "# epoch_number = 300\n", + "# epoch_number = 500\n", + "\n", + "batch_size = 2\n", + "# batch_size = 4\n", + "# batch_size = 8\n", + "# batch_size = 16\n", + "# batch_size = 32\n", + "# batch_size = 64 #< OOM #Original model\n", + "\n", + "\n", + "## Transformer settings \n", + "# head_size=256; num_heads=4; num_transformer_blocks = 2\n", + "head_size=256; num_heads=4; num_transformer_blocks = 4 #Original model\n", + "# head_size=256; num_heads=4; num_transformer_blocks = 8\n", + "# head_size=512; num_heads=4; num_transformer_blocks = 4\n", + "# head_size=1024; num_heads=4; num_transformer_blocks = 4\n", + "# head_size=1024; num_heads=8; num_transformer_blocks = 8\n", + "\n", + "\n", + "\n", + "##Number of epochs with no improvement after which training will be stopped.\n", + "# callbacks_patience = 10 \n", + "callbacks_patience = 50 \n", + "\n", + "\n", + "model = build_model(\n", + " input_shape,\n", + " head_size=head_size,\n", + " num_heads=num_heads,\n", + " ff_dim=4,\n", + " num_transformer_blocks=num_transformer_blocks,\n", + " mlp_units=[128],\n", + " mlp_dropout=0.4,\n", + " dropout=0.25,\n", + ")\n", + "\n", + "model.compile(\n", + " loss=\"sparse_categorical_crossentropy\",\n", + " optimizer=keras.optimizers.Adam(learning_rate=1e-4),\n", + " metrics=[\"sparse_categorical_accuracy\"],\n", + ")\n", + "model.summary()\n", + "\n", + "callbacks = [\n", + " keras.callbacks.ModelCheckpoint(\"best_transforer_model.h5\", save_best_only=True, monitor=\"val_loss\"),\n", + " keras.callbacks.EarlyStopping(patience=callbacks_patience, restore_best_weights=True)\n", + "]\n", + "\n", + "#other callbacks\n", + "# keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\", factor=0.5, patience=20, min_lr=0.0001),\n", + "# keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=50, verbose=1),\n", + "\n", + "print(f'input_shape: {input_shape}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "keras.utils.plot_model(model, show_shapes=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train the model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-09-30 03:29:56.789432: I tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:637] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n", + "2023-09-30 03:29:57.019283: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8800\n", + "2023-09-30 03:29:58.232879: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7ff4e051a440 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "2023-09-30 03:29:58.232929: I tensorflow/compiler/xla/service/service.cc:177] StreamExecutor device (0): NVIDIA RTX A2000 8GB Laptop GPU, Compute Capability 8.6\n", + "2023-09-30 03:29:58.241230: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", + "2023-09-30 03:29:58.483556: I ./tensorflow/compiler/jit/device_compiler.h:180] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1440/1440 [==============================] - 29s 13ms/step - loss: 0.8611 - sparse_categorical_accuracy: 0.5556 - val_loss: 0.6205 - val_sparse_categorical_accuracy: 0.6436\n", + "Epoch 2/10\n", + "1440/1440 [==============================] - 19s 13ms/step - loss: 0.6613 - sparse_categorical_accuracy: 0.6538 - val_loss: 0.5595 - val_sparse_categorical_accuracy: 0.7198\n", + "Epoch 3/10\n", + "1440/1440 [==============================] - 19s 13ms/step - loss: 0.5711 - sparse_categorical_accuracy: 0.7108 - val_loss: 0.5239 - val_sparse_categorical_accuracy: 0.7434\n", + "Epoch 4/10\n", + "1440/1440 [==============================] - 18s 13ms/step - loss: 0.5178 - sparse_categorical_accuracy: 0.7413 - val_loss: 0.4950 - val_sparse_categorical_accuracy: 0.7684\n", + "Epoch 5/10\n", + "1440/1440 [==============================] - 19s 13ms/step - loss: 0.4778 - sparse_categorical_accuracy: 0.7681 - val_loss: 0.4823 - val_sparse_categorical_accuracy: 0.7809\n", + "Epoch 6/10\n", + "1440/1440 [==============================] - 19s 13ms/step - loss: 0.4321 - sparse_categorical_accuracy: 0.8083 - val_loss: 0.4596 - val_sparse_categorical_accuracy: 0.7947\n", + "Epoch 7/10\n", + "1440/1440 [==============================] - 19s 13ms/step - loss: 0.4226 - sparse_categorical_accuracy: 0.8038 - val_loss: 0.4520 - val_sparse_categorical_accuracy: 0.8017\n", + "Epoch 8/10\n", + "1440/1440 [==============================] - 18s 13ms/step - loss: 0.3904 - sparse_categorical_accuracy: 0.8274 - val_loss: 0.4382 - val_sparse_categorical_accuracy: 0.7989\n", + "Epoch 9/10\n", + "1440/1440 [==============================] - 18s 13ms/step - loss: 0.3636 - sparse_categorical_accuracy: 0.8368 - val_loss: 0.4351 - val_sparse_categorical_accuracy: 0.8141\n", + "Epoch 10/10\n", + "1440/1440 [==============================] - 18s 13ms/step - loss: 0.3438 - sparse_categorical_accuracy: 0.8497 - val_loss: 0.4399 - val_sparse_categorical_accuracy: 0.8072\n" + ] + } + ], + "source": [ + "# fit network\n", + "history = model.fit(\n", + " x_train,\n", + " y_train,\n", + " validation_split=0.2,\n", + " epochs=epoch_number,\n", + " batch_size=batch_size,\n", + " callbacks=callbacks,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot the model's training and validation loss" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "history.params: {'verbose': 1, 'epochs': 10, 'steps': 1440}\n", + "history.history.keys(): dict_keys(['loss', 'sparse_categorical_accuracy', 'val_loss', 'val_sparse_categorical_accuracy'])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "metric = \"sparse_categorical_accuracy\"\n", + "\n", + "print(f'history.params: {history.params}' )\n", + "print(f'history.history.keys(): {history.history.keys()}')\n", + "\n", + "fig = plt.figure(figsize=(12,5))\n", + "fig.suptitle(\"title\")\n", + "ax1 = fig.add_subplot()\n", + "ax2 = ax1.twinx()\n", + "\n", + "ax1.plot(history.history['sparse_categorical_accuracy'], color='darkgreen', label = 'train_acc', linestyle='solid', linewidth=3)\n", + "ax1.plot(history.history['val_sparse_categorical_accuracy'], color='green', label = 'val_acc',linestyle='--', linewidth=3)\n", + "\n", + "ax2.plot(history.history['loss'], color='firebrick', label = 'train_loss', linestyle='solid')\n", + "ax2.plot(history.history['val_loss'], color='red', label = 'val_loss',linestyle='--')\n", + "\n", + "ax1.set_ylabel(\"accuracy\")\n", + "ax2.set_ylabel(\"loss\")\n", + "\n", + "ax1.legend(loc = 'lower left')\n", + "ax2.legend(loc = 'upper left')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate model on test data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "660/660 [==============================] - 4s 5ms/step - loss: 0.4387 - sparse_categorical_accuracy: 0.8114\n", + "=============================\n", + "=============================\n", + "Test accuracy 81.13636374473572 and Test loss 43.87391209602356\n", + "=============================\n", + "=============================\n" + ] + } + ], + "source": [ + "loaded_model = keras.models.load_model(\"best_transforer_model.h5\")\n", + "test_loss, test_acc = loaded_model.evaluate(x_test, \n", + " y_test, \n", + " batch_size=batch_size,\n", + " verbose=1)\n", + "\n", + "print(f'=============================')\n", + "print(f'=============================')\n", + "print(f'Test accuracy {test_acc*100} and Test loss {test_loss*100}')\n", + "print(f'=============================')\n", + "print(f'=============================')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_1 (InputLayer) [(None, 500, 1)] 0 [] \n", + " \n", + " layer_normalization (LayerNorm (None, 500, 1) 2 ['input_1[0][0]'] \n", + " alization) \n", + " \n", + " multi_head_attention (MultiHea (None, 500, 1) 7169 ['layer_normalization[0][0]', \n", + " dAttention) 'layer_normalization[0][0]'] \n", + " \n", + " dropout (Dropout) (None, 500, 1) 0 ['multi_head_attention[0][0]'] \n", + " \n", + " tf.__operators__.add (TFOpLamb (None, 500, 1) 0 ['dropout[0][0]', \n", + " da) 'input_1[0][0]'] \n", + " \n", + " layer_normalization_1 (LayerNo (None, 500, 1) 2 ['tf.__operators__.add[0][0]'] \n", + " rmalization) \n", + " \n", + " conv1d (Conv1D) (None, 500, 4) 8 ['layer_normalization_1[0][0]'] \n", + " \n", + " dropout_1 (Dropout) (None, 500, 4) 0 ['conv1d[0][0]'] \n", + " \n", + " conv1d_1 (Conv1D) (None, 500, 1) 5 ['dropout_1[0][0]'] \n", + " \n", + " tf.__operators__.add_1 (TFOpLa (None, 500, 1) 0 ['conv1d_1[0][0]', \n", + " mbda) 'tf.__operators__.add[0][0]'] \n", + " \n", + " layer_normalization_2 (LayerNo (None, 500, 1) 2 ['tf.__operators__.add_1[0][0]'] \n", + " rmalization) \n", + " \n", + " multi_head_attention_1 (MultiH (None, 500, 1) 7169 ['layer_normalization_2[0][0]', \n", + " eadAttention) 'layer_normalization_2[0][0]'] \n", + " \n", + " dropout_2 (Dropout) (None, 500, 1) 0 ['multi_head_attention_1[0][0]'] \n", + " \n", + " tf.__operators__.add_2 (TFOpLa (None, 500, 1) 0 ['dropout_2[0][0]', \n", + " mbda) 'tf.__operators__.add_1[0][0]'] \n", + " \n", + " layer_normalization_3 (LayerNo (None, 500, 1) 2 ['tf.__operators__.add_2[0][0]'] \n", + " rmalization) \n", + " \n", + " conv1d_2 (Conv1D) (None, 500, 4) 8 ['layer_normalization_3[0][0]'] \n", + " \n", + " dropout_3 (Dropout) (None, 500, 4) 0 ['conv1d_2[0][0]'] \n", + " \n", + " conv1d_3 (Conv1D) (None, 500, 1) 5 ['dropout_3[0][0]'] \n", + " \n", + " tf.__operators__.add_3 (TFOpLa (None, 500, 1) 0 ['conv1d_3[0][0]', \n", + " mbda) 'tf.__operators__.add_2[0][0]'] \n", + " \n", + " global_average_pooling1d (Glob (None, 500) 0 ['tf.__operators__.add_3[0][0]'] \n", + " alAveragePooling1D) \n", + " \n", + " dense (Dense) (None, 128) 64128 ['global_average_pooling1d[0][0]'\n", + " ] \n", + " \n", + " dropout_4 (Dropout) (None, 128) 0 ['dense[0][0]'] \n", + " \n", + " dense_1 (Dense) (None, 2) 258 ['dropout_4[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 78,758\n", + "Trainable params: 78,758\n", + "Non-trainable params: 0\n", + "__________________________________________________________________________________________________\n", + "None\n" + ] + } + ], + "source": [ + "#Understanding your h5 model > https://www.youtube.com/watch?v=_a-UYLfF6TE\n", + "print(loaded_model.summary())\n", + "# for layer in loaded_model.layers:\n", + " # print(layer.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "42/42 [==============================] - 2s 43ms/step\n" + ] + } + ], + "source": [ + "## Load model\n", + "predictions = loaded_model.predict(x_test)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_test.shape: (1320, 500, 1), predictions.shape: (1320, 2)\n", + "Ground truth for test timeseries: 1\n", + "Predictions for each class:\n", + "\n", + "class: 0 probability: 0.16478287\n", + "class: 1 probability: 0.8352172\n", + "len(predicted_labels): 1320\n", + "[0 1 1 ... 1 0 1]\n", + "[0 0 0 ... 1 1 1]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 55.65546539603249, 'Predicted label')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfYAAAHpCAYAAABwax7yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABRU0lEQVR4nO3deVhUZfsH8O8My7DIgIAwkIgKiZKQW+nkvoGKpUmZhormkoTmkkqmKUiKWeaWaZmJmfzKFkvNVHDBeoFUikRUEtJAZcmNEZV9fn/4ct6OgM7ojHDG76frXBdzznOeuYfXl3vu53nOOTKtVqsFERERmQR5fQdAREREhsPETkREZEKY2ImIiEwIEzsREZEJYWInIiIyIUzsREREJoSJnYiIyIQwsRMREZkQJnYiIiITwsRORERkQpjYiYhIskpKSqDRaIyylZSU6BxHZGQkZDKZaGvdurVwvFevXjWOT548WdRHTk4OgoKCYGNjAxcXF8yePRsVFRV6/07M9T6DiIioASgpKYG1nRNQcdMo/atUKpw9exZWVlY6tX/iiSeQkJAgvDY3F6fYiRMnYtGiRcJrGxsb4efKykoEBQVBpVIhKSkJeXl5GDNmDCwsLLBkyRK94mZiJyIiSSorKwMqbkLhGwqYWRq288oy5J/cjLKyMp0Tu7m5OVQqVZ3HbWxs6jy+b98+nDx5EgkJCXB1dUW7du0QHR2NiIgIREZGwtJS98/HoXgiIpI2cyvIDLzB/HYyv3N4vrS0tM4wzpw5A3d3d7Rs2RIhISHIyckRHd+6dSucnZ3Rtm1bzJ07Fzdv/m+kITk5GX5+fnB1dRX2BQYGQqPRICMjQ79fh16tiYiIGhoZAJnM8H0C8PDwEO1euHAhIiMjazTv3LkzYmNj4ePjg7y8PERFRaF79+44ceIE7Ozs8PLLL8PT0xPu7u44fvw4IiIikJmZie+++w4AkJ+fL0rqAITX+fn5eoXOxE5ERFSH3NxcKJVK4bVCoai13cCBA4Wf/f390blzZ3h6emLbtm0YP348Jk2aJBz38/ODm5sb+vbti+zsbHh5eRk0Zg7FExGRtMnkxtkAKJVK0VZXYr+Tg4MDWrVqhaysrFqPd+7cGQCE4yqVCgUFBaI21a/vNm9fGyZ2IiIiAysuLkZ2djbc3NxqPZ6WlgYAwnG1Wo309HQUFhYKbeLj46FUKuHr66vXezOxExGRtMlkxtn0MGvWLCQmJuLcuXNISkrC888/DzMzM4wcORLZ2dmIjo5Gamoqzp07hx07dmDMmDHo0aMH/P39AQABAQHw9fXF6NGj8ccff2Dv3r2YP38+wsPDdR4lqMY5diIiogd0/vx5jBw5EpcvX0aTJk3QrVs3pKSkoEmTJigpKUFCQgJWrlyJGzduwMPDA8HBwZg/f75wvpmZGXbt2oWwsDCo1WrY2toiNDRUdN27rmRarVZryA9HRET0MGg0Gtjb20PRYQpkZvpVtfeirSxF6W8foqioSLR4Tgo4FE9ERGRCOBRPRETSdh9z4jr1KVGs2ImIiEwIK3YiIpK4/113btA+JYqJnYiIpI1D8SLS/UpCRERENbBiJyIiaZMZYSje4EP7D490IyciIqIaWLETEZG0cY5dhBU7ERGRCWHFTkRE0sY5dhHpRk5EREQ1sGInIiJp4xy7CCt2IiIiE8KKnYiIpI1z7CJM7EREJG0ymRESO4fiiYiIqAFgxU5ERNIml93eDN2nRLFiJyIiMiGs2ImISNq4eE5EupETERFRDazYiYhI2niDGhFW7ERERCaEFTsREUkb59hFpBs5kRGcOXMGAQEBsLe3h0wmw/fff2/Q/s+dOweZTIbY2FiD9msKmjdvjrFjx9Z3GCRF1UPxht4kiomdGpzs7Gy8+uqraNmyJaysrKBUKtG1a1esWrUKt27dMup7h4aGIj09HYsXL8aWLVvQqVMno76fKTp58iQiIyNx7ty5+g6F6JHEoXhqUH788Ue8+OKLUCgUGDNmDNq2bYuysjL88ssvmD17NjIyMvDJJ58Y5b1v3bqF5ORkzJs3D1OmTDHKe3h6euLWrVuwsLAwSv8NwcmTJxEVFYVevXqhefPmOp+XmZkJuZy1Bt0HDsWLMLFTg3H27FmMGDECnp6eOHDgANzc3IRj4eHhyMrKwo8//mi09//nn38AAA4ODkZ7D5lMBisrK6P1LzVarRYlJSWwtraGQqGo73CITIJ0v5KQyVm2bBmKi4uxceNGUVKv5u3tjWnTpgmvKyoqEB0dDS8vLygUCjRv3hxvvfUWSktLRec1b94cgwcPxi+//IKnn34aVlZWaNmyJT7//HOhTWRkJDw9PQEAs2fPhkwmE6rNsWPH1lp5RkZGQnbHPFx8fDy6desGBwcHNGrUCD4+PnjrrbeE43XNsR84cADdu3eHra0tHBwcMGTIEJw6darW98vKysLYsWPh4OAAe3t7jBs3Djdv3qz7F/tfvXr1Qtu2bXH8+HH07NkTNjY28Pb2xjfffAMASExMROfOnWFtbQ0fHx8kJCSIzv/777/x2muvwcfHB9bW1nBycsKLL74oGnKPjY3Fiy++CADo3bs3ZDIZZDIZDh06BOB//1vs3bsXnTp1grW1NT7++GPhWPUcu1arRe/evdGkSRMUFhYK/ZeVlcHPzw9eXl64cePGPT8zPSI4xy7CxE4Nxs6dO9GyZUs888wzOrWfMGECFixYgA4dOmDFihXo2bMnYmJiMGLEiBpts7Ky8MILL6B///5Yvnw5GjdujLFjxyIjIwMAMGzYMKxYsQIAMHLkSGzZsgUrV67UK/6MjAwMHjwYpaWlWLRoEZYvX47nnnsO//nPf+56XkJCAgIDA1FYWIjIyEjMnDkTSUlJ6Nq1a63z1MOHD8f169cRExOD4cOHIzY2FlFRUTrFePXqVQwePBidO3fGsmXLoFAoMGLECHz11VcYMWIEBg0ahKVLl+LGjRt44YUXcP36deHco0ePIikpCSNGjMDq1asxefJk7N+/H7169RK+WPTo0QOvv/46AOCtt97Cli1bsGXLFrRp00boJzMzEyNHjkT//v2xatUqtGvXrkacMpkMn332GUpKSjB58mRh/8KFC5GRkYFNmzbB1tZWp89M9KjhUDw1CBqNBhcuXMCQIUN0av/HH39g8+bNmDBhAjZs2AAAeO211+Di4oL3338fBw8eRO/evYX2mZmZOHz4MLp37w7gdnL08PDApk2b8P7778Pf3x9KpRIzZsxAhw4dMGrUKL0/Q3x8PMrKyvDTTz/B2dlZ5/Nmz54NR0dHJCcnw9HREQAwdOhQtG/fHgsXLsTmzZtF7du3b4+NGzcKry9fvoyNGzfi3Xffved7Xbx4EXFxcRg5ciQAoH///mjdujVefvllJCUloXPnzgCANm3aIDAwEN9++61QRQcFBeGFF14Q9ffss89CrVbj22+/xejRo9GyZUt0794dq1evRv/+/dGrV68aMWRlZWHPnj0IDAy8a6wtWrTA8uXL8eqrr2Lr1q3w9vbGe++9h2nTpqFHjx73/Kz0COEcu4h0IyeTotFoAAB2dnY6td+9ezcAYObMmaL9b7zxBgDUmIv39fUVkjoANGnSBD4+Pvjrr7/uO+Y7Vc/N//DDD6iqqtLpnLy8PKSlpWHs2LFCUgcAf39/9O/fX/ic//bvChYAunfvjsuXLwu/w7tp1KiRaETDx8cHDg4OaNOmjZDUAQg///v3Y21tLfxcXl6Oy5cvw9vbGw4ODvjtt990+LS3tWjR4p5JvdqkSZMQGBiIqVOnYvTo0fDy8sKSJUt0fi+iRxETOzUISqUSAERDv3fz999/Qy6Xw9vbW7RfpVLBwcEBf//9t2h/s2bNavTRuHFjXL169T4jrumll15C165dMWHCBLi6umLEiBHYtm3bXZN8dZw+Pj41jrVp0waXLl2qMZd852dp3LgxAOj0WZo2bVpjXYC9vT08PDxq7Luzz1u3bmHBggXw8PCAQqGAs7MzmjRpgmvXrqGoqOie712tRYsWOrcFgI0bN+LmzZs4c+YMYmNjRV8wiABwjv0OTOzUICiVSri7u+PEiRN6nXdnkqqLmZlZrfu1Wu19v0dlZaXotbW1NQ4fPoyEhASMHj0ax48fx0svvYT+/fvXaPsgHuSz1HWuLn1OnToVixcvxvDhw7Ft2zbs27cP8fHxcHJy0nmEAoDeifnQoUPCgsj09HS9ziV6FDGxU4MxePBgZGdnIzk5+Z5tPT09UVVVhTNnzoj2FxQU4Nq1a8IKd0No3Lgxrl27VmP/naMCACCXy9G3b1988MEHOHnyJBYvXowDBw7g4MGDtfZdHWdmZmaNY6dPn4azs3ODWST2zTffIDQ0FMuXLxcWInbr1q3G70bXL1u6yMvLw9SpUxEQEIDBgwdj1qxZtf7e6VEn/988u6E2CadH6UZOJmfOnDmwtbXFhAkTUFBQUON4dnY2Vq1aBQAYNGgQANRYuf7BBx8AuL3Qy1C8vLxQVFSE48ePC/vy8vKwfft2UbsrV67UOLd6xfedl+BVc3NzQ7t27bB582ZRgjxx4gT27dsnfM6GwMzMrMaowJo1a2qMRlR/Eanty5C+Jk6ciKqqKmzcuBGffPIJzM3NMX78eJ1GJ+gRwqF4Ea6KpwbDy8sLcXFxeOmll9CmTRvRneeSkpLw9ddfCyu0n3zySYSGhuKTTz7BtWvX0LNnTxw5cgSbN2/G0KFDRSviH9SIESMQERGB559/Hq+//jpu3ryJdevWoVWrVqJFY4sWLcLhw4cRFBQET09PFBYW4qOPPkLTpk3RrVu3Ovt/7733MHDgQKjVaowfPx63bt3CmjVrYG9vj8jISIN9jgc1ePBgbNmyBfb29vD19UVycjISEhLg5OQkateuXTuYmZnh3XffRVFRERQKBfr06QMXFxe93m/Tpk348ccfERsbi6ZNmwK4/UVi1KhRWLduHV577TWDfTYiU8LETg3Kc889h+PHj+O9997DDz/8gHXr1kGhUMDf3x/Lly/HxIkThbaffvopWrZsidjYWGzfvh0qlQpz587FwoULDRqTk5MTtm/fjpkzZ2LOnDlo0aIFYmJicObMGVFif+6553Du3Dl89tlnuHTpEpydndGzZ09ERUUJi9Fq069fP+zZswcLFy7EggULYGFhgZ49e+Ldd9/Ve6GZMa1atQpmZmbYunUrSkpK0LVrV+Ea/H9TqVRYv349YmJiMH78eFRWVuLgwYN6Jfbz589jxowZePbZZxEaGirsDwkJwbfffos5c+Zg4MCBDer3Q/VIJjPC5W7SrdhlWo5pERGRBGk0Gtjb20MRsAwyC8NeLaEtv4XSfXNQVFQkXLUjFazYiYhI2niDGhHpRk5EREQ1sGInIiJpM8YqdgnPsbNiJyIiMiFM7EREJG2GvjnNfczZVz9W+d9b69atheMlJSUIDw+Hk5MTGjVqhODg4Br368jJyUFQUBBsbGzg4uKC2bNno6KiQu9fB4fiiYiIDOCJJ55AQkKC8Nrc/H8pdsaMGfjxxx/x9ddfw97eHlOmTMGwYcOExzpXVlYiKCgIKpUKSUlJyMvLw5gxY2BhYaH3g49MOrFXVVXh4sWLsLOzM+htLomISHdarRbXr1+Hu7s75HIjDBQ3kDl2c3NzqFSqGvuLioqwceNGxMXFoU+fPgBu34CpTZs2SElJQZcuXbBv3z6cPHkSCQkJcHV1Rbt27RAdHY2IiAhERkbC0tJS9zj0jlxCLl68WOOpVUREVD9yc3OFuwgalBEvd7vzccgKhQIKhaLWU86cOQN3d3dYWVlBrVYjJiYGzZo1Q2pqKsrLy9GvXz+hbevWrdGsWTMkJyejS5cuSE5Ohp+fH1xdXYU2gYGBCAsLQ0ZGBtq3b69z6Cad2Kuf7W3pGwqZme7fdogamr/2L6vvEIju2/XrGrT28hT+JkvJncXhwoULa73Vc+fOnREbGwsfHx/k5eUhKioK3bt3x4kTJ5Cfnw9LS0s4ODiIznF1dUV+fj4AID8/X5TUq49XH9OHSSf26uF3mZklEztJmtTufEVUG6NNiRpxKD43N1f0/7+6qvWBAwcKP/v7+6Nz587w9PTEtm3b9H5U8YPiqngiIqI6KJVK0VZXYr+Tg4MDWrVqhaysLKhUKpSVldV44mFBQYEwJ69SqWqskq9+Xdu8/d0wsRMRkaTdeZmZobYHUVxcjOzsbLi5uaFjx46wsLDA/v37heOZmZnIycmBWq0GAKjVaqSnp6OwsFBoEx8fD6VSCV9fX73e26SH4omIiB6GWbNm4dlnn4WnpycuXryIhQsXwszMDCNHjoS9vT3Gjx+PmTNnwtHREUqlElOnToVarUaXLl0AAAEBAfD19cXo0aOxbNky5OfnY/78+QgPD9d5lKAaEzsREUmaISrsWjrVq/n58+cxcuRIXL58GU2aNEG3bt2QkpKCJk2aAABWrFgBuVyO4OBglJaWIjAwEB999JFwvpmZGXbt2oWwsDCo1WrY2toiNDQUixYt0j90U35sq/BIP7+JXDxHkvZPyur6DoHovmk0Gjzm0tjgj0Ct/htv/dxaozy29daOcD62lYiI6KGT/XczdJ8SxcVzREREJoQVOxERSVpDmGNvSJjYiYhI0pjYxTgUT0REZEJYsRMRkaSxYhdjxU5ERGRCWLETEZGksWIXY8VORERkQlixExGRtPEGNSKs2ImIiEwIK3YiIpI0zrGLMbETEZGkyWQwQmI3bHcPE4fiiYiITAgrdiIikjQZjDAUL+GSnRU7ERGRCWHFTkREksbFc2Ks2ImIiEwIK3YiIpI23qBGhBU7ERGRCWHFTkRE0maEOXYt59iJiIioIWDFTkREkmaMVfGGvy7+4WFiJyIiSWNiF+NQPBERkQlhxU5ERNLGy91EWLETERGZEFbsREQkaZxjF2PFTkREZEJYsRMRkaSxYhdjxU5ERGRCWLETEZGksWIXY8VORERkQlixExGRpLFiF2NiJyIiaeMNakQ4FE9ERGRCWLETEZGkcShejBU7ERGRCWHFTkREksaKXYwVOxERkQlhxU5ERJLGil2MFTsREZEJYcVORETSxuvYRVixExGRpFUPxRt6exBLly6FTCbD9OnThX29evWq8R6TJ08WnZeTk4OgoCDY2NjAxcUFs2fPRkVFhV7vzYqdiIjIgI4ePYqPP/4Y/v7+NY5NnDgRixYtEl7b2NgIP1dWViIoKAgqlQpJSUnIy8vDmDFjYGFhgSVLluj8/qzYiYhI0hpSxV5cXIyQkBBs2LABjRs3rnHcxsYGKpVK2JRKpXBs3759OHnyJL744gu0a9cOAwcORHR0NNauXYuysjKdY2BiJyIiqoNGoxFtpaWld20fHh6OoKAg9OvXr9bjW7duhbOzM9q2bYu5c+fi5s2bwrHk5GT4+fnB1dVV2BcYGAiNRoOMjAydY+ZQPBERSZoMRrjc7b+r5zw8PET7Fy5ciMjIyFrP+fLLL/Hbb7/h6NGjtR5/+eWX4enpCXd3dxw/fhwRERHIzMzEd999BwDIz88XJXUAwuv8/HydY2diJyIiqkNubq5ouFyhUNTZbtq0aYiPj4eVlVWtbSZNmiT87OfnBzc3N/Tt2xfZ2dnw8vIyWMwciiciIkkz5hy7UqkUbXUl9tTUVBQWFqJDhw4wNzeHubk5EhMTsXr1apibm6OysrLGOZ07dwYAZGVlAQBUKhUKCgpEbapfq1QqnX8fTOxEREQPqG/fvkhPT0daWpqwderUCSEhIUhLS4OZmVmNc9LS0gAAbm5uAAC1Wo309HQUFhYKbeLj46FUKuHr66tzLByKJyIiaWsAN6ixs7ND27ZtRftsbW3h5OSEtm3bIjs7G3FxcRg0aBCcnJxw/PhxzJgxAz169BAuiwsICICvry9Gjx6NZcuWIT8/H/Pnz0d4eHidIwW1YWInIiIyMktLSyQkJGDlypW4ceMGPDw8EBwcjPnz5wttzMzMsGvXLoSFhUGtVsPW1hahoaGi6951wcRORESS1lAfAnPo0CHhZw8PDyQmJt7zHE9PT+zevfuB3peJnYiIJK2hJvb6wsVzREREJoQVOxERSZpMdnszdJ9SxYqdiIjIhLBiJyIiSbtdsRt6jt2g3T1UrNiJiIhMCCt2IiKSNiPMsRv8hjcPESt2IiIiE8KKnYiIJI3XsYuxYiciIjIhrNiJiEjSeB27GBM7ERFJmlwug1xu2EysNXB/DxOH4omIiEwIK3YiIpI0DsWLsWInIiIyIazYiYhI0ni5mxgrdiIiIhPCxE4irw7vgdM/RuFqygoc/nwWOj3hedf2U17uhT+2v40ryR/gzE/RWPbGMCgs/zcQ1LWDF75Z+Sr+2rcYt37/EM/28jf2R6BH3CfrP8ITrVrC2d4GvburcezokTrbnjqZgZARL+CJVi1hZ2WGtWtW1Whz/fp1RMyaAd/HW6CJgy369uqG1GNHjfkRSE/Vc+yG3qSKiZ0ELwR0wLtvPI/FH/8E9cvv4vifF7Djo3A0adyo1vYvDeiE6NeHYMnHP6HdsHcwOWorXgjsiEVTnxPa2ForkP7nBUyP+ephfQx6hH379VeYO+cNvDnvbfyScgxt/fzx/LMD8U9hYa3tb968ieYtWiLqnSVwValqbTMlbCIO7E/AJ59tRkrqH+jbtz+eGxSAixcuGPOjEN03JnYSvD6qDzZ9l4QtO1Jw+q98TF38JW6VlCF0qLrW9l2ebIHktL/w1Z5jyMm7gv0pp7FtzzFRlb/vPycR9dEu7Dh4/GF9DHqEfbh6Jca+MgGjQ8ehdRtfrPpwHaxtbPD55k21tu/Y6SksjlmGF4aPgMJSUeP4rVu38MP27xC9ZCm6de8BLy9vvPX2QrT08sann6w39schHVXPsRt6kyomdgIAWJiboX0bDxz4NVPYp9VqceDXTDzt36LWc1L+OIv2vh5CIm/+mBMCuz6BPb9kPJSYif6trKwMv/+Wil59+gr75HI5evXuiyO/Jt9XnxUVFaisrISVwkq038rKGslJ/3mgeImMhaviCQDg3LgRzM3NUHjlumh/4WUNfJq71nrOV3uOwamxLfZvmgEZZLCwMMMnX/+M9z7b9zBCJhK5fOkSKisr4eIi/vfq4uqKM39m1nHW3dnZ2eHpLmq8G7MYPq3bwMXVFV9/9X848msyWnp5GyJsMgCuihdjxU73rXvHxzH7lUBMi/kK6pffxUszP8HAbk/gzYkD6js0IoPZsHEztFotWrX0gJPSGus/+hAvDh8BuZx/PhsKLp4Ta7D/Mq9cuYKQkBAolUo4ODhg/PjxKC4uru+wTNalq8WoqKiEi6OdaL+LkxL5lzW1nrPwtSD8349HELs9GRlZF7Hj4HEs+HAnZo8LkPS3XZImJ2dnmJmZobCwQLS/sKAALq61jzrpoqWXF/YkHET+ZQ1OZ/2NQ7+koLyiHM1b1D5FRVTfGmxiDwkJQUZGBuLj47Fr1y4cPnwYkyZNqu+wTFZ5RSV+P5WL3p19hH0ymQy9n26FI8fP1nqOtZUlqqq0on1VVVX/Pdd4sRLVxtLSEu07dETiwQPCvqqqKiQeOoCnO9e+AFQftra2ULm54erVq9gfvw9Bg5+790n0UMhghMVzkO4fsXqdY6+qqsL777+PTz75BLm5uXB1dcWrr76KYcOGYc+ePTh69Cg6deoEAFizZg0GDRqE999/H+7u7vUZtsla/cUBbFg0Gqknc3DsxDlMebk3bKwV+PyHFADAp9GjcbGwCAvW7AAA7D58Aq+P6o0/Ms/jSPo5eHk0wYKwwdh9OF1I+LbWlvDyaCK8R/PHnODf6jFc1dxEbv7Vh/8hyaRNeX06Xp0wDu07dETHp57GR2tW4eaNGxg9ZiwAYNIroXBzfwxR7ywBcHvB3elTJ2//XF6Gixcv4PgfabBt1Ahe/51DT4jfC61Wi8cf98Ff2VmY/1YEHvdpjdGh4+rlMxLdS70m9rlz52LDhg1YsWIFunXrhry8PJw+fRrJyclwcHAQkjoA9OvXD3K5HL/++iuef/75WvsrLS1FaWmp8FqjqX0ImWr3zb7f4Ny4ERaEBcHVyQ7HMy9gSPhaYUGdh8pRVKEv/XQPtFotFr42GO4u9rh0tRg/Hj6ByA93Cm06+Hpi36fThNfLZgUDALbsSMGkhV88pE9Gj4rgF1/CpUuXsHhRJAoK8uH/ZDt8t2O3MBSfm5sL2b/mxvMuXkTXzh2F16tXLMfqFcvRrXtP/BR/u/LXFBUh8u15uHDhPBo7OmLI0GFYEPUOLCwsHupno7rxITBiMq1Wq713M8O7fv06mjRpgg8//BATJkwQHVuyZAk2b96MzEzxSlYXFxdERUUhLCys1j4jIyMRFRVVY7/CbyJkZpaGC57oIfsnZXV9h0B03zQaDR5zaYyioiIolUqD9mtvbw//uTtgZmVrsH4BoLLkBo7HPGfwmB+GeptjP3XqFEpLS9G3b997N9bR3LlzUVRUJGy5ubkG65uIiBom3qBGrN6G4q2tres8plKpUHjHLSArKipw5coVqOq47SMAKBQKKBQ17x5FRET0qKi3iv3xxx+HtbU19u/fX+OYWq3GtWvXkJqaKuw7cOAAqqqq0Llz54cZJhERNXC8jl2s3ip2KysrREREYM6cObC0tETXrl3xzz//ICMjA+PHj8eAAQMwceJErF+/HuXl5ZgyZQpGjBjBFfFERCTCO8+J1euq+Lfffhvm5uZYsGABLl68CDc3N0yePBkAsHXrVkyZMgV9+/aFXC5HcHAwVq/mAiIiIqK7qdfELpfLMW/ePMybN6/GMUdHR8TFxdVDVEREJCW83E2swd55joiIiPTHp7sREZGkcY5djBU7ERGRCWHFTkRE0maMy9OkW7CzYiciIjIlrNiJiEjSOMcuxoqdiIjIhLBiJyIiSeN17GJM7EREJGkcihfjUDwREZGBLV26FDKZDNOnTxf2lZSUIDw8HE5OTmjUqBGCg4NRUFAgOi8nJwdBQUGwsbGBi4sLZs+ejYqKCr3em4mdiIgkraE93e3o0aP4+OOP4e/vL9o/Y8YM7Ny5E19//TUSExNx8eJFDBs2TDheWVmJoKAglJWVISkpCZs3b0ZsbCwWLFig1/szsRMRERlIcXExQkJCsGHDBjRu3FjYX1RUhI0bN+KDDz5Anz590LFjR2zatAlJSUlISUkBAOzbtw8nT57EF198gXbt2mHgwIGIjo7G2rVrUVZWpnMMTOxERCRp1XPsht4AQKPRiLbS0tK7xhIeHo6goCD069dPtD81NRXl5eWi/a1bt0azZs2QnJwMAEhOToafnx9cXV2FNoGBgdBoNMjIyND598HETkREVAcPDw/Y29sLW0xMTJ1tv/zyS/z222+1tsnPz4elpSUcHBxE+11dXZGfny+0+XdSrz5efUxXXBVPRESSZsxV8bm5uVAqlcJ+hUJRa/vc3FxMmzYN8fHxsLKyMmgs+mLFTkREVAelUina6krsqampKCwsRIcOHWBubg5zc3MkJiZi9erVMDc3h6urK8rKynDt2jXReQUFBVCpVAAAlUpVY5V89evqNrpgYiciIklrCKvi+/bti/T0dKSlpQlbp06dEBISIvxsYWGB/fv3C+dkZmYiJycHarUaAKBWq5Geno7CwkKhTXx8PJRKJXx9fXWOhUPxRERED8jOzg5t27YV7bO1tYWTk5Owf/z48Zg5cyYcHR2hVCoxdepUqNVqdOnSBQAQEBAAX19fjB49GsuWLUN+fj7mz5+P8PDwOkcKasPETkREkiaVO8+tWLECcrkcwcHBKC0tRWBgID766CPhuJmZGXbt2oWwsDCo1WrY2toiNDQUixYt0ut9mNiJiEjSGuq94g8dOiR6bWVlhbVr12Lt2rV1nuPp6Yndu3c/0Ptyjp2IiMiEsGInIiJJk8pQ/MPCip2IiMiEsGInIiJJk8EIc+yG7e6hYsVORERkQlixExGRpMllMsgNXLIbur+HiRU7ERGRCWHFTkREktZQr2OvL0zsREQkabzcTYxD8URERCaEFTsREUmaXHZ7M3SfUsWKnYiIyISwYiciImmTGWFOnBU7ERERNQSs2ImISNJ4uZsYK3YiIiITwoqdiIgkTfbf/wzdp1SxYiciIjIhrNiJiEjSeB27GBM7ERFJGm8pK8aheCIiIhPCip2IiCSNl7uJsWInIiIyIazYiYhI0uQyGeQGLrEN3d/DxIqdiIjIhLBiJyIiSeMcuxgrdiIiIhPCip2IiCSN17GLsWInIiIyIazYiYhI0jjHLqZTYt+xY4fOHT733HP3HQwREZG+eLmbmE6JfejQoTp1JpPJUFlZ+SDxEBER0QPQKbFXVVUZOw4iIqL7IvvvZug+peqBFs+VlJQYKg4iIiIyAL0Te2VlJaKjo/HYY4+hUaNG+OuvvwAAb7/9NjZu3GjwAImIiO6m+nI3Q29SpXdiX7x4MWJjY7Fs2TJYWloK+9u2bYtPP/3UoMERERGRfvRO7J9//jk++eQThISEwMzMTNj/5JNP4vTp0wYNjoiI6F7kMuNsUqV3Yr9w4QK8vb1r7K+qqkJ5eblBgiIiIqL7o3di9/X1xc8//1xj/zfffIP27dsbJCgiIiJdcY5dTO87zy1YsAChoaG4cOECqqqq8N133yEzMxOff/45du3aZYwYiYiISEd6V+xDhgzBzp07kZCQAFtbWyxYsACnTp3Czp070b9/f2PESEREdFfVt5U11CZl93Wv+O7duyM+Pt7QsRAREemNT3cTu++HwBw7dgynTp0CcHvevWPHjgYLioiIiO6P3kPx58+fR/fu3fH0009j2rRpmDZtGp566il069YN58+fN0aMREREdWoIl7utW7cO/v7+UCqVUCqVUKvV+Omnn4TjvXr1qrE4b/LkyaI+cnJyEBQUBBsbG7i4uGD27NmoqKjQ//eh7wkTJkxAeXk5Tp06hStXruDKlSs4deoUqqqqMGHCBL0DICIikrqmTZti6dKlSE1NxbFjx9CnTx8MGTIEGRkZQpuJEyciLy9P2JYtWyYcq6ysRFBQEMrKypCUlITNmzcjNjYWCxYs0DsWvYfiExMTkZSUBB8fH2Gfj48P1qxZg+7du+sdABER0YNoCHPszz77rOj14sWLsW7dOqSkpOCJJ54AANjY2EClUtV6/r59+3Dy5EkkJCTA1dUV7dq1Q3R0NCIiIhAZGSm60+u96F2xe3h41HojmsrKSri7u+vbHRERUYOl0WhEW2lp6T3PqaysxJdffokbN25ArVYL+7du3QpnZ2e0bdsWc+fOxc2bN4VjycnJ8PPzg6urq7AvMDAQGo1GVPXrQu/E/t5772Hq1Kk4duyYsO/YsWOYNm0a3n//fX27IyIieiAyI23A7WLW3t5e2GJiYuqMIz09HY0aNYJCocDkyZOxfft2+Pr6AgBefvllfPHFFzh48CDmzp2LLVu2YNSoUcK5+fn5oqQOQHidn5+v1+9Dp6H4xo0bi4Ylbty4gc6dO8Pc/PbpFRUVMDc3xyuvvIKhQ4fqFQAREVFDlZubC6VSKbxWKBR1tvXx8UFaWhqKiorwzTffIDQ0FImJifD19cWkSZOEdn5+fnBzc0Pfvn2RnZ0NLy8vg8asU2JfuXKlQd+UiIjIUOQyGeQGnmOv7q96lbsuLC0thWepdOzYEUePHsWqVavw8ccf12jbuXNnAEBWVha8vLygUqlw5MgRUZuCggIAqHNevi46JfbQ0FC9OiUiInpYjHG3OEP0V1VVVeecfFpaGgDAzc0NAKBWq7F48WIUFhbCxcUFABAfHw+lUikM5+vqvm9QAwAlJSUoKysT7dP1mw0REZGpmDt3LgYOHIhmzZrh+vXriIuLw6FDh7B3715kZ2cjLi4OgwYNgpOTE44fP44ZM2agR48e8Pf3BwAEBATA19cXo0ePxrJly5Cfn4/58+cjPDz8rsP/tdE7sd+4cQMRERHYtm0bLl++XON4ZWWlvl0SERHdt4ZwuVthYSHGjBmDvLw82Nvbw9/fH3v37kX//v2Rm5uLhIQErFy5Ejdu3ICHhweCg4Mxf/584XwzMzPs2rULYWFhUKvVsLW1RWhoKBYtWqR37Hon9jlz5uDgwYNYt24dRo8ejbVr1+LChQv4+OOPsXTpUr0DICIikrqNGzfWeczDwwOJiYn37MPT0xO7d+9+4Fj0Tuw7d+7E559/jl69emHcuHHo3r07vL294enpia1btyIkJOSBgyIiItJVQ51jry96X8d+5coVtGzZEsDt+fQrV64AALp164bDhw8bNjoiIiLSi96JvWXLljh79iwAoHXr1ti2bRuA25W8g4ODQYMjIiK6l+rL3Qy9SZXeiX3cuHH4448/AABvvvkm1q5dCysrK8yYMQOzZ882eIBERESkO73n2GfMmCH83K9fP5w+fRqpqanw9vYWlu0TERE9LJxjF3ug69iB26v4PD09DRELERERPSCdEvvq1at17vD111+/72CIiIj01RCuY29IdErsK1as0KkzmUzWIBN7zqH3eUc8krTGA5fVdwhE901bUWLU/uW4jwVjOvQpVTol9upV8ERERNSwPfAcOxERUX3iULyYlEcbiIiI6A6s2ImISNJkMkDOy90ErNiJiIhMCCt2IiKSNLkRKnZD9/cw3VfF/vPPP2PUqFFQq9W4cOECAGDLli345ZdfDBocERER6UfvxP7tt98iMDAQ1tbW+P3331FaWgoAKCoqwpIlSwweIBER0d1Ur4o39CZVeif2d955B+vXr8eGDRtgYWEh7O/atSt+++03gwZHRERE+tF7jj0zMxM9evSosd/e3h7Xrl0zRExEREQ64xy7mN4Vu0qlQlZWVo39v/zyC1q2bGmQoIiIiHRV/XQ3Q29SpXdinzhxIqZNm4Zff/0VMpkMFy9exNatWzFr1iyEhYUZI0YiIiLSkd5D8W+++SaqqqrQt29f3Lx5Ez169IBCocCsWbMwdepUY8RIRERUJ7lMBrmBS2xD9/cw6Z3YZTIZ5s2bh9mzZyMrKwvFxcXw9fVFo0aNjBEfERER6eG+b1BjaWkJX19fQ8ZCRESkNz62VUzvxN67d++7Xt934MCBBwqIiIiI7p/eib1du3ai1+Xl5UhLS8OJEycQGhpqqLiIiIh0YoxV7BKeYtc/sa9YsaLW/ZGRkSguLn7ggIiIiOj+GWwaYdSoUfjss88M1R0REZFO5JAJK+MNtkG6JbvBnu6WnJwMKysrQ3VHRESkEw7Fi+md2IcNGyZ6rdVqkZeXh2PHjuHtt982WGBERESkP70Tu729vei1XC6Hj48PFi1ahICAAIMFRkREpAveK15Mr8ReWVmJcePGwc/PD40bNzZWTERERHSf9Fo8Z2ZmhoCAAD7FjYiIGgyZDAZfPCflOXa9V8W3bdsWf/31lzFiISIiogekd2J/5513MGvWLOzatQt5eXnQaDSijYiI6GHiY1vFdJ5jX7RoEd544w0MGjQIAPDcc8+Jbi2r1Wohk8lQWVlp+CiJiIhIJzon9qioKEyePBkHDx40ZjxERER64ap4MZ0Tu1arBQD07NnTaMEQERHRg9Hrcre7PdWNiIioPsj++5+h+5QqvRJ7q1at7pncr1y58kABERER6YND8WJ6JfaoqKgad54jIiKihkOvxD5ixAi4uLgYKxYiIiK9sWIX0/k6ds6vExERNXx6r4onIiJqSGQymcGLTykXszpX7FVVVRyGJyIiqsW6devg7+8PpVIJpVIJtVqNn376STheUlKC8PBwODk5oVGjRggODkZBQYGoj5ycHAQFBcHGxgYuLi6YPXs2Kioq9I5F71vKEhERNSTVc+yG3vTRtGlTLF26FKmpqTh27Bj69OmDIUOGICMjAwAwY8YM7Ny5E19//TUSExNx8eJFDBs2TDi/srISQUFBKCsrQ1JSEjZv3ozY2FgsWLBA79+H3s9jJyIiIrFnn31W9Hrx4sVYt24dUlJS0LRpU2zcuBFxcXHo06cPAGDTpk1o06YNUlJS0KVLF+zbtw8nT55EQkICXF1d0a5dO0RHRyMiIgKRkZGwtLTUORZW7EREJGnGfAjMnQ86Ky0tvWc8lZWV+PLLL3Hjxg2o1WqkpqaivLwc/fr1E9q0bt0azZo1Q3JyMgAgOTkZfn5+cHV1FdoEBgZCo9EIVb+umNiJiIjq4OHhAXt7e2GLiYmps216ejoaNWoEhUKByZMnY/v27fD19UV+fj4sLS3h4OAgau/q6or8/HwAQH5+viipVx+vPqYPDsUTEZGkyWUyyA28ir26v9zcXCiVSmG/QqGo8xwfHx+kpaWhqKgI33zzDUJDQ5GYmGjQuHTBxE5ERJJmzBvUVK9y14WlpSW8vb0BAB07dsTRo0exatUqvPTSSygrK8O1a9dEVXtBQQFUKhUAQKVS4ciRI6L+qlfNV7fROXa9WhMREZFOqqqqUFpaio4dO8LCwgL79+8XjmVmZiInJwdqtRoAoFarkZ6ejsLCQqFNfHw8lEolfH199XpfVuxERCRt/1rsZsg+9TF37lwMHDgQzZo1w/Xr1xEXF4dDhw5h7969sLe3x/jx4zFz5kw4OjpCqVRi6tSpUKvV6NKlCwAgICAAvr6+GD16NJYtW4b8/HzMnz8f4eHhdx3+rw0TOxER0QMqLCzEmDFjkJeXB3t7e/j7+2Pv3r3o378/AGDFihWQy+UIDg5GaWkpAgMD8dFHHwnnm5mZYdeuXQgLC4NarYatrS1CQ0OxaNEivWNhYiciIkmTQwa5gZ+frm9/GzduvOtxKysrrF27FmvXrq2zjaenJ3bv3q3X+9aGc+xEREQmhBU7ERFJmswIc+wSfgYMK3YiIiJTwoqdiIgkzZjXsUsRK3YiIiITwoqdiIgkzZi3lJUiJnYiIpI0Lp4T41A8ERGRCWHFTkREkiaHEYbiDXzDm4eJFTsREZEJYcVORESSxjl2MVbsREREJoQVOxERSZochq9SpVz1Sjl2IiIiugMrdiIikjSZTAaZgSfFDd3fw8TETkREkib772boPqWKQ/FEREQmhBU7ERFJGu8VL8aKnYiIyISwYiciIsmTbn1teKzYiYiITAgrdiIikjTeUlaMFTsREZEJYcVORESSxhvUiLFiJyIiMiGs2ImISNL4EBgxJnYiIpI0DsWLSflLCREREd2BFTsREUkaHwIjxoqdiIjIhLBiJyIiSeMcuxgrdiIiIhPCip2IiCSNl7uJSTl2MoL1H62Fj3dzODSyQvdnOuPokSN1tj2ZkYERw4Ph490c1hYyrFm1skab69evY9bM6Wjl5YnGdtbo1f0ZHDt61IifgB51rz7XHqe3vIqrP87E4dWj0MlHddf2U57viD8+m4Aru2bgzNbJWDa5DxQWZsLxrn5N8c2iYfjry9dwK34Onn3G29gfgeiBMLGT4OttXyFi9kzMm78QyUd+g7//k3guKBCFhYW1tr958yZatGiJ6MVLoVLV/scz7NUJOLA/Hp/FbsGx39PRr38Aggb0w4ULF4z5UegR9ULP1nj31d5Y/MV/oA7bjON//YMdMcPRxMGm1vYv9W6D6Ak9sWTLf9Bu/EZM/mAPXujVGote6SG0sbWyQPpfhZi+Jv5hfQzSU/Ucu6E3qWJiJ8HqlR9g3PiJGDN2HNr4+mLNR+thbWODzbGf1dq+01NPIebd9zD8pRGwVChqHL916xa+/+5bLI5Zhm7de8DL2xvzF0TCy8sbGz5eZ+yPQ4+g14M7YdNPx7Fl7wmczrmMqav24lZpOUID/Wpt3+WJx5CccQFfHTyFnAIN9qeew7aDp9CptZvQZt/Rs4iK/QU7/nPmYX0MogfCxE4AgLKyMvz+Wyr69O0n7JPL5ejTpx+OpCTfV58VFRWorKyElZWVaL+VtTWS/vPLA8VLdCcLcznat1LhwG/nhH1aLXDgt7/xtK97reekZFxA+8ddheH65ip7BD7dEnuO/PUwQiYDkRlpkyouniMAwKVLl1BZWQkXF1fRfhdXV2Rmnr6vPu3s7NC5ixoxi6Ph07oNXF1dse3L/8OvKcnw8uY8JRmWs70NzM3kKLx6U7S/8OoN+Hg41nrOVwdPwcneGvtXhEAmAyzMzfDJzt/x3v+lPIyQyUD4PHaxBluxL168GM888wxsbGzg4OBQ3+HQffosdgu0Wi28PB+Dva0Caz9cjeEvjYRc3mD/6dEjpLu/B2aP7IJpa+KhDtuMlyK3Y2BnL7wZoq7v0IjuW4P961pWVoYXX3wRYWFh9R3KI8HZ2RlmZmYoLCwQ7S8sKKhzYZwuWnp5If5AIi5dK8aZs7n4JfkIyivK0aJFywcNmUjkUtFNVFRWwaWxeKGcS2Nb5F+9Ues5C8d2w/8lnETsT8eRce4SdvznDBZ8dhizR3SRdMX2qJFDZpRNquo1sVdVVWHZsmXw9vaGQqFAs2bNsHjxYgBAVFQUZsyYAT+/2he9kGFZWlqifYeOOHhgv7CvqqoKBw/ux9NdHrx6sbW1hZubG65evYqEfXsx+NkhD9wn0b+VV1Th9z/z0bu9p7BPJgN6t/fEkZMXaz3HWmGBKq1WtK+qSvvfc6X7h50ebfU6xz537lxs2LABK1asQLdu3ZCXl4fTp+9vPhcASktLUVpaKrzWaDSGCPOR8fr0mZj4Sig6duyETk89jQ9Xr8TNGzcwJnQcAGD82DFwf+wxRC+OAXB7VOXUyZPCzxcvXsAfaWlo1KiRMIcev28vtFotWrXyQXZ2Ft6KmI1WPq0xZuy4+vmQZNJWf3sMG+YMQuqf+TiWmYcpz3eCjZUFPt+bDgD4dM4gXLxUjAWfHQYA7E7JxuvBnfBHVgGOnM6Dl7sDFoR2w+6UbCHB21pZwOuxxsJ7NFc5wN/LBVc1t5D7z/WH/yGpBs6xi9VbYr9+/TpWrVqFDz/8EKGhoQAALy8vdOvW7b77jImJQVRUlKFCfOS8OPwlXPrnHyyKWoCC/Hz4P9kOP+zaA1fX2wvqcnNzRHPjeRcvostT7YXXKz94Hys/eB/de/TEvv2HAABFRUVYMH8uLpw/D0dHRwx5PhhR0YthYWHxUD8bPRq+STwNZwdrLAjtBtfGtjieXYghb32Nwmu3F9R5uChFFfrSrUnQarVYOLY73J0b4VLRLfyYkoXIz34W2nRopcK+5SOF18vC+gAAtuxLx6T3fnpIn4xIdzKt9o5xqIfkyJEj6Ny5M/766y+0aNGiznaxsbGYPn06rl27ds8+a6vYPTw8UHC5CEql0hBhE9WLxgOX1XcIRPdNW1GC0kMLUVRk2L/FGo0G9vb22JacBZtGdgbrFwBuFl/HcLW3zjHHxMTgu+++w+nTp2FtbY1nnnkG7777Lnx8fIQ2vXr1QmJioui8V199FevXrxde5+TkICwsDAcPHkSjRo0QGhqKmJgYmJvrXofXW8VubW1t8D4VCgUUtdwohYiIyJgSExMRHh6Op556ChUVFXjrrbcQEBCAkydPwtbWVmg3ceJELFq0SHhtY/O/xZ6VlZUICgqCSqVCUlIS8vLyMGbMGFhYWGDJkiU6x1Jvif3xxx+HtbU19u/fjwkTJtRXGEREJHENYY59z549otexsbFwcXFBamoqevT43y2KbWxs6rzSaN++fTh58iQSEhLg6uqKdu3aITo6GhEREYiMjISlpaVOsdTbqngrKytERERgzpw5+Pzzz5GdnY2UlBRs3LgRwO3hiLS0NOTk5KCyshJpaWlIS0tDcXFxfYVMREQNkMwIl7rJ/nu5m0ajEW3/nu69m6KiIgCAo6P45khbt26Fs7Mz2rZti7lz5+Lmzf/dUCk5ORl+fn7CuiYACAwMhEajQUZGhs6/j3pdFf/222/D3NwcCxYswMWLF+Hm5obJkycDABYsWIDNmzcLbdu3v71I6+DBg+jVq1d9hEtERI8YDw8P0euFCxciMjLyrudUVVVh+vTp6Nq1K9q2bSvsf/nll+Hp6Ql3d3ccP34cERERyMzMxHfffQcAyM/PFyV1AMLr/Px8nWOu18Qul8sxb948zJs3r8ax2NhYxMbGPvygiIhIUow5FJ+bmytaPKfLOq7w8HCcOHECv/wifibGpEmThJ/9/Pzg5uaGvn37Ijs7G15eXoYJHA34znNERET1TalUirZ7JfYpU6Zg165dOHjwIJo2bXrXtp07dwYAZGVlAQBUKhUKCsR3/6x+rc8dQJnYiYhI0qordkNv+tBqtZgyZQq2b9+OAwcO3PUy7mppaWkAADe3248JVqvVSE9PR2FhodAmPj4eSqUSvr6+OsfCp7sRERE9oPDwcMTFxeGHH36AnZ2dMCdub28Pa2trZGdnIy4uDoMGDYKTkxOOHz+OGTNmoEePHvD39wcABAQEwNfXF6NHj8ayZcuQn5+P+fPnIzw8XK9LuZnYiYhI0mT/WsVuyD71sW7dOgCosbh706ZNGDt2LCwtLZGQkICVK1fixo0b8PDwQHBwMObPny+0NTMzw65duxAWFga1Wg1bW1uEhoaKrnvXBRM7ERHRA7rXTVw9PDxq3HWuNp6enti9e/cDxcLETkREkiaX3d4M3adUcfEcERGRCWHFTkREktYQ5tgbEiZ2IiKStIZwr/iGhEPxREREJoQVOxERSZoMhh86l3DBzoqdiIjIlLBiJyIiSePlbmKs2ImIiEwIK3YiIpI0Xu4mxoqdiIjIhLBiJyIiSeN17GKs2ImIiEwIK3YiIpI0GQx/3bmEC3YmdiIikjY5ZJAbeOxcLuHUzqF4IiIiE8KKnYiIJI1D8WKs2ImIiEwIK3YiIpI2luwirNiJiIhMCCt2IiKSNN5SVowVOxERkQlhxU5ERNJmhFvKSrhgZ8VORERkSlixExGRpHFRvBgTOxERSRszuwiH4omIiEwIK3YiIpI0Xu4mxoqdiIjIhLBiJyIiSZMZ4XI3g18+9xCxYiciIjIhrNiJiEjSuChejBU7ERGRCWHFTkRE0saSXYSJnYiIJI2Xu4lxKJ6IiMiEsGInIiJJ4+VuYqzYiYiITAgrdiIikjSunRNjxU5ERGRCWLETEZG0sWQXYcVORERkQlixExGRpPE6djFW7ERERA8oJiYGTz31FOzs7ODi4oKhQ4ciMzNT1KakpATh4eFwcnJCo0aNEBwcjIKCAlGbnJwcBAUFwcbGBi4uLpg9ezYqKir0ioWJnYiIJK36OnZDb/pITExEeHg4UlJSEB8fj/LycgQEBODGjRtCmxkzZmDnzp34+uuvkZiYiIsXL2LYsGHC8crKSgQFBaGsrAxJSUnYvHkzYmNjsWDBAv1+H1qtVqtf+NKh0Whgb2+PgstFUCqV9R0O0X1rPHBZfYdAdN+0FSUoPbQQRUWG/Vtc/Tc++eQFNLIz7N/44usaqH0fu++Y//nnH7i4uCAxMRE9evRAUVERmjRpgri4OLzwwgsAgNOnT6NNmzZITk5Gly5d8NNPP2Hw4MG4ePEiXF1dAQDr169HREQE/vnnH1haWur03qzYiYiIDKyoqAgA4OjoCABITU1FeXk5+vXrJ7Rp3bo1mjVrhuTkZABAcnIy/Pz8hKQOAIGBgdBoNMjIyND5vbl4joiIpM2Il7tpNBrRboVCAYVCcddTq6qqMH36dHTt2hVt27YFAOTn58PS0hIODg6itq6ursjPzxfa/DupVx+vPqYrVuxERER18PDwgL29vbDFxMTc85zw8HCcOHECX3755UOIsCZW7EREJGnGvNwtNzdXNMd+r2p9ypQp2LVrFw4fPoymTZsK+1UqFcrKynDt2jVR1V5QUACVSiW0OXLkiKi/6lXz1W10wYqdiIioDkqlUrTVldi1Wi2mTJmC7du348CBA2jRooXoeMeOHWFhYYH9+/cL+zIzM5GTkwO1Wg0AUKvVSE9PR2FhodAmPj4eSqUSvr6+OsfMip2IiCStITy2NTw8HHFxcfjhhx9gZ2cnzInb29vD2toa9vb2GD9+PGbOnAlHR0colUpMnToVarUaXbp0AQAEBATA19cXo0ePxrJly5Cfn4/58+cjPDz8niMF/8bETkRE9IDWrVsHAOjVq5do/6ZNmzB27FgAwIoVKyCXyxEcHIzS0lIEBgbio48+EtqamZlh165dCAsLg1qthq2tLUJDQ7Fo0SK9YmFiJyIiSWsIz4DR5ZYwVlZWWLt2LdauXVtnG09PT+zevVvPdxfjHDsREZEJYcVORETS1hBK9gaEiZ2IiCSNT3cT41A8ERGRCWHFTkREktYQLndrSFixExERmRBW7EREJGlcOyfGip2IiMiEsGInIiJpY8kuwoqdiIjIhLBiJyIiSeN17GJM7EREJG1GuNxNwnmdQ/FERESmhBU7ERFJGtfOibFiJyIiMiGs2ImISNpYsouwYiciIjIhrNiJiEjSeLmbGCt2IiIiE8KKnYiIJI2PbRVjxU5ERGRCWLETEZGkcVG8mEkndq1WCwC4rtHUcyRED0ZbUVLfIRDdt+p/v9V/kw2OmV3EpBP79evXAQDeLTzqORIiIrp+/Trs7e3rOwyTZ9KJ3d3dHbm5ubCzs4NMyishGjCNRgMPDw/k5uZCqVTWdzhEeuO/YePTarW4fv063N3djdI/L3cTM+nELpfL0bRp0/oO45GgVCr5R5Ekjf+GjYuV+sNj0omdiIhMnwxGuNzNsN09VLzcjYiIyISwYqcHolAosHDhQigUivoOhei+8N+w9HFRvJhMa7TrD4iIiIxHo9HA3t4eGWcLYWfg9RHXNRo80cIFRUVFklt7wYqdiIgkjbeUFeMcOxERkQlhxU5ERBLHWfZ/Y2InIiJJ41C8GIfiiYiITAgrdiIikjQOxIsxsdN9OXv2LPbu3YuKigr4+Pigf//+9R0S0X2rqqqCXM4BTDINTOykt/T0dPTq1Qve3t4oLi7GqVOnMGHCBEyfPh2+vr71HR6Rzq5duwYHBwfI5XImdwnjHLsY/xWTXoqLizFlyhSMGTMGv/76K1JSUrBv3z5s374d8+bNw7Fjx+o7RCKdnDx5Ep6enli0aBEACMmdSOqY2EkvlpaWKC4uxhNPPAEAsLW1Rb9+/bB37178/vvvWLp0KS5fvlzPURLd3fnz5zF69Gi4ublh9erVeOeddwAwuUuVzEj/SRWH4klnWq0WxcXFuH79OvLz84V9FRUV6NChA7799lt06dIFTz/9NObMmVPP0RLVrqqqCtu3b0fz5s0xZcoUpKamCol9/vz5kMvlqKyshJmZWT1HSnR/mNhJJ1qtFjKZDI6OjoiIiMDUqVPxzDPPoE+fPqiqqkJZWRk6duyIxYsXIzY2FuPGjYOzszNkUp6oIpMkl8sxcOBAODs7o3fv3mjfvj20Wi0WL14M4HZyNzMz45y7lHBZvAgTO91TdVKPj4/Hnj170Lt3b7z00ksIDw/H+vXr0bNnT1hYWAAAnJycYG5uDjs7OyZ1anCq/y17e3vD29sbAODg4IBXXnkFAETJXavVYseOHVCr1WjSpEm9xUykLyZ2uieZTIbvvvsOo0aNwvz589GsWTOEhYXhxo0bGD16ND788EMMHjwYAPDnn39CqVSirKwMVlZW9Rw50f/c+QU1JCQEHTp0AHD7C+m4ceMgk8nwzjvvQKvVoqioCCtXrkRubm49R073woJdjONMdE9//vknZs2aheXLl+Ott96Cv78/nn76abz55psYMmQIhg4divbt20OtVmPDhg1Ys2aN5B5zSKav+gvqkCFD0LhxY9z5xGpnZ2eMGzcOb731FhYuXIjPPvsMKSkpcHNzq6eISVfVl7sZetPX4cOH8eyzz8Ld3R0ymQzff/+96PjYsWMhk8lE24ABA0Rtrly5gpCQECiVSjg4OGD8+PEoLi7WKw5W7HRPOTk5sLCwwKBBgwD872YeHTp0QIcOHTBq1CgkJSXBysoKAQEB8PLyqueIiWr69xfUsLCwWts4OTkhIyMDdnZ2+OWXX3hfBtLLjRs38OSTT+KVV17BsGHDam0zYMAAbNq0SXitUChEx0NCQpCXl4f4+HiUl5dj3LhxmDRpEuLi4nSOg4md7qm4uBi3bt0S7atO7gcOHICHhwdmzJhRT9ER6ebOL6jA/4bnq8XFxWHPnj04ePAgk7qEGOPytPvpb+DAgRg4cOBd2ygUCqhUqlqPnTp1Cnv27MHRo0fRqVMnAMCaNWswaNAgvP/++3B3d9cpDg7F0z09+eSTuHTpEj755BMAt1cVV68W3rFjB7744guUlZXVGNokakju/IJaVVUlJPVDhw7h1KlT6NevH44ePSrMvRNpNBrRVlpa+kD9HTp0CC4uLvDx8UFYWJjovh/JyclwcHAQkjoA9OvXD3K5HL/++qvO78HETvfUokULfPjhh3jvvfcwZ84cnDhxAqdOnUJERAQ2b96MkSNHwtLSkqvgqUGr7Qtqte+//x5xcXFwdnZGs2bN6itEul8yI20APDw8YG9vL2wxMTH3HeaAAQPw+eefY//+/Xj33XeRmJiIgQMHorKyEgCQn58PFxcX0Tnm5uZwdHQU7h2iCw7Fk07Gjh0LOzs7vPrqq/i///s/WFlZwczMDAcOHEDr1q3rOzyie6r+gjp58mSUl5djzJgxMDMzQ2xsLDZv3ozk5GRet0415ObmihYD3zknro8RI0YIP/v5+cHf3x9eXl44dOgQ+vbt+0Bx/hsTO+lELpfjxRdfRNeuXfH3339DJpOhRYsWcHV1re/QiHTGL6imyZiXuymVSqNd5dOyZUs4OzsjKysLffv2hUqlQmFhoahNRUUFrly5Uue8fG2Y2Ekv7u7uOi/gIGpo+AWVGpLz58/j8uXLwiWVarUa165dQ2pqKjp27AgAOHDgAKqqqtC5c2ed+2ViJ6JHDr+gmpaG8tjW4uJiZGVlCa/Pnj2LtLQ0ODo6wtHREVFRUQgODoZKpUJ2djbmzJkDb29vBAYGAgDatGmDAQMGYOLEiVi/fj3Ky8sxZcoUjBgxQq9/rzItlzITEZEEaTQa2Nvb4+zFKwYfLtdoNGjh7oiioiKd+z506BB69+5dY39oaCjWrVuHoUOH4vfff8e1a9fg7u6OgIAAREdHi0aMrly5gilTpmDnzp2Qy+UIDg7G6tWr0ahRI51jZ2InIiJJamiJvaHgUDwREUlaQxmKbyh4bQcREZEJYWInIiIyIUzsREREJoRz7EREJGmcYxdjxU5kAGPHjsXQoUOF17169cL06dMfehyHDh2CTCbDtWvX6mxT23Oi7yYyMhLt2rV7oLjOnTsHmUyGtLS0B+qHiO6NiZ1M1tixYyGTySCTyWBpaQlvb28sWrQIFRUVRn/v7777DtHR0Tq11SUZE1HdZEb6T6o4FE8mbcCAAdi0aRNKS0uxe/duhIeHw8LCAnPnzq3RtqysDJaWlgZ5X0dHR4P0Q0SkL1bsZNIUCgVUKhU8PT0RFhaGfv36YceOHQD+N3y+ePFiuLu7w8fHB8DtpzkNHz4cDg4OcHR0xJAhQ3Du3Dmhz8rKSsycORMODg5wcnLCnDlzajyL/s6h+NLSUkRERMDDwwMKhQLe3t7YuHEjzp07J9ypqnHjxpDJZBg7diyA288Lj4mJQYsWLWBtbY0nn3wS33zzjeh9du/ejVatWsHa2hq9e/cWxamriIgItGrVCjY2NmjZsiXefvttlJeX12j38ccfw8PDAzY2Nhg+fDiKiopExz/99FO0adMGVlZWaN26NT766CO9YyG6H9Vz7IbepIoVOz1SrK2tcfnyZeH1/v37oVQqER8fDwAoLy9HYGAg1Go1fv75Z5ibm+Odd97BgAEDcPz4cVhaWmL58uWIjY3FZ599hjZt2mD58uXYvn07+vTpU+f7jhkzBsnJyVi9ejWefPJJnD17FpcuXYKHhwe+/fZbBAcHIzMzE0qlEtbW1gCAmJgYfPHFF1i/fj0ef/xxHD58GKNGjUKTJk3Qs2dP5ObmYtiwYQgPD8ekSZNw7NgxvPHGG3r/Tuzs7BAbGwt3d3ekp6dj4sSJsLOzw5w5c4Q2WVlZ2LZtG3bu3AmNRoPx48fjtddew9atWwEAW7duxYIFC/Dhhx+iffv2+P333zFx4kTY2toiNDRU75iI9GHMp7tJkpbIRIWGhmqHDBmi1Wq12qqqKm18fLxWoVBoZ82aJRx3dXXVlpaWCuds2bJF6+Pjo62qqhL2lZaWaq2trbV79+7VarVarZubm3bZsmXC8fLycm3Tpk2F99JqtdqePXtqp02bptVqtdrMzEwtAG18fHytcR48eFALQHv16lVhX0lJidbGxkablJQkajt+/HjtyJEjtVqtVjt37lytr6+v6HhERESNvu4EQLt9+/Y6j7/33nvajh07Cq8XLlyoNTMz054/f17Y99NPP2nlcrk2Ly9Pq9VqtV5eXtq4uDhRP9HR0Vq1Wq3VarXas2fPagFof//99zrfl0hfRUVFWgDa8wVXtZpblQbdzhdc1QLQFhUV1ffH1BsrdjJpu3btQqNGjVBeXo6qqiq8/PLLiIyMFI77+fmJ5tX/+OMPZGVlwc7OTtRPSUkJsrOzUVRUhLy8PNEjFM3NzdGpU6caw/HV0tLSYGZmhp49e+ocd1ZWFm7evIn+/fuL9peVlaF9+/YAgFOnTtV4lKNardb5Pap99dVXWL16NbKzs1FcXIyKiooa98Zu1qwZHnvsMdH7VFVVITMzE3Z2dsjOzsb48eMxceJEoU1FRQXs7e31jodIbyzZRZjYyaT17t0b69atg6WlJdzd3WFuLv4nb2trK3pdXFyMjh07CkPM/9akSZP7iqF6aF0fxcXFAIAff/xRlFCB2+sGDCU5ORkhISGIiopCYGAg7O3t8eWXX2L58uV6x7phw4YaXzTMzMwMFisR6YaJnUyara0tvL29dW7foUMHfPXVV3BxcanziU5ubm749ddf0aNHDwC3K9PU1FR06NCh1vZ+fn6oqqpCYmIi+vXrV+N49YhBZWWlsM/X1xcKhQI5OTl1Vvpt2rQRFgJWS0lJufeH/JekpCR4enpi3rx5wr6///67RrucnBxcvHhReCZ0SkoK5HI5fHx84OrqCnd3d/z1118ICQnR6/2JDMEYl6dJ+XI3roon+peQkBA4OztjyJAh+Pnnn3H27FkcOnQIr7/+Os6fPw8AmDZtGpYuXYrvv/8ep0+fxmuvvXbXa9CbN2+O0NBQvPLKK/j++++FPrdt2wYA8PT0hEwmw65du/DPP/+guLgYdnZ2mDVrFmbMmIHNmzcjOzsbv/32G9asWYPNmzcDACZPnowzZ85g9uzZyMzMRFxcHGJjY/X6vI8//jhycnLw5ZdfIjs7G6tXr8b27dtrtLOyskJoaCj++OMP/Pzzz3j99dcxfPhwqFQqAEBUVBRiYmKwevVq/Pnnn0hPT8emTZvwwQcf6BUPET04Jnaif7GxscHhw4fRrFkzDBs2DG3atMH48eNRUlIiVPBvvPEGRo8ejdDQUKjVatjZ2eH555+/a7/r1q3DCy+8gNdeew2tW7fGxIkTcePGDQDAY489hqioKLz55ptwdXXFlClTAADR0dF4++23ERMTgzZt2mDAgAH48ccf0aJFCwC3572//fZbfP/993jyySexfv16LFmyRK/P+9xzz2HGjBmYMmUK2rVrh6SkJLz99ts12nl7e2PYsGEYNGgQAgIC4O/vL7qcbcKECfj000+xadMm+Pn5oWfPnoiNjRViJTImXu4mJtPWteKHiIioAdNoNLC3t8fFf67VOXX2IH27N3FAUVGRwfs2Ns6xExGRpHFRvBiH4omIiEwIK3YiIpI2luwiTOxERCRpvNxNjEPxREREJoQVOxERSZoxLk+T8uVuTOxERCRpGo1GEn0+LEzsREQkSZaWllCpVHi8hYdR+lepVKKHREkFb1BDRESSVVJSgrKyMqP0bWlpCSsrK6P0bUxM7ERERCaEq+KJiIhMCBM7ERGRCWFiJyIiMiFM7ERERCaEiZ2IiMiEMLETERGZECZ2IiIiE/L/cQO3YtnXv+sAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f'x_test.shape: {x_test.shape}, predictions.shape: {predictions.shape}')\n", + "\n", + "index = 100 # up to 9999\n", + "print('Ground truth for test timeseries: ',y_test[index])\n", + "print('Predictions for each class:\\n')\n", + "for i in range(2):\n", + " print('class:', i, ' probability: ', predictions[index][i])\n", + "\n", + "# For each sample timeseries in the test dataset, select the class label with the highest probability.\n", + "predicted_labels = [np.argmax(i) for i in predictions]\n", + "print(f'len(predicted_labels): {len(predicted_labels)}')\n", + "\n", + "\n", + "test_pred = np.argmax(predictions, axis=1)\n", + "print(test_pred)\n", + "print(y_test)\n", + "\n", + "# cm = sklearn.metrics.confusion_matrix(y_test, test_pred)\n", + "cm = sklearn.metrics.confusion_matrix(y_test, test_pred)\n", + "\n", + "\n", + "class_names = ['c0', 'c1']\n", + "\n", + "figure = plt.figure(figsize=(5, 5))\n", + "plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n", + "plt.title(\"Confusion matrix\")\n", + "plt.colorbar()\n", + "tick_marks = np.arange(len(class_names))\n", + "plt.xticks(tick_marks, class_names, rotation=45)\n", + "plt.yticks(tick_marks, class_names)\n", + "\n", + "# Normalize the confusion matrix.\n", + "cm = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], decimals=2)\n", + "# Use white text if squares are dark; otherwise black.\n", + "threshold = cm.max() / 2.\n", + "\n", + "for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n", + " color = \"white\" if cm[i, j] > threshold else \"black\"\n", + " plt.text(j, i, cm[i, j], horizontalalignment=\"center\", color=color)\n", + "\n", + "plt.tight_layout()\n", + "plt.ylabel('True label')\n", + "plt.xlabel('Predicted label')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aN4ikV4Qh0vt" + }, + "source": [ + "## Conclusions\n", + "\n", + "In about 110-120 epochs (25s each on Colab), the model reaches a training\n", + "accuracy of ~0.95, validation accuracy of ~84 and a testing\n", + "accuracy of ~85, without hyperparameter tuning. And that is for a model\n", + "with less than 100k parameters. Of course, parameter count and accuracy could be\n", + "improved by a hyperparameter search and a more sophisticated learning rate\n", + "schedule, or a different optimizer.\n", + "\n", + "You can use the trained model hosted on [Hugging Face Hub](https://huggingface.co/keras-io/timeseries_transformer_classification) and try the demo on [Hugging Face Spaces](https://huggingface.co/spaces/keras-io/timeseries_transformer_classification)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "name": "timeseries_transformer_classification", + "provenance": [], + "toc_visible": true + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/rtt4ssa/models/transformer-model/timeseries_transformer_classification.ipynb b/rtt4ssa/models/transformer-model/timeseries_transformer_classification.ipynb deleted file mode 100644 index 3c913ec..0000000 --- a/rtt4ssa/models/transformer-model/timeseries_transformer_classification.ipynb +++ /dev/null @@ -1,1167 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "iEINjF1qh0vc" - }, - "source": [ - "# Timeseries classification with a Transformer model\n", - "\n", - "**Author:** [Theodoros Ntakouris](https://github.com/ntakouris)
\n", - "**Replication:** [mxochicale](https://github.com/mxochicale/)
\n", - "**Date created:** 2021/06/25
\n", - "**Description:** This notebook demonstrates how to do timeseries classification using a Transformer model.\n", - "\n", - "**Logs:**\n", - "* MX: Fri 21 Jul 2023 # Out of Memory issue\n", - " ```\n", - " # RESOURCE_EXHAUSTED: OOM when allocating tensor with shape[64,500,4,256] and \n", - " # type float on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc\n", - " # SOLUTION > Change batch size https://github.com/tensorflow/models/issues/8487 \n", - " # OOM means out of memory. May be it is using more memory at that time. \n", - " # Decrease batch_size significantly. I set to 16, then it worked fine\n", - " # >https://stackoverflow.com/questions/49665757\n", - " ```\n", - "* MX: Sat 22 Jul 12:05:24 BST 2023 # Adds confusion matrix https://towardsdatascience.com/exploring-confusion-matrix-evolution-on-tensorboard-e66b39f4ac12\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0EmcFKhgh0vk" - }, - "source": [ - "## Introduction\n", - "\n", - "This is the Transformer architecture from\n", - "[Attention Is All You Need](https://arxiv.org/abs/1706.03762),\n", - "applied to timeseries instead of natural language.\n", - "\n", - "This example requires TensorFlow 2.4 or higher.\n", - "\n", - "## Load the dataset\n", - "\n", - "We are going to use the same dataset and preprocessing as the\n", - "[TimeSeries Classification from Scratch](https://keras.io/examples/timeseries/timeseries_classification_from_scratch)\n", - "example." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-09 09:30:31.814335: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2023-08-09 09:30:31.874603: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - } - ], - "source": [ - "import tensorflow as tf\n", - "from tensorflow import keras\n", - "from tensorflow.keras import layers\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import itertools\n", - "import sklearn.metrics\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "bSpvocLzh0vl" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(3601, 500), (3601,)\n", - "(1320, 500), (1320,)\n", - "x_train.shape: (3601, 500, 1), y_train.shape: (3601,)\n", - "x_test.shape: (1320, 500, 1), y_test.shape: (1320,)\n", - "n_classes: 2\n", - "(3601,)\n", - "(1320,)\n" - ] - } - ], - "source": [ - "def readucr(filename):\n", - " data = np.loadtxt(filename, delimiter=\"\\t\")\n", - " y = data[:, 0]\n", - " x = data[:, 1:]\n", - " return x, y.astype(int)\n", - "\n", - "\n", - "root_url = \"https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/\"\n", - "\n", - "x_train, y_train = readucr(root_url + \"FordA_TRAIN.tsv\")\n", - "x_test, y_test = readucr(root_url + \"FordA_TEST.tsv\")\n", - "\n", - "print(f'{x_train.shape}, {y_train.shape}')\n", - "print(f'{x_test.shape}, {y_test.shape}')\n", - "\n", - "x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], 1))\n", - "x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], 1))\n", - "\n", - "print(f'x_train.shape: {x_train.shape}, y_train.shape: {y_train.shape}')\n", - "print(f'x_test.shape: {x_test.shape}, y_test.shape: {y_test.shape}')\n", - "\n", - "n_classes = len(np.unique(y_train))\n", - "print(f'n_classes: {n_classes}')\n", - "\n", - "# Randomise samples \n", - "idx = np.random.permutation(len(x_train))\n", - "x_train = x_train[idx]\n", - "y_train = y_train[idx]\n", - "\n", - "# Rename labels \n", - "y_train[y_train == -1] = 0\n", - "y_test[y_test == -1] = 0\n", - "\n", - "print(y_train.shape)\n", - "print(y_test.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "(3601, 500, 1)\n", - "(3500, 450, 1)\n", - "(3601,)\n", - "(3500,)\n", - "\n", - "(1320, 500, 1)\n", - "(1200, 450, 1)\n", - "(1320,)\n", - "(1200,)\n" - ] - } - ], - "source": [ - "## Reducing train and test data size\n", - "\n", - "lenght_of_time_series=450 # Original size # 500\n", - "train_size=3500 # Original size # 3601\n", - "print(type(x_train))\n", - "print(x_train.shape)\n", - "x_train = np.resize(x_train, (train_size,lenght_of_time_series))\n", - "x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], 1))\n", - "print(x_train.shape)\n", - "\n", - "print(y_train.shape)\n", - "y_train = np.resize(y_train, (train_size,))\n", - "print(y_train.shape)\n", - "\n", - "test_size = 1200 # Original size #1320\n", - "print(type(x_test))\n", - "print(x_test.shape)\n", - "x_test = np.resize(x_test, (test_size,lenght_of_time_series))\n", - "x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], 1))\n", - "\n", - "print(x_test.shape)\n", - "\n", - "print(y_test.shape)\n", - "y_test = np.resize(y_test, (test_size,))\n", - "print(y_test.shape)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualize the data\n", - "\n", - "Here we visualize one timeseries example for each class in the dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "idx: 700\n", - " class 0 with c_x_train.shape (1800, 450, 1)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " class 1 with c_x_train.shape (1700, 450, 1)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "idx: 701\n", - " class 0 with c_x_train.shape (1800, 450, 1)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " class 1 with c_x_train.shape (1700, 450, 1)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "classes = np.unique(np.concatenate((y_train, y_test), axis=0))\n", - "\n", - "start_sample_numbers=700\n", - "end_interval=2\n", - "\n", - "for idx in range(start_sample_numbers,start_sample_numbers+end_interval):\n", - " print(f'idx: {idx}') \n", - " \n", - " for c in classes:\n", - " c_x_train = x_train[y_train == c]\n", - " print(f' class {c} with c_x_train.shape {c_x_train.shape}')\n", - " plt.figure().set_figheight(1)\n", - " plt.plot(c_x_train[idx], label=\"class \" + str(c))\n", - " plt.legend(loc=\"best\")\n", - " plt.title(f'train time series for sample number {idx}')\n", - " plt.show()\n", - " plt.close()\n", - " plt.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Qig1eolEh0vo" - }, - "source": [ - "## Build the model\n", - "\n", - "Our model processes a tensor of shape `(batch size, sequence length, features)`,\n", - "where `sequence length` is the number of time steps and `features` is each input\n", - "timeseries.\n", - "\n", - "You can replace your classification RNN layers with this one: the\n", - "inputs are fully compatible!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "E9kzn8RWh0vp" - }, - "source": [ - "We include residual connections, layer normalization, and dropout.\n", - "The resulting layer can be stacked multiple times.\n", - "\n", - "The projection layers are implemented through `keras.layers.Conv1D`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "Vta2JAckh0vq" - }, - "outputs": [], - "source": [ - "def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):\n", - " # Normalization and Attention\n", - " x = layers.LayerNormalization(epsilon=1e-6)(inputs)\n", - " x = layers.MultiHeadAttention(\n", - " key_dim=head_size, num_heads=num_heads, dropout=dropout\n", - " )(x, x)\n", - " x = layers.Dropout(dropout)(x)\n", - " res = x + inputs\n", - "\n", - " # Feed Forward Part\n", - " x = layers.LayerNormalization(epsilon=1e-6)(res)\n", - " x = layers.Conv1D(filters=ff_dim, kernel_size=1, activation=\"relu\")(x)\n", - " x = layers.Dropout(dropout)(x)\n", - " x = layers.Conv1D(filters=inputs.shape[-1], kernel_size=1)(x)\n", - " return x + res\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "zIHHLcdoh0vq" - }, - "source": [ - "The main part of our model is now complete. We can stack multiple of those\n", - "`transformer_encoder` blocks and we can also proceed to add the final\n", - "Multi-Layer Perceptron classification head. Apart from a stack of `Dense`\n", - "layers, we need to reduce the output tensor of the `TransformerEncoder` part of\n", - "our model down to a vector of features for each data point in the current\n", - "batch. A common way to achieve this is to use a pooling layer. For\n", - "this example, a `GlobalAveragePooling1D` layer is sufficient." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "zxOnY6GSh0vr" - }, - "outputs": [], - "source": [ - "def build_model(\n", - " input_shape,\n", - " head_size,\n", - " num_heads,\n", - " ff_dim,\n", - " num_transformer_blocks,\n", - " mlp_units,\n", - " dropout=0,\n", - " mlp_dropout=0,\n", - " ):\n", - " \n", - " inputs = keras.Input(shape=input_shape)\n", - " x = inputs\n", - " for _ in range(num_transformer_blocks):\n", - " x = transformer_encoder(x, head_size, num_heads, ff_dim, dropout)\n", - "\n", - " x = layers.GlobalAveragePooling1D(data_format=\"channels_first\")(x)\n", - " for dim in mlp_units:\n", - " x = layers.Dense(dim, activation=\"relu\")(x)\n", - " x = layers.Dropout(mlp_dropout)(x)\n", - " outputs = layers.Dense(n_classes, activation=\"softmax\")(x)\n", - " \n", - " return keras.Model(inputs, outputs)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8FFG41R6h0vs" - }, - "source": [ - "## Setup model" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "l8CubWn7h0vs" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-09 09:30:36.540654: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:36.575651: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:36.575998: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:36.579240: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:36.579514: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:36.579696: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:37.110670: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:37.110955: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:37.111139: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:996] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-09 09:30:37.111287: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 6202 MB memory: -> device: 0, name: NVIDIA RTX A2000 8GB Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_1 (InputLayer) [(None, 450, 1)] 0 [] \n", - " \n", - " layer_normalization (LayerNorm (None, 450, 1) 2 ['input_1[0][0]'] \n", - " alization) \n", - " \n", - " multi_head_attention (MultiHea (None, 450, 1) 7169 ['layer_normalization[0][0]', \n", - " dAttention) 'layer_normalization[0][0]'] \n", - " \n", - " dropout (Dropout) (None, 450, 1) 0 ['multi_head_attention[0][0]'] \n", - " \n", - " tf.__operators__.add (TFOpLamb (None, 450, 1) 0 ['dropout[0][0]', \n", - " da) 'input_1[0][0]'] \n", - " \n", - " layer_normalization_1 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d (Conv1D) (None, 450, 4) 8 ['layer_normalization_1[0][0]'] \n", - " \n", - " dropout_1 (Dropout) (None, 450, 4) 0 ['conv1d[0][0]'] \n", - " \n", - " conv1d_1 (Conv1D) (None, 450, 1) 5 ['dropout_1[0][0]'] \n", - " \n", - " tf.__operators__.add_1 (TFOpLa (None, 450, 1) 0 ['conv1d_1[0][0]', \n", - " mbda) 'tf.__operators__.add[0][0]'] \n", - " \n", - " layer_normalization_2 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_1[0][0]'] \n", - " rmalization) \n", - " \n", - " multi_head_attention_1 (MultiH (None, 450, 1) 7169 ['layer_normalization_2[0][0]', \n", - " eadAttention) 'layer_normalization_2[0][0]'] \n", - " \n", - " dropout_2 (Dropout) (None, 450, 1) 0 ['multi_head_attention_1[0][0]'] \n", - " \n", - " tf.__operators__.add_2 (TFOpLa (None, 450, 1) 0 ['dropout_2[0][0]', \n", - " mbda) 'tf.__operators__.add_1[0][0]'] \n", - " \n", - " layer_normalization_3 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_2[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d_2 (Conv1D) (None, 450, 4) 8 ['layer_normalization_3[0][0]'] \n", - " \n", - " dropout_3 (Dropout) (None, 450, 4) 0 ['conv1d_2[0][0]'] \n", - " \n", - " conv1d_3 (Conv1D) (None, 450, 1) 5 ['dropout_3[0][0]'] \n", - " \n", - " tf.__operators__.add_3 (TFOpLa (None, 450, 1) 0 ['conv1d_3[0][0]', \n", - " mbda) 'tf.__operators__.add_2[0][0]'] \n", - " \n", - " layer_normalization_4 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_3[0][0]'] \n", - " rmalization) \n", - " \n", - " multi_head_attention_2 (MultiH (None, 450, 1) 7169 ['layer_normalization_4[0][0]', \n", - " eadAttention) 'layer_normalization_4[0][0]'] \n", - " \n", - " dropout_4 (Dropout) (None, 450, 1) 0 ['multi_head_attention_2[0][0]'] \n", - " \n", - " tf.__operators__.add_4 (TFOpLa (None, 450, 1) 0 ['dropout_4[0][0]', \n", - " mbda) 'tf.__operators__.add_3[0][0]'] \n", - " \n", - " layer_normalization_5 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_4[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d_4 (Conv1D) (None, 450, 4) 8 ['layer_normalization_5[0][0]'] \n", - " \n", - " dropout_5 (Dropout) (None, 450, 4) 0 ['conv1d_4[0][0]'] \n", - " \n", - " conv1d_5 (Conv1D) (None, 450, 1) 5 ['dropout_5[0][0]'] \n", - " \n", - " tf.__operators__.add_5 (TFOpLa (None, 450, 1) 0 ['conv1d_5[0][0]', \n", - " mbda) 'tf.__operators__.add_4[0][0]'] \n", - " \n", - " layer_normalization_6 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_5[0][0]'] \n", - " rmalization) \n", - " \n", - " multi_head_attention_3 (MultiH (None, 450, 1) 7169 ['layer_normalization_6[0][0]', \n", - " eadAttention) 'layer_normalization_6[0][0]'] \n", - " \n", - " dropout_6 (Dropout) (None, 450, 1) 0 ['multi_head_attention_3[0][0]'] \n", - " \n", - " tf.__operators__.add_6 (TFOpLa (None, 450, 1) 0 ['dropout_6[0][0]', \n", - " mbda) 'tf.__operators__.add_5[0][0]'] \n", - " \n", - " layer_normalization_7 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_6[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d_6 (Conv1D) (None, 450, 4) 8 ['layer_normalization_7[0][0]'] \n", - " \n", - " dropout_7 (Dropout) (None, 450, 4) 0 ['conv1d_6[0][0]'] \n", - " \n", - " conv1d_7 (Conv1D) (None, 450, 1) 5 ['dropout_7[0][0]'] \n", - " \n", - " tf.__operators__.add_7 (TFOpLa (None, 450, 1) 0 ['conv1d_7[0][0]', \n", - " mbda) 'tf.__operators__.add_6[0][0]'] \n", - " \n", - " global_average_pooling1d (Glob (None, 450) 0 ['tf.__operators__.add_7[0][0]'] \n", - " alAveragePooling1D) \n", - " \n", - " dense (Dense) (None, 128) 57728 ['global_average_pooling1d[0][0]'\n", - " ] \n", - " \n", - " dropout_8 (Dropout) (None, 128) 0 ['dense[0][0]'] \n", - " \n", - " dense_1 (Dense) (None, 2) 258 ['dropout_8[0][0]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 86,730\n", - "Trainable params: 86,730\n", - "Non-trainable params: 0\n", - "__________________________________________________________________________________________________\n", - "input_shape: (450, 1)\n" - ] - } - ], - "source": [ - "input_shape = x_train.shape[1:]\n", - "\n", - "# epoch_number = 2\n", - "# epoch_number = 10\n", - "# epoch_number = 25\n", - "epoch_number = 50\n", - "# epoch_number = 100\n", - "# epoch_number = 200\n", - "# epoch_number = 300\n", - "# epoch_number = 500\n", - "\n", - "batch_size = 4\n", - "# batch_size = 8\n", - "# batch_size = 16\n", - "# batch_size = 32\n", - "# batch_size = 64 #< OOM\n", - "\n", - "\n", - "## Transformer settings \n", - "head_size=256; num_heads=4; num_transformer_blocks = 4\n", - "# head_size=256; num_heads=4; num_transformer_blocks = 8\n", - "# head_size=512; num_heads=4; num_transformer_blocks = 4\n", - "# head_size=1024; num_heads=4; num_transformer_blocks = 4\n", - "# head_size=1024; num_heads=8; num_transformer_blocks = 8\n", - "\n", - "\n", - "\n", - "##Number of epochs with no improvement after which training will be stopped.\n", - "# callbacks_patience = 10 \n", - "callbacks_patience = 50 \n", - "\n", - "\n", - "\n", - "model = build_model(\n", - " input_shape,\n", - " head_size=head_size,\n", - " num_heads=num_heads,\n", - " ff_dim=4,\n", - " num_transformer_blocks=num_transformer_blocks,\n", - " mlp_units=[128],\n", - " mlp_dropout=0.4,\n", - " dropout=0.25,\n", - ")\n", - "\n", - "model.compile(\n", - " loss=\"sparse_categorical_crossentropy\",\n", - " optimizer=keras.optimizers.Adam(learning_rate=1e-4),\n", - " metrics=[\"sparse_categorical_accuracy\"],\n", - ")\n", - "model.summary()\n", - "\n", - "callbacks = [\n", - " keras.callbacks.ModelCheckpoint(\"best_transforer_model.h5\", save_best_only=True, monitor=\"val_loss\"),\n", - " keras.callbacks.EarlyStopping(patience=callbacks_patience, restore_best_weights=True)\n", - "]\n", - "\n", - "#other callbacks\n", - "# keras.callbacks.ReduceLROnPlateau(monitor=\"val_loss\", factor=0.5, patience=20, min_lr=0.0001),\n", - "# keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=50, verbose=1),\n", - "\n", - "print(f'input_shape: {input_shape}')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "keras.utils.plot_model(model, show_shapes=True)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train the model" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/50\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-09 09:30:44.834665: I tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:637] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n", - "2023-08-09 09:30:45.023167: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8800\n", - "2023-08-09 09:30:46.047494: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7f57b0e198f0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", - "2023-08-09 09:30:46.047525: I tensorflow/compiler/xla/service/service.cc:177] StreamExecutor device (0): NVIDIA RTX A2000 8GB Laptop GPU, Compute Capability 8.6\n", - "2023-08-09 09:30:46.052966: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", - "2023-08-09 09:30:46.296594: I ./tensorflow/compiler/jit/device_compiler.h:180] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "700/700 [==============================] - 42s 37ms/step - loss: 0.9513 - sparse_categorical_accuracy: 0.5032 - val_loss: 0.7548 - val_sparse_categorical_accuracy: 0.5300\n", - "Epoch 2/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.8309 - sparse_categorical_accuracy: 0.5136 - val_loss: 0.7472 - val_sparse_categorical_accuracy: 0.5000\n", - "Epoch 3/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.7504 - sparse_categorical_accuracy: 0.5400 - val_loss: 0.7289 - val_sparse_categorical_accuracy: 0.4886\n", - "Epoch 4/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.7030 - sparse_categorical_accuracy: 0.5671 - val_loss: 0.7149 - val_sparse_categorical_accuracy: 0.5329\n", - "Epoch 5/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.6835 - sparse_categorical_accuracy: 0.5789 - val_loss: 0.7219 - val_sparse_categorical_accuracy: 0.5157\n", - "Epoch 6/50\n", - "700/700 [==============================] - 26s 36ms/step - loss: 0.6647 - sparse_categorical_accuracy: 0.6071 - val_loss: 0.7128 - val_sparse_categorical_accuracy: 0.5114\n", - "Epoch 7/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.6543 - sparse_categorical_accuracy: 0.6189 - val_loss: 0.7258 - val_sparse_categorical_accuracy: 0.4971\n", - "Epoch 8/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.6463 - sparse_categorical_accuracy: 0.6246 - val_loss: 0.7320 - val_sparse_categorical_accuracy: 0.5100\n", - "Epoch 9/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.6277 - sparse_categorical_accuracy: 0.6471 - val_loss: 0.7381 - val_sparse_categorical_accuracy: 0.4914\n", - "Epoch 10/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.6147 - sparse_categorical_accuracy: 0.6600 - val_loss: 0.7460 - val_sparse_categorical_accuracy: 0.4971\n", - "Epoch 11/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.6026 - sparse_categorical_accuracy: 0.6764 - val_loss: 0.7442 - val_sparse_categorical_accuracy: 0.5100\n", - "Epoch 12/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5920 - sparse_categorical_accuracy: 0.7018 - val_loss: 0.7567 - val_sparse_categorical_accuracy: 0.4814\n", - "Epoch 13/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5734 - sparse_categorical_accuracy: 0.6975 - val_loss: 0.7578 - val_sparse_categorical_accuracy: 0.5029\n", - "Epoch 14/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.5689 - sparse_categorical_accuracy: 0.7146 - val_loss: 0.7533 - val_sparse_categorical_accuracy: 0.4943\n", - "Epoch 15/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5625 - sparse_categorical_accuracy: 0.7096 - val_loss: 0.7432 - val_sparse_categorical_accuracy: 0.5043\n", - "Epoch 16/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.5434 - sparse_categorical_accuracy: 0.7332 - val_loss: 0.7620 - val_sparse_categorical_accuracy: 0.4786\n", - "Epoch 17/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5379 - sparse_categorical_accuracy: 0.7311 - val_loss: 0.7644 - val_sparse_categorical_accuracy: 0.4929\n", - "Epoch 18/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5301 - sparse_categorical_accuracy: 0.7361 - val_loss: 0.7673 - val_sparse_categorical_accuracy: 0.4900\n", - "Epoch 19/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.5132 - sparse_categorical_accuracy: 0.7479 - val_loss: 0.7732 - val_sparse_categorical_accuracy: 0.4686\n", - "Epoch 20/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5035 - sparse_categorical_accuracy: 0.7564 - val_loss: 0.7776 - val_sparse_categorical_accuracy: 0.4686\n", - "Epoch 21/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.5073 - sparse_categorical_accuracy: 0.7554 - val_loss: 0.7831 - val_sparse_categorical_accuracy: 0.4729\n", - "Epoch 22/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.4936 - sparse_categorical_accuracy: 0.7718 - val_loss: 0.7881 - val_sparse_categorical_accuracy: 0.4800\n", - "Epoch 23/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.4853 - sparse_categorical_accuracy: 0.7754 - val_loss: 0.8171 - val_sparse_categorical_accuracy: 0.4971\n", - "Epoch 24/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.4804 - sparse_categorical_accuracy: 0.7707 - val_loss: 0.8008 - val_sparse_categorical_accuracy: 0.4957\n", - "Epoch 25/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.4750 - sparse_categorical_accuracy: 0.7843 - val_loss: 0.8061 - val_sparse_categorical_accuracy: 0.4757\n", - "Epoch 26/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.4469 - sparse_categorical_accuracy: 0.7961 - val_loss: 0.8131 - val_sparse_categorical_accuracy: 0.4786\n", - "Epoch 27/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.4530 - sparse_categorical_accuracy: 0.7971 - val_loss: 0.8211 - val_sparse_categorical_accuracy: 0.4671\n", - "Epoch 28/50\n", - "700/700 [==============================] - 24s 35ms/step - loss: 0.4427 - sparse_categorical_accuracy: 0.7975 - val_loss: 0.8486 - val_sparse_categorical_accuracy: 0.4614\n", - "Epoch 29/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.4392 - sparse_categorical_accuracy: 0.8093 - val_loss: 0.8327 - val_sparse_categorical_accuracy: 0.4800\n", - "Epoch 30/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.4332 - sparse_categorical_accuracy: 0.8111 - val_loss: 0.8295 - val_sparse_categorical_accuracy: 0.4657\n", - "Epoch 31/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.4163 - sparse_categorical_accuracy: 0.8225 - val_loss: 0.8484 - val_sparse_categorical_accuracy: 0.4714\n", - "Epoch 32/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.4133 - sparse_categorical_accuracy: 0.8179 - val_loss: 0.8691 - val_sparse_categorical_accuracy: 0.4657\n", - "Epoch 33/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.4042 - sparse_categorical_accuracy: 0.8264 - val_loss: 0.8683 - val_sparse_categorical_accuracy: 0.4614\n", - "Epoch 34/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3998 - sparse_categorical_accuracy: 0.8304 - val_loss: 0.8673 - val_sparse_categorical_accuracy: 0.4886\n", - "Epoch 35/50\n", - "700/700 [==============================] - 26s 37ms/step - loss: 0.4086 - sparse_categorical_accuracy: 0.8246 - val_loss: 0.8661 - val_sparse_categorical_accuracy: 0.4714\n", - "Epoch 36/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3981 - sparse_categorical_accuracy: 0.8282 - val_loss: 0.8798 - val_sparse_categorical_accuracy: 0.4843\n", - "Epoch 37/50\n", - "700/700 [==============================] - 27s 38ms/step - loss: 0.3912 - sparse_categorical_accuracy: 0.8329 - val_loss: 0.8816 - val_sparse_categorical_accuracy: 0.4771\n", - "Epoch 38/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3870 - sparse_categorical_accuracy: 0.8332 - val_loss: 0.8902 - val_sparse_categorical_accuracy: 0.4671\n", - "Epoch 39/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.3812 - sparse_categorical_accuracy: 0.8357 - val_loss: 0.9107 - val_sparse_categorical_accuracy: 0.4671\n", - "Epoch 40/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3711 - sparse_categorical_accuracy: 0.8457 - val_loss: 0.9038 - val_sparse_categorical_accuracy: 0.4671\n", - "Epoch 41/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3781 - sparse_categorical_accuracy: 0.8393 - val_loss: 0.9013 - val_sparse_categorical_accuracy: 0.4757\n", - "Epoch 42/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3608 - sparse_categorical_accuracy: 0.8511 - val_loss: 0.9095 - val_sparse_categorical_accuracy: 0.4600\n", - "Epoch 43/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3696 - sparse_categorical_accuracy: 0.8468 - val_loss: 0.9397 - val_sparse_categorical_accuracy: 0.4729\n", - "Epoch 44/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3506 - sparse_categorical_accuracy: 0.8596 - val_loss: 0.9483 - val_sparse_categorical_accuracy: 0.4714\n", - "Epoch 45/50\n", - "700/700 [==============================] - 26s 37ms/step - loss: 0.3460 - sparse_categorical_accuracy: 0.8629 - val_loss: 0.9469 - val_sparse_categorical_accuracy: 0.4643\n", - "Epoch 46/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3281 - sparse_categorical_accuracy: 0.8704 - val_loss: 0.9692 - val_sparse_categorical_accuracy: 0.4514\n", - "Epoch 47/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3444 - sparse_categorical_accuracy: 0.8554 - val_loss: 0.9600 - val_sparse_categorical_accuracy: 0.4500\n", - "Epoch 48/50\n", - "700/700 [==============================] - 25s 35ms/step - loss: 0.3226 - sparse_categorical_accuracy: 0.8679 - val_loss: 0.9673 - val_sparse_categorical_accuracy: 0.4514\n", - "Epoch 49/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3367 - sparse_categorical_accuracy: 0.8611 - val_loss: 0.9695 - val_sparse_categorical_accuracy: 0.4643\n", - "Epoch 50/50\n", - "700/700 [==============================] - 25s 36ms/step - loss: 0.3402 - sparse_categorical_accuracy: 0.8600 - val_loss: 0.9865 - val_sparse_categorical_accuracy: 0.4386\n" - ] - } - ], - "source": [ - "# fit network\n", - "history = model.fit(\n", - " x_train,\n", - " y_train,\n", - " validation_split=0.2,\n", - " epochs=epoch_number,\n", - " batch_size=batch_size,\n", - " callbacks=callbacks,\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plot the model's training and validation loss" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "history.params: {'verbose': 1, 'epochs': 50, 'steps': 700}\n", - "history.history.keys(): dict_keys(['loss', 'sparse_categorical_accuracy', 'val_loss', 'val_sparse_categorical_accuracy'])\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "metric = \"sparse_categorical_accuracy\"\n", - "\n", - "print(f'history.params: {history.params}' )\n", - "print(f'history.history.keys(): {history.history.keys()}')\n", - "\n", - "fig = plt.figure(figsize=(12,5))\n", - "fig.suptitle(\"title\")\n", - "ax1 = fig.add_subplot()\n", - "ax2 = ax1.twinx()\n", - "\n", - "ax1.plot(history.history['sparse_categorical_accuracy'], color='darkgreen', label = 'train_acc', linestyle='solid')\n", - "ax1.plot(history.history['val_sparse_categorical_accuracy'], color='green', label = 'val_acc',linestyle='--')\n", - "\n", - "ax2.plot(history.history['loss'], color='firebrick', label = 'train_loss', linestyle='solid')\n", - "ax2.plot(history.history['val_loss'], color='red', label = 'val_loss',linestyle='--')\n", - "\n", - "ax1.set_ylabel(\"accuracy\")\n", - "ax2.set_ylabel(\"loss\")\n", - "\n", - "ax1.legend(loc = 'lower left')\n", - "ax2.legend(loc = 'upper left')\n", - "\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluate model on test data" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "300/300 [==============================] - 4s 12ms/step - loss: 0.7174 - sparse_categorical_accuracy: 0.4800\n", - "=============================\n", - "=============================\n", - "Test accuracy 47.999998927116394 and Test loss 71.73838019371033\n", - "=============================\n", - "=============================\n" - ] - } - ], - "source": [ - "loaded_model = keras.models.load_model(\"best_transforer_model.h5\")\n", - "test_loss, test_acc = loaded_model.evaluate(x_test, \n", - " y_test, \n", - " batch_size=batch_size,\n", - " verbose=1)\n", - "\n", - "print(f'=============================')\n", - "print(f'=============================')\n", - "print(f'Test accuracy {test_acc*100} and Test loss {test_loss*100}')\n", - "print(f'=============================')\n", - "print(f'=============================')" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_1 (InputLayer) [(None, 450, 1)] 0 [] \n", - " \n", - " layer_normalization (LayerNorm (None, 450, 1) 2 ['input_1[0][0]'] \n", - " alization) \n", - " \n", - " multi_head_attention (MultiHea (None, 450, 1) 7169 ['layer_normalization[0][0]', \n", - " dAttention) 'layer_normalization[0][0]'] \n", - " \n", - " dropout (Dropout) (None, 450, 1) 0 ['multi_head_attention[0][0]'] \n", - " \n", - " tf.__operators__.add (TFOpLamb (None, 450, 1) 0 ['dropout[0][0]', \n", - " da) 'input_1[0][0]'] \n", - " \n", - " layer_normalization_1 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d (Conv1D) (None, 450, 4) 8 ['layer_normalization_1[0][0]'] \n", - " \n", - " dropout_1 (Dropout) (None, 450, 4) 0 ['conv1d[0][0]'] \n", - " \n", - " conv1d_1 (Conv1D) (None, 450, 1) 5 ['dropout_1[0][0]'] \n", - " \n", - " tf.__operators__.add_1 (TFOpLa (None, 450, 1) 0 ['conv1d_1[0][0]', \n", - " mbda) 'tf.__operators__.add[0][0]'] \n", - " \n", - " layer_normalization_2 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_1[0][0]'] \n", - " rmalization) \n", - " \n", - " multi_head_attention_1 (MultiH (None, 450, 1) 7169 ['layer_normalization_2[0][0]', \n", - " eadAttention) 'layer_normalization_2[0][0]'] \n", - " \n", - " dropout_2 (Dropout) (None, 450, 1) 0 ['multi_head_attention_1[0][0]'] \n", - " \n", - " tf.__operators__.add_2 (TFOpLa (None, 450, 1) 0 ['dropout_2[0][0]', \n", - " mbda) 'tf.__operators__.add_1[0][0]'] \n", - " \n", - " layer_normalization_3 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_2[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d_2 (Conv1D) (None, 450, 4) 8 ['layer_normalization_3[0][0]'] \n", - " \n", - " dropout_3 (Dropout) (None, 450, 4) 0 ['conv1d_2[0][0]'] \n", - " \n", - " conv1d_3 (Conv1D) (None, 450, 1) 5 ['dropout_3[0][0]'] \n", - " \n", - " tf.__operators__.add_3 (TFOpLa (None, 450, 1) 0 ['conv1d_3[0][0]', \n", - " mbda) 'tf.__operators__.add_2[0][0]'] \n", - " \n", - " layer_normalization_4 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_3[0][0]'] \n", - " rmalization) \n", - " \n", - " multi_head_attention_2 (MultiH (None, 450, 1) 7169 ['layer_normalization_4[0][0]', \n", - " eadAttention) 'layer_normalization_4[0][0]'] \n", - " \n", - " dropout_4 (Dropout) (None, 450, 1) 0 ['multi_head_attention_2[0][0]'] \n", - " \n", - " tf.__operators__.add_4 (TFOpLa (None, 450, 1) 0 ['dropout_4[0][0]', \n", - " mbda) 'tf.__operators__.add_3[0][0]'] \n", - " \n", - " layer_normalization_5 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_4[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d_4 (Conv1D) (None, 450, 4) 8 ['layer_normalization_5[0][0]'] \n", - " \n", - " dropout_5 (Dropout) (None, 450, 4) 0 ['conv1d_4[0][0]'] \n", - " \n", - " conv1d_5 (Conv1D) (None, 450, 1) 5 ['dropout_5[0][0]'] \n", - " \n", - " tf.__operators__.add_5 (TFOpLa (None, 450, 1) 0 ['conv1d_5[0][0]', \n", - " mbda) 'tf.__operators__.add_4[0][0]'] \n", - " \n", - " layer_normalization_6 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_5[0][0]'] \n", - " rmalization) \n", - " \n", - " multi_head_attention_3 (MultiH (None, 450, 1) 7169 ['layer_normalization_6[0][0]', \n", - " eadAttention) 'layer_normalization_6[0][0]'] \n", - " \n", - " dropout_6 (Dropout) (None, 450, 1) 0 ['multi_head_attention_3[0][0]'] \n", - " \n", - " tf.__operators__.add_6 (TFOpLa (None, 450, 1) 0 ['dropout_6[0][0]', \n", - " mbda) 'tf.__operators__.add_5[0][0]'] \n", - " \n", - " layer_normalization_7 (LayerNo (None, 450, 1) 2 ['tf.__operators__.add_6[0][0]'] \n", - " rmalization) \n", - " \n", - " conv1d_6 (Conv1D) (None, 450, 4) 8 ['layer_normalization_7[0][0]'] \n", - " \n", - " dropout_7 (Dropout) (None, 450, 4) 0 ['conv1d_6[0][0]'] \n", - " \n", - " conv1d_7 (Conv1D) (None, 450, 1) 5 ['dropout_7[0][0]'] \n", - " \n", - " tf.__operators__.add_7 (TFOpLa (None, 450, 1) 0 ['conv1d_7[0][0]', \n", - " mbda) 'tf.__operators__.add_6[0][0]'] \n", - " \n", - " global_average_pooling1d (Glob (None, 450) 0 ['tf.__operators__.add_7[0][0]'] \n", - " alAveragePooling1D) \n", - " \n", - " dense (Dense) (None, 128) 57728 ['global_average_pooling1d[0][0]'\n", - " ] \n", - " \n", - " dropout_8 (Dropout) (None, 128) 0 ['dense[0][0]'] \n", - " \n", - " dense_1 (Dense) (None, 2) 258 ['dropout_8[0][0]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 86,730\n", - "Trainable params: 86,730\n", - "Non-trainable params: 0\n", - "__________________________________________________________________________________________________\n", - "None\n" - ] - } - ], - "source": [ - "#Understanding your h5 model > https://www.youtube.com/watch?v=_a-UYLfF6TE\n", - "print(loaded_model.summary())\n", - "# for layer in loaded_model.layers:\n", - " # print(layer.name)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "38/38 [==============================] - 3s 78ms/step\n" - ] - } - ], - "source": [ - "## Load model\n", - "predictions = loaded_model.predict(x_test)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x_test.shape: (1200, 450, 1), predictions.shape: (1200, 2)\n", - "Ground truth for test timeseries: 1\n", - "Predictions for each class:\n", - "\n", - "class: 0 probability: 0.56422406\n", - "class: 1 probability: 0.43577594\n", - "len(predicted_labels): 1200\n", - "[0 0 1 ... 1 1 1]\n", - "[0 0 0 ... 0 0 0]\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 55.65546539603249, 'Predicted label')" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print(f'x_test.shape: {x_test.shape}, predictions.shape: {predictions.shape}')\n", - "\n", - "index = 100 # up to 9999\n", - "print('Ground truth for test timeseries: ',y_test[index])\n", - "print('Predictions for each class:\\n')\n", - "for i in range(2):\n", - " print('class:', i, ' probability: ', predictions[index][i])\n", - "\n", - "# For each sample timeseries in the test dataset, select the class label with the highest probability.\n", - "predicted_labels = [np.argmax(i) for i in predictions]\n", - "print(f'len(predicted_labels): {len(predicted_labels)}')\n", - "\n", - "\n", - "test_pred = np.argmax(predictions, axis=1)\n", - "print(test_pred)\n", - "print(y_test)\n", - "\n", - "# cm = sklearn.metrics.confusion_matrix(y_test, test_pred)\n", - "cm = sklearn.metrics.confusion_matrix(y_test, test_pred)\n", - "\n", - "\n", - "class_names = ['c0', 'c1']\n", - "\n", - "figure = plt.figure(figsize=(5, 5))\n", - "plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n", - "plt.title(\"Confusion matrix\")\n", - "plt.colorbar()\n", - "tick_marks = np.arange(len(class_names))\n", - "plt.xticks(tick_marks, class_names, rotation=45)\n", - "plt.yticks(tick_marks, class_names)\n", - "\n", - "# Normalize the confusion matrix.\n", - "cm = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], decimals=2)\n", - "# Use white text if squares are dark; otherwise black.\n", - "threshold = cm.max() / 2.\n", - "\n", - "for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n", - " color = \"white\" if cm[i, j] > threshold else \"black\"\n", - " plt.text(j, i, cm[i, j], horizontalalignment=\"center\", color=color)\n", - "\n", - "plt.tight_layout()\n", - "plt.ylabel('True label')\n", - "plt.xlabel('Predicted label')\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aN4ikV4Qh0vt" - }, - "source": [ - "## Conclusions\n", - "\n", - "In about 110-120 epochs (25s each on Colab), the model reaches a training\n", - "accuracy of ~0.95, validation accuracy of ~84 and a testing\n", - "accuracy of ~85, without hyperparameter tuning. And that is for a model\n", - "with less than 100k parameters. Of course, parameter count and accuracy could be\n", - "improved by a hyperparameter search and a more sophisticated learning rate\n", - "schedule, or a different optimizer.\n", - "\n", - "You can use the trained model hosted on [Hugging Face Hub](https://huggingface.co/keras-io/timeseries_transformer_classification) and try the demo on [Hugging Face Spaces](https://huggingface.co/spaces/keras-io/timeseries_transformer_classification)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "name": "timeseries_transformer_classification", - "provenance": [], - "toc_visible": true - }, - "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.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}