examples/mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Пример реализации полносвязной нейросети на MNIST\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "\n",
    "# For dlf package import\n",
    "notebook_dir = os.path.split(os.getcwd())[0]\n",
    "if notebook_dir not in sys.path:\n",
    "    sys.path.append(notebook_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Данные\n",
    "Продемонстрирую работу своего мини-фрэймворка на классической  задачи распознавания рукописных цифр. Датасет состоит из пар X - изображение 28 на 28 пикселей со значениями яркости кажого пикселя от 0 до 1 и y - класс, изображённая цифра (0-9)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loader(X, Y, batch_size):    \n",
    "    n = X.shape[0]\n",
    "\n",
    "    # перемешиваем индексы\n",
    "    indices = np.arange(n)\n",
    "    np.random.shuffle(indices)\n",
    "    \n",
    "    for start in range(0, n, batch_size):\n",
    "        end = min(start + batch_size, n)\n",
    "        batch_idx = indices[start:end]\n",
    "\n",
    "        yield X[batch_idx], Y[batch_idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Скачиваем датасет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from sklearn.datasets import fetch_openml \n",
    "\n",
    "if os.path.exists('mnist.npz'):\n",
    "    data = np.load(\"mnist.npz\", allow_pickle=True)\n",
    "    X = data['X']\n",
    "    y = data['y']\n",
    "else:\n",
    "    mnist = fetch_openml(\"mnist_784\")\n",
    "    X = np.array(mnist.data / 255.0)\n",
    "    y = np.array(mnist.target.astype(int))\n",
    "    np.savez('mnist.npz', X=X, y=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def onehot(y):\n",
    "    \"\"\"Onehot encorder.\"\"\"\n",
    "    y_onehot = np.zeros(shape=(len(y), 10))\n",
    "    y_onehot[np.arange(len(y)), y] = 1\n",
    "    return y_onehot\n",
    "\n",
    "def predict2class(predict):\n",
    "    \"\"\"Reverse operation to onehot.\"\"\"\n",
    "    return predict.argmax(axis=1)\n",
    "\n",
    "assert (predict2class(onehot(y)) == y).all(), \"Something go wrong with onehot encode/decode!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Делим данные на обучающию и тестовую выборку в соотношение 4 к 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_test_split(X, y, test_size):\n",
    "    train_end = int(np.ceil(len(X)*(1-test_size)))\n",
    "    X_train, y_train = X[:train_end], y[:train_end]\n",
    "    X_test, y_test = X[train_end:], y[train_end:]\n",
    "    return X_train, X_test, y_train, y_test\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, onehot(y), .2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Логи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _space_add(x, min_len=10):\n",
    "    return \" \"*(min_len-len(x)) + x if len(x) < min_len else x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_log(accuracy_val, accuracy_train=None, spaces=10, **vec_metrics):\n",
    "    columns = \" \"\n",
    "    rows = [str(i) for i in range(10)]\n",
    "    for metric_name, data in vec_metrics.items():\n",
    "        columns += _space_add(metric_name, spaces)\n",
    "        for i in range(10):\n",
    "            rows[i] += _space_add(\"%.4f\" % data[i], spaces)\n",
    "\n",
    "    if len(rows[0]) > 1:\n",
    "        print(columns)\n",
    "        print(\"\\n\".join(rows) + \"\\n\")\n",
    "    if accuracy_train is not None:\n",
    "        print(\"accuracy_train: %.4f\" % accuracy_train)\n",
    "    print(\"accuracy_val: %.4f\" % accuracy_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_confusion_matrix(conf_m, classes, spaces=10):\n",
    "    rows = [\" \" + \"\".join([_space_add(str(x), spaces) for x in range(10)]) + \" true\"]\n",
    "    for i, cl in enumerate(classes):\n",
    "        s = str(cl) + \"\".join([_space_add(\"%d\" % x, spaces) for x in conf_m[i]]) \n",
    "        rows.append(s)\n",
    "    print(\"\\n\".join(rows))\n",
    "    print(\"pred\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обучение модели"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0 - просто эпоха\n",
    "# 1 - +accuracy_val\n",
    "# 2 - +accuracy_train\n",
    "# 3 - +f_score; +precision; +recall\n",
    "VERBOSITY = 2\n",
    "CLEAR_OUTPUT = False\n",
    "\n",
    "learning_rate = 1e-3\n",
    "batch_size = 128\n",
    "epochs = 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создаём модель."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dlf.linear import Linear\n",
    "from dlf.activation import LeakyReLU\n",
    "from dlf.base import Sequential\n",
    "from dlf.penalty import Dropout, BatchNorm\n",
    "from dlf.loss import CrossEntropy\n",
    "from dlf.optim import NAdam\n",
    "\n",
    "model = Sequential(\n",
    "    Linear(784, 300),\n",
    "    LeakyReLU(),\n",
    "    Dropout(.4),\n",
    "    BatchNorm(300),\n",
    "    Linear(300, 300),\n",
    "    LeakyReLU(),\n",
    "    Dropout(.4),\n",
    "    BatchNorm(300),\n",
    "    Linear(300, 300),\n",
    "    LeakyReLU(),\n",
    "    Dropout(.4),\n",
    "    BatchNorm(300),\n",
    "    Linear(300, 10),\n",
    ")\n",
    "\n",
    "criterion = CrossEntropy()\n",
    "optimizer = NAdam(learning_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обучаем модель и собираем статистику."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1\n",
      "accuracy_train: 0.8936\n",
      "accuracy_val: 0.9639\n",
      "epoch 2\n",
      "accuracy_train: 0.9426\n",
      "accuracy_val: 0.9722\n",
      "epoch 3\n",
      "accuracy_train: 0.9511\n",
      "accuracy_val: 0.9755\n",
      "epoch 4\n",
      "accuracy_train: 0.9582\n",
      "accuracy_val: 0.9746\n",
      "epoch 5\n",
      "accuracy_train: 0.9625\n",
      "accuracy_val: 0.9790\n",
      "epoch 6\n",
      "accuracy_train: 0.9665\n",
      "accuracy_val: 0.9790\n",
      "epoch 7\n",
      "accuracy_train: 0.9686\n",
      "accuracy_val: 0.9806\n",
      "epoch 8\n",
      "accuracy_train: 0.9692\n",
      "accuracy_val: 0.9814\n",
      "epoch 9\n",
      "accuracy_train: 0.9713\n",
      "accuracy_val: 0.9813\n",
      "epoch 10\n",
      "accuracy_train: 0.9730\n",
      "accuracy_val: 0.9808\n",
      "epoch 11\n",
      "accuracy_train: 0.9729\n",
      "accuracy_val: 0.9822\n",
      "epoch 12\n",
      "accuracy_train: 0.9758\n",
      "accuracy_val: 0.9829\n",
      "epoch 13\n",
      "accuracy_train: 0.9761\n",
      "accuracy_val: 0.9821\n",
      "epoch 14\n",
      "accuracy_train: 0.9774\n",
      "accuracy_val: 0.9817\n",
      "epoch 15\n",
      "accuracy_train: 0.9770\n",
      "accuracy_val: 0.9836\n",
      "epoch 16\n",
      "accuracy_train: 0.9784\n",
      "accuracy_val: 0.9831\n",
      "epoch 17\n",
      "accuracy_train: 0.9791\n",
      "accuracy_val: 0.9835\n",
      "epoch 18\n",
      "accuracy_train: 0.9793\n",
      "accuracy_val: 0.9831\n",
      "epoch 19\n",
      "accuracy_train: 0.9803\n",
      "accuracy_val: 0.9824\n",
      "epoch 20\n",
      "accuracy_train: 0.9809\n",
      "accuracy_val: 0.9836\n",
      "epoch 21\n",
      "accuracy_train: 0.9811\n",
      "accuracy_val: 0.9837\n",
      "epoch 22\n",
      "accuracy_train: 0.9818\n",
      "accuracy_val: 0.9846\n",
      "epoch 23\n",
      "accuracy_train: 0.9833\n",
      "accuracy_val: 0.9835\n",
      "epoch 24\n",
      "accuracy_train: 0.9832\n",
      "accuracy_val: 0.9846\n",
      "epoch 25\n",
      "accuracy_train: 0.9835\n",
      "accuracy_val: 0.9837\n",
      "epoch 26\n",
      "accuracy_train: 0.9848\n",
      "accuracy_val: 0.9848\n",
      "epoch 27\n",
      "accuracy_train: 0.9842\n",
      "accuracy_val: 0.9839\n",
      "epoch 28\n",
      "accuracy_train: 0.9849\n",
      "accuracy_val: 0.9857\n",
      "epoch 29\n",
      "accuracy_train: 0.9854\n",
      "accuracy_val: 0.9844\n",
      "epoch 30\n",
      "accuracy_train: 0.9851\n",
      "accuracy_val: 0.9849\n",
      "epoch 31\n",
      "accuracy_train: 0.9859\n",
      "accuracy_val: 0.9859\n",
      "epoch 32\n",
      "accuracy_train: 0.9865\n",
      "accuracy_val: 0.9851\n",
      "epoch 33\n",
      "accuracy_train: 0.9848\n",
      "accuracy_val: 0.9845\n",
      "epoch 34\n",
      "accuracy_train: 0.9864\n",
      "accuracy_val: 0.9854\n",
      "epoch 35\n",
      "accuracy_train: 0.9865\n",
      "accuracy_val: 0.9862\n",
      "epoch 36\n",
      "accuracy_train: 0.9864\n",
      "accuracy_val: 0.9852\n",
      "epoch 37\n",
      "accuracy_train: 0.9869\n",
      "accuracy_val: 0.9848\n",
      "epoch 38\n",
      "accuracy_train: 0.9883\n",
      "accuracy_val: 0.9857\n",
      "epoch 39\n",
      "accuracy_train: 0.9881\n",
      "accuracy_val: 0.9854\n",
      "epoch 40\n",
      "accuracy_train: 0.9884\n",
      "accuracy_val: 0.9858\n",
      "epoch 41\n",
      "accuracy_train: 0.9881\n",
      "accuracy_val: 0.9864\n",
      "epoch 42\n",
      "accuracy_train: 0.9890\n",
      "accuracy_val: 0.9852\n",
      "epoch 43\n",
      "accuracy_train: 0.9889\n",
      "accuracy_val: 0.9851\n",
      "epoch 44\n",
      "accuracy_train: 0.9892\n",
      "accuracy_val: 0.9846\n",
      "epoch 45\n",
      "accuracy_train: 0.9884\n",
      "accuracy_val: 0.9864\n",
      "epoch 46\n",
      "accuracy_train: 0.9885\n",
      "accuracy_val: 0.9859\n",
      "epoch 47\n",
      "accuracy_train: 0.9892\n",
      "accuracy_val: 0.9857\n",
      "epoch 48\n",
      "accuracy_train: 0.9897\n",
      "accuracy_val: 0.9856\n",
      "epoch 49\n",
      "accuracy_train: 0.9905\n",
      "accuracy_val: 0.9862\n",
      "epoch 50\n",
      "accuracy_train: 0.9894\n",
      "accuracy_val: 0.9852\n",
      "epoch 51\n",
      "accuracy_train: 0.9895\n",
      "accuracy_val: 0.9846\n",
      "epoch 52\n",
      "accuracy_train: 0.9904\n",
      "accuracy_val: 0.9846\n",
      "epoch 53\n",
      "accuracy_train: 0.9902\n",
      "accuracy_val: 0.9843\n",
      "epoch 54\n",
      "accuracy_train: 0.9900\n",
      "accuracy_val: 0.9852\n",
      "epoch 55\n",
      "accuracy_train: 0.9905\n",
      "accuracy_val: 0.9862\n",
      "epoch 56\n",
      "accuracy_train: 0.9907\n",
      "accuracy_val: 0.9845\n",
      "epoch 57\n",
      "accuracy_train: 0.9902\n",
      "accuracy_val: 0.9859\n",
      "epoch 58\n",
      "accuracy_train: 0.9906\n",
      "accuracy_val: 0.9856\n",
      "epoch 59\n",
      "accuracy_train: 0.9906\n",
      "accuracy_val: 0.9851\n",
      "epoch 60\n",
      "accuracy_train: 0.9913\n",
      "accuracy_val: 0.9851\n"
     ]
    }
   ],
   "source": [
    "from dlf.utils import accuracy, precision, recall, f_score, confusion_matrix\n",
    "\n",
    "history = {\n",
    "    \"train_loss\":[], \"val_loss\":[], \n",
    "    \"accuracy_train\":[], \"accuracy_val\":[],\n",
    "}\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "    # Train\n",
    "    train_losses = []\n",
    "    y_pred_l = []\n",
    "    y_true_l = []\n",
    "    for x, y in loader(X_train, y_train, batch_size=batch_size):\n",
    "        y_pred = model(x)\n",
    "        loss = criterion(y_pred, y)\n",
    "\n",
    "        grad = criterion.backward(y_pred, y)\n",
    "        model.backward(x, grad)\n",
    "        \n",
    "        optimizer(model.parameters(), model.grad_parameters())\n",
    "        if VERBOSITY > 1:\n",
    "            y_pred_l.append(y_pred)\n",
    "            y_true_l.append(y)\n",
    "        train_losses.append(loss)\n",
    "    accuracy_train = accuracy(\n",
    "        predict2class(np.vstack(y_pred_l)), predict2class(np.vstack(y_true_l))\n",
    "    ) if VERBOSITY > 1 else None\n",
    "\n",
    "    # Validation\n",
    "    val_losses = []\n",
    "    y_pred_l = []\n",
    "    y_true_l = []\n",
    "    model.eval()\n",
    "    for x, y in loader(X_test, y_test, batch_size=batch_size):\n",
    "        y_pred = model(x)\n",
    "        loss = criterion(y_pred, y)\n",
    "        if VERBOSITY > 0:\n",
    "            y_pred_l.append(y_pred)\n",
    "            y_true_l.append(y)\n",
    "        val_losses.append(loss)\n",
    "    model.train()\n",
    "\n",
    "    # metrics\n",
    "    if VERBOSITY > 0:\n",
    "        y_pred= predict2class(np.vstack(y_pred_l))\n",
    "        y_true = predict2class(np.vstack(y_true_l))\n",
    "        accuracy_val = accuracy(y_pred, y_true)\n",
    "        if VERBOSITY > 2:\n",
    "            f1_score = f_score(y_pred, y_true)\n",
    "            precision_score = precision(y_pred, y_true)\n",
    "            recall_score = recall(y_pred, y_true)\n",
    "    # history\n",
    "    history[\"train_loss\"].append(np.mean(np.hstack(train_losses)))\n",
    "    history[\"val_loss\"].append(np.mean(np.hstack(val_losses)))\n",
    "    if VERBOSITY > 0:\n",
    "        history[\"accuracy_val\"].append(accuracy_val)\n",
    "    if VERBOSITY > 1:\n",
    "        history[\"accuracy_train\"].append(accuracy_train)\n",
    "    #\n",
    "    metrics = dict(\n",
    "        f1_score=f1_score, \n",
    "        precision=precision_score, \n",
    "        recall=recall_score\n",
    "    ) if VERBOSITY > 2 else dict()\n",
    "    print(\"epoch %d\" % epoch)\n",
    "    if VERBOSITY > 0:\n",
    "        print_log(accuracy_val, accuracy_train, **metrics)\n",
    "    if CLEAR_OUTPUT:\n",
    "        clear_output(True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выводим статистику."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAAFNCAYAAABFbcjcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABD4ElEQVR4nO3dd5hU5fn/8ffNArJLERVERBAUFNEIQcSWWCM/MComIaIxaoyGYK+JRvxqTNfYYiyIUaOJJcaSoKJYY4mioGJBxSCiICCoCCgKLHv//njOuMPsLDu7zMyZOfN5XddcM3PqvbA83Oep5u6IiIiISGloFXcAIiIiIlJPyZmIiIhICVFyJiIiIlJClJyJiIiIlBAlZyIiIiIlRMmZiIiISAlRciYlzcweNLOjW3juHDP7Vr5jEpFkMzM3s77R5/Fm9n+5HNuC+xxhZg+3NM51XHdvM5uX7+tK8Sg5k7wzs8/SXnVm9kXa9yOacy13H+HuNxcqVhFJHjObbGa/yrJ9pJktNLPWuV7L3ce6+6/zEFPvKJH76t7ufqu7D1vfa0vyKDmTvHP3DqkX8D5wUNq2W1PHNaeAFBFphr8CR5qZZWw/ErjV3WuLH5JI7pScSdGkqtrN7GwzWwjcZGYbmdn9ZrbYzJZEn7dIO+c/ZnZc9PlHZvaMmV0SHfuumY3I8d4bmNkVZjY/el1hZhtE+7pE9/3UzD4xs6fNrFW072wz+8DMlpvZTDPbrwB/NCKSX/8CNga+mdpgZhsBBwK3mNlQM3su+je/wMyuMrO22S5kZn81s9+kff9ZdM58M/txxrHfNrOXzWyZmc01s1+m7X4qev80akXYLVWmpZ2/u5lNNbOl0fvuafv+Y2a/NrP/RuXRw2bWJZc/DDPbLjr/UzObYWYHp+07wMzeiK75gZmdFW1vtFyUwtMftBTbZoRCc0tgDOF38Kboey/gC+CqdZy/CzAT6AJcDNyQ5ek4m3HArsAgYCAwFDgv2ncmMA/oCnQDzgXczLYFTgJ2dveOwP8D5uT2Y4pIXNz9C+BO4Ki0zYcCb7n7K8Aa4HRCObIbsB9wQlPXNbPhwFnA/kA/ILNP6+fRPTsD3waON7NDon17Ru+do1aE5zKuvTHwAHAlsAlwGfCAmW2SdtgPgGOATYG2USxNxdwGuA94ODrvZODWqHwDuAH4aVTG7QA8Hm3PWi42dT/JDyVnUmx1wAXuvtLdv3D3j939bndf4e7Lgd8Ce63j/Pfc/Xp3XwPcDHQnFBxNOQL4lbsvcvfFwIWEJg6A1dF1tnT31e7+tIdFZ9cAGwADzKyNu89x93da9FOLSLHdDHzfzKqj70dF23D3F919irvXuvsc4DrWXe6kHArc5O6vu/vnwC/Td7r7f9z9NXevc/dXgdtzvC6EZO5/7v63KK7bgbeAg9KOucnd305LPgflcN1dgQ7AH9x9lbs/DtwPHB7tX00o4zq5+xJ3fylte7ZyUYpAyZkU22J3/zL1xcxqzOw6M3vPzJYRqv47m1lVI+cvTH1w9xXRxw453Hdz4L207+9F2wD+CMwCHjaz2WZ2TnT9WcBphAJ4kZndYWabIyIlz92fARYDI81sK2Bn4DYAM9smarJbGJU7vyPUojVlc2Bu2vf0MgUz28XMnoi6aSwFxuZ43dS138vY9h7QI+37wrTPK8i97Jvr7nWNXPd7wAHAe2b2pJntFm3PWi5KcSg5k2LLfPI6E9gW2MXdO1Ff9Z9LU2VzzCc0nab0irbh7svd/Ux334rwlHpGqm+Zu9/m7t+IznXgojzHJSKFcwuhxuxI4GF3/zDafi2hVqpfVO6cS25lzgKgZ9r3Xhn7bwMmAj3dfUNgfNp1m6p1yiyjUtf/IIe4mrpuz4z+Yl9d192nuvtIQpPnvwg1cussF6XwlJxJ3DoS+pl9GvW5uKBA97kdOM/MukadaM8H/g5gZgeaWd+o79oyQnPmGjPb1sz2jQYOfBnFuaZA8YlI/t1C6Bf2E6ImzUhHwr/1z8ysP3B8jte7E/iRmQ0wsxoallcdgU/c/UszG0roI5aymNCtY6tGrj0J2MbMfmBmrc1sNDCA0AS5Pp4n9IX7uZm1MbO9CcnWHWbW1sJcaxu6+2rqy79Gy8X1jEVypORM4nYFUA18BEwBHirQfX4DTANeBV4DXoq2QejY+yjwGfAccI27/4fQ3+wPUWwLCU+W5xYoPhHJs6g/2bNAe0KNVspZhMRpOXA98I8cr/cgocx6nNDk93jGIScAvzKz5YQHwDvTzl1B6FP732gE5K4Z1/6YMJr0TOBj4OfAge7+US6xrSPmVcDBwAhCWXYNcJS7vxUdciQwJ2reHQv8MNreWLkoRWDq3yciIiJSOlRzJiIiIlJClJyJiIiIlBAlZyIiIiIlRMmZiIiISAlRciYiIiJSQlrHHUA+denSxXv37h13GCJSJC+++OJH7t417jjyQeWXSOVprAxLVHLWu3dvpk2bFncYIlIkZpa53E3ZUvklUnkaK8PUrCkikoWZDTezmWY2K9u6gmbW38yeM7OVZnZW2vae0fqKb5rZDDM7tbiRi0i5S1TNmYhIPphZFXA1sD8wD5hqZhPd/Y20wz4BTgEOyTi9FjjT3V8ys47Ai2b2SMa5IiKNUs2ZiEhDQ4FZ7j47Wv7mDmBk+gHuvsjdpwKrM7YvcPeXos/LgTeBHsUJW0SSQMmZiEhDPYC5ad/n0YIEy8x6A18nLD4tIpITJWciIg1Zlm3NWojYzDoAdwOnufuyRo4ZY2bTzGza4sWLWxCmiCSRkjMRkYbmAT3Tvm8BzM/1ZDNrQ0jMbnX3exo7zt0nuPsQdx/StWsiZgQRkTxQciYi0tBUoJ+Z9TGztsBhwMRcTjQzA24A3nT3ywoYo4gklEZriohkcPdaMzsJmAxUATe6+wwzGxvtH29mmwHTgE5AnZmdBgwAdgSOBF4zs+nRJc9190lF/jFEpEwpORMRySJKpiZlbBuf9nkhobkz0zNk77MmIpKTimzWfOIJ+Mc/4o5CRKT55s6FCRNg0aK4IxGRQqnI5OyGG+C88+KOQkSk+WbMgJ/+FN55J+5IRKRQCpqc5bD8yUgze9XMpkfDyb+Rtm+Omb2W2pfPuNq1gy+/zOcVRUSKo7o6vH/xRbxxiEjhFKzPWY7LnzwGTHR3N7MdgTuB/mn793H3j/Idm5IzESlXqeRsxYp44xCRwilkzVkuy5985u6piR3b08xJHltKyZmIlCvVnIkkXyGTs5yWPzGz75jZW8ADwI/TdjnwsJm9aGZj8hmYkjMRKVdKzkSSr5DJWU7Ln7j7ve7eHzgE+HXarj3cfTAwAjjRzPbMepMWLH/Srh3U1oaXiEg5qakJ70rORJKrkMlZs5Y/cfengK3NrEv0fX70vgi4l9BMmu28Zi9/0q5deFftmYiUG9WciSRfIZOzJpc/MbO+0VInmNlgoC3wsZm1N7OO0fb2wDDg9XwFpuRMRMqVkjOR5CvYaM1clj8BvgccZWargS+A0dHIzW7AvVHe1hq4zd0fyldsSs5EpFxtsAGYKTkTSbKCLt+Uw/InFwEXZTlvNjCwUHEpORORcmUWyjAlZyLJVZErBKSaBZSciUg5qq7WPGciSVaRyZlqzkSknFVXq+ZMJMmUnImIlBklZyLJpuRMRKTM1NQoORNJsopOzlS4iUg5Us2ZSLJVdHKmmjMRKUdKzkSSTcmZiEiZUXImkmxKzkREyoySM5FkU3ImIlJmNM+ZSLIpORMRKTOqORNJNiVnIiJlRsmZSLJVZHJWVQVt2ig5E5HypORMJNkqMjmDUHum5ExEylFNDaxaBWvWxB2JiBRCRSdnevIUkXJUXR3e9YApkkwVnZypYBORcpRKzvSAKZJMSs5ERMqMkjORZFNyJiJSZlLJmeY6E0kmJWciIlmY2XAzm2lms8zsnCz7+5vZc2a20szOyth3o5ktMrPXCxGbas5Ekk3JmYhIBjOrAq4GRgADgMPNbEDGYZ8ApwCXZLnEX4HhhYpPyZlIsik5ExFpaCgwy91nu/sq4A5gZPoB7r7I3acCqzNPdvenCMlbQSg5E0m2ik3OqquVnIlIo3oAc9O+z4u2lYSamvCu5EwkmSo2OVPNmYisg2XZ5nm/idkYM5tmZtMWL16c83mqORNJtopOzlSwiUgj5gE9075vAczP903cfYK7D3H3IV27ds35PCVnIslW0cmZas5EpBFTgX5m1sfM2gKHARNjjukrSs5Ekk3JmYhIBnevBU4CJgNvAne6+wwzG2tmYwHMbDMzmwecAZxnZvPMrFO073bgOWDbaPux+YxP85yJJFvruAOIi5IzEVkXd58ETMrYNj7t80JCc2e2cw8vZGyqORNJtoqvOfO8d/EVESmsdu3Cu5IzkWSq6OQMYNWqeOMQEWkuMw1qEkmyik/O1LQpIuWopkbJmUhSFTQ5y2FtupFm9qqZTY/m+vlGrueuLyVnIlLOqquVnIkkVcGSsxzXpnsMGOjug4AfA39pxrnrRR1qRaScKTkTSa5C1pzlsjbdZ+5fdclvT/0M3E2eu75UcyYi5UzJmUhyFTI5y2ltOjP7jpm9BTxAqD3L+dz1oeRMRMpZdbXmORNJqkImZzmtTefu97p7f+AQ4NfNORdavjadkjMRKWeqORNJrkImZ81am87dnwK2NrMuzTm3pWvTKTkTkXKm5EwkuQqZnDW5Np2Z9TUziz4PBtoCH+dy7vpSciYi5UzJmUhyFWz5JnevNbPU2nRVwI2ptemi/eOB7wFHmdlq4AtgdDRAIOu5+YxPyZmIlDMlZyLJVdC1NXNYm+4i4KJcz80nJWciUs40Ca1IcmmFACVnIlKGVHMmklwVn5ypcBORcqTkTCS5KjY5S60QoJozESlH1dWwciWsWRN3JCKSbxWbnKlZU0TKmR4wRZKrYpOztm3Duwo2ESlHWh9YJLkqNjkzC7VnSs5EpBwpORNJropNzkDJmYiULyVnIsml5EzJmYiUoZqa8K7kTCR5lJwpORORMqSaM5HkUnKm5ExEypCSM5HkqvjkTAWbiJSjVHK2YkW8cYhI/lV0clZdrZozESlPqjkTSa6KTs7UrCki5UrJmUhyKTlTciYiZUjJmUhyKTlTciYiZUjJmUhyKTlTciYiZUjznIkkl5IzJWcikoWZDTezmWY2y8zOybK/v5k9Z2Yrzeys5pybD+3ahXclZyLJo+RMyZmIZDCzKuBqYAQwADjczAZkHPYJcApwSQvOzUOMmg5IJKmUnCk5E5GGhgKz3H22u68C7gBGph/g7ovcfSqwurnn5kt1tZIzkSSq+ORMBZuIZNEDmJv2fV60rdDnNkt1tSahFUmiik/OamvDS0QkjWXZ5vk+18zGmNk0M5u2ePHinINLUc2ZSDJVdHKWGoq+cmW8cYhIyZkH9Ez7vgUwP9/nuvsEdx/i7kO6du3a7CCVnIkkU0UnZ6nRTup3JiIZpgL9zKyPmbUFDgMmFuHcZlFyJpJMreMOIE5KzkQkG3evNbOTgMlAFXCju88ws7HR/vFmthkwDegE1JnZacAAd1+W7dxCxFlTo+RMJImUnKHkTEQacvdJwKSMbePTPi8kNFnmdG4hVFfDxx8X+i4iUmxq1kTJmYiUJzVriiSTkjOUnIlIeVJyJpJMSs5QciYi5UnznIkkU0GTsxzWpjvCzF6NXs+a2cC0fXPM7DUzm25m0woRn9amE5FyppozkWQq2ICAtPXl9ifM+zPVzCa6+xtph70L7OXuS8xsBDAB2CVt/z7u/lGhYlTNmYiUMyVnIslUyJqzXName9bdl0Rfp9DIyKdCUXImIuWsujpMol1XF3ckIpJPhUzOmru+3LHAg2nfHXjYzF40szEFiO+rFQKUnIlIOVIZJpJMhZznrDnry+1DSM6+kbZ5D3efb2abAo+Y2Vvu/lSWc8cAYwB69erVrABVcyYi5aymJrx/8UX9ZxEpf4WsOctpfTkz2xH4CzDS3b+aTtHd50fvi4B7Cc2kDazP2nRKzkSknKVqztTvTCRZCpmcNbm+nJn1Au4BjnT3t9O2tzezjqnPwDDg9XwHqORMRMqZkjORZCpYs2Yua9MB5wObANeYGUCtuw8BugH3RttaA7e5+0P5jlHJmYiUs1RyprnORJKloGtr5rA23XHAcVnOmw0MzNyeb61bQ1WVkjMRKU+qORNJpopeIQBC7ZkKNhEpR0rORJJJyVk71ZyJSHlSciaSTErOlJyJSJlSciaSTErOlJyJSJlKn+dMRJKj4pOz6molZyJSnlRzJpJMFZ+cqeZMRMqVkjORZFJypuRMRMqU5jkTSSYlZ0rORKRMpSbSVs2ZSLIoOVNyJiJlqlUr2GADJWciSaPkTJPQikgZq65WGSaSNErOVHMmImVMyZlI8ig5U3ImImWspkbJmUjSKDlTciYiZUw1ZyLJo+RMyZmIlDElZyLJU/HJWWqFAPe4IxERab7qas1zJpI0FZ+ctWsXErPVq+OORESk+VRzJpI8Ss6iSRzVtCki6cxsuJnNNLNZZnZOlv1mZldG+181s8Fp+041s9fNbIaZnVbIOJWciSSPkjMlZyKSwcyqgKuBEcAA4HAzG5Bx2AigX/QaA1wbnbsD8BNgKDAQONDM+hUqViVnIsmj5EzLn4hIQ0OBWe4+291XAXcAIzOOGQnc4sEUoLOZdQe2A6a4+wp3rwWeBL5TqECVnIkkj5Iz1ZyJSEM9gLlp3+dF23I55nVgTzPbxMxqgAOAnoUKVMmZSPK0jjuAuCk5E5EsLMu2zDHdWY9x9zfN7CLgEeAz4BWgNutNzMYQmkTp1atXiwLVJLQiyaOaMyVnItLQPNau7doCmJ/rMe5+g7sPdvc9gU+A/2W7ibtPcPch7j6ka9euLQo0NR1QXV2LTheREqTkTMmZiDQ0FehnZn3MrC1wGDAx45iJwFHRqM1dgaXuvgDAzDaN3nsB3wVuL1Sg1dXhXWWYSHKoWVPJmYhkcPdaMzsJmAxUATe6+wwzGxvtHw9MIvQnmwWsAI5Ju8TdZrYJsBo40d2XFCrWVHL2xRehiVNEyl/FJ2d66hSRbNx9EiEBS982Pu2zAyc2cu43CxtdvfTkTESSQc2aqjkTkTKW6qq2cGG8cYhI/ig5U3ImImWsb9/wPmtWvHGISP4oOdMktCJSxrbeOrwrORNJDiVnqjkTkTJWUwM9esD/sk7WISLlqKDJWQ4LBx8RLRj8qpk9a2YDcz03X5SciUi569dPNWciSVKw5CzHhYPfBfZy9x2BXwMTmnFuXmywQXhXciYi5apvX9WciSRJIWvOmlw42N2fTZv/Zwphhu2czs2XVq2gbVslZyJSvvr1g8WLYenSuCMRkXzIKTkzs1PNrFM0E/YNZvaSmQ1r4rRcFg5OdyzwYAvPXS/t2ik5E0myFpZhZSM1YvOdd+KNQ0TyI9easx+7+zJgGNCVMBP2H5o4J5eFg8OBZvsQkrOzW3DuGDObZmbTFi9e3ERI2aXWphORxGpJGVY2UsmZmjZFkiHX5CyVLB0A3OTur5A9gUqXy8LBmNmOwF+Ake7+cXPOhfwsHKyaM5HEa0kZVjY0nYZIsuSanL1oZg8TCrbJZtYRqGvinCYXDo4WBb4HONLd327OufnUrp3mORNJuJaUYWWjfXvYfHPVnIkkRa5rax4LDAJmu/sKM9uYtRf5bSDHhYPPBzYBrjEzgNqoFizruc3/8XKjmjORxGt2GVZuNJ2GSHLkmpztBkx398/N7IfAYOBPTZ2Uw8LBxwHH5XpuoSg5E0m8FpVh5aRvX7jvvrijEJF8yLVZ81pgRTRJ7M+B94BbChZVkbVrBytWxB2FiBRQosswCDVnixbBsmVxRyIi6yvX5KzW3Z0w19if3P1PQMfChVVcPXvCe+/FHYWIFFCiyzDQdBoiSZJrcrbczH4BHAk8EM3g36ZwYRVX//4wdy589lnckYhIgSS6DANNpyGSJLkmZ6OBlYS5ghYSJoT9Y8GiKrL+/cP722+v+zgRKVuJLsOgPjnToACR8pdTchYVZrcCG5rZgcCX7p6Y/hrbbhve33or3jhEpDCSXoZBmE6je3fVnIkkQa7LNx0KvAB8HzgUeN7MRhUysGLq2zessankTCSZkl6GpWg6DZFkyHUqjXHAzu6+CMDMugKPAncVKrBiatcO+vRRciaSYIkuw1L69oVJRZmASEQKKdc+Z61ShVrk42acWxb691dyJpJgiS/DINScLVwIy5fHHYmIrI9ca84eMrPJwO3R99EUaYLYYunfHx59FNasgaqquKMRkTxLfBkGa0+nMWhQrKGIyHrIKTlz95+Z2feAPQiLBU9w93sLGlmR9e8PK1fC+++HJk4RSY5KKMNg7ek0lJyJlK9ca85w97uBuwsYS6xS02m89ZaSM5EkSnoZBppOQyQp1pmcmdlywLPtAtzdOxUkqhikJ2cjRsQbi4jkRyWVYQAdOsBmmyk5Eyl360zO3D1Ry5usS5cusMkmGhQgkiSVVIal9Ounuc5Eyl3iRiutD43YFJFy17evas5Eyp2SszRKzkSk3G23HSxYAG+8EXckItJSSs7S9O8PixbBJ5/EHYmIxM3MhpvZTDObZWbnZNlvZnZltP9VMxuctu90M5thZq+b2e1m1q5YcR9zDHTqBGefXaw7iki+KTlLkxoUMHNmvHGISLzMrAq4GhgBDAAON7MBGYeNAPpFrzHAtdG5PYBTgCHuvgNQBRxWpNDp0gXGjYP774fHHy/WXUUkn5ScpUkfsSkiFW0oMMvdZ7v7KuAOYGTGMSOBWzyYAnQ2s+7RvtZAtZm1BmqA+cUKHOCUU2DLLeHMM6Gurph3FpF8UHKWpndvaNtWyZmI0AOYm/Z9XrStyWPc/QPgEuB9YAGw1N0fLmCsDbRrB7//PUyfDn//ezHvLCL5oOQsTevWYRi6kjORimdZtmXOl5b1GDPbiFCr1gfYHGhvZj/MehOzMWY2zcymLV68eL0CzjR6NOy8M5x7LqxYkddLi0iBKTnLoBGbIkKoBeuZ9n0LGjZNNnbMt4B33X2xu68G7gF2z3YTd5/g7kPcfUjXrl3zFjxAq1Zw6aXwwQdw+eV5vbSIFJiSswzbbhsWDV61Ku5IRCRGU4F+ZtbHzNoSOvRPzDhmInBUNGpzV0Lz5QJCc+auZlZjZgbsB7xZzOBTvvlNOOgguOKKOO4uIi2l5CxD//6wZg3Mnh13JCISF3evBU4CJhMSqzvdfYaZjTWzsdFhk4DZwCzgeuCE6NzngbuAl4DXCOXshOL+BPV23x0++gg+/zyuCESkuXJe+LxSpI/YTH0Wkcrj7pMICVj6tvFpnx04sZFzLwAuKGiAOeoejR9dsKB+YXQRKW2qOcuw7bbhXf3ORCQJNt88vC9YEG8cIpI7JWcZOnUKhZmWPhGRJEivOROR8qDkLIuhQ+Gpp8AzB86LiJSZVHI2v6jT4IrI+lBylsWwYfDee/C//8UdiYjI+tl44zC5tmrORMpHQZOzHBYO7m9mz5nZSjM7K2PfHDN7zcymm9m0QsaZaf/9w/sjjxTzriIi+WcWas+UnImUj4IlZzkuHPwJYYHgSxq5zD7uPsjdhxQqzmy23hr69IGHi7rgiohIYXTvrmZNkXJSyJqzJhcOdvdF7j4VWF3AOJrNLNSePfEErC6pyEREmk81ZyLlpZDJWS4LB6+LAw+b2YtmNiavkeVg2DBYvhyef77YdxYRya/NN1dyJlJOCpmc5bJw8Lrs4e6DCc2iJ5rZnllvUqCFg/fdN6xNp35nIlLuuneHJUvgyy/jjkREclHI5CyXhYMb5e7zo/dFwL2EZtJsxxVk4eCNNoKdd1a/MxEpf5rrTKS8FDI5y2Xh4KzMrL2ZdUx9BoYBrxcs0kbsvz+88AJ8+mmx7ywikj9aJUCkvBQsOctl4WAz28zM5gFnAOeZ2Twz6wR0A54xs1eAF4AH3P2hQsXamGHDoK4OHn+82HcWEckf1ZyJlJeCLnyew8LBCwnNnZmWAQMLGVsudt0VOnQI/c6++924oxERaRmtEiBSXrRCwDq0aQP77KN+ZyJS3rp0gdatVXMmUi6UnDVh//1h9uzwEhEpR61awWabKTkTKRdKzpqgpZxEJAm0SoBI+VBy1oRtt4XevWFiTuNMRURKk1YJECkfSs6aYAajRoV+Z0uWxB2NiEjLaJUAkfKh5CwHo0dDbS3ce2/ckYiItEz37vDRR7BqVdyRiEhTlJzlYKedoE8fuPPOuCMREWmZ1HQaCxfGG4eINE3JWQ7M4NBD4dFH4eOP445GRKT5tEqASPlQcpaj0aNhzRq45564IxERaT6tEiBSPpSc5WjQIOjbV02bIlKetEqASPlQcpYjs1B79vjjsHhx3NGIiDTPppuGyWhVcyZS+pScNcOhh4aF0O++O+5IRESap6oKunVTciZSDpScNcPXvhYmpVXTpoiUI60SIFIelJw1Q6pp88knNRxdRMqPVgkQKQ9Kzpop1bT5z3/GHYmISPNkWyXgscfCS0RKh5KzZtp+exgyBMaPB/e4oxGRQjGz4WY208xmmdk5WfabmV0Z7X/VzAZH27c1s+lpr2VmdlrRf4AsuneHRYvCiicAX3wBhx0GJ58cb1wisjYlZy1w4onwxhvwn//EHYmIFIKZVQFXAyOAAcDhZjYg47ARQL/oNQa4FsDdZ7r7IHcfBOwErABKYvG37t3DQ+WHH4bvt94alnR66y1Yvjze2ESknpKzFhg9GjbZBK66Ku5IRKRAhgKz3H22u68C7gBGZhwzErjFgylAZzPrnnHMfsA77v5e4UNuWvoqAe5wxRVQXR0+v/RSrKGJSBolZy1QXQ3HHQf//jfMnRt3NCJSAD2A9H/d86JtzT3mMOD2vEfXQumrBDz2GMyYARdeGLZNmxZfXCKyNiVnLTR2bBgYcN11cUciIgVgWbZl9jJd5zFm1hY4GGh0+JCZjTGzaWY2bXERZrdOXyXg8svDvGennAK9eik5EyklSs5aqHdvOOggmDABVq6MOxoRybN5QM+071sAmTOENXXMCOAld/+wsZu4+wR3H+LuQ7p27bqeITetW7cwJdB//gOTJsEJJ8AGG4RBTlOnFvz2IpIjJWfr4aSTwlJOd90VdyQikmdTgX5m1ieqATsMmJhxzETgqGjU5q7AUndPn6jicEqoSROgTRvo2hXuuCMkZWPHhu077wzvvANLlsQbn4gESs7Ww377wTbbaGCASNK4ey1wEjAZeBO4091nmNlYM4tSGiYBs4FZwPXACanzzawG2B+4p6iB5yDVtHnEEWG9TQg1Z6CmTZFSoeRsPbRqFabVmDJFTQIiSePuk9x9G3ff2t1/G20b7+7jo8/u7idG+7/m7tPSzl3h7pu4+9K44m9MKjk77bT6bTvtFN6VnImUBiVn6+noo8O0GiefDGvWxB2NiMi6HXoonHpqWCs4ZaONoG9fPWSKlAolZ+tpww3hyivh+efhz3+OOxoRkXU75pgwv1mmIUNUcyZSKpSc5cHhh8O3vw3jxsHs2XFHIyLSfDvvHOZt/LDRsaUiUixKzvLADK69FqqqYMwYrbkpIuVHgwJESoeSszzp2RMuvjjMun3TTXFHIyLSPIMHhwdNJWci8StocmZmw81sppnNMrNzsuzvb2bPmdlKMzurOeeWojFjYM894Ywz4L2SWElPRCQ3HTrAdttpUIBIKShYcmZmVcDVhFmyBwCHm9mAjMM+AU4BLmnBuSWnVSv4y1/C5/32g3nz4o1HRKQ5UoMC1DVDJF6FrDkbCsxy99nuvgq4AxiZfoC7L3L3qcDq5p5bqvr1g8mTYdEi2HffsIadiEg52HnnMCBAD5Yi8SpkctYDmJv2fV60La/nFnvh4Fzssgs89BAsWBAStAULmj5HRCRuGhQgUhoKmZxZlm25VpbnfG6xFw7O1e67w4MPhifQ/faDjz+OOyIRkXUbOBBat1ZyJhK3QiZn84Cead+3AHJt5Fufc0vGN74BDzwQFhQ+7DCorY07IhGRxlVXh9qzu+7SiicicSpkcjYV6GdmfcysLXAYMLEI55aUvfaC8ePh0UfhnLIYcyoilez00+Htt+Hee+OORKRyFSw5c/da4CRgMvAmcKe7zzCzsWY2FsDMNjOzecAZwHlmNs/MOjV2bqFiLbRjjoGTToJLL4Vbb407GhGRxn3ve2Fg0+9+p1GbInFpXciLu/skYFLGtvFpnxcSmixzOrecXXYZvPYaHHcc9O8PO+0Ud0QiIg1VVYVa/mOPDSPPhw+POyKRyqMVAoqkTRv45z9h003hkEPCQukiIqXohz8Mq5787ndxRyJSmZScFVHXrjBxYlgiZffd4Wc/gy++iDsqEZG1tW0byqennw4vESkuJWdFNnAgvP56aN685BIYNAjuuy8smfLyy/Dqq/DRR3FHKSKV7thjwwPl738fdyQilUfJWQw6dYLrrgsjOFeuhIMPhqFDw8LDAweG9e2WLYs7ShGpZDU1YeTmgw+GB0cRKR4lZzHab79QizZ5cqg9+9e/4NprQ83Z1VfHHZ2IVLoTToDOncM8jXPmxB2NSOUo6GhNaVqHDjBs2Nrb7rsvTLtx8slhv4hIHDbcEO6/Hw48MPSTfegh2HHHuKMSST7VnJWg888Pyz1dc03ckYhIpdtjD3jmmTDFxje/CU8+GXdEIsmnmrMStMsu8P/+XxgwcOKJ0L593BGJSCXbfnt49tlQLg0bFrpkdOgAHTtCly5wxhnQrVvcUYokh2rOStT558PixWHggIhI3Hr2DDVoo0aFsum110J/2UsvheOPjzs6kWRRclaidt89PJ1efDGsWBF3NCIisPHGYQm6qVPhzTdh3jy48MKwDucTT8QdnUhyKDkrYRdcAB9+GJZS+fOf4cwz4fvfh8sv15p3IlIazjgDttwyTLuxZk3c0Ygkg/qclbBvfhP22SckZgDt2oVJIe+6C5YuhV/+MtbwRESoroY//hEOPRRuvBF+8pO4IxIpf6o5K3H33AMvvBBq0FasCHMN/fjHoSlBM3eLSCkYNSo8TI4bFx4cG7N6NUybVry4RMqVkrMS17kz7LxzWDDdDFq1ggkT4Igj4Nxz4Yor4o5QRCqdWSiLPvoIfvObxo/73e9Cefbss0ULTaQsKTkrQ1VV8Ne/hqfV008P76edFgrF666DuXPjjlCk/JnZcDObaWazzOycLPvNzK6M9r9qZoPT9nU2s7vM7C0ze9PMditu9MU3eDAccwz86U/wv/813L98edgH8Ic/FDc2kXKjPmdlqnXrMGqqc2d4/HF45JH69Tg7dgyDBn784/BEKyLNY2ZVwNXA/sA8YKqZTXT3N9IOGwH0i167ANdG7wB/Ah5y91Fm1haoKVrwMfrtb+Gf/wwPjfffv/a+8eNhyRIYORL+/e+wdN0OO8QTp0ipU81ZGWvbFq6/Ht55J/TzWLkS3ngDdtoJjjsODjoIFiyIO0qRsjQUmOXus919FXAHMDLjmJHALR5MATqbWXcz6wTsCdwA4O6r3P3TIsYem802CwOVHnhg7eTsyy/DfGjf+lYYNNC+vWrPRNZFyVmCtG0L220Hjz0Wmg8eeyw8mf7975p6Q6SZegDpHQTmRdtyOWYrYDFwk5m9bGZ/MbOKWefj5JNDOXTaaSEpA7jppjCo6dxzw1xpP/0p3HEHvPturKGKlCwlZwnUqhWccgpMnw7bbANHHhmWXZk9O+7IRMpGtg4BmY84jR3TGhgMXOvuXwc+Bxr0WQMwszFmNs3Mpi1evHh94i0ZbdrAlVeGGv1LLw0jNC++GHbbDfbeOxxzxhmhnPrjH2MNVaRkKTlLsG23DcutXHUVTJkSatH+8Af473/D96lTQzOoatVEGpgH9Ez7vgUwP8dj5gHz3P35aPtdhGStAXef4O5D3H1I165d8xJ4KfjWt+B73wt90C6+OEwBdO659X1ge/SAo44KTZwLF8YaqkhJUnKWcFVVYfH0N9+E4cPhF7+Ab3wjPMUOHRoWND7kkNDkICJfmQr0M7M+UYf+w4CJGcdMBI6KRm3uCix19wXuvhCYa2bbRsftB7xBhbn00vB+3nmw447w7W+vvf/nP4dVq+pHcIpIPSVnFaJHjzCh7YsvhsWKJ02C++4LT7aTJ4datXvvjTtKkdLg7rXAScBk4E3gTnefYWZjzWxsdNgkYDYwC7geOCHtEicDt5rZq8Ag4HfFir1UbLlleBiE8J45cnybbcI0QNdcU983TSSf5s+H73wHLrqo/NaoNk9Qm9aQIUN8mqafbrY33gj90l56CX7wAzjssFCr1q1b3JGJrJuZvejuQ+KOIx+SWH6tWRO6T+yyS/ZpfSZNCjVqDz8M++/f9PUmTAgDn370o7yHKgkza1b4nfrgg9DvsXt3OP98OPbY0C+yVDRWhqnmTBgwIPRBO//8MEfRwQeHIfG9e4eVCCZPhrq6uKMUkXJTVQW77tr4fIt77RWSrYceWvd13EPz6E9/Gia6/cc/mh/Ll1+GgQhz5jT/XCkvr7wSuu8sXx76WD/1FGy1FRx/fBhJ/NZbcUfYNCVnAoQniQsvhE8/haefDv1FdtklJGbDh8PWW4elVz74IO5IRSQp2reHPfdcd3LmDmedFbpgHHtsWMPz6KPhueead6/rrguTc0+YsH4xS2l7+umQ9LdpEwbE7bxz+J15+ukw996SJSFJK/VGQyVnspaamvDEccYZ4en0gw/g9tuhT5+wqPEWW4RatWHD4MwzQ3OEiEhLDR8eulZkW3aurg5OOgkuuyy8T5gQ+sb27BlWGsh1nrQVK+D3vw+fH3kkf7FLafnkEzjwwPB/1H//C/371+8zC03ov/kN/Oc/cNddsYWZEyVnsk4bbBD6oD3+eKgKvvRSGDEi/CO45powf9pf/xp3lCJSroYPD++TJzfcd/75oZz52c/C3GmtWsEmm4QakNra8J/tq6/CE0+E5ewuvzz0Ncp07bVhRPqwYWFQ1McfF+ZnUfePeF15ZVjG8K67oFev7MeMGQMDB4bKheYOEpgyBf7v/9Y/zpy4e2JeO+20k0vxfPGF+/77u7dq5X7nnXFHI5UImOYlUPbk41Wp5VddnXuPHu7f+97a2z/5xL2mxv2ww8IxmZ54wr11a/fQQFX/6t7d/b336o9bvty9S5dQVv33v+GYfJdXb77pPmSI+047uX/5ZcP9tbXuRxzh/qc/5fe+ufjkE/dx49xPPTX7n2OhffaZ+623uq9ZU9j7LFvmvtFG7occ0vSxTz4Zfg/OP3/t7Xff7X7ooe5Ll2Y/7/vfD+f973/rH29KY2VYQQsbYDgwkzDU/Jws+w24Mtr/KjA4bd8c4DVgeq4FcKUWbnH67DP3PfZwb9PG/YEH6rcvW+b+r3+5P/ZYPAWCVAYlZ8lw7LHuG27ovnp1/baLLgr/Q02f3vh5U6e6/+1voZx56y33F14I19l+e/clS8Ixv/99uM5zz4Xrd+rk/pOfNLzW+++H7fPnZ7/XlVe69+7tfsEF9cfU1blfe617dXW4L7ifc07Dc1MxdOhQH1ehLVvm/utf18cF7jffXJx7pxs7Ntz7wQcLe5+LLw73eeGF3I4/7DD3du3c3303JGM/+lH9n9MddzQ8fs2akORD+F3Il6InZ0AV8A5hnbm2wCvAgIxjDgAejJK0XYHn0/bNAbo0556VXLjF6dNP3QcPDr/o48a577tvSNZSv+j9+7tfdVUoLETySclZMvzzn6GseOaZ8H3VqlCbtu++zb/WY4+F8mfffd0XL3bfeGP3Aw6o3z9yZEiyMh8aTz45xLDXXmsnie7uU6aEWrqePcMxbdq4/+AH7gceGL4PG+b+wQchyWzVKhyf8vLL4fjddgvH/v73zf+ZmuvBB+sTiYMPDjHssYf7JpuEP5Niee45d7MQx3HHteway5eH2r91WbHCvVu3UDuaq/ffDzWze+7p3qdP+HsbN869c2f3H/+44fGvvFL/f9qIEc37GdYljuRsN2By2vdfAL/IOOY64PC07zOB7q7krOwsXuw+YED4jfra19x//vPQ7PC3v4XqfghPrOed5/7553FHK0mh5CwZlixxr6oK5YN7aAYD9/vvb9n1brklnJ9KpqZNq9931VXeoGnqs89C+bT11t6g9uvTT0Myt+WWIc633w5NhJ06ubdt63755fVNdkuXhntuu21IGL74ItTide/u/tFH7t/6lvtmm2Vv+syXGTNCDd2OO66dJL7+ekgSjzqqcPdOt2pViKFHD/eDDgrJYmbS25TPPnPfYYdw7rpqUFN/p0880bzr/+Y34bw+feofDEaNct9ii4bJ+xVXhGO/+91QEbFiRcPrjRsXagqb01oUR3I2CvhL2vcjgasyjrkf+Eba98eAIdHnd4GXgBeBMbncs5ILt1KwfHl4esxUVxeeoEaNCr9xW27pfu+99b/AdXXhqeSaa8K7SK6UnCXH7ruHB7m6utB3a9tt16+f0q9+FcqbkSPX3j5zZth+zTX1266/Pmx7+unQtAnu990XYhk9OiSOzz679nWWL3f/+OOG933kkXD+GWe4n3mmr9WkN3ly+H7DDeuOfeVK99NPdx8/PiR1ufrkE/e+fUMt0ty5DfePGxfu/+ijuV+zpf74x3Cve+5xv+uu8Pmxx3I/v67O/fDDQ81bt26hP9nUqQ2PW7XKvVev8PvT3C40K1e633772n3MJkwIsb7xxtrHHnxw+LNN/R1OmrT2/hUrQoyjRzcvhjiSs+9nSc7+nHHMA1mSs52iz5tH75tGTaJ7NnKfMcA0YFqvXr2a96ciRffkk+FJCNyHD3c/+ujwVJneoXf06NB/ZF1eecX93HObV3BJ8ig5S45f/Sr8R3z33aEcuPba9bteXV3oO7RwYcPtvXq5f+c79dt22inUcNXVhdquQYPCf7S//GWI5be/bd69x44NP4uZ+wknrH3vgQPdt9tu3Ynnv/9dXx62bh2aT//2t1AT9s47oYtIZiJSWxvK1DZt6muBMq1YERKMvn2z1/zky5w5ocnwwANDnJ9/Hr4ff3zu10jVhv3mN6FfWJ8+obYyM0m+6SZfr1rWTO++G653xRX121J9FceMCb8fNTXuJ5209nk33xzOe/zx5t2v7Jo1M477JXBWU/es9MKtXKxaFZoCOnUK/UFGj3a/8cYw4mncOPf27UP7/49+FGrc0guxZcvCE2VVlX/Vny19ZJZUFiVnyfHCC+Hf9MYbh1chuz+kD0BI3feqq+r3z5oVyicIfddqa5t3/eXL3bfayn2bbULTXLq//a3pZOKoo0LfpxdecD/rrNA0mDkqtUOH0JfuiitCLc/Pfx62X3fdumN79NFw3LhxzfuZcrV6dWjGrKkJSVrKqFGhSTeXP8vnngtJ5oEH1pf/77/v3q9f+LnPPDOM7t1hh9C0PHBgfgeebbPN2v0UU78jqYECBx4Y/n7T77nbbuG85sYRR3LWmrAocJ+0AQHbZxzz7YwBAS9E29sDHdM+PwsMb+qelV64lZtVq7L/Q/3ww5CAbbCBfzU0/vjjQ+HZo0d4Gv3pT8No0E6d3Dff3P2119Z9rzVrijdKSopHyVlypI+GK1TikPKPf/hXIziPOSY8EGZOn3D//e577529q0YuPv00+yCoVatCv7S99sp+3qpVITFL7xtWW+v+4ouhqfXGG8NI1rFjQ7KSnrCNHZtbbN/9bvizzsf0FrW17n/9a2gOHjKkvty++OK1j7v99rD9qafWfb1Fi0Kfrz59Gg4EmD8/9GOrqgqJ0EEHheQ1n1NbuIdasZqa+r6Bf/hDiD1VC3v11eH7zJnhe2qwwGWXNf9eRU/Owj05AHg7GrU5Lto2FhgbfTbg6mj/a2n9zbaKkrlXgBmpc5t6VXrhljRLlrj//e/hCammJvy2DhoUCtSUV14JyVvnzo3/o//gg9BsYRYK2wkTmh79I+VByVmyHHFEqDFpbDqLfPnoo1AenH56mAZjzJjC3i/TpZeG8izbtA8PPxz2/etfuV3r3XdDmXbBBaEPVS5STYGvvppjwI1YsSI0D0NoBt5331CrdeedDRO/ZctC4nbqqY1fb9GiUFZvsIH7Sy9lP6auLiSwhTRxoq/VR27YsFBLlzJ7tq/V9HnCCSHmbH0QmxJLclbslwq35FqxInQGzTba5913w1NUmzbuZ5+99tPqK6+Ep9QOHUJBvM024be+bVv3I48MtXTZLFhQ3CHn0jJKzpLlgw/CRLHFsNNO9d0jXn65OPdMWbo0NKtmmzD1pz8NNXmF7hOW2a+quRYvdt9115DkXnFFbs15Bx8casWy1di9914on9u1y1//sZZatiz09Tv77JDwVle7n3LK2sf07x+StuXL3Tt2DP+ftERjZZiWb5KyUF0NQ4ZA69YN9/XuHdZRO/xwuOgi2GYbuPlmmDQprBNaVxcWvb3ssrAE1dSpMHZsWDt0wAC47bb6RXDffTcsrrzFFtCtW1iU+bLLYPbsov64IhVp881h992Lc6/994c1a2DXXWHQoOLcM6VTJzjtNPjXv2D69Prta9aEbQccEMq8QtlyS9h667DsVUu88074e5o+PSyVdOqpYe3KpowaBfPmwQsvrL39jTfC9T78MKx9+u1vtyyufOnYMcTz8MPw/PPwxRew775rH3PAAfDkk3DDDbB8efg/Ja+yZWzl+tKTp0yZ4r7LLv5VH4xBg9znzct+7IwZ9cceeGBo2mjdOlRPn3JKWNpjxx3rr3XkkWGkjpQOVHMmLZRawueWW+K5/5IlofYsfdToU0/5Wh3PC+m448L9c+mg//nn4c/rt78NE7C2bx8GbTS3lnPJktDCcdZZ4fucOWG6kI03DtNllNJUSr/9bfi7OOGEMEAts89yasqUmpowt2dLByQ0VobFXiDl86XCTdxDlfktt7ifdlqocl6X2trQibO6OjR1nnhiw2Ru9uwwKSWEavwFCwoXuzSPkjNZH9Omxbu83AUX+FrNqqedFsqhYqymcttt4d7pE/SmTJhQ389q4419rUEHAwaEB9m3327ZfUeMCCsVbLdd/TW33z6MkC0lU6eG2Nq0CQMdMn35ZUhSIQwQaKnGyjAL+5JhyJAhPm3atLjDkDK0eHFo/uzWrfFj7rkHjjwSNtkEJk4MzQIPPwz//jc89RTsvHNoWj3gAGjXrnixVzIze9Hdh8QdRz6o/Ko8n34aumXsuy/cfXf4vOOOcN99hb/3ggWhGfnii+FnP6vf/v770KcPbLUVbL99OGbzzWHgwNDUt8km63ffe+6Bo48O1xo+PLz698+tWbSY1qwJ/x98/HH487n44obHfOc74f+A+fNhww1bdp/GyrAsPXhEKk/Xrk0f893vhsLz4INht91CMrdqFWy8MXzzmyFBu+uu0J/koIPCe20trF4NrVpBr16hwNt66/DerVvpFUgiUjydO8Ppp8Mvfwk33hgSowsvLM69u3eH7baDxx9fOzm77rrw/uijoW9avn33u+FV6qqq4FvfCn2TM/ubpVx5ZUhyW5qYrYuSM5FmGDw4DCj4xS+gS5eQqO2+exioUFsbOtjedhs8+GB48mrdOrzWrIGFC+sHHgDU1IQkbautwrU+/hg++ii8PvssJG6tWoX3Nm1CbVzqNXAgnHBCGNAgIuXr1FPh8svh+ONDQnDQQcW79z77hMFTq1eHMmblSrj+ejjwwMIkZuXmyCPh9dfDw3c2PXuGVyGoWVOkSL78EubMCSM/33knjAx9553w/ZNPQnNBly7h1aHD2vOBr14dCs4vv4TPP4cpU8L3/faDk08OhWlVVdw/YfGpWVOS4MILQ+3ZfvuFGqtiufvuMILyv/8ND5m33go//CFMngzDhhUvjkqmZk2RmLVrF/pW9O+//tdavBj+8he45ho45BDYdNPQVDBqFOy1V8MpR95/H555Jkwp8vLLoU/J0KHh9fWvh1o8EYnHqafCnXfCmDHFve/ee4f3xx8PydnVV0O/fqE5T+KlmjORMlZbGzoP33EH3H8/rFgRauC6dw81a6tWhZq2jz4Kx3fqFOZ0mjMnJGwQmjNGjYITTwwFdGY/OPdQyzdtGrz4Yrju2LH5STLXl2rORNbPoEGhzLjkktBt4/LLwxxsUhyqORNJoNatw4ih73wnJGaTJ4fRo8uWwQYbhFe7drDDDmFC3q99rb75c+HC0H/ukUfgllvg9ttDQX3EEbB0aX3z68yZYVQZhESuVavQEfaQQ+Dss2GXXcI+99BX7u234bnnQtPr88+HPnWXXBLunWn58lBrV4lNsiKlYN99Qw38pZeGf4s/+lHcEQmo5kxECLVrt94KV10Fr71WP7p0662hb9/wRL3TTiHJW7YM/vzncOySJaFD7IoVIYFbs6b+mt27h2bTp58O+044IfStad8+1PbddBM89FAYAfuzn4X/FJo7BYlqzkTWz333hYFNAD/5CUyYEG88laaxMkzJmYh8xT0MDe/aNdSSrctnn4V+b9OmhSkBUq9evcKSOD17hibSTz6B88+Ha68N+yFs69EDRo8OfeFeeCFMLXLaaWHUWq5D05WciayfpUvDdEB1dWE5poED446osqhZU0SaZBYmnMxFhw659U3ZeONQyzZmTEjS2rULtWT77x+aM93DGnV/+EOYoqSuDs49d31+ChHJ1YYbhqkizJSYlRIlZyJSFDvuGBZ1zmQWRo3tvXcYSdq7d3HjEql0992nCbFLTau4AxARSfn612GjjeKOIjCz4WY208xmmdk5WfabmV0Z7X/VzAan7ZtjZq+Z2XQzU1ullLSOHUNNuJQO1ZyJiGQwsyrgamB/YB4w1cwmuvsbaYeNAPpFr12Aa6P3lH3c/aMihSwiCaKaMxGRhoYCs9x9truvAu4ARmYcMxK4xYMpQGcz617sQEUkeZSciYg01AOYm/Z9XrQt12MceNjMXjSzIs/7LiLlTs2aIiINZesenTnv0LqO2cPd55vZpsAjZvaWuz/V4CYhcRsD0KtXr/WJV0QSRDVnIiINzQN6pn3fApif6zHunnpfBNxLaCZtwN0nuPsQdx/StWvXPIUuIuVOyZmISENTgX5m1sfM2gKHARMzjpkIHBWN2twVWOruC8ysvZl1BDCz9sAw4PViBi8i5U3NmiIiGdy91sxOAiYDVcCN7j7DzMZG+8cDk4ADgFnACuCY6PRuwL0WJo5qDdzm7g8V+UcQkTKm5ExEJAt3n0RIwNK3jU/77MCJWc6bDWiudRFpMTVrioiIiJQQJWciIiIiJcRCzXwymNli4L0cD+8ClOrs3YqtZRRby5VyfOuKbUt3T8QwxwSVX1Da8Sm2llFsLdNUbFnLsEQlZ81hZtPcfUjccWSj2FpGsbVcKcdXyrHFpdT/TEo5PsXWMoqtZVoam5o1RUREREqIkjMRERGRElLJydmEuANYB8XWMoqt5Uo5vlKOLS6l/mdSyvEptpZRbC3Totgqts+ZiIiISCmq5JozERERkZJTkcmZmQ03s5lmNsvMzok5lhvNbJGZvZ62bWMze8TM/he9bxRTbD3N7Akze9PMZpjZqaUSn5m1M7MXzOyVKLYLSyW2KI4qM3vZzO4vpbiiWOaY2WtmNt3MppVSfGbW2czuMrO3ot+73UoltlKh8ivn2FR+rV+MJVmGVUr5VXHJmZlVAVcDI4ABwOFmNiDGkP4KDM/Ydg7wmLv3Ax6LvsehFjjT3bcDdgVOjP6sSiG+lcC+7j4QGAQMt7D4dCnEBnAq8Gba91KJK2Ufdx+UNsS7VOL7E/CQu/cnLIH0ZgnFFjuVX82i8mv9lHIZlvzyy90r6gXsBkxO+/4L4Bcxx9QbeD3t+0yge/S5OzAz7j+3KJZ/A/uXWnxADfASsEspxAZsEf0j3Be4v9T+ToE5QJeMbbHHB3QC3iXqC1tKsZXKS+XXesWp8iv3mEq2DKuU8qvias6AHsDctO/zom2lpJu7LwCI3jeNOR7MrDfwdeB5SiS+qNp9OrAIeMTdSyW2K4CfA3Vp20ohrhQHHjazF81sTLStFOLbClgM3BQ1p/zFzNqXSGylQuVXC6j8arYrKN0yrCLKr0pMzizLNg1ZXQcz6wDcDZzm7svijifF3de4+yDCU95QM9sh5pAwswOBRe7+YtyxrMMe7j6Y0DR2opntGXdAkdbAYOBad/868DkV3ITZCJVfzaTyq3nKoAyriPKrEpOzeUDPtO9bAPNjiqUxH5pZd4DofVFcgZhZG0LBdqu731Nq8QG4+6fAfwh9X+KObQ/gYDObA9wB7Gtmfy+BuL7i7vOj90XAvcDQEolvHjAvqkEAuItQ2JVCbKVC5VczqPxqkZIuwyql/KrE5Gwq0M/M+phZW+AwYGLMMWWaCBwdfT6a0Fei6MzMgBuAN939srRdscdnZl3NrHP0uRr4FvBW3LG5+y/cfQt370343Xrc3X8Yd1wpZtbezDqmPgPDgNdLIT53XwjMNbNto037AW+UQmwlROVXjlR+tUwpl2EVVX4Vu9NcKbyAA4C3gXeAcTHHcjuwAFhNyLyPBTYhdMb8X/S+cUyxfYPQZPIqMD16HVAK8QE7Ai9Hsb0OnB9tjz22tBj3pr4zbUnERegX8Ur0mpH6/S+h+AYB06K/138BG5VKbKXyUvmVc2wqv9Y/zpIqwyqp/NIKASIiIiIlpBKbNUVERERKlpIzERERkRKi5ExERESkhCg5ExERESkhSs5ERERESoiSM6kIZra3md0fdxwiIs2l8qvyKDkTERERKSFKzqSkmNkPzewFM5tuZtdFiwN/ZmaXmtlLZvaYmXWNjh1kZlPM7FUzu9fMNoq29zWzR83sleicraPLdzCzu8zsLTO7NZpBXEQkL1R+Sb4oOZOSYWbbAaMJC9sOAtYARwDtgZc8LHb7JHBBdMotwNnuviPwWtr2W4Gr3X0gsDthBnOArwOnAQMIM03vUeAfSUQqhMovyafWcQcgkmY/YCdgavRQWE1YJLYO+Ed0zN+Be8xsQ6Czuz8Zbb8Z+Ge07loPd78XwN2/BIiu94K7z4u+Twd6A88U/KcSkUqg8kvyRsmZlBIDbnb3X6y10ez/Mo5b15pj66rqX5n2eQ36/ReR/FH5JXmjZk0pJY8Bo8xsUwAz29jMtiT8no6KjvkB8Iy7LwWWmNk3o+1HAk+6+zJgnpkdEl1jAzOrKeYPISIVSeWX5I0ybykZ7v6GmZ0HPGxmrYDVwInA58D2ZvYisJTQrwPgaGB8VHjNBo6Jth8JXGdmv4qu8f0i/hgiUoFUfkk+mfu6alhF4mdmn7l7h7jjEBFpLpVf0hJq1hQREREpIao5ExERESkhqjkTERERKSFKzkRERERKiJIzERERkRKi5ExERESkhCg5ExERESkhSs5ERERESsj/B9t1VjLPzMQUAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------- Confusion Matrix --------------------------------------------------\n",
      "          0         1         2         3         4         5         6         7         8         9 true\n",
      "0      1358         0         2         0         1         3         4         1         2         1\n",
      "1         1      1557         1         0         2         0         2         4         3         3\n",
      "2         2         1      1417         4         2         0         0         7         1         0\n",
      "3         1         1         2      1396         0        14         1         2         7         6\n",
      "4         1         0         1         0      1356         1         4         1         4        14\n",
      "5         1         0         1         2         0      1221         2         0         5         7\n",
      "6         3         4         0         0         3         9      1325         0         0         0\n",
      "7         1         3         5         4         2         1         0      1459         3         2\n",
      "8         1         3         1         4         2         2         1         2      1336         0\n",
      "9         4         0         0         3         8         2         0         7         4      1366\n",
      "pred\n"
     ]
    }
   ],
   "source": [
    "def plot_loss(figsize=(10, 5)):\n",
    "    _, (ax1, ax2) = plt.subplots(ncols=2, figsize=figsize)\n",
    "    ax1.plot(history[\"train_loss\"], c=\"blue\")\n",
    "    ax2.plot(history[\"val_loss\"], c=\"blue\")\n",
    "    ax1.set_title('Train loss')\n",
    "    ax2.set_title('Validation loss')\n",
    "    for ax in ax1, ax2:\n",
    "        ax.set_ylabel(\"loss\")\n",
    "        ax.set_xlabel(\"epoch\")\n",
    "    plt.show()\n",
    "    \n",
    "def plot_accuracy(figsize=(10, 10)):\n",
    "    fig, ax = plt.subplots(figsize=figsize)\n",
    "    if history.get(\"accuracy_train\", False):\n",
    "        ax.plot(history[\"accuracy_train\"], c=\"blue\", label=\"Train\")\n",
    "    ax.plot(history[\"accuracy_val\"], c=\"red\", label=\"validation\")\n",
    "    ax.set_title(\"Accuracy\")\n",
    "    ax.set_xlabel(\"epoch\")\n",
    "    ax.set_ylabel(\"accuracy\")\n",
    "    ax.legend()\n",
    "    plt.show()\n",
    "\n",
    "plot_loss()\n",
    "plot_accuracy()\n",
    "print(\"-\"*50, \"Confusion Matrix\", \"-\"*50)\n",
    "print_confusion_matrix(*confusion_matrix(y_pred, y_true))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "88279d2366fe020547cde40dd65aa0e3aa662a6ec1f3ca12d88834876c85e1a6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}