NLP/text_classification/LSTM.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "LSTM.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Nee9skmIIuH"
      },
      "source": [
        "# The LSTM Network\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I2iNeZ4qIRmO"
      },
      "source": [
        "Long Short Term Memory networks - LSTM là một dạng của RNN được sử dụng nhằm khắc phục nhược điểm của mạng RNN truyền thống đó là vấn đề học các phụ thuộc dài hạn (long-term dependencies). Việc LSTM có thể khắc phục được vấn đề này bởi vì nó sử dụng 4 neural tương tác với nhau để hỗ trợ quá trình ghi nhớ, chỉnh sửa thông tin bên trong thay vì chỉ duy nhất 1 neural như với mô hình RNN.\n",
        "\n",
        "![image](https://colah.github.io/posts/2015-08-Understanding-LSTMs/img/LSTM3-chain.png)\n",
        "\n",
        "LSTM có thể hiểu cơ bản là sự lặp lại các module chứa các layer tương tác với nhau (Nguồn: [colah's blog](https://colah.github.io/posts/2015-08-Understanding-LSTMs/))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jyd0FpQhZPMN"
      },
      "source": [
        "Về cơ bản LSTM là một ô trạng thái (cell state), nếu không có sự tương tác với các cổng bên dưới thì mỗi ô chỉ chứa duy nhất 1 đường thẳng  nằm trên cùng chạy ngang hết cell state. Do không có sự tương tác giữa các cổng nên thông tin cơ bản sẽ không bị thay đổi.\n",
        "\n",
        "![image](https://colah.github.io/posts/2015-08-Understanding-LSTMs/img/LSTM3-C-line.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wx6iHphicYD9"
      },
      "source": [
        "# Step-by-Step LSTM Walk Through"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gkcHbnIKcY2t"
      },
      "source": [
        "## The Forget Gate\n",
        "Cổng quên nơi sẽ nhận thông tin đầu vào và hidden state trước đó và áp dụng phép biến đổi tuyến tính cùng với sigmoid function. Đầu ra của hàm sigmoid sẽ cho ra một giá trị từ 0 đến 1. Nhờ tính chất này cổng quên có thể **quên đi** những thông tin phía trước khi kết quả của sigmoid function là 0. Ngược lại với một giá trị lớn hơn 0 sẽ đại diện cho việc chúng ta sẽ ghi nhớ bao nhiêu lượng thông tin đầu.\n",
        "\n",
        "![image](https://colah.github.io/posts/2015-08-Understanding-LSTMs/img/LSTM3-focus-f.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E9xI_dJ7gkUN"
      },
      "source": [
        "Lượng thông tin $f_t$ sau đó sẽ được kết hợp với cell state trước đó. Ta có thể viết lại công thức như sau:\n",
        "\n",
        "$$\n",
        "f_t = \\sigma(U_fx_t+V_fh_{t-1}+b_f) \n",
        "$$\n",
        "\n",
        "$$\n",
        "C^{'}_t = f_tC_{t-1}\n",
        "$$\n",
        "\n",
        "Với $b_f$ là bias tại forget layer và $U_f, V_f$ là trọng số."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HVqcR8v4kL5Y"
      },
      "source": [
        "## Input gate"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x5HBc8gdkOWl"
      },
      "source": [
        "Cổng input được xem như là giải pháp cho việc lưu trữ thông tin dài hạn của LSTM. Tại đây input gate sẽ kết hợp giá trị giữa thông tin đầu vào và hidden state trước đó. Lượng thông tin sau cùng sẽ được kết hợp với lượng thông tin đầu ra tại cổng forget được minh họa dưới hình sau\n",
        "\n",
        "![imageimage](https://colah.github.io/posts/2015-08-Understanding-LSTMs/img/LSTM3-focus-i.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LqGUE5tolLzv"
      },
      "source": [
        "Với $b_i, U_i, V_i$ lần lượt là bias và trọng số tương ứng với input layer. $b_c, U_c, V_c$ lần lượt là bias và trọng số tương ứng với concat layer. Hàm sigmoid tại input layer đại diện cho việc chúng ta sẽ sử dụng bao nhiêu lượng thông tin đầu vào. Hàm tanh sẽ thể hiện cho việc quyết định lấy lượng thông tin gốc hay không. \n",
        "\n",
        "$$\n",
        "i_t = \\sigma(U_ix_t + V_ih_{t-1} + b_i)\n",
        "$$\n",
        "\n",
        "$$\n",
        "C^+_t = tanh(U_cx_t + V_ch_{t-1} + b_c)\n",
        "$$\n",
        "\n",
        "$$\n",
        "C_t = C^{'}_t + i_tC^+_t\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8xYzvEvPQga0"
      },
      "source": [
        "## Output gate\n",
        "Với cổng output chúng ta sẽ quyết định những thông tin nào sẽ được đi ra. Đầu tiên sử dụng sigmoid để lấy một phần thông tin đầu vào và hidden state. Tiếp theo kết quả sẽ được tính toán với cell state bên trong hàm tanh để cho ra phần thông tin cuối cùng.\n",
        "\n",
        "![imageimage](https://colah.github.io/posts/2015-08-Understanding-LSTMs/img/LSTM3-focus-o.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZVN8PBBrSweH"
      },
      "source": [
        "Với $b_o, U_o, V_o$ lần lượt là bias và trọng số tương ứng với output layer.\n",
        "\n",
        "$$\n",
        "o_t = \\sigma(U_ox_t+V_oh_{t-1}+b_o)\n",
        "$$\n",
        "\n",
        "$$\n",
        "h_t = o_t tanh(C_t)\n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nymtaLlSUput"
      },
      "source": [
        "# Thực nghiệm\n",
        "Sử dụng Tweet dataset được cung cấp bởi cuộc thi \"Natural Language Processing with Disaster Tweets: Predict which Tweets are about real disasters and which ones are not\" trên [**kaggle**](https://www.kaggle.com/c/nlp-getting-started)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ibqy2h6MUyeg"
      },
      "source": [
        "## Download data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zLeSQ-OxH6It",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a8690ec-3110-4655-8674-a33dc1ef9c08"
      },
      "source": [
        "!gdown --id 1jk4z9Cz1zYWrDR56x2t-jLm3dHR71TlR"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1jk4z9Cz1zYWrDR56x2t-jLm3dHR71TlR\n",
            "To: /content/tweets.csv\n",
            "\r  0% 0.00/996k [00:00<?, ?B/s]\r100% 996k/996k [00:00<00:00, 67.7MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4X13EKkMU6z-"
      },
      "source": [
        "## Download glove embeddings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yGUIn0ftVzsh"
      },
      "source": [
        "## Libs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_YsBSy6tV0rz"
      },
      "source": [
        "import re \n",
        "import os\n",
        "import random\n",
        "import math\n",
        "import numpy as np \n",
        "import pandas as pd \n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd \n",
        "import string as pystring \n",
        "\n",
        "from typing import List\n",
        "from collections import Counter \n",
        "from itertools import chain \n",
        "from tqdm import tqdm \n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn \n",
        "import torch.optim as optim \n",
        "import torch.nn.functional as F \n",
        "from torch.utils.data import Dataset, DataLoader \n",
        "\n",
        "from torchtext.vocab import Vectors, GloVe\n",
        "from torchtext.legacy.data import Field, LabelField, Pipeline, TabularDataset, BucketIterator, Dataset \n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhKsV3XVuyAK"
      },
      "source": [
        "## Create dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8UJVshcuzZG"
      },
      "source": [
        "df = pd.read_csv(\"tweets.csv\")\n",
        "df = df.drop(columns=['id', 'keyword', 'location'])"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2i2ivi7NvXew",
        "outputId": "cbb05d5e-5213-41d1-dec1-20798bf2ba0f"
      },
      "source": [
        "df_train, df_test = train_test_split(df, shuffle=True)\n",
        "df_train, df_val = train_test_split(df_train, shuffle=True)\n",
        "print(df_train.shape, df_test.shape, df_val.shape)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(4281, 2) (1904, 2) (1428, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8aK-hwYEwEbz"
      },
      "source": [
        "df_train.to_csv(\"train.csv\", index=False)\n",
        "df_test.to_csv(\"test.csv\", index=False)\n",
        "df_val.to_csv(\"val.csv\", index=False)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISpKXcocV4t_"
      },
      "source": [
        "## Preprocess text"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-dzLjfBLV7ym"
      },
      "source": [
        "def preprocess_text(string):\n",
        "  p = re.compile(r'<[^<>]+>')\n",
        "  string = p.sub(\" \", string)\n",
        "  replace_chars = [\"\\n\", \"\\t\", \"_\"] + list(pystring.punctuation)\n",
        "  for char in replace_chars:\n",
        "    string = string.replace(char, \" \")\n",
        "  \n",
        "  return string.lower()"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Um7cVUJkV9YN"
      },
      "source": [
        "def load_data(input_dir, source_dir=None, batch_size=16, max_vocab=40000, min_freq=20, glove_dim=300, glove_name=\"6B\"):\n",
        "  # Read csv, preprocessing\n",
        "  print(\"[INFO] Preprocessing Data\")\n",
        "  if source_dir != None:\n",
        "      load_data_from_file(source_dir, input_path)\n",
        "  \n",
        "  tokenize = lambda x: x.split()\n",
        "  text_field = Field(sequential=True, tokenize=tokenize, lower=True, include_lengths=True, batch_first=True) # include lenth = 1000\n",
        "  label_field = LabelField()\n",
        "  \n",
        "  fields = [('text', text_field), ('target', label_field)]\n",
        "\n",
        "  train, valid, test = TabularDataset.splits(path=input_dir,\n",
        "                                             train='train.csv',\n",
        "                                             validation='val.csv',\n",
        "                                             test='train.csv',\n",
        "                                             format='CSV', fields=fields, skip_header=True)\n",
        "  \n",
        "  text_field.build_vocab(train, max_size=max_vocab, min_freq=min_freq, vectors=GloVe(name=glove_name, dim=glove_dim))\n",
        "  label_field.build_vocab(train)\n",
        "  word_embeddings = text_field.vocab.vectors\n",
        "  vocab_size = len(text_field.vocab)\n",
        "\n",
        "  print (\"[INFO] Length of Text Vocabulary: \" + str(len(text_field.vocab)))\n",
        "  print (\"[INFO] Vector size of Text Vocabulary: \", text_field.vocab.vectors.size())\n",
        "  print (\"[INFO] Label Length: \" + str(len(label_field.vocab)))\n",
        "\n",
        "  train_loader, valid_loader, test_loader = BucketIterator.splits((train, valid, test),\n",
        "                                                              batch_size=32, sort_key=lambda x: len(x.text),\n",
        "                                                              repeat=False, sort=True, shuffle=True)\n",
        "  \n",
        "  return text_field, vocab_size, word_embeddings, train_loader, valid_loader, test_loader"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5UVp7IjQV_Tw",
        "outputId": "68bd9c75-f082-4599-b91e-6c8454e48c57"
      },
      "source": [
        "text_field, vocab_size, word_embeddings, train_loader, valid_loader, test_loader = load_data(\".\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[INFO] Preprocessing Data\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            ".vector_cache/glove.6B.zip: 862MB [02:41, 5.34MB/s]                           \n",
            "100%|█████████▉| 399999/400000 [00:48<00:00, 8299.98it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[INFO] Length of Text Vocabulary: 371\n",
            "[INFO] Vector size of Text Vocabulary:  torch.Size([371, 300])\n",
            "[INFO] Label Length: 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8alrXtiMbK4H"
      },
      "source": [
        "class LSTMClassifier(nn.Module):\n",
        "  def __init__(self, vocab_size, output_size=2, hidden_size=256, embedding_size=300, weights=None, dropout_ratio=0.5, LSTM_layers=1):\n",
        "    super(LSTMClassifier, self).__init__()\n",
        "\n",
        "    self.output_size = output_size\n",
        "    self.hidden_size = hidden_size\n",
        "    self.vocab_size = vocab_size\n",
        "    self.embedding_size = embedding_size\n",
        "\n",
        "    self.word_embeddings = nn.Embedding(vocab_size, embedding_size)\n",
        "    if weights != None:\n",
        "      self.word_embeddings.weight = nn.Parameter(weights, requires_grad=False)\n",
        "\n",
        "    self.lstm = nn.LSTM(embedding_size, hidden_size, LSTM_layers, batch_first=True, dropout=dropout_ratio)\n",
        "    self.fc = nn.Linear(hidden_size, output_size)\n",
        "\n",
        "\n",
        "  def forward(self, input):\n",
        "    input_embedding = self.word_embeddings(input)\n",
        "\n",
        "    output_lstm, (final_hidden_state, final_cell_state) = self.lstm(input_embedding)\n",
        "\n",
        "    final_output = self.fc(final_hidden_state[-1,:,:])\n",
        "    final_output = torch.squeeze(final_output)\n",
        "\n",
        "    return final_output"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "agwwBRUXd021"
      },
      "source": [
        "## Train"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tm0ug8h_d11X",
        "outputId": "7587f4fd-263d-4c75-f051-2ee04efbd152"
      },
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "model = LSTMClassifier(vocab_size=vocab_size, weights=word_embeddings)\n",
        "model.to(device)\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/nn/modules/rnn.py:65: UserWarning: dropout option adds dropout after all but last recurrent layer, so non-zero dropout expects num_layers greater than 1, but got dropout=0.5 and num_layers=1\n",
            "  \"num_layers={}\".format(dropout, num_layers))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tbae73nieGWZ"
      },
      "source": [
        "def evaluate(model, val_loader):\n",
        "    model.eval()\n",
        "    valid_loss = 0\n",
        "    nparr_predict_all = np.array([], dtype=int)\n",
        "    nparr_label_all = np.array([], dtype=int)\n",
        "    with torch.no_grad():\n",
        "        for _ , (data, label) in enumerate(val_loader):      \n",
        "            (input, len_input) = data     \n",
        "            input = input.to(device)\n",
        "            label = label.to(device)\n",
        "\n",
        "            y_pred = model(input)\n",
        "\n",
        "            loss = F.cross_entropy(y_pred, label)\n",
        "\n",
        "            valid_loss += loss.item()\n",
        "\n",
        "            label = label.data.cpu().numpy()\n",
        "            predict = torch.max(y_pred.data, 1)[1].cpu().numpy()\n",
        "            nparr_label_all = np.append(nparr_label_all, label)\n",
        "            nparr_predict_all = np.append(nparr_predict_all, predict)\n",
        "    \n",
        "    val_epoch_loss = valid_loss / len(val_loader)\n",
        "    val_epoch_acc = accuracy_score(nparr_label_all, nparr_predict_all)\n",
        "    val_precision = precision_score(nparr_label_all, nparr_predict_all)\n",
        "    val_recall= recall_score(nparr_label_all, nparr_predict_all)\n",
        "    val_f1_score = f1_score(nparr_label_all, nparr_predict_all)\n",
        "\n",
        "    return val_epoch_loss, val_epoch_acc, val_precision, val_recall, val_f1_score\n",
        "\n",
        "def train_model(model, model_dir, model_name, train_loader, val_loader, optimizer, n_epochs=25, eval_every=100):\n",
        "    \"\"\"returns trained model\"\"\"\n",
        "    # initialize tracker for minimum validation loss\n",
        "    new_model_dir = os.path.join(model_dir, model_name)\n",
        "    if not os.path.exists(new_model_dir):\n",
        "      os.mkdir(new_model_dir)\n",
        "\n",
        "    valid_loss_min = np.Inf\n",
        "    global_step = 0 \n",
        "    global_steps_list = []\n",
        "    train_loss_list, train_acc_list = [], []\n",
        "    valid_loss_list, valid_acc_list = [], []\n",
        "\n",
        "    train_precision_list, valid_precision_list = [], []\n",
        "    train_recall_list, valid_recall_list = [], []\n",
        "    train_f1_list, valid_f1_list = [], []\n",
        "\n",
        "    # train the model \n",
        "    model.train()\n",
        "    for epoch in range(1, n_epochs):\n",
        "        train_loss = 0\n",
        "\n",
        "        nparr_predict_all = np.array([], dtype=int)\n",
        "        nparr_label_all = np.array([], dtype=int)\n",
        "        for _ , (data, label) in enumerate(train_loader):\n",
        "            (input, len_input) = data         \n",
        "            input = input.to(device)\n",
        "            label = label.to(device)\n",
        "\n",
        "            y_pred = model(input)\n",
        "\n",
        "            loss = F.cross_entropy(y_pred, label)\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            # update running value\n",
        "            train_loss += loss.item()\n",
        "            global_step += 1\n",
        "\n",
        "            label = label.data.cpu().numpy()\n",
        "            predict = torch.max(y_pred.data, 1)[1].cpu().numpy()\n",
        "            nparr_label_all = np.append(nparr_label_all, label)\n",
        "            nparr_predict_all = np.append(nparr_predict_all, predict)\n",
        "        \n",
        "        train_epoch_loss = train_loss / len(train_loader)\n",
        "        train_epoch_acc = accuracy_score(nparr_label_all, nparr_predict_all)\n",
        "        train_precision = precision_score(nparr_label_all, nparr_predict_all)\n",
        "        train_recall= recall_score(nparr_label_all, nparr_predict_all)\n",
        "        train_f1_score = f1_score(nparr_label_all, nparr_predict_all)\n",
        "                    \n",
        "        # validate the model \n",
        "        val_epoch_loss, val_epoch_acc, val_precision, val_recall, val_f1_score = evaluate(model, val_loader)\n",
        "\n",
        "        # add history\n",
        "        train_loss_list.append(train_epoch_loss) \n",
        "        train_acc_list.append(train_epoch_acc)\n",
        "        train_precision_list.append(train_precision)\n",
        "        train_recall_list.append(train_recall)\n",
        "        train_f1_list.append(train_f1_score)\n",
        "\n",
        "        valid_loss_list.append(val_epoch_loss)\n",
        "        valid_acc_list.append(val_epoch_acc)\n",
        "        valid_precision_list.append(val_precision)\n",
        "        valid_recall_list.append(val_recall)\n",
        "        valid_f1_list.append(val_f1_score)\n",
        "\n",
        "        # reset training\n",
        "        model.train()\n",
        "        \n",
        "        # print training/validation statistics \n",
        "        print('Epoch: {}, Training Loss: {:.6f}, Training Acc: {:.6} || Validation Loss: {:.6f}, Validation Acc: {:.6f}'.\n",
        "              format(epoch, train_epoch_loss, train_epoch_acc, val_epoch_loss, val_epoch_acc))\n",
        "        \n",
        "        ## TODO: save the model if validation loss has decreased\n",
        "        if val_epoch_loss < valid_loss_min:\n",
        "            save_model_name = \"{}_loss_{:.6f}_acc_{:.6f}.pt\".format(model_name, val_epoch_loss, val_epoch_acc)\n",
        "            model_path = os.path.join(new_model_dir, save_model_name)\n",
        "            torch.save(model, model_path)\n",
        "            print('Validation loss decreased ({:.6f} --> {:.6f}).  Saving {} ....'.format(\n",
        "            valid_loss_min,\n",
        "            val_epoch_loss,\n",
        "            model_path))\n",
        "            valid_loss_min = val_epoch_loss\n",
        "        \n",
        "            \n",
        "    # return trained model\n",
        "    return model, save_model_name, train_loss_list, train_acc_list, valid_loss_list, valid_acc_list"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YoIlXVWBfSyJ",
        "outputId": "01b8de91-c207-4053-d831-d8d1eaf44054"
      },
      "source": [
        "model_dir = \"models\"\n",
        "model_name = \"lstm\"\n",
        "if not os.path.exists(model_dir):\n",
        "  os.mkdir(model_dir)\n",
        "\n",
        "trained_model, save_model_name, train_loss_list, train_acc_list, valid_loss_list, valid_acc_list = \\\n",
        "    train_model(model, model_dir, model_name, train_loader, valid_loader, optimizer, n_epochs=5, eval_every=100)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 1, Training Loss: 0.578326, Training Acc: 0.697267 || Validation Loss: 0.555395, Validation Acc: 0.721289\n",
            "Validation loss decreased (inf --> 0.555395).  Saving models/lstm/lstm_loss_0.555395_acc_0.721289.pt ....\n",
            "Epoch: 2, Training Loss: 0.529002, Training Acc: 0.750759 || Validation Loss: 0.582289, Validation Acc: 0.706583\n",
            "Epoch: 3, Training Loss: 0.517674, Training Acc: 0.758 || Validation Loss: 0.619588, Validation Acc: 0.640756\n",
            "Epoch: 4, Training Loss: 0.519845, Training Acc: 0.758234 || Validation Loss: 0.582466, Validation Acc: 0.704482\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 323
        },
        "id": "A48qbmU24XzD",
        "outputId": "b82bbfbf-eb19-48cf-94ea-f9704f0edbc9"
      },
      "source": [
        "plt.style.use('seaborn')\n",
        "train_losses = np.array(train_loss_list)\n",
        "valid_losses = np.array(valid_loss_list)\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(8, 4.5))\n",
        "\n",
        "ax.plot(train_losses, color=\"blue\", label=\"Training_losses\")\n",
        "ax.plot(valid_losses, color=\"red\", label=\"Valid_losses\")\n",
        "ax.set(title=\"Loss over epochs\",\n",
        "       xlabel=\"Epoch\",\n",
        "       ylabel=\"loss\")\n",
        "ax.legend()\n",
        "fig.show()\n",
        "\n",
        "plt.style.use('default')"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfgAAAEyCAYAAAAWW8KtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hTZfvA8W9mk7a0TREKKiAqryJbtuwyKqOAlMqUPUVBlgy17L1kyQYRFASZlSJ7yN6gvuAAi6yW0d2mzTq/P6L17Y9VoG067s91cV1NcnLOnbuhd879nDyPSlEUBSGEEELkKmpXByCEEEKIjCcFXgghhMiFpMALIYQQuZAUeCGEECIXkgIvhBBC5EJS4IUQQohcSAq8ECLXOn78OLVr13Z1GEK4hBR4IVzE39+fI0eOuDoMIUQuJQVeCJHhbDabq0MQIs+TAi9ENmOxWJgwYQI1a9akZs2aTJgwAYvFAkBUVBS9e/emUqVKVKlShfbt2+NwOABYvHgxtWrVokKFCgQEBHD06NEH7j8+Pp6PP/6YatWqUa9ePb744gscDgcWi4VKlSrx22+/pW4bFRVF2bJluXfvHgD79u2jRYsWVKpUibZt23Lp0qXUbf39/Vm8eDGBgYGUL1/+gUX+8uXLdO3alSpVqhAQEEBYWFjqY8OHDyckJISuXbtSoUIFOnbsyI0bN1IfP3PmDEFBQVSsWJGgoCDOnDmT+lhMTAwjRoygZs2aVK5cmffffz/NcZcvX0716tWpWbMmGzZsSL3/wIEDNGnShAoVKlCrVi2WLVv2+F+QEDmFIoRwiXr16imHDx++7/7PP/9cCQ4OVu7evavcu3dPadOmjTJr1ixFURRl+vTpymeffaZYLBbFYrEoJ0+eVBwOh3L58mWldu3aSkREhKIoinLt2jXl6tWrDzzu0KFDlT59+ijx8fHKtWvXlEaNGinr1q1TFEVRhg8frsycOTN129WrVyvdunVTFEVRfvnlF6VatWrKuXPnFJvNpmzcuFGpV6+ekpKSkvp6mjdvrty8eVMxm833HTcxMVGpXbu28t133ylWq1X55ZdflCpVqii///67oiiKMmzYMKV8+fLKiRMnlJSUFGXcuHFK27ZtFUVRlOjoaKVSpUrKpk2bFKvVqoSGhiqVKlVSoqKiFEVRlJ49eyoDBgxQYmJiFIvFohw/flxRFEU5duyYUrJkSeXzzz9XLBaLsn//fqVs2bJKTEyMoiiKUqNGDeXkyZOKoihKTEyM8vPPP6f79ydEdidn8EJkM6GhofTr14/8+fPj6+tLv3792Lp1KwBarZY7d+5w8+ZNdDodlSpVQqVSodFosFgsXL58GavVyosvvkjRokXv27fdbicsLIzBgwfj6enJiy++SNeuXVP3HxgYyLZt29LEEhgYCMC3335LmzZtKFeuHBqNhnfeeQedTse5c+dSt3/vvfcoXLgwBoPhvmPv37+fF154gaCgILRaLW+88QYBAQH88MMPqdvUrVuXypUro9frGThwIOfOnePWrVvs37+fYsWK0bJlS7RaLc2aNePll19m37593L59m4MHDzJmzBi8vb3R6XRUqVIldZ9arZZ+/fqh0+moU6cO7u7u/Pnnn6mP/fHHHyQkJODt7U2pUqWe5VcnRLYiBV6IbOb27ds8//zzqbeff/55bt++DUD37t0pVqwY3bp1o379+ixevBiAYsWKMXLkSObOnctbb73FwIEDiYyMvG/f0dHRWK3W+/b/z7ZVq1YlOTmZ8+fPc/36dS5dukSDBg0AuHnzJitWrKBSpUqp/yIiIlJjAyhcuPBDX9eNGze4cOFCmueHhoZy586d1G0KFSqU+rOHhwfe3t7cvn37vpz8b9wRERF4e3vj7e39wOP6+Pig1WpTbxuNRpKSkgCYM2cOBw4coF69enTs2JGzZ88+NH4hchrt4zcRQmSlggULcvPmTUqUKAHArVu3KFiwIACenp4MHz6c4cOH89tvv9G5c2fKlClD9erVCQwMJDAwkISEBEJCQpg+fTrTpk1Ls2+TyYROp+PmzZu8+uqrqfv38/MDQKPR8Pbbb/P999/z3HPPUbduXTw9PQFn8e7Tpw99+/Z9aOwqleqhjxUuXJjKlSuzYsWKh24TERGR+nNiYiKxsbEULFgwNSf/69atW9SqVYtChQoRGxtLXFwcXl5eD933g5QtW5YFCxZgtVr5+uuv+eijjzhw4MAT7UOI7ErO4IVwIavVSkpKSuo/m81G06ZNWbBgAVFRUURFRTF//vzUNvm+ffu4evUqiqKQL18+NBoNKpWKK1eucPToUSwWC3q9Hjc3N9Tq+/97/1PAZ82aRUJCAjdu3GDFihU0b948dZvAwEC2b99OaGgozZo1S70/ODiYtWvXcv78eRRFISkpif3795OQkJCu11q3bl3Cw8PZvHkzVqsVq9XKhQsXuHz5cuo2Bw4c4NSpU1gsFmbPnk25cuUoXLgwderUITw8nNDQUGw2G2FhYfzxxx/UrVuXggULUrt2bcaMGUNsbCxWq5WTJ08+Nh6LxcLWrVuJj49Hp9Ph4eHxwJwJkVPJGbwQLtSrV680t/v06cP7779PYmJiatF9++23U68Kv3r1KuPGjSMqKgovLy/atWtHtWrVuHTpEjNmzODy5cvodDoqVKjA2LFjH3jMzz77jHHjxtGgQQPc3NwIDg4mKCgo9fFy5cphNBq5fft2mkliypQpw7hx4xg7dixXr17FYDDw5ptvUqlSpXS9Vk9PT5YtW8bkyZOZPHkyiqLw2muvMWLEiNRtmjVrxvz58zl37hxvvPFGagfCZDKxcOFCJk6cyOjRoylWrBgLFy7E19cXgKlTpzJp0iQaN26M1WqlatWqVK5c+bExbdmyhXHjxmG32ylevPh9HQ8hcjKVoiiKq4MQQojhw4fj5+fHwIEDXR2KELmC9KOEEEKIXEgKvBBCCJELSYteCCGEyIXkDF4IIYTIhaTACyGEELlQrvma3J078Rm+T5PJnejopAzfb04kuUhL8pGW5ONfkou0JB9pZXQ+ChTI99DH5Az+EbRajatDyDYkF2lJPtKSfPxLcpGW5COtrMyHFHghhBAiF5ICL4QQQuRCUuCFEEKIXEgKvBBCCJELZWqBP3jwIAEBATRs2DB13er/LywsjCZNmtC0aVMGDx4MwMWLF2nTpg1NmzYlMDCQsLCwzAxTCCGEyHUy7WtydrudsWPHsmLFCvz8/GjdujX+/v6pa1ADhIeHs3jxYtasWYO3tzf37t0DwGAwMGXKFF566SUiIyMJCgqiZs2aT7zWsxBCCJFXZdoZ/IULFyhWrBhFihRBr9fTtGlT9uzZk2abdevW0aFDB7y9vQHInz8/AMWLF+ell14CwM/PD19fX6KiojIrVCGEECLXybQCHxkZSaFChVJv+/n5ERkZmWab8PBw/vzzT9q2bcu7777LwYMH79vPhQsXsFqtFC1aNLNCFUIIIXIdl85kZ7fbuXr1KqtWrSIiIoKOHTsSGhqa2oq/ffs2Q4cOZcqUKajVj/4sYjK5Z8oEAo+aJehxoqOj6dKlCwB3795FrVbj6+sLwPr169Hr9Q997k8//cSWLVv49NNPH3mMtm3bsnbt2qeO8f/buHEjP//8MyEhIfc99iy5yI0kH2lJPoADB+DHHynQty/83ZEU8t74/7IqH5lW4P38/IiIiEi9HRkZiZ+f333blCtXDp1OR5EiRXjppZcIDw+nbNmyJCQk0Lt3bwYOHEj58uUfe7zMmAqxQIF8zzgFrpalS1cDsGzZIoxGd9q3fw+A2NgUbLZEtNoH/woKFXqJ3r0HPPb4c+cuydBpeuPjkzGbLfft89lzkbtIPtLK6/lQR9zCY/QnGDZ+B4Bj5kwSPxlNcodOoMnbM7nl9ffG/5fR+XjUh4VMK/BlypQhPDyca9eu4efnx7Zt25gxY0aabRo0aMC2bdsICgoiKiqK8PBwihQpgsVioV+/frRo0YK33347s0J0iQkTRqPX6/ntt18pW7Yc9es3YvbsGVgsKbi5GRg5MoSiRV/izJlTrF27mqlTP2fZskVERkZw8+YNIiMjeffddgQHtwWgYcNa7Nr1I2fOnGL58sX4+Phw5cplXnutJCEh41CpVBw9eoi5c2dhMBgpW7YcN2/eYOrUzx8b661bN5k0aSyxsTEUKPAcQ4Z8SqFChdi7dzcrVixGrdbg6enJ/PlLuHLlMpMmjcFqtaEoDsaPn0qRIkXZsSOM775bi9Vq4403SjF48HAAJk8ex6VL/0WlUtG0aXPatOmQqXkXIlNYrRiXLsJ96kTUiQlYK7yJrnkgTJ9BviEDMKz+koQpM7FVqOjqSEUelGkFXqvVEhISQo8ePbDb7QQFBVGiRAlmz55N6dKlqV+/PrVq1eLw4cM0adIEjUbDxx9/jMlkYsuWLZw6dYqYmBg2bdoEwOTJkylZsuRTxzN6tBuhoU/2ctVqcDg8Hvp4YKCN0aNTnjiWO3dus3DhcjQaDYmJCcyfvwStVsvJk8dZtGg+EyZMu+85f/11lTlzFpKUlET79kG8807r+87+f//9V1atWsdzzxWgb9/uXLhwntdfL8m0aZOYN28xzz//AqNGjUx3nLNmTaNx42Y0btyMAwd2MHv2NCZNmsGXXy5h5sx5FChQkPh45yfRLVs2EBzcjkaNGmO1WnE47ISH/8mePbtYsGA5Wq2W6dMns3PndooXf4U7d26zatU6gNR9CJGT6I4cwnP4YLSXLuIwmYgfO4fkDp0o4OdNdFB7PEZ/imHjenze9ie5Y2cSR45Ckba9yEKZOgZfp04d6tSpk+a+AQMGpP6sUqkYMWIEI0aMSLNNixYtaNGiRWaG5lL16jVA83fbLiEhgfHjR3P9+l+oVCpsNtsDn1O9eg30ej16vR6TyURU1D0KFkw75FGyZKnU+0qU+A8RETdxdzfy/PMv8PzzLwDQsGEAW7duSlecv/xygYkTnR82WrRowdSpUwEoU6YcEyaMxt+/IXXq1AOgVKmyfPXVcm7fjqROHX+KFCnK6dMn+PXXi/To0QmAlJRkTCYTNWrU5ubNG8yaNZXq1WtSpUq19CdPCBdTR0Y4i/eGdSgqFeb3upL4SQiK77/F21GoMPELl5HcqSuewwdjXPUlbt9vIXHkKJI7ds7zbXuRNXLNcrGPM3p0yhOfbTvHShIzPBaDwZD689KlC3nzzUpMmjSdW7du8uGHvR/4HJ3u3wvy1Go1drv9vm3+96K9h22TEYYOHckvv/zM0aOH6N79PZYtW0WjRm9TqlRpjhw5xNChAxg6dCSKotC4cTP69Pngvn18+eUaTpw4ypYtG9i7dxcjR47KlFiFyDA2G8Zli3CfMhF1QjzW8hVImDwD25uVHvoU61s1id5zyPm8qZPIN/QjDKtXkjB5OraKlbMweJEXyVS1LpaQkECBAgUACAsLzfD9Fy1ajJs3b3Dr1k0A9uzZle7nli5dlt27dwAQGhpK2bIVALhx4zqlSpWmR48++PiYuH07khs3rvP88y8QHNyWmjXrcPny71SsWIX9+/cQHe2cwyAuLpaIiFvExMSgKA7q1q1Pz559+e23XzP4VQuRsXTHjmCqXwvPz0aAVkP8tM+J2b73kcX93yfrMPf5gOijp0lu3Qbd+bOYGtfHc9CHqP6e3EuIzJBnzuCzqw4dOjF+/GhWrlxG9eo1M3z/bm4GBg0axuDBH2IwGClZ8o10P3fgwI+ZOHEMa9asSr3IDmD+/Nlcv/4XiqJQsWIVXn31P6xevZIdO8LQarX4+uanU6eueHl507NnXwYO/ABFcaDRaBk0aBhubm5MmjQGh0MBoHfvfhn+uoXICKrISDzHfoZhvfOrqOaOnUn8ZPRTjaU7/AoR/8USkt/rgufwIRhXr3S27UeEkNypq7TtRYZTKYqiuDqIjJAZX8PILV/vSEpKwt3dHUVRmDFjCkWKFHniq9ZzSy4yiuQjrVyXD5sN44oluE+egDo+DmvZ8s62eqUqj31qunJhs2FcvtjZ7n/C/ec0ue698Yyy8mty0qLPA0JDN9GlS3vee+9dEhMTaNEiyNUhCZFtaY8fw9SgNp6fDAO1mvgpM4nZsS9ji69Wi7nX+0QdOU1ycFt0F85hatIAz4/6obp7N+OOI/I0OYN/hNz8yXPbtq2sX592BrwyZcoxePCwB26fm3PxNCQfaeWGfKju3HG247/9BgBz+/dI/HQMynPPPdF+niYXumNH8Bw2GO3FX3B4+5A44jOSO3fLFW373PDeyEhZeQYvBf4R5I35L8lFWpKPtHJ0Pmw2DCuX4TFpPOq4WKyly5IwZQa2ylWfandPnYv/PyxQppyzbf+UcWQXOfq9kQmkRS+EEFlAe/I4Po3qkm/EUADiJ00nZtcB1xRVrRZzz75EHT1Dcpv26H46j6lpQzwHvI/qzp2sj0fkeFLghRB5juruXTw/6oepaUN0P18guW0HZ2Ht3svlbXGlYEHi5y4kOnQntlJlMK5Zje9bFTEsWwQPmQhLiAeRAi+EyDvsdgwrluJb/U2M36zCVqoM0aE7iZ+zAOXv+SiyC1vVakTvOkD8pGmgKOQbMRRTwzpojx9zdWgih5ACL4TIE7SnT+ITUI98wwaBw0H8xKlE7zqArWo2nipZqyW5e2/n1fZtO6D95SdMgY3I92EfVLdvuzo6kc1Jgc9kH37Ym+PHj6a5b926b5g+fdIDt//gg15cuvRfAIYM6f/AhViWLVvEN9+seugxJ0wYzb59u58haiFyD9W9e3gO+hBT4/roLpwj+d12zoLZow88ZLnm7EYpWJD4OQuI/n4X1tJlMXz7jbNtv3ShtO3FQ0mBz2QNGgSwZ8/ONPft3r2TBg0CHvvc6dPnkC/fw6+QFEI8gt2OYeVyfKtXwLh6JbaSpYjZ+gPx8xah+Pk9/vnZkK1KVWJ2HSB+0nRQqcg38mNMDWqjPXb08U8WeU7O+Piag9WrV58lSxZgtVrR6XTcunWTu3fvsHv3DubOnUVKSgr16tWne/f7F5lp3TqQpUtX4ePjw8qVy9i+fRsmk4mCBf147bX0LZ176tQJ5s//HLvdzuuvv8GQISPQ6/UsWDCXw4cPotFoqFy5Gh988NED13m32+0sXDiPn346i9mczDvvBNOyZRB3795l1KgRJCYmYrfbGDJkBOXKVcjo9AnxVLRnT+M5bBC6c2dxeOYjYfxkzN165Zgz9kfSaEju3ouU5u/gMWE0xm9WYWoeQPK77UgIGYdSsKCrIxTZRC54t6ePx+hPcQvd/GRPUqvwdTx8moCUwJYkjh7/yF14eXnzxhulOHbsMLVq1WX37p34+zdMnavdbrczYEBf/vjjd159tcQD93Hp0kX27NnJl19+g91uo1u3jukq8CkpKUycOIbPP/+CokWLMW5cCJs3f0dAQBMOHtzHN99sQKVSpQ4DPGid9++/34KHhwcbNmzgxo179O3bnSpVqnHgwD6qVKlG587dsdvtpKQkPzYeITKbKuoeHhPGYlj9JSpFIbl1GxJHjcPhV8jVoWU4pUABEj6fT3KHTngOH4Jh3Rr027eRNGxk7vkwI56JtOizQIMGAeze7WzT79njbM/v3buLbt060K1bB8LDrxAefuWhz79w4Sy1a9fDYDDg4eFJzZq103Xcv/66SuHCz1O0aDEAGjduxrlzZ/Hw8ESvd2PSpLEcOLA3dfnaf9Z537p1Ew6Hc6nZkyeP8cMPYbRo0YJevboQFxfL9evXKFnyDcLCQlm2bBFXrvyBu7vHs6RIiGfjcGBY9aXz6vhVK7C/9joxm8OI/2JJrizu/8tWuSoxO/cTP2UmqNV4fjocU/1a6I4dcXVowsXyzEe8xNHjH3u2/f8VKJCPqAyYcahmzTrMmTOTX3+9RHJyMl5eXqxZs5olS77Cy8uLCRNGY7FYnvk46aXValmyZCWnT59g3749bNiwjjlzFj5wnXdFURg4cCjNmjW6b/al+fOXcOTIISZMGEObNu1p3LhZlr0GIf6hPXcGz+GD0Z05jcPDk4SxEzF37w06natDyzoaDclde5AS2NLZtv/6K3yav52rOxji8eQMPgu4u7vz5puVmDRpLA0bBpCYmIjBYMTT05OoqHsce8wn7XLl3uTHH/eTkpJMUlIihw//mK7jFi1ajFu3bnL9+jUAduwIo3z5N0lKSiIxMYHq1WvSv/9g/vjjd+DB67xXqVKdzZu/w2q1As6ugNlsJiLiFiaTL82bv0NgYAtZ011kOVV0FJ5DB+ITUA/dmdMktwom+uhpzH0+yFvF/X8ozz1Hwqx5RG/fg7VcBQzffYupekWMi+bL1fZ5UJ45g3e1Bg0CGDlyCGPGTKRYsZf4z39eo3371vj5+VGmTLlHPve1117H378hnTu3x2Qy8frr6VvT3c3NjZEjR/HZZ8NSL7Jr2TKIuLg4RowYhMViQVEUPvxwIPDgdd5feaUEERG3aNWqFVarDR8fE5MmzeDs2dN8881XaLVajEZ3Pv10zDPnSIh0cTgwrFmNx7gQ1FFR2F57nYTJM7DWqOXqyLINW8XKxPywF8PqlXhMGI3nZyMwfLPKmafqNVwdnsgistjMI8giCf+SXKQl+Ugrq/KhvXDOeXX86VM4PDxJGjIcc6++2eqMPbu9N1T37uExcQyG1SudFx4GvUvi6PFZ1rbPbvlwNVlsRggh/ocqJhrPYYPwaVgH3elTJLdsRfSRU5j79c9WxT07UvLnJ2HGHGK278FavgKGDeucbfsF8+DvoTeRO0mLPgebMWMKP/10Ps19wcFtadq0uYsiEiKDORy4ffsNnmM/Q33vHrYS/yFh0nSsteu6OrIcx/ZmJWK278Xw9VfOtv2okRjWrHLmU4Y3ciUp8DnY4MHDXB2CEJlG+9N5PIcNRnfqBIq7BwmfjcXc+33Q610dWs6l0ZDcqSspzZqnzhfg805Tklu1JnH0BByFCrs6QpGBpEUvhMhWVLExeI4Y4mzHnzpBcvN3iDp8EvOHH0lxzyCKb34SZswm5oe9WCu8iWHjd862/fw50rbPRaTACyGyB4cDt7Vf41u9IsZli7EXf5mYdZuJX7oSxwsvujq6XMlWoSIx2/cSP3MuuOnxHPMpJv8a6A4ddHVoIgNIgRdCuJzm55/waf42Xv37okpKJOHT0UTvP4q1rr+rQ8v91GqSO3Ym6shpzJ27o/ntV3xaNSNfry6ob910dXTiGUiBF0K4jCouFo9PPsbUoBa6E8dIadaCqEMnMfcfBG5urg4vT1F885MwbRYxO/ZhfbMihs0bnd2UebMhC2faFBlHCrwQIuspCm7r1uBbvSLuSxZif6k4MWs3Erd8FY4Xi7g6ujzNVv5NYsL2ED9rHorRgOfYzzDVewvdwf2uDk08ISnwQogspfnvL3i3aIzXB71RJcSTODKE6APHsPo3cHVo4h9qNckdOjnb9l26o/njd3xaNydfzy6ob95wdXQinaTACyGyhCo+Do/PhmOqXxP9sSOkNAkk6tBJkj4aIu34bEox+ZIwdRYxuw5grVgZw5aN+L5VCeOcWdK2zwGkwAshMpei4Pb3oifui77AUaQosWu+I+7Lr3EUKerq6EQ62MqWJ2bbLuJmf+Fs248fhaludXQH9rk6NPEIUuCFEJlGc/G/eLdsgtf7PVHHxZI4/FOiDh7HUr+Rq0MTT0qtJqVdR6KOnsHcrSeaK5fxCW6BV/dOqG9cd3V04gGkwAshMpwqIR6PUZ9g8q+B/uhhUt5u6mzHD/oYDAZXhyeegeJjImHyDGfbvlIV3EI341ujEsY5M6Vtn81IgRdCZBxFwW3Td5jeqoT7grk4XixC7NfriPtqDY6ixVwdnchAtjLliPl+J3FzFqC4u+M5fjSmOtXQ7dvj6tDE36TACyEyhObXS3gHBeLVuxvqmGgSPx5J1I8nsDR829WhicyiVpPStoOzbd+9F5o/r+DT5h28ur2H+vo1V0eX52VqgT948CABAQE0bNiQxYsXP3CbsLAwmjRpQtOmTRk8eHDq/Zs2baJRo0Y0atSITZs2ZWaYQohnoEqIh48/xlTvLfSHDpIS0Jiog8dJGjJc2vF5hOLtQ8Kk6UTvOoi1SjXcvt+Cb83KuH8+HVJSXB1enpVpq8nZ7XbGjh3LihUr8PPzo3Xr1vj7+/Pqq6+mbhMeHs7ixYtZs2YN3t7e3Lt3D4CYmBjmzZvHhg0bUKlUtGrVCn9/f7y9vTMrXCHEk1IU3LZuwiNkJNy6iaPoSyRMmIIloLGrIxMuYi9TlpjQHbitW4PnmM/wmDgW1q9BN26KzHPgApl2Bn/hwgWKFStGkSJF0Ov1NG3alD170o7NrFu3jg4dOqQW7vz58wNw6NAhatSogY+PD97e3tSoUYMff/wxs0IVQjwhze+/4d26BV49u6COugejRhH143Ep7gJUKlLatCfq6GmSevaBy5fxadsKry4dUF/7y9XR5SmZVuAjIyMpVKhQ6m0/Pz8iIyPTbBMeHs6ff/5J27Zteffddzl48GC6nyuEcIGEBDzGOb8Drf9xPykNGhF18DiMHg1Go6ujE9mI4u1D4oSpcOYM1qrVcQsLdbbtZ02Ttn0WybQWfXrY7XauXr3KqlWriIiIoGPHjoSGhj7Vvkwmd7RaTQZHCAUK5MvwfeZUkou08lQ+FAU2bICBA+H6dShWDObMwS0wEDeVCshj+XgMycX/KFAO3dHDsHo1qqFD8Zg0Do/1a2DOHGicNzs+WfX+yLQC7+fnR0REROrtyMhI/Pz87tumXLly6HQ6ihQpwksvvUR4eDh+fn6cOHEizXOrVKnyyONFRydl7AvA+Uu4cyc+w/ebE0ku0spL+dD88TueI4agP7APRa8nadDHJPUfBO7ucDcByFv5eBzJRVoFCuTjzt0EeLslqrfq4T51IsZli1E1aUJK42YkjJuUp75CmdHvj0d9WMi0Fn2ZMmUIDw/n2rVrWCwWtm3bhr9/2rWdGzRokFrIo6KiCA8Pp0iRItSsWZNDhw4RGxtLbGwshw4dombNmpkVqhDiQRIT8ZgwBlOdaugP7MPi34Dog8dIGv6ps7gL8YQUL28Sx08hevePWKq9hdv2751t+xlTIMot51gAACAASURBVDnZ1eHlOpl2Bq/VagkJCaFHjx7Y7XaCgoIoUaIEs2fPpnTp0tSvX59atWpx+PBhmjRpgkaj4eOPP8ZkMgHw/vvv07p1awD69euHj49PZoUqhPhfioJ+Wyienw1Hc+M69heLkDB+CpbGTeHvdrwQz8JeqjSxW7bjtmEdHqM/xWPKBAzffkPCxKlYGgS4OrxcQ6UoiuLqIDJCZrTEpNX2L8lFWrk1H5orf+A5Yij6fXtQdDqS+g0gacBg8PB45PNyaz6ehuQircflQxUfh/vUSRiXLkRlt5PydhMSxk3GUeylrAsyC+WKFr0QIgdJSsJ90lhMtauh37cHS11/Zzt+ZMhji7sQz0LJ50XiuElE7z2MpXoN3H4Iw7dWFdynT5a2/TOSAi9EXqYo6MO+x7dWFTxmTcfxXAFil60i9ttN2F8p4eroRB5iL/kGsZvDiFuwFIe3Dx5TJ+Jbqwr6ndtdHVqOJQVeiDxKfeUyXu1b492lPeqIWyT1H0TU4VNYAlvIWLtwDZWKlKB3iT5yiqQ+H6C+fg3vjm3weq8N6vA/XR1djiMFXoi8JikJ98nj8a1dFbc9u7DUrkf0/qMkfjpa2vEiW1DyeZE4diLR+45gqVELtx3bnW37qRPBbHZ1eDmGFHgh8hD9D2H41q6Kx8ypOPI/R+zSlcSu34y9xH9cHZoQ97G/XpLYjd8Tt2g5DpMvHtMn41urKvod0rZPDynwQuQB6j+v4NUhGO9ObVHfvEHSBx852/HN35F2vMjeVCpS3mntbNu/3x/1zet4v9cGrw7BqP+84urosjUp8ELkZmYz7lMnOtvxu3ZgqVXH2Y4PGQuenq6OToh0UzzzkTh6vLNtX7M2brt24Fu7Ku5TJkjb/iGkwAuRS+l3bse3VlU8pk/GYfIlbvEKYr/biv0/r7k6NCGemv2114ndEErc4hXOtv2MKc6r7bdvc66ZIFJJgRcil1FfDcfrvTZ4d2yD+uZ1kt7vT/SRU6S0DJJ2vMgdVCpSWgY52/b9BqC+eQPvzu2cbfsrl10dXbYhBV6I3CI5Gffpk/GtVQW3Hdux1KhF9N7DJI4ej+Ipq5uJ3EfxzEfiqHFE7z+KpVZd3HbvdLbtJ4+DpIxfgCynkQIvRC6g3+P8w+YxdSIObx/iFi4jduP32F8v6erQhMh09v+8Rux3W4hduhJH/ufwmDnN2bYP+z5Pt+2lwAuRg6n/uopX5/Z4t2uN+tpfJPX5wNmObxUs7XiRt6hUWJq/Q9ThUyR9OBB1xC28u7THu10Qmit/uDo6l5ACL0ROlJKC+yznWYrb9u+xVK/hbMePnYiSz8vV0QnhOp6eJH42xtm2r10P/d7dmGpXw33S2DzXtpcCL0QOo9u7C1PtqnhMGofimY+4L5YQuzkMe8k3XB2aENmGvcR/iF2/mdhlX+F4rgAes6bjW7My+u+35pm2vRR4IXII9fVreHXtiE/bIDR/XSWp9/tEHT1NSus20o4X4kFUKiyBLZ1t+/6DUEdG4N2tI95tW6G5/Luro8t0UuCFyO5SUjDOnoFvjUq4bduKtWp1onf/SOK4yShe3q6OTojsz8ODxE9HE33gGJa6/uj37cFUpzoeE8ZAYqKro8s0UuCFyMZ0+/ZgqlsdzwljUDw8iZu3iJitP2AvVdrVoQmR49hfLUHst5uIXb4aR4GCuM+e4Wzbh27JlW17KfBCZEPqG9fx6t4JnzbvoPnzCkk9+zjb8e+2k3a8EM9CpcLSrDlRh06S+NEQ1Hdu4939PbzfbYnmj9zVtpcCL0R2YrFgnDPL2Y4P3Yy1clWidx0kccJUFG8fV0cnRO7h4UHSyBCiDxzFUq8++gP7MNWphsf40bmmbS8FXohsQndwv7MdP34Uirs7cXMWEBO6A3uZsq4OTYhcy/5KCWLXbiR2xdc4/ArhPmcmvjUqod+6Kce37aXAC+Fi6ps3yNezCz6tm6O5chlz915EHTlNStsOoJb/okJkOpUKS9NAZ9t+4BDUd+/g3aMz3sEt0fz+m6uje2ry10MIV7FYMM6bje9blTBs2Yi1YmVidh0gYdJ0FB+Tq6MTIu9xdydpRAjRB4+RUr8h+oP7MNWtjsfYEEhIcHV0T0wKvBAuoPvxACb/GniO/QzFaCD+8/nEbNuFrUw5V4cmRJ5nf/lV4r75jtiVa3AUKoz7vM+d18Vs2Zij2vZS4IXIQupbN8nXuys+QYFofv8Nc5fuRB05TXL796QdL0R2olJhadyUqB9PkDjoY9RR9/Dq2QXv1i3Q/Parq6NLF/mLIkRWsFoxfjEX01uVMGzagLViJWJ27idh6iwUk6+roxNCPIy7O0nDPyXq4HFSGjRC/6PzYliPMZ+hSoh3dXSPJAVeiEymO/yjsx0/+hNw0xM/cy4x23ZjK1fB1aEJIdLJUfxl4r5eT+xXa3E8/wLu82djeqsSbpu+y7ZteynwQmQSdWQE+fp0x+edpmh++xVzp27OdnzHztKOFyInUqmwvN3E2bYfMhx1dBRevbvhHRSI5tdLro7uPvJXRoiMZrNhXDgPU/WKGDaux1q+AjE/7CVh+ucovvldHZ0Q4lkZjSR9PNLZtm/0NvpDBzHVewuPUZ9kq7a9FHghMpDu6GFM9WviGTISdFrip88mZvtebBUqujo0IUQGcxR/mbjV64hd/S2O51/EfcFcTNUr4rZxfbZo20uBFyIDqCIjyfd+T3xaNEZz6SLm97oQdeQMyZ26gkbj6vCEEJnI0qgxUT8eJ3HoCNSxMXj16Y73O03RXLro0rikwAvxLGw2jIu/wPetihi++xZruQrEhO0mYcYclPzSjhcizzAaSRo6gqgfT5DydhP0Rw452/YhI1HFx7kkJCnwQjwl7bGjmBrUxvPT4aBREz91FjE/7MVWsbKrQxNCuIij2EvEfbWW2K/X4XixCO5/X4/j9t23Wd62lwIvxBNS3b4NXbpgah6A9r8/Y+7QydmO79Jd2vFCCAAsDd92Xm0/7BPUcbF4vd8T75ZN4O7dLItBCrwQ6aT55Wc8P+pH/oqlYOVKrGXKER22m4RZ81Cee87V4QkhshuDgaTBw/5u2zdFf/QwHDmSZYfXZtmRhMiJ7Hb0O3/AuPgL9Id/dN71UnE0w4cR06KNnLELIR7L2bZfg+rOHZ5742W4kzVfpcvUAn/w4EEmTJiAw+EgODiYXr16pXl848aNTJ06FT8/PwA6duxIcHAwAFOnTuXAgQM4HA5q1KjBJ598gkqlysxwhUiliovF8M0qjEsXo/krHABLrbqYe/XF0qARBQr5ZNl/UiFE7qAUKJClx8u0Am+32xk7diwrVqzAz8+P1q1b4+/vz6uvvppmuyZNmhASEpLmvjNnznDmzBm2bt0KQPv27Tlx4gRVq1bNrHCFAEBz+XeMSxfhtvYb1IkJKAYD5ve6YO7RB3vJN1wdnhBCpFumFfgLFy5QrFgxihQpAkDTpk3Zs2fPfQX+QVQqFRaLBavViqIoWK1WnpMxTpFZFAXd/r0YlyzAbfdOAOzPv0DCwCEkd+wss88JIXKkTCvwkZGRFCpUKPW2n58fFy5cuG+7nTt3cvLkSYoXL86IESMoXLgwFSpUoGrVqtSsWRNFUejYsSOvvPJKZoUq8qrERAzr12JcuhDt38s/WitXxdyrLylNAkGnc3GAQgjx9Fx6kV29evVo1qwZer2etWvXMmzYML766iuuXr3K5cuXOXDgAADdunXj1KlTVKpU6aH7Mpnc0Woz/oKnAgXyZfg+c6pck4u//oJ582DpUoiOdhbyjh1hwAB0lSqR3rKea/KRQSQf/5JcpCX5SCur8pFpBd7Pz4+IiIjU25GRkakX0/3DZDKl/hwcHMy0adMA2LVrF+XKlcPDwwOAWrVqcfbs2UcW+OjopIwMH3D+Eu7IhVRALsiFoqA9fgz3JQvQb9uKyuHA8VwBzIOHkdylOw6/v7tN6XyNOT4fGUzy8S/JRVqSj7QyOh+P+rCQad+DL1OmDOHh4Vy7dg2LxcK2bdvw9/dPs83t27dTf967d29qG/7555/n5MmT2Gw2rFYrJ0+ezNIWvaLAypU6zp7NskOKzJKSgtvar/FpWAdT8wDcQjdjK1WGuDkLuHfmF5KGffJvcRdCiFwk087gtVotISEh9OjRA7vdTlBQECVKlGD27NmULl2a+vXrs2rVKvbu3YtGo8Hb25tJkyYBEBAQwLFjxwgMDESlUlGrVq37PhxkpsRE+OQTNz75BKZM0dGhgzXLji0yhioyEuOXSzGuXI767h0UtZqUps0x9+qLtdpbIF+5FELkcipFyQZr2mWAjG4B7d2roW9fd6KjoXNnCxMmpKDXZ+ghcpSc0mbTnj+LcfEC3DZvQGW14vD2IblDJ8zdeuIoWizDjpNT8pFVJB//klykJflIKytb9DKT3UP4+9s5dQoCA+2sXKnnv//VsGyZmUKFcsXnodzFZkMfFor74gXoThxz3lXiP5h79CH53Xbw97UcQgiRl0iBf4SXX4Zt25IYPNjAxo06GjRwZ9myZKpWtbs6NAGooqMwrFqJccUSNDeuA5BSvyHmnn2x1vUHtSy1IITIu6TAP4aHByxYkEy5cnbGjHGjVSsjEyak0LmzVYZxXURz6SLGJQsxfLcWldmM4u6BuVtP52xzr5ZwdXhCCJEtSIFPB5UK+va1Urq0g169DHz8sYFz59RMnpyCweDq6PIIhwP97h0YFy9Ef3AfAPaixTB3701y+44o3j4uDlAIIbIXKfBPoFYtOzt3JtG1q5FvvtFz8aKG5cvNvPCCjMtnFlVCPG5rv8a4ZCHaP68AYKlRC3PPvlgCGstqbkII8RBS4J9QkSIKoaFJDB1qYN06HQ0burN0aTJvvSXj8hlJHf4nxmWLMHyzGnV8HIqbG+b27znb8KXLuDo8IYTI9qTAPwWjEebOTaZ8eTshIW4EBRkZOzaFHj1kXP6ZKAq6QwcxLlmAfsd2VIqC3a8Qif36Y+7UDUUWHBJCiHSTAv+UVCro0cNKqVIOunc38MknBs6d0zB9ejJGo6ujy2HMZgwb1mFcsgDtxf8CYH2zIuaefUkJbEmenoBACCGekhT4Z1S9up3du5Po1s3I+vU6Ll1Ss2KFmaJFZVz+cdQ3b2BcsRTDqhWoo6JQtFqS3wnC3LMvtkpVXB2eEELkaPJF4Qzw/PMKW7Yk0bGjhZ9+0tCokTsHD8rFXw+kKGhPHidfry74ViyN++wZACR+NISo0z8Tv2iFFHchhMgAcgafQdzcYObMFMqXdzBihBvvvmskJCSFvn1lXB4AiwW3rZswLlmA7uwZAGwlS2Hu1ZfkVsHIuIYQQmSsdJ3Bh4WFkZCQAMDs2bPp3r07P//8c6YGllN16mRl8+YkChRQGD3aQJ8+BhITXR2V66ju3MF9xhR8K5bG6/2eaM+dJeXtpsRs/J7o/UdI7tBJirsQQmSCdBX4BQsW4OnpyYULFzh06BAtW7Zk/PjxmR1bjlW5soPdu5OoXNnOpk06mjRx588/89ZpvObnn/Ac8D7533wDjykTUCUlkdS7H1HHzxH31RqsNWvLim5CCJGJ0lXgtVpnJ//w4cMEBwcTGBhISkpKpgaW0/n5KWzalETXrhYuXtTQqJEHe/fm8nF5ux39tlC8WzbB178GxjWrsb/wIvGTphF1/iKJ4ybheKm4q6MUQog8IV0FXqVSERYWRlhYGNWrVwfAapU10h9Hr4cpU1L4/HMzZjO0a2dk9mw9uWOB3n+pYmMwfjEX36rl8e7aAf2RQ1jq1CP263VEHzlNcvfeKJ4PX9JQCCFExkvXRXaffvopS5cupXXr1hQpUoTw8HCqVq2a2bHlGu3b23j9dedX6SZMcOP8eTVz5iTj6enqyJ6N5o/fMS5ZgOHbNaiSElGMRsydumHu2Qf7a6+7OjwhhMjTVIqSO84n79yJz/B9FiiQL0P3e+eOip49DRw5ouW11+x8+aWZV17JGelPzYXDgW7/HtwXL0C/dzcA9hdexNytF8kdO6GYfF0cadbI6PdGTif5+JfkIi3JR1oZnY8CBR7eHU1Xi37y5MnEx8djs9lo37495cuXZ8uWLRkWYF5RoIDC+vVmevWy8OuvznH5nTtzyLh8QgKG5Usw1ayMT9sg9Ht3Y61andhlXxF18gLmDz/KM8VdCCFygnQV+CNHjpAvXz4OHTqEn58fO3bsYPny5ZkdW66k08H48SnMn2/GaoWOHd2ZNk2Pw+HqyB5M/ddVPEZ9Ai++SL7hg9H8dZXkd9sRvesAMaE7sAS2BK1MpyCEENnNE/1lPnnyJA0bNsTPzw+VfMXpmQQH23jtNefSs9OmufHTT2rmzUvGy8vVkeFc9OXoYYyLF6D/YRsqhwMKFiRxyHDMnbuj+Pm5OkIhhBCPka4z+Pz58zNq1Ci2b99OjRo1sNls2O2yPOqzKlvWwc6dSdSqZeOHH3QEBHjw228unD04ORm3tV/jU78WPi2b4BYWiq10WeLmLoS//iLp45FS3IUQIodIVzWZMWMGxYsXZ+bMmXh7exMREUHXrl0zO7Y8IX9+hW+/NdOvn4XLl9UEBLjz/fdZ2/JWR0bgPnk8+d98A6/+fdFe/IXk5u8QHbqTmF0HSGnT3jkXrxBCiBwj3VfR22w2/vzzTwCKFy+eOvlNdpETrqJ/nM2btXz0kYGkJBUDB6bw8ccWNJl4DZ727GmMixfgtnUTKqsVh48PyR27YO7WE8eLRdJsK1fCpiX5SEvy8S/JRVqSj7Sy8ir6dFXpn376if79+6PX61EUBZvNxty5cylVqlSGBSmgZUsbJUok0aWLkVmz3LhwQcOCBWZ8fDLwIFYrbtu2Yly8AN2pEwDYXnsdc48+JLduAx4eGXgwIYQQrpKuAj9hwgQmTpyYOovd0aNHGTduHGvXrs3U4PKiUqUc7NyZSN++Rvbs0dKokQdffmnmjTee7TJ7VdQ9DKu+xLhiKZqbNwBIaRiAuWdfrHXqybzwQgiRy6RrDN5sNqcWd4Dq1atjNpszLai8zmSCr78289FHKYSHq2nSxJ0tW55uSERz8b94DvqQ/OVL4jlhDKrYWJJ69Cbq2Bnivl6Pta6/FHchhMiF0lU1jEYjx48fT52e9sSJExhlic9MpdHAyJEWypZ18OGHBnr2NHLunIVPPkl5/NfO7Xb0u3ZgXLIA/Y8HnHcVewlzj94kt+uI4uWd+S9ACCGES6WrwI8cOZIBAwag1+sB50Izc+bMydTAhFOzZs5x+c6djcyfr+enn9QsXmzG9wGTxqni4zB8swrj0kVoroYDYKlZG3Ov97E0DCBTr9gTQgiRraSrwJctW5adO3emuYpep9NlamDiX6+95hyX79fPyI4dznH5FSvMlCnjHJdXX7mMcdkiDN+sRp2YgGIwYO7QCXOPPthLlXZx9EIIIVzhkQX+/4+zFyni/OqUzWbDZrNJmz4LeXnBypVmZszQM22aG02bGPm213YCfp2HftcOVIqCvfDzJA4YhPm9rij587s6ZCGEEC70yAJfoUIFVCoV/3xV/p/paRVFQaVScfHixcyPUKRSq2Fovxha3V2P18qFvDH3FwAsb1YmuXdfUpq1cE52L4QQIs97ZIG/dOlSVsUhHkN94zrG5UswrP6SAtHRODRaQvO1Y1z8R+gMb7KkZjIFdDlj6VkhhBCZz4UTn4vHUhS0x4+Rr0dnfCuVwX3uLFCrSRw0lOizv1D6/CIKNq3AkSNaGjZ05+xZ+XUKIYRwyl7zzQqnlBTctmzEuGQhuvNnAbCVKkNSr76kvNMaDAYAPIHly5OZM8fBxIl6mjd3Z+rUZNq1s7kweCGEENlBpp7yHTx4kICAABo2bMjixYvve3zjxo1Uq1aNFi1a0KJFC9avX5/62M2bN+nWrRuNGzemSZMmXL9+PTNDzRZUt2/jPm0S+d8shdcHvdH+dJ6UJoHEbA4jeu8hUtp1TC3uqc9RwYABFtasMWMwwIABRoYNc8NicdGLEEIIkS1k2hm83W5n7NixrFixAj8/P1q3bo2/vz+vvvpqmu2aNGlCSEjIfc8fNmwYffr0oUaNGiQmJqJW5972s/bCOeeiL5s3oLJYcHh5k9TnA8zde+Eo9lK69uHvb2fnzkS6dDGyYoWeX35Rs2xZMn5+Mi4vhBB5UaYV+AsXLlCsWLHUr9Y1bdqUPXv23FfgH+SPP/7AZrNRo0YNADxy4wIoNhv67ducs80dO+K865VXnYu+tGkPnp5PvMvixRXCwpIYONDA5s06GjRwZ/lyM5UrP9s89kIIIXKeTDstjoyMpFChQqm3/fz8iIyMvG+7nTt3EhgYSP/+/bl16xYA4eHheHl58cEHH9CyZUumTJmC3W7PrFCzlComGuO82fhWKYd39/fQHzuCpV59Ytd8R/ThUyR37/VUxf0fHh6waFEyo0Ylc+eOipYt3fnqK/nqnBBC5DUuvciuXr16NGvWDL1ez9q1axk2bBhfffUVNpuNU6dOsXnzZgoXLszAgQPZuHEjwcHBD92XyeSOVpvxU7E+aq3dJ3LxIsyZA199BUlJ4O4OfftC//7oX38dfcYcJdXo0VCzJrRtC0OGGLh0ycC8eeDm9vT7zLBc5BKSj7QkH/+SXKQl+Ugrq/KRaQXez8+PiIiI1NuRkZH4+fml2cZkMqX+HBwczLRp0wAoVKgQJUuWTG3v169fn/Pnzz/yeNHRSRkVeqoCBfJx50780+/A4UC/dxfGxQvQ798LgL1IUcxDe5Hc4T0Un79f/7Mc4xHKlYMdO1R06WJk6VINZ8/aWb7cTOHCTz4u/8y5yGUkH2lJPv4luUhL8pFWRufjUR8WMq1FX6ZMGcLDw7l27RoWi4Vt27bh7++fZpvbt2+n/rx3715eeeWV1OfGxcURFRUFwPHjx9M1dp9tJCRgWLYIU41KeLcPRr9/L5bqNYhdvpqo4+cw9+v/b3HPZEWLKnz/fRKtW1s5fVpDgwbuHDsmi84IIURul2ln8FqtlpCQEHr06IHdbicoKIgSJUowe/ZsSpcuTf369Vm1ahV79+5Fo9Hg7e3NpEmTANBoNAwbNozOnTsDUKpUqUe257ML9dVwjEsXYfhmFer4OBS9nuS2HTD37IOtTDmXxeXuDvPnJ1Ohgp2QEDdatTIyblwK3bpZZSl4IYTIpVTKPxPN53CZ0QJKVytFUdAd/tHZht8R5lz0paAfyV17YO7UDaVAgQyP61kcOaKhRw8Dd++qefddK9OmJZOeNYOkzZaW5CMtyce/JBdpST7SysoWvcxk97TMZgwb12NcshDtf38GwFq+AuaefUlp0Qr0GX3ZXMZ46y07u3Yl0bWrkXXrdFy6pObLL828+GKu+JwnhBDib1Lgn5A64haGFUswfrUC9b17KBoNyS1aYe7ZF1vlKuSEnvcLLyhs3ZrEsGEG1qzR0bChO0uWJFOzZu74KqIQQghZbCbdtKdPkq9PN3zfLIXHrOngcJDUfxBRp34ifsmX2KpUzRHF/R8GA3z+eTJTpiQTF6ciONjIggU6cseAjRBCCDmDfxSrFbeN6zEuWYDu9CkAbK+XxNyzL8lB7zqvXsvBVCro2tXKG2846N7dwKhRBs6f1zBzZnJOf2lCCJHnSYF/EEXBuGQBfDEHr5s3UVQqUgIaY+7ZF2utOjnqTD09qla1s3t3Et26Gdm4UcevvzrH5YsVk9N5IYTIqaRF/wCqxAQ8xnwG8fEk9epL1NEzxK36FmvturmuuP+jUCGFTZuS6NTJwi+/aGjUyIN9++T78kIIkVNJgX8AxTMfUUfPwPXrJI6fguPlV1wdUpZwc4Pp01OYOTOZxERo187InDl6GZcXQogcSAr8QziKFgMvL1eH4RIdO1rZsiUJPz+F8ePd6NHDQEKCq6MSQgjxJKTAiweqWNHBrl1JVKtmIzRUR7VqcOVK7hyeEEKI3EgKvHioggUVNmww06OHhV9+gUaNPNi1S8blhRAiJ5ACLx5Jp4OJE1NYuRIsFujY0ciMGXocDldHJoQQ4lGkwIt06dQJQkOTeOEFhSlT3OjSxUC8TC8thBDZlhR4kW7lyjnYuTOJmjVt/PCDjoAAd37/Xd5CQgiRHclfZ/FEnntOYd06M337WvjjDw0BAe5s3y7zJQkhRHYjBV48Ma0WxoxJYeFCM3Y7dO5sZPJkGZcXQojsRAq8eGqtWtnYti2JokUdzJzpRseORmJjXR2VEEIIkAIvnlHp0g527Uqkbl0bu3dradTIg4sX5W0lhBCuJn+JxTMzmWDNGjP9+6fw559qGjd2JzRUxuWFEMKVpMCLDKHRwKefWli2zAxA9+5Gxo3TY7e7ODAhhMijpMCLDBUYaOOHH5IoXtzB3LlutGtnJCrK1VEJIUTeIwVeZLjXX3ewc2ciDRrY2L/fOS7/88/yVhNCiKwkf3VFpvD2htWrzQwenMJff6lp2tSdDRtkXF4IIbKKFHiRadRqGDbMwsqVZjQa6NvXSEiIGzabqyMTQojcTwq8yHSNG9vYsSOJEiXsLFyo5913jdy9K0vPCiFEZpICL7JEiRIOfvghicaNrRw6pKVhQ3fOn5e3nxBCZBb5CyuyTL58sGJFMsOHp3DzpopmzdxZu1bG5YUQIjNIgRdZSq2GQYMsfP21GTc36N/fyIgRblitro5MCCFyFynwwiUaNLCzc2cir79uZ9kyPUFBRiIjZVxeCCEyihR44TIvv6wQFpZEYKCVY8ec4/KnT8tbUgghMoL8NRUu5ekJS5cm89lnKdy+raJFC3dWr9a5OiwhhMjxpMALl1Op4MMPLaxda8bDAwYNMjB4sBspKa6OTAghci4p8CLbqFvXOS5fqpSdVav0tGzpTkSEjMsLIcTTkAIvspVixRS2bUuiVSsrp09raNDAnePHNa4OSwghchwp8CLbcXfn/9q79+CoyvuP4++9ZHMhIQZJFimXGBIuCUi0kjmE4gAAFaFJREFURRAcbMKEICEEm2SsTrVFGWyrpeqgiFpG+akIaBXa2hY7tRVGmEZCgyAShlRg1OINzJBE8TJRsLBBgULIdXfP749tsh7DJWp2N9n9vGYy2XPZ3ed85+x+9jnP2T388Y8tLF3awpdfWrjuulj++tcoDCPULRMR6TsU8NIrWSzw85+3U1bWTGKiwX33xXDnnTG0tIS6ZSIifUNAA3737t3k5+eTl5fHmjVruiwvLy9n0qRJFBUVUVRURFlZmWl5Y2MjU6dOZenSpYFspvRiV1/tYceOJsaP97B+fRSzZ8fx+ecalxcRuZCABbzH42Hp0qX85S9/YevWrWzZsoWPPvqoy3ozZ86koqKCiooKSktLTcuefvppJkyYEKgmSh8xZIjB5s1NXH99O/v328jLi+O11zQuLyJyPgEL+OrqaoYPH87QoUNxOBwUFBSwc+fObt//wIEDfPnll0yZMiVQTZQ+JDYWVq9uYdmyFk6etFBSEsuaNRqXFxE5l4AFvMvlYtCgQZ3TTqcTl8vVZb3KykoKCwtZsGABR44cAcDr9bJ8+XIWLVoUqOZJH2SxwK23tlNe3syAAQYPPhjDL38ZQ1NTqFsmItL7hPRSXjk5OcyaNQuHw8GGDRtYtGgRzz//PC+88AJTp041fUC4kKSkOOz2nj9sm5yc0OOP2Vf1lloUFsK+fVBcDBs3RvHxx1Fs2gSpqcFtR2+pR2+hevipFmaqh1mw6hGwgHc6nRw9erRz2uVy4XQ6TeskJSV13i4tLWXlypUA7Nu3j3feeYf169dz5swZ2tvbiYuLY+HChed8vhMner4bl5ycwLFjp3v8cfui3lYLhwNefBHuvz+atWsdXHGFwZo1zVxzjScoz9/b6hFqqoefamGmepj1dD3O92EhYAE/btw46uvrOXToEE6nk61bt/Lkk0+a1mloaCAlJQWAqqoqRowYAWBar7y8nAMHDpw33CUyRUfDk0+2Mn68l8WLo7n++lgefLCV229vx6IT7UUkwgUs4O12O0uWLGHevHl4PB6Ki4vJyMhg1apVjB07lmnTprF27Vqqqqqw2WwkJiaybNmyQDVHwtjNN7czZoyHW2+NZenSGN57z8bTT7fQr1+oWyYiEjoWwwiP85ADcQhIh5b8+kItXC4L8+bFsHevnTFjPDz3XDNpaYHZvftCPYJJ9fBTLcxUD7NgHqLXL9lJ2HA6DTZubOaWW9qoq7ORn9+PnTv1fXkRiUwKeAkrDgc8/ngrq1c309ICN94Yy9NPO/R9eRGJOAp4CUs//rGbl15qYvBgg8cei2bu3BgaG0PdKhGR4FHAS9jKzvZSWdnElCluXn45ihkz4vjoI51eLyKRQQEvYS052aCsrJnbbmvj4EHfuPwrr2hcXkTCnwJewp7dDv/3f60880wzbjfcfHMcK1Y48HpD3TIRkcBRwEvEKClxs2VLE8OGeXniiWhuvjmWU6dC3SoRkcBQwEtEGTfOS2XlGaZOdVNZaWf69H588IFeBiISfvTOJhFnwADYsKGZO+5o5ZNPrMyYEceWLSG97pKISI9TwEtEstthyZI2nn22GcOAW26J5dFHHXiCc60aEZGAU8BLRCsqcvPyy02kpnpZtSqaG2+M5cSJULdKROS7U8BLxMvM9I3LT5vm5l//8o3L19TopSEifZvexUSAiy6CdeuaufvuVj791EpBQRybNmlcXkT6LgW8yP/YbHDffW0891wzFgvcdlssDz0Ujdsd6paJiHxzCniRrykocLN9exPp6R6eecbB9dfH8uWX+olbEelbFPAiZzFypJdXXmlixox29uyxM316HNXVermISN+hdyyRc+jfH/72txbuvbeVQ4eszJoVxz/+oXF5EekbFPAi52G1wsKFbaxb10RUFNxxRywPPBBNe3uoWyYicn7qjoh0w/TpHiorz/Czn8Xy7LMOduyA8eNjyMrykpXlISvLyyWXGFg0VC8ivYQCXqSbRoww2LaticWLY9i2LYqKiigqKvzLk5IMMjM9ptAfOdJLTEzo2iwikUsBL/INxMfD737XwsCBUbz7biM1NTZqa63U1FipqbHx+us2XnvN/7Ky2QzS071kZXnJzPQHv9Op3r6IBJYCXuRbsFhg2DCDYcPcXHutf35jI9TVWamttXWGfm2tlQ8+sFFe7l/v4os7At/b2esfOdJLdHTwt0VEwpMCXqQHxcfDhAleJkzwds7zeuGzzyzU1HSEvi/49+yxs2eP/752u0FGhrmnn5XlJSXFCMGWiEhfp4AXCTCrFVJTDVJT3RQU+OefPs1Xevq+Xn9dnZW6OhsbN0Z1rpec7O/tdwR/RoaXqKizPJmIyP8o4EVCJCEBJk70MHGi/xq1Xi/U1/t7+77xfRu7dtnZtct/36gog5EjzaGfmell4ED19kXERwEv0otYrZCWZpCW5qaw0D//v//19fa/ekLf++/7/oO/K+90dg399HQvdr3SRSKOXvYifUBiIlx1lYerrvL39j0e+OQTqyn0a2qsVFXZqaryv7Sjow1GjfIHf8cYf1JSKLZERIJFAS/SR9lskJHhG48vKvLPP34c6upsptD/4AMr1dXm3v7gweaz+LOyvKSlebHZgr8tItLzFPAiYWbAAJgyxcOUKR7A95u6bjd8/LHVdBZ/ba2VHTvs7NjhfxuIjTUYPdoc+pmZHhITQ7QxIvKtKeBFIoDdDqNGeRk1ysuPfuSf/8UXFtMh/o7b+/aZu/FDhpjH9rOyPKSmGlh1NQuRXksBLxLBBg40mDrVw9Sp/t5+ezt8+KH/q3sdvf7t2+1s3+5/y4iLMxgzxtfDnzQJhg61kZXlISEhRBsjIiYKeBExiYqCzEzfGfjg7pzf0GAxfXWvpsbKe+9ZeecdG2vXAsQBMGyY+Sz+rCwPw4erty8SbAp4EemWlBSDlBQPOTn+3n5rq6+3f+hQP954o63zA8C2bVFs2+a/b79+RmfYd/wfM8ZLfHxotkUkEijgReRbi46GsWO95OTAtde2AmAY/t7+gQO+cf3aWivvvmvlrbf8Y/sWi0FqqvGV0PcF/9ChuhCPSE9QwItIj7JYwOk0cDo95Ob6v7ff0gIHD379hD4bW7ZEsWWL//4JCYbpLP6sLA+jR3uJiwvBxoj0YQEN+N27d/Poo4/i9XopLS1l/vz5puXl5eWsWLECp9MJwE9+8hNKS0upq6vjoYceorGxEavVyi9+8QtmzpwZyKaKSIDFxMBll3m57DL/2L5hwJEjli4n9L31lo29e/1vTxaLQVqaYTqLPzPTy/e+p96+yLkELOA9Hg9Lly7lueeew+l0UlJSQm5uLunp6ab1Zs6cyZIlS0zzYmJiWL58OampqbhcLoqLi7n66qvp379/oJorIiFgscDgwQaDB3vIy/P39pua4IMPzKFfU2Nj8+YoNm/23/+ii77a2/eF/qhRXmJjQ7AxIr1MwAK+urqa4cOHM3ToUAAKCgrYuXNnl4A/m0svvbTzttPpZMCAARw/flwBLxIh4uLg8su9XH65/7K7hgGff24x/UJfTY2NN96w8frr/rcyq9UgPd1rOos/K8vLoEHq7UtkCVjAu1wuBg0a1DntdDqprq7usl5lZSVvvfUWl156KYsXL+aSSy4xLa+urqa9vZ1hw4YFqqki0gdYLDBkiMGQIR7y8/29/TNn6LzwTsdZ/LW1Ng4etLFpk//+AwZ0Df2RI71ER4dgY6TXMAzfbz+0tEBzs4WWFmhpsXxt+mzzzj59vnVsNti4EbrRz+0RIT3JLicnh1mzZuFwONiwYQOLFi3i+eef71ze0NDAPffcw/Lly7Fe4Eu0SUlx2O09/yPaycn61Y4OqoWZ6mEWqnokJ0NqKsyY4Z9nGFBfD++95/urrob33rOyZ4+VPXv869lsMHo0jB9v/nM6+U69fe0bZt+kHl4vNDcH76+lxfecgRAb6//r39/3M9IJCcHbPwIW8E6nk6NHj3ZOu1yuzpPpOiR95XJWpaWlrFy5snO6sbGR2267jbvuuovs7OwLPt+JE0090Gqz5OQEjh073eOP2xepFmaqh1lvrEd8PEyZ4vvr0NhIZw/ffDa/hRde8K83cKDX9NW9rCzfRX0cjgs/b2+sxbdlGNDW5u/B+gLRco7ps/dcLRYHJ06009p6oV6y739bW2DGUaKiDGJiICbGIDYWLr7YPx0T4wvhjtv+eeea9j/O1+/T8T86+uwfEnt6/zjfh4WABfy4ceOor6/n0KFDOJ1Otm7dypNPPmlap6GhgZSUFACqqqoYMWIEAG1tbdx+++0UFRUx46sfy0VEvoP4eLjySi9XXunvsnm9UF9vMZ3QV1trY/duO7t3++8bFWWQkWEO/cxML8nJRtDa7/FwwVD9+v/uHGY+W1h3zDOMngjcKNOUxWIOx/h434eq7oTs+YO367odQRyJV0kMWMDb7XaWLFnCvHnz8Hg8FBcXk5GRwapVqxg7dizTpk1j7dq1VFVVYbPZSExMZNmyZQBs27aNt99+m5MnT7Lpf4Nojz/+OGPGjAlUc0UkQlmtkJZmkJbmZtYs//xTp+gM/Y7v7NfV+cK/rMwfWCkpXtNZ/FdcAQ0Ntm71bs8esucO3vb2wPRuHQ5zMCYnG/+7ffaea/dC1nd78OB+NDU1msLb4fhuQyDSPRbDMIL38TOAAnFILJwOtX1XqoWZ6mEWKfXweHy9ff8Jfb7/hw/33A/tW63fLVTP3Zs99+MGsncbKftGd4XFIXoRkXBjs8GIEQYjRriZPds//+RJX2+/ttbK8eMxeL2t5w3Z84V1VJR6t9IzFPAiIt/RRRfB5MkeJk/2kJwcw7FjbaFukgi6gKOIiEgYUsCLiIiEIQW8iIhIGFLAi4iIhCEFvIiISBhSwIuIiIQhBbyIiEgYUsCLiIiEIQW8iIhIGAqb36IXERERP/XgRUREwpACXkREJAwp4EVERMKQAl5ERCQMKeBFRETCkAJeREQkDEV8wO/evZv8/Hzy8vJYs2ZNl+VtbW3ceeed5OXlUVpayuHDh0PQyuC5UD3Ky8uZNGkSRUVFFBUVUVZWFoJWBsfixYu56qqrmDVr1lmXG4bBI488Ql5eHoWFhdTU1AS5hcF1oXrs3buX73//+537xu9///sgtzB4jhw5wk033cTMmTMpKCjg73//e5d1Imn/6E49ImX/aG1tpaSkhNmzZ1NQUMDq1au7rBO0XDEimNvtNqZNm2Z89tlnRmtrq1FYWGh8+OGHpnXWrVtn/OY3vzEMwzC2bNli/PrXvw5FU4OiO/XYuHGj8fDDD4eohcH15ptvGgcOHDAKCgrOuvzVV181br31VsPr9Rr79u0zSkpKgtzC4LpQPf79738b8+fPD3KrQsPlchkHDhwwDMMwTp8+bUyfPr3LayWS9o/u1CNS9g+v12s0NjYahmEYbW1tRklJibFv3z7TOsHKlYjuwVdXVzN8+HCGDh2Kw+GgoKCAnTt3mtapqqriuuuuAyA/P5833ngDI0x/G6g79YgkEyZMIDEx8ZzLd+7cyZw5c7BYLGRnZ3Pq1CkaGhqC2MLgulA9IklKSgpZWVkAxMfHk5aWhsvlMq0TSftHd+oRKSwWC/369QPA7XbjdruxWCymdYKVKxEd8C6Xi0GDBnVOO53OLjuly+XikksuAcBut5OQkMCJEyeC2s5g6U49ACorKyksLGTBggUcOXIkmE3sVb5er0GDBkXsm1qH/fv3M3v2bObNm8eHH34Y6uYExeHDh6mrq2P8+PGm+ZG6f5yrHhA5+4fH46GoqIjJkyczefLks+4bwciViA54+eZycnKoqqripZdeYvLkySxatCjUTZJeIisri6qqKjZv3sxNN93E7bffHuomBdyZM2dYsGAB999/P/Hx8aFuTsidrx6RtH/YbDYqKirYtWsX1dXVHDx4MCTtiOiAdzqdHD16tHPa5XLhdDq7rNPRS3W73Zw+fZqkpKSgtjNYulOPpKQkHA4HAKWlpWF94tCFfL1eR48e7VKvSBIfH995aPKaa67B7XZz/PjxELcqcNrb21mwYAGFhYVMnz69y/JI2z8uVI9I2z8A+vfvz8SJE9mzZ49pfrByJaIDfty4cdTX13Po0CHa2trYunUrubm5pnVyc3PZtGkTANu3b2fSpEldxlPCRXfq8dUxxKqqKkaMGBHsZvYaubm5/POf/8QwDPbv309CQgIpKSmhblbIHDt2rHMcsbq6Gq/XG7Yfhg3D4IEHHiAtLY25c+eedZ1I2j+6U49I2T+OHz/OqVOnAGhpaeH1118nLS3NtE6wcsXe44/Yh9jtdpYsWcK8efPweDwUFxeTkZHBqlWrGDt2LNOmTaOkpIR77rmHvLw8EhMTeeqpp0Ld7IDpTj3Wrl1LVVUVNpuNxMREli1bFupmB8zdd9/Nm2++yYkTJ5g6dSq/+tWvcLvdANxwww1cc8017Nq1i7y8PGJjY3nsscdC3OLAulA9tm/fzvr167HZbMTExPDb3/42bD8Mv/POO1RUVDBy5EiKiooAX33+85//AJG3f3SnHpGyfzQ0NHDffffh8XgwDIMZM2aQk5MTklzR5WJFRETCUEQfohcREQlXCngREZEwpIAXEREJQwp4ERGRMKSAFxERCUMR/TU5EfHJzc3F4XAQHR3dOe8Pf/gDQ4YM6bHnOHz4MMXFxezdu7fHHlNEzk0BLyIArF69mpEjR4a6GSLSQ3SIXkTOadSoUaxevZqioiLy8/PZvn1757Ldu3czZ84cCgsL+elPf8qnn37auezFF19k9uzZzJ49m+LiYr744ovOZU899RRz5swhPz+ft99+O6jbIxJJ1IMXEQAWLFjQeYjeZrNRXl4OgNVqpaKigk8++YQbbriBH/zgBwDce++9rFu3jvT0dMrKyli4cCFlZWXs3buXP//5z7zwwgskJydz5swZ7HY7LS0tnDx5kuzsbO666y42b97ME088wYYNG0K2zSLhTAEvIsC5D9GXlpYCkJaWRmZmJvv378disTB69GjS09MBKC4u5uGHH6axsZFXX32VoqIikpOTATovMAIQFxdHTk4OANnZ2SxfvjzQmyUSsXSIXkSCpuNKhOA7MtDxW/Yi0vMU8CJyXhs3bgSgvr6e2tpasrOzyc7O5v333+fjjz8GYNOmTWRmZhIfH88Pf/hDKioqOsfdz5w5Q2tra8jaLxKpdIheRADzGDzAI488AoDH42HOnDk0NzezdOlSLr74YgBWrFjBwoULcbvdDBgwgJUrVwIwceJE5s+fz9y5c7FYLDgcDv70pz8Ff4NEIpyuJici5zRq1Cjeffdd0zi6iPQNOkQvIiIShtSDFxERCUPqwYuIiIQhBbyIiEgYUsCLiIiEIQW8iIhIGFLAi4iIhCEFvIiISBj6f0k/WW2OQ3YHAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 576x324 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "id": "u-36yrhi4aeT",
        "outputId": "25c6c68a-8961-4599-d8c8-88b72a64a748"
      },
      "source": [
        "plt.style.use('seaborn')\n",
        "train_acc = np.array(train_acc_list)\n",
        "valid_acc= np.array(valid_acc_list)\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(8, 4.5))\n",
        "\n",
        "ax.plot(train_acc, color=\"blue\", label=\"Training_acc\")\n",
        "ax.plot(valid_acc, color=\"red\", label=\"Valid_acc\")\n",
        "ax.set(title=\"Accuracy over epochs\",\n",
        "       xlabel=\"Epoch\",\n",
        "       ylabel=\"Acc\")\n",
        "ax.legend()\n",
        "fig.show()\n",
        "\n",
        "plt.style.use('default')"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 800x450 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFjE42yQjS3F"
      },
      "source": [
        "## Test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3xOAFBTijUP0"
      },
      "source": [
        "loaded_model = torch.load(\"model.pt\")"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uFlX107QkIpE"
      },
      "source": [
        "test_loss, test_acc, test_precision, test_recall, test_f1_score = evaluate(model, test_loader)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zsm8jPvekVXg",
        "outputId": "975b6ae6-9599-4103-bbf4-48b757d3e367"
      },
      "source": [
        "print(\"test_acc: \", test_acc)\n",
        "print(\"test_precision: \", test_precision)\n",
        "print(\"test_recall: \", test_recall)\n",
        "print(\"test_f1_score: \", test_f1_score)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "test_acc:  0.7175893482831114\n",
            "test_precision:  0.8478260869565217\n",
            "test_recall:  0.42184964845862627\n",
            "test_f1_score:  0.5633802816901408\n"
          ]
        }
      ]
    }
  ]
}