02_Model-Training-CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:58:17.714671: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-02-10 11:58:18.836918: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'2.12.1'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os \n",
    "import tensorflow as tf\n",
    "\n",
    "# Importing matplotlib to plot images.\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "# Importing SK-learn to calculate precision and recall\n",
    "import sklearn\n",
    "import sklearn.metrics\n",
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# the data, split between train and test sets\n",
    "(x_train, y_train), (x_val, y_val) = tf.keras.datasets.mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "shape = (28, 28, 1)\n",
    "# reshape image data\n",
    "x_train = x_train.reshape(-1, shape[0] *  shape[1] * shape[2])\n",
    "x_val = x_val.reshape(-1, shape[0] *  shape[1] * shape[2])\n",
    "\n",
    "# convert to float\n",
    "x_train = x_train.astype(np.float32)\n",
    "x_val = x_val.astype(np.float32)\n",
    "\n",
    "# normalize to a scale between -1 and 1\n",
    "x_train = x_train / 127.5 -1\n",
    "x_val = x_val / 127.5 -1\n",
    "\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print(x_val.shape[0], 'test samples')\n",
    "\n",
    "# convert class vectors to binary class matrices (one-hot notation)\n",
    "num_classes = 10\n",
    "y_train_one_hot = tf.keras.utils.to_categorical(y_train, num_classes)\n",
    "y_val_one_hot = tf.keras.utils.to_categorical(y_val, num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f7a08d8d2d0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "i = np.random.randint(0, len(x_train))\n",
    "plt.imshow(x_train[i].reshape(shape))\n",
    "plt.title(\"Label for image %i is: %s\" % (i, y_train[i]))\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GPU and CPU settings\n",
    "If GPU is not available, comment out the bottom block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "if True:\n",
    "    # Enter either 0 or 1 below to select the GPU to use\n",
    "    os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
    "\n",
    "    physical_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "    tf.config.set_visible_devices(physical_devices[0], 'GPU')\n",
    "    tf.config.experimental.set_memory_growth(physical_devices[0], True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " reshape (Reshape)           (None, 28, 28, 1)         0         \n",
      "                                                                 \n",
      " conv2d (Conv2D)             (None, 26, 26, 5)         50        \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 3380)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 10)                33810     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 33,860\n",
      "Trainable params: 33,860\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:58:21.683445: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 30300 MB memory:  -> device: 0, name: Tesla V100-SXM2-32GB, pci bus id: 0000:62:00.0, compute capability: 7.0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:58:23.151245: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8600\n",
      "2024-02-10 11:58:23.413098: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7f778805e930 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2024-02-10 11:58:23.413140: I tensorflow/compiler/xla/service/service.cc:177]   StreamExecutor device (0): Tesla V100-SXM2-32GB, Compute Capability 7.0\n",
      "2024-02-10 11:58:23.420398: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2024-02-10 11:58:23.610378: I ./tensorflow/compiler/jit/device_compiler.h:180] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "469/469 [==============================] - 5s 6ms/step - loss: 0.3865 - accuracy: 0.8883 - val_loss: 0.1863 - val_accuracy: 0.9503\n",
      "Epoch 2/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.1634 - accuracy: 0.9541 - val_loss: 0.1274 - val_accuracy: 0.9629\n",
      "Epoch 3/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.1134 - accuracy: 0.9679 - val_loss: 0.1149 - val_accuracy: 0.9676\n",
      "Epoch 4/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.0869 - accuracy: 0.9746 - val_loss: 0.0929 - val_accuracy: 0.9733\n",
      "Epoch 5/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.0728 - accuracy: 0.9791 - val_loss: 0.0856 - val_accuracy: 0.9729\n",
      "Epoch 6/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.0633 - accuracy: 0.9820 - val_loss: 0.0830 - val_accuracy: 0.9761\n",
      "Epoch 7/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.0565 - accuracy: 0.9832 - val_loss: 0.0725 - val_accuracy: 0.9780\n",
      "Epoch 8/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.0491 - accuracy: 0.9858 - val_loss: 0.0734 - val_accuracy: 0.9778\n",
      "Epoch 9/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.0439 - accuracy: 0.9869 - val_loss: 0.0781 - val_accuracy: 0.9775\n",
      "Epoch 10/10\n",
      "469/469 [==============================] - 3s 6ms/step - loss: 0.0399 - accuracy: 0.9883 - val_loss: 0.0720 - val_accuracy: 0.9786\n"
     ]
    }
   ],
   "source": [
    "########## HYPER PARAMETERS\n",
    "batch_size = 32\n",
    "epochs = 10\n",
    "optimizer = tf.keras.optimizers.Adam()\n",
    "########## HYPER PARAMETERS\n",
    "\n",
    "########## MODEL ARCHITECTURE\n",
    "model = tf.keras.Sequential()\n",
    "model.add(tf.keras.layers.Input(shape=(None, shape[0] *  shape[1] * shape[2]), name=\"input\"))\n",
    "model.add(tf.keras.layers.Reshape((shape[0], shape[1], shape[2])))\n",
    "model.add(tf.keras.layers.Conv2D(5, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(tf.keras.layers.Flatten())\n",
    "#model.add(tf.keras.layers.Dense(5, activation='relu'))\n",
    "model.add(tf.keras.layers.Dense(num_classes, activation='softmax'))\n",
    "########## MODEL ARCHITECTURE\n",
    "\n",
    "# Print summary\n",
    "model.summary()\n",
    "\n",
    "# compile model for training\n",
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer=optimizer,\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "history = model.fit(x_train, y_train_one_hot,\n",
    "                    batch_size=batch_size,\n",
    "                    epochs=epochs,\n",
    "                    verbose=1,\n",
    "                    validation_data=(x_val, y_val_one_hot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot training and test accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 1s 2ms/step\n",
      "\n",
      " Summary of the precision, recall, F1 score for each class:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98       980\n",
      "           1       0.99      0.99      0.99      1135\n",
      "           2       0.97      0.98      0.98      1032\n",
      "           3       0.97      0.99      0.98      1010\n",
      "           4       0.98      0.98      0.98       982\n",
      "           5       0.99      0.97      0.98       892\n",
      "           6       0.98      0.98      0.98       958\n",
      "           7       0.97      0.98      0.97      1028\n",
      "           8       0.99      0.96      0.97       974\n",
      "           9       0.98      0.96      0.97      1009\n",
      "\n",
      "    accuracy                           0.98     10000\n",
      "   macro avg       0.98      0.98      0.98     10000\n",
      "weighted avg       0.98      0.98      0.98     10000\n",
      "\n",
      "\n",
      " Confusion matrix: \n",
      "[[ 970    1    3    0    1    1    3    1    0    0]\n",
      " [   1 1126    2    2    0    0    4    0    0    0]\n",
      " [   2    5 1011    2    1    0    2    7    2    0]\n",
      " [   1    0    4  995    0    3    1    3    3    0]\n",
      " [   1    0    1    0  965    0    4    2    0    9]\n",
      " [   2    0    2   15    0  862    5    1    4    1]\n",
      " [   7    2    1    1    3    2  940    0    2    0]\n",
      " [   0    3   10    3    2    0    0 1005    1    4]\n",
      " [   6    0    5    5    3    3    3    5  939    5]\n",
      " [   4    5    0    4    7    3    0   11    2  973]]\n"
     ]
    }
   ],
   "source": [
    "# use model for inference to get test accuracy\n",
    "y_val_pred = model.predict(x_val)\n",
    "y_val_pred = np.argmax(y_val_pred, axis=1)\n",
    "\n",
    "print ('\\n Summary of the precision, recall, F1 score for each class:')\n",
    "print (sklearn.metrics.classification_report(y_val, y_val_pred))\n",
    "\n",
    "print ('\\n Confusion matrix: ')\n",
    "print (sklearn.metrics.confusion_matrix(y_val, y_val_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f7aee7b9410>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAG2CAYAAACZEEfAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGVElEQVR4nO3deXgT5d7G8TtJ23ShLXsXDkvBHqlYQfbFBQGtqBxBXECQggouLCJyRFRQVEARFREF8WVxYRFeD4j6CgdRAZFNsIiCiIiASguCtLTQtE3m/SMlNl2ghZS0w/dzXXMl88zMM78k6NydPDOxGIZhCAAAwKSs/i4AAACgPBF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqfk17KxZs0bdunVTbGysLBaLli5d6rXcMAyNHTtWMTExCgkJUZcuXbR7926vdY4ePao+ffooIiJCVatW1T333KPMzMzz+CoAAEBF5tewk5WVpaZNm+r1118vdvmkSZM0depUzZgxQxs3blRYWJiSkpKUnZ3tWadPnz764YcftHLlSn388cdas2aNBg0adL5eAgAAqOAsFeWHQC0Wi5YsWaLu3btLcp/ViY2N1SOPPKKRI0dKktLT0xUVFaW5c+eqV69e2rlzpy655BJt3rxZLVu2lCQtX75cN9xwg3777TfFxsb66+UAAIAKIsDfBZRk7969Sk1NVZcuXTxtkZGRatOmjdavX69evXpp/fr1qlq1qifoSFKXLl1ktVq1ceNG9ejRo9i+HQ6HHA6HZ97lcuno0aOqUaOGLBZL+b0oAADgM4Zh6Pjx44qNjZXVWvKXVRU27KSmpkqSoqKivNqjoqI8y1JTU1W7dm2v5QEBAapevbpnneJMnDhR48aN83HFAADAHw4cOKB//OMfJS6vsGGnPI0ePVojRozwzKenp6tevXo6cOCAIiIi/FgZAAAorYyMDNWtW1fh4eGnXa/Chp3o6GhJUlpammJiYjztaWlpatasmWedQ4cOeW2Xl5eno0ePerYvjt1ul91uL9IeERFB2AEAoJI50xCUCht24uLiFB0drVWrVnnCTUZGhjZu3KgHHnhAktSuXTsdO3ZMW7ZsUYsWLSRJn3/+uVwul9q0aeOv0gEAKMowJMN1hil/HZczf95ZaN5VwnJXCeufaXlJ/Z3L/oyi61/3nBQU5re33q9hJzMzUz///LNnfu/evUpJSVH16tVVr149DR8+XM8995zi4+MVFxenMWPGKDY21nPFVkJCgq6//noNHDhQM2bMUG5uroYMGaJevXpxJRYA+Nqpg5grV3LmSq489+TMdbe5nH8/d+YWWrfw8vxtS+rLa3n+o2d5gcdTB9fSBIjTLj/HPlSKPi5kncZcuGHnm2++0TXXXOOZPzWOJjk5WXPnztWjjz6qrKwsDRo0SMeOHdMVV1yh5cuXKzg42LPNvHnzNGTIEHXu3FlWq1U9e/bU1KlTz/trAVCBGUahg3D+wdKZU+gAm+v93HAW+Au2LAdB5xmWF9NH4b+kS32gLcPB3uUsIUCcJnQUDCiuPH9/khcQi2S1SRarZMl/tNoki6WYtlPzp9umuPWtktVaQn/WEtY/yxoCig4dOa/vZkW5z44/ZWRkKDIyUunp6YzZAc7E5ZRyT0p5Dikv23vyCgt5+WEi1/tgWiRglLRewXBS2vVKCDEcpMuXNUCyBkq2QPeBzfM8wD3ZAvPbAgqsm//oWR7g/dzTVnjdAO/+iztAF5ksZV+u4rY5i35KtU4JbZWcYRjuHG8Yslkt5XJrl9IevyvsmB0Ap+FyusNFbnbRwHEqhOQWmj/t8oLhxVEozBRabpbgYLFJtiCvg6thDZRhC5RhDZBhCZRhscrIP/gYsnrmDVlkyCqXxf14at6wWOQ6tczr0SJX/nNX/vp/z+dPhve80yj4PH+ZYZHz1KNhlVPueadhkcuQnIb7+ak2r0kWOQ3JKZucClCexSanJcA9f+pRAXJZbcrLf+5ut7ofLQH5bTa5Tm1jCZBL7gOzRQUOZMU89RznXJLFZZHyCrUXfp6/ZUnHx4IHTkuB9SyFlnvv37vPwrVZZPn7eYG2gitb5JLkksViKWb7YvZdqJ/i9l142amA4DLcgeHUc1eB8OC9vJj1XWVcv7j+XWVcv1D/BU+lpIy9VlVDg4r7KM8Lwg7gS85cKSdTysnKnwo+d88bjkzlZWfKyD0h5TlkycuWJT9UWPKyJWe2LAUCisUrdOS3VZTAYQuSAoLdp6htdikgyPNXt5H/V7nL6n7usgTIlf/otAa6508ddOVuy5MtfwrwPObmP881rMpRoPvRsBWarHK4bHK4bMqRVSedNjlcVmW7rPmPNp10uudPOq3KdlqU45JynYZys13KdbmU6zTkdF3wJ7pLwZk/5fi7EFQi/v4OibCDC5NhuMNDoUBi5GQqL/u4ck8cV+5J93Nn9nG5HJkyHO7llpwsWXKzZM07IVvuCQU4TygwL0tBrpMKMHLPuGuLpEAfvpQcwyaHgpStQOUoSA4jUA4FKltBylHB50Fy5M87PMv+fvQ8t9iVo8D85+723Pxtcy2ntglSriVQhmyynDr2yaI8l0u5eS7lugzlOl1+/x+cN1f+VHoWixRgtchqsbgfre5HWzFtVqtFNot7mc1aaFmBdlsJbbZC23u12QotK66twLKCdRbs12qxeJ09OKXgx1RwZIN3e8F3xjhDHwXbjRLai9+n115K04/xd1+n+jH+3sizrWF4NRWY//u1/L2dUfy6BdqL9uf9Gtz9eb9Pxe278Es3DEMWi/uzslrk+cw88/lfB1kLtJW8fsHl+W3WMq5fcLm1+H2eOiNmtZbcZ0SwL/+vV3aEHVQOOSdkODKUezJTjqwM5Zw8rtz8yZl9XM7sTHcgycmUHO7gYsnNki3vhGx5WQrIO6FA50kFuk7I7jwpu3FStmIOfKeCyLn+Z+kwAnRCwcpSsE4YdvdzIzi/za4TRrCyFeSejL9DSHaBsOI9H1Rk+akw4/Lb7/l6Uk6pBdosCrBaFWizKCjAqkCbewqwWRRkOzVvUYDNmj9vcbcFWBVo/ft5kM2qAKvF3W6zKih/m1PPi+33VB8Bf+8nyGbN3+7v9QIKbG+zVv5xEwAIOzhLuU6XHHkuZec6/37MdSk7z/3oyHMqO/+x8LznMccpm+Mv2bMPK9jxp0Jz/lSVnCMKzzuiyLwjquo8qmrGUdUw/lKYsmWRFJQ/+dJJI8gTSrIU7Akm2ZZgZVtDlGMNUa4tRLm2UDkDQuUMCJMrMFRGYJiMwDBZ7FVkCa4iq72KbPZwBYZUkd0erJAgm0ICbZ7HGkE2/aPAfKDNHVKK+yvP/Zej4f2XoFH8X6Gn1vP6S9Xw/iuy8Haev1CL/IV8hhqK9ONde2DBgJIfWP4OD+UzQBEAzoSwYyKGYSj9ZK7+zHQo/WSeHAWDSCkei20rYd3TjW2wyakaylAtyzHVPjXpL9W2HFO9/PlalmOqpWOyW0o/9sRlWPLDiPtMyUmFKNsarJz8QJJjC1WeJ5CEyhUYJiMoTAoMk4KqyBocJltwuKz2KgoIDldgSLjsIVUUHBykkECbQoNsqhFoU51CYQQAULkRdiq4PKdLR0/k6M/jOfoz06EjWQ7P8z8zTz26pyOZOcorxwGWduWoliVdtfWXaln/DjLR1mOKtqarto6ppv5SVWUU+xVRSbIDI5VtrylHcC3lhNRWXmhtucJqyxUWJUt4tCwR0QqIiFZwWKSCgwJUPcimKIIIAKCUCDt+kJ3r1JGsHP15/O+QctgTWnJ0pMDzv07klHmQZ3hwgKqGBio4wKbgQJvsAdYij/ZT8wFWhVtOqrrxlyLzjijSeVThuX8qLPeIQh1/KsRxWPbswwo8eUgBORmlL8JilcJqS+FRUpXovx+r1JbCowu0RSk4wK7gM/cIAMBZIez4gGEYynTk6UiBMy2HC4aW4znuMzKZ7oBz3FG2y4YtFql6aJBqVrGrZniQaoTZPc9rVrGrZpVTj3ZVDwtScKDNfdfXk0el46lSZqp0PM378a/8x8xDUu6J0hdjsxcNMPmhxastrKb7Rl8AAPgZYacELpehY/njXzxfGR0v/DXS318lOfLKdklroM3iDi3hfweVGlWCVKvA84IBplRXhbhc0s8rpa9fk/avL9vN3+wR7sASHl3gsXbRUBNc1RR39gQAXDgIOwUMfOcbZTgDdSTToSNZOWW+wVhokM0rpBQ+63JqWa0qdkWEBPjuypS8HOn7D6R1r0qHdxYqqmahAJN/Fqbw2ZmgUN/UAgBABUPYKWD9niOy2r0P+pEhgapZJUg18kPKqeeeIBNuV838MzShQef57XQcl7a+I61/Xcr43d0WFC61HCC16C9Vree+FT4AABcwwk4Bz97cRPViaqpW/lmYGmF2BQVUwKt+Mg9JG9+UNr8lZae726pESW0fkFoMkEKq+rU8AAAqEsJOAT2a/6Ni/+r5kT3S+mnSt/Mkp8PdVuMiqf0w6bI7pECuaQIAoDDCTmXw+1b3eJydyyQjfyB0nZbSFcOli2/gqicAAE6DsFNRGYa0Z5U75Oxd83d7/HVSh+FS/fZcFQUAQCkQdioaZ570wxJ3yEnb7m6zBkiX3ip1GCZFNfFvfQAAVDKEnYoiJ0v69j33mJxj+91tgWFSi2Sp7YNS1br+rQ8AgEqKsONvWUekTTPd08mj7rbQmlKb+6VW90ih1f1bHwAAlRxhx1/++tV9f5yt70p5J91t1RpI7YdKzfpIgSH+rA4AANMg7JxvB79zj8f5YYlkON1tMU3dg44vuZkrqwAA8DHCzvlgGO4rqtZNkfZ8/nd7o05Sh4ekuKu5sgoAgHJC2ClPLqf73jhfTZEOprjbLFapyS3uK6timvqzOgAALgiEnfKQe1JKme/+9fG/9rrbAkKk5ndJ7Qa7x+YAAIDzgrDjSyeOSt/Mcv9uVdZhd1tINan1fVLrgVJYTf/WBwDABYiw4wvpv0nr35C2zJVys9xtkfWk9kOky/tKQWF+LQ8AgAsZYedcpO2Qvp4qbV8sufLcbVGXuq+satJdsgX6szoAACDCTtkZhrTva/fl47tX/N3e4Ep3yLmoM1dWAQBQgRB2SsvlknZ94g45v23Ob7RIl/zLffl4nRZ+LQ8AABSPsHMmeQ5p20L311VHfna32exSszvddzuu0ci/9QEAgNMi7JQkO136Zra0YbqUmeZuC46UWt3rvroqPMq/9QEAgFIh7BSWcVDa8Ib0zRwp57i7LTzWfX+cFsmSPdy/9QEAgDIh7BT0ySPS7iWSK9c9X6uxezzOpbdKAUH+rQ0AAJwVwk5B370v2S1SvXbuK6vir5OsVn9XBQAAzgFhp6CLkqRrR0r12vi7EgAA4COEnYJumyVFRPi7CgAA4EN8RwMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEytQocdp9OpMWPGKC4uTiEhIWrUqJGeffZZGYbhWccwDI0dO1YxMTEKCQlRly5dtHv3bj9WDQAAKpIKHXZeeOEFTZ8+XdOmTdPOnTv1wgsvaNKkSXrttdc860yaNElTp07VjBkztHHjRoWFhSkpKUnZ2dl+rBwAAFQUFqPgaZIK5qabblJUVJRmzZrlaevZs6dCQkL03nvvyTAMxcbG6pFHHtHIkSMlSenp6YqKitLcuXPVq1evUu0nIyNDkZGRSk9PV0RERLm8FgAA4FulPX5X6DM77du316pVq/TTTz9JkrZt26avvvpKXbt2lSTt3btXqamp6tKli2ebyMhItWnTRuvXry+xX4fDoYyMDK8JAACYU4C/Czidxx57TBkZGWrcuLFsNpucTqfGjx+vPn36SJJSU1MlSVFRUV7bRUVFeZYVZ+LEiRo3blz5FQ4AACqMCn1mZ9GiRZo3b57mz5+vrVu36u2339bkyZP19ttvn1O/o0ePVnp6umc6cOCAjyoGAAAVTYU+s/Pvf/9bjz32mGfsTWJiovbt26eJEycqOTlZ0dHRkqS0tDTFxMR4tktLS1OzZs1K7Ndut8tut5dr7QAAoGKo0Gd2Tpw4IavVu0SbzSaXyyVJiouLU3R0tFatWuVZnpGRoY0bN6pdu3bntVYAAFAxVegzO926ddP48eNVr149NWnSRN9++61efvll3X333ZIki8Wi4cOH67nnnlN8fLzi4uI0ZswYxcbGqnv37v4tHgAAVAgVOuy89tprGjNmjB588EEdOnRIsbGxuu+++zR27FjPOo8++qiysrI0aNAgHTt2TFdccYWWL1+u4OBgP1YOAAAqigp9n53zhfvsAABQ+ZjiPjsAAADnirADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMLaA0KzVv3rxMnVosFi1btkx16tQ5q6IAAAB8pVRhJyUlRY888oiqVKlyxnUNw9Dzzz8vh8NxzsUBAACcq1KFHUn697//rdq1a5dq3ZdeeumsCwIAAPClUo3Z2bt3r2rVqlXqTnfs2KH69eufdVEF/f777+rbt69q1KihkJAQJSYm6ptvvvEsNwxDY8eOVUxMjEJCQtSlSxft3r3bJ/sGAACVX6nCTv369WWxWErdad26dWWz2c66qFP++usvdejQQYGBgfr000+1Y8cOvfTSS6pWrZpnnUmTJmnq1KmaMWOGNm7cqLCwMCUlJSk7O/uc9w8AACo/i2EYxtlsmJeXpzfffFNffvmlnE6nOnTooMGDBys4ONhnxT322GNat26d1q5dW+xywzAUGxurRx55RCNHjpQkpaenKyoqSnPnzlWvXr1KtZ+MjAxFRkYqPT1dERERPqsfAACUn9Iev8/60vNhw4ZpyZIluuaaa3T11Vdr/vz5GjBgwNl2V6xly5apZcuWuu2221S7dm1dfvnleuuttzzL9+7dq9TUVHXp0sXTFhkZqTZt2mj9+vUl9utwOJSRkeE1AQAAcyr1AOUlS5aoR48envn//ve/2rVrl+frqqSkJLVt29anxf3yyy+aPn26RowYoccff1ybN2/WsGHDFBQUpOTkZKWmpkqSoqKivLaLioryLCvOxIkTNW7cOJ/WCgAAKqZSn9mZPXu2unfvrj/++EOS+947999/v5YvX66PPvpIjz76qFq1auXT4lwul5o3b64JEybo8ssv16BBgzRw4EDNmDHjnPodPXq00tPTPdOBAwd8VDEAAKhoSh12PvroI/Xu3VsdO3bUa6+9ppkzZyoiIkJPPPGExowZo7p162r+/Pk+LS4mJkaXXHKJV1tCQoL2798vSYqOjpYkpaWlea2TlpbmWVYcu92uiIgIrwkAAJhTmcbs3HHHHdq0aZO2b9+upKQk9e3bV1u2bFFKSopef/31Ml2eXhodOnTQrl27vNp++uknz2XtcXFxio6O1qpVqzzLMzIytHHjRrVr186ntQAAgMqpzAOUq1atqpkzZ+rFF19Uv3799O9//7vcLvN++OGHtWHDBk2YMEE///yz5s+fr5kzZ2rw4MGS3D9LMXz4cD333HNatmyZtm/frn79+ik2Nlbdu3cvl5oAAEDlUuqws3//ft1+++1KTExUnz59FB8fry1btig0NFRNmzbVp59+6vPiWrVqpSVLlmjBggW69NJL9eyzz2rKlCnq06ePZ51HH31UQ4cO1aBBg9SqVStlZmZq+fLlPr0EHgAAVF6lvs9Ox44dFR0drf79+2vFihXas2ePli1bJknauXOn7rvvPkVHR2vRokXlWnB54D47AABUPqU9fpf60vNvvvlG27ZtU6NGjZSUlKS4uDjPsoSEBK1Zs0YzZ848t6oBAAB8rNRhp0WLFho7dqySk5P12WefKTExscg6gwYN8mlxAAAA56rUY3beeecdORwOPfzww/r999/15ptvlmddAAAAPlHqMzv169fX//7v/5ZnLQAAAD5XqjM7Zf3tqOPHj59VMQAAAL5WqrBTrVo1HTp0qNSd1qlTR7/88stZFwUAAOArpfoayzAM/c///I+qVKlSqk5zc3PPqSgAAABfKVXYqVevnt56661SdxodHa3AwMCzLgoAAMBXShV2fv3113IuAwAAoHyU+bexAAAAKhPCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMLUyh50GDRromWee0f79+8ujHgAAAJ8qc9gZPny4/vOf/6hhw4a69tprtXDhQjkcjvKoDQAA4JydVdhJSUnRpk2blJCQoKFDhyomJkZDhgzR1q1by6NGAACAs2YxDMM4lw5yc3P1xhtvaNSoUcrNzVViYqKGDRumAQMGyGKx+KrOcpWRkaHIyEilp6crIiLC3+UAAIBSKO3xu1R3UC5Obm6ulixZojlz5mjlypVq27at7rnnHv322296/PHH9dlnn2n+/Pln2z0AAIBPlDnsbN26VXPmzNGCBQtktVrVr18/vfLKK2rcuLFnnR49eqhVq1Y+LRQAAOBslDnstGrVStdee62mT5+u7t27F/uDn3FxcerVq5dPCgQAADgXZQ47v/zyi+rXr3/adcLCwjRnzpyzLgoAAMBXynw11qFDh7Rx48Yi7Rs3btQ333zjk6IAAAB8pcxhZ/DgwTpw4ECR9t9//12DBw/2SVEAAAC+Uuaws2PHDjVv3rxI++WXX64dO3b4pCgAAABfKXPYsdvtSktLK9J+8OBBBQSc9ZXsAAAA5aLMYee6667T6NGjlZ6e7mk7duyYHn/8cV177bU+LQ4AAOBclflUzOTJk3XVVVepfv36uvzyyyVJKSkpioqK0rvvvuvzAgEAAM5FmcNOnTp19N1332nevHnatm2bQkJCNGDAAPXu3bvYe+4AAAD401kNsgkLC9OgQYN8XQsAAIDPnfWI4h07dmj//v3Kycnxav/Xv/51zkUBAAD4ylndQblHjx7avn27LBaLTv1o+qlfOHc6nb6tEAAA4ByU+Wqshx56SHFxcTp06JBCQ0P1ww8/aM2aNWrZsqW+/PLLcigRAADg7JX5zM769ev1+eefq2bNmrJarbJarbriiis0ceJEDRs2TN9++2151AkAAHBWynxmx+l0Kjw8XJJUs2ZN/fHHH5Kk+vXra9euXb6tDgAA4ByV+czOpZdeqm3btikuLk5t2rTRpEmTFBQUpJkzZ6phw4blUSMAAMBZK3PYefLJJ5WVlSVJeuaZZ3TTTTfpyiuvVI0aNfT+++/7vEAAAIBzYTFOXU51Do4ePapq1ap5rsiqbDIyMhQZGan09HRFRET4uxwAAFAKpT1+l2nMTm5urgICAvT99997tVevXr3SBh0AAGBuZQo7gYGBqlevHvfSAQAAlUaZr8Z64okn9Pjjj+vo0aPlUQ8AAIBPlXmA8rRp0/Tzzz8rNjZW9evXV1hYmNfyrVu3+qw4AACAc1XmsNO9e/dyKAMAAKB8+ORqrMqOq7EAAKh8yuVqLAAAgMqmzF9jWa3W015mzpVaAACgIilz2FmyZInXfG5urr799lu9/fbbGjdunM8KAwAA8AWfjdmZP3++3n//fX344Ye+6O68YswOAACVz3kfs9O2bVutWrXKV90BAAD4hE/CzsmTJzV16lTVqVPHF90BAAD4TJnH7BT+wU/DMHT8+HGFhobqvffe82lxAAAA56rMYeeVV17xCjtWq1W1atVSmzZtVK1aNZ8WBwAAcK7KHHb69+9fDmUAAACUjzKP2ZkzZ44WL15cpH3x4sV6++23fVIUAACAr5Q57EycOFE1a9Ys0l67dm1NmDDBJ0UBAAD4SpnDzv79+xUXF1ekvX79+tq/f79PigIAAPCVMoed2rVr67vvvivSvm3bNtWoUcMnRQEAAPhKmcNO7969NWzYMH3xxRdyOp1yOp36/PPP9dBDD6lXr17lUSMAAMBZK/PVWM8++6x+/fVXde7cWQEB7s1dLpf69evHmB0AAFDhnPVvY+3evVspKSkKCQlRYmKi6tev7+vazht+GwsAgMqntMfvMp/ZOSU+Pl7x8fFnuzkAAMB5UeYxOz179tQLL7xQpH3SpEm67bbbfFIUAACAr5Q57KxZs0Y33HBDkfauXbtqzZo1PikKAADAV8ocdjIzMxUUFFSkPTAwUBkZGT4pqiTPP/+8LBaLhg8f7mnLzs7W4MGDVaNGDVWpUkU9e/ZUWlpaudYBAAAqjzKHncTERL3//vtF2hcuXKhLLrnEJ0UVZ/PmzXrzzTd12WWXebU//PDD+uijj7R48WKtXr1af/zxh2655ZZyqwMAAFQuZR6gPGbMGN1yyy3as2ePOnXqJElatWqVFixYUOxvZvlCZmam+vTpo7feekvPPfecpz09PV2zZs3S/PnzPbXMmTNHCQkJ2rBhg9q2bVsu9QAAgMqjzGd2unXrpqVLl+rnn3/Wgw8+qEceeUS//fabPvvsM3Xv3r0cSpQGDx6sG2+8UV26dPFq37Jli3Jzc73aGzdurHr16mn9+vUl9udwOJSRkeE1AQAAczqrS89vvPFG3XjjjUXav//+e1166aXnXFRBCxcu1NatW7V58+Yiy1JTUxUUFKSqVat6tUdFRSk1NbXEPidOnKhx48b5tE4AAFAxlfnMTmHHjx/XzJkz1bp1azVt2tQXNXkcOHBADz30kObNm6fg4GCf9Tt69Gilp6d7pgMHDvisbwAAULGcddhZs2aN+vXrp5iYGE2ePFmdOnXShg0bfFmbtmzZokOHDql58+YKCAhQQECAVq9eralTpyogIEBRUVHKycnRsWPHvLZLS0tTdHR0if3a7XZFRER4TQAAwJzK9DVWamqq5s6dq1mzZikjI0O33367HA6Hli5dWi5XYnXu3Fnbt2/3ahswYIAaN26sUaNGqW7dugoMDNSqVavUs2dPSdKuXbu0f/9+tWvXzuf1AACAyqfUYadbt25as2aNbrzxRk2ZMkXXX3+9bDabZsyYUW7FhYeHFxkDFBYWpho1anja77nnHo0YMULVq1dXRESEhg4dqnbt2nElFgAAkFSGsPPpp59q2LBheuCBByrUb2K98sorslqt6tmzpxwOh5KSkvTGG2/4uywAAFBBlPpXzzds2KBZs2bp/fffV0JCgu666y716tVLMTEx2rZtW7neULC88avnAABUPqU9fpd6gHLbtm311ltv6eDBg7rvvvu0cOFCxcbGyuVyaeXKlTp+/LhPCgcAAPClUp/ZKc6uXbs0a9Ysvfvuuzp27JiuvfZaLVu2zJf1nRec2QEAoPLx+Zmd4lx88cWaNGmSfvvtNy1YsOBcugIAACgX53Rmxyw4swMAQOVzXs7sAAAAVHSEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGoVOuxMnDhRrVq1Unh4uGrXrq3u3btr165dXutkZ2dr8ODBqlGjhqpUqaKePXsqLS3NTxUDAICKpkKHndWrV2vw4MHasGGDVq5cqdzcXF133XXKysryrPPwww/ro48+0uLFi7V69Wr98ccfuuWWW/xYNQAAqEgshmEY/i6itA4fPqzatWtr9erVuuqqq5Senq5atWpp/vz5uvXWWyVJP/74oxISErR+/Xq1bdu2VP1mZGQoMjJS6enpioiIKM+XAAAAfKS0x+8KfWansPT0dElS9erVJUlbtmxRbm6uunTp4lmncePGqlevntavX19iPw6HQxkZGV4TAAAwp0oTdlwul4YPH64OHTro0ksvlSSlpqYqKChIVatW9Vo3KipKqampJfY1ceJERUZGeqa6deuWZ+kAAMCPKk3YGTx4sL7//nstXLjwnPsaPXq00tPTPdOBAwd8UCEAAKiIAvxdQGkMGTJEH3/8sdasWaN//OMfnvbo6Gjl5OTo2LFjXmd30tLSFB0dXWJ/drtddru9PEsGAAAVRIU+s2MYhoYMGaIlS5bo888/V1xcnNfyFi1aKDAwUKtWrfK07dq1S/v371e7du3Od7kAAKACqtBndgYPHqz58+frww8/VHh4uGccTmRkpEJCQhQZGal77rlHI0aMUPXq1RUREaGhQ4eqXbt2pb4SCwAAmFuFvvTcYrEU2z5nzhz1799fkvumgo888ogWLFggh8OhpKQkvfHGG6f9GqswLj0HAKDyKe3xu0KHnfOFsAMAQOVjyvvsAAAAlBVhBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmFqAvwuoLFwul3JycvxdBlAugoKCZLXytw8AcyLslEJOTo727t0rl8vl71KAcmG1WhUXF6egoCB/lwIAPkfYOQPDMHTw4EHZbDbVrVuXv35hOi6XS3/88YcOHjyoevXqyWKx+LskAPApws4Z5OXl6cSJE4qNjVVoaKi/ywHKRa1atfTHH38oLy9PgYGB/i4HAHyK0xRn4HQ6JYnT+zC1U/++T/17BwAzIeyUEqf2YWb8+wZgZoQdAABgaoQdlKhjx44aPny4Z75BgwaaMmXKabexWCxaunTpOe/bV/0AAEDYMaFu3brp+uuvL3bZ2rVrZbFY9N1335W5382bN2vQoEHnWp6Xp59+Ws2aNSvSfvDgQXXt2tWn+yrJyZMnVb16ddWsWVMOh+O87BMAcP4Qdkzonnvu0cqVK/Xbb78VWTZnzhy1bNlSl112WZn7rVWr1nm7Ii06Olp2u/287OuDDz5QkyZN1LhxY7+fTTIMQ3l5eX6tAQDMhrBTRoZh6EROnl8mwzBKVeNNN92kWrVqae7cuV7tmZmZWrx4se655x4dOXJEvXv3Vp06dRQaGqrExEQtWLDgtP0W/hpr9+7duuqqqxQcHKxLLrlEK1euLLLNqFGj9M9//lOhoaFq2LChxowZo9zcXEnS3LlzNW7cOG3btk0Wi0UWi8VTc+GvsbZv365OnTopJCRENWrU0KBBg5SZmelZ3r9/f3Xv3l2TJ09WTEyMatSoocGDB3v2dTqzZs1S37591bdvX82aNavI8h9++EE33XSTIiIiFB4eriuvvFJ79uzxLJ89e7aaNGkiu92umJgYDRkyRJL066+/ymKxKCUlxbPusWPHZLFY9OWXX0qSvvzyS1ksFn366adq0aKF7Ha7vvrqK+3Zs0c333yzoqKiVKVKFbVq1UqfffaZV10Oh0OjRo1S3bp1ZbfbddFFF2nWrFkyDEMXXXSRJk+e7LV+SkqKLBaLfv755zO+JwBgJtxnp4xO5jp1ydgVftn3jmeSFBp05o8sICBA/fr109y5c/XEE094rrRZvHixnE6nevfurczMTLVo0UKjRo1SRESEPvnkE911111q1KiRWrdufcZ9uFwu3XLLLYqKitLGjRuVnp7uNb7nlPDwcM2dO1exsbHavn27Bg4cqPDwcD366KO644479P3332v58uWeA3lkZGSRPrKyspSUlKR27dpp8+bNOnTokO69914NGTLEK9B98cUXiomJ0RdffKGff/5Zd9xxh5o1a6aBAweW+Dr27Nmj9evX6z//+Y8Mw9DDDz+sffv2qX79+pKk33//XVdddZU6duyozz//XBEREVq3bp3n7Mv06dM1YsQIPf/88+ratavS09O1bt26M75/hT322GOaPHmyGjZsqGrVqunAgQO64YYbNH78eNntdr3zzjvq1q2bdu3apXr16kmS+vXrp/Xr12vq1Klq2rSp9u7dqz///FMWi0V333235syZo5EjR3r2MWfOHF111VW66KKLylwfAFRmhB2Tuvvuu/Xiiy9q9erV6tixoyT3wa5nz56KjIxUZGSk14Fw6NChWrFihRYtWlSqsPPZZ5/pxx9/1IoVKxQbGytJmjBhQpFxNk8++aTneYMGDTRy5EgtXLhQjz76qEJCQlSlShUFBAQoOjq6xH3Nnz9f2dnZeueddxQWFiZJmjZtmrp166YXXnhBUVFRkqRq1app2rRpstlsaty4sW688UatWrXqtGFn9uzZ6tq1q6pVqyZJSkpK0pw5c/T0009Lkl5//XVFRkZq4cKFnpvt/fOf//Rs/9xzz+mRRx7RQw895Glr1arVGd+/wp555hlde+21nvnq1auradOmnvlnn31WS5Ys0bJlyzRkyBD99NNPWrRokVauXKkuXbpIkho2bOhZv3///ho7dqw2bdqk1q1bKzc3V/Pnzy9ytgcALgSEnTIKCbRpxzNJftt3aTVu3Fjt27fX7Nmz1bFjR/38889au3atnnnmGUnum8dNmDBBixYt0u+//66cnBw5HI5Sj8nZuXOn6tat6wk6ktSuXbsi673//vuaOnWq9uzZo8zMTOXl5SkiIqLUr+PUvpo2beoJOpLUoUMHuVwu7dq1yxN2mjRpIpvt7/coJiZG27dvL7Ffp9Opt99+W6+++qqnrW/fvho5cqTGjh0rq9WqlJQUXXnllcXeVfjQoUP6448/1Llz5zK9nuK0bNnSaz4zM1NPP/20PvnkEx08eFB5eXk6efKk9u/fL8n9lZTNZtPVV19dbH+xsbG68cYbNXv2bLVu3VofffSRHA6HbrvttnOuFQAqG8bslJHFYlFoUIBfprLe+O2ee+7RBx98oOPHj2vOnDlq1KiR5+D44osv6tVXX9WoUaP0xRdfKCUlRUlJST79Zff169erT58+uuGGG/Txxx/r22+/1RNPPFFuvx5fOJBYLJbT/njrihUr9Pvvv+uOO+5QQECAAgIC1KtXL+3bt0+rVq2SJIWEhJS4/emWSfL8jlrBsVYljSEqGOQkaeTIkVqyZIkmTJigtWvXKiUlRYmJiZ737kz7lqR7771XCxcu1MmTJzVnzhzdcccd/OQJgAsSYcfEbr/9dlmtVs2fP1/vvPOO7r77bk9gWrdunW6++Wb17dtXTZs2VcOGDfXTTz+Vuu+EhAQdOHBABw8e9LRt2LDBa52vv/5a9evX1xNPPKGWLVsqPj5e+/bt81onKCjojD9RkJCQoG3btikrK8vTtm7dOlmtVl188cWlrrmwWbNmqVevXkpJSfGaevXq5RmofNlll2nt2rXFhpTw8HA1aNDAE4wKq1WrliR5vUcFByufzrp169S/f3/16NFDiYmJio6O1q+//upZnpiYKJfLpdWrV5fYxw033KCwsDBNnz5dy5cv1913312qfQOA2RB2TKxKlSq64447NHr0aB08eFD9+/f3LIuPj9fKlSv19ddfa+fOnbrvvvuUlpZW6r67dOmif/7zn0pOTta2bdu0du1aPfHEE17rxMfHa//+/Vq4cKH27NmjqVOnasmSJV7rNGjQQHv37lVKSor+/PPPYu9z06dPHwUHBys5OVnff/+9vvjiCw0dOlR33XWX5yussjp8+LA++ugjJScn69JLL/Wa+vXrp6VLl+ro0aMaMmSIMjIy1KtXL33zzTfavXu33n33Xe3atUuS+z5BL730kqZOnardu3dr69ateu211yS5z760bdtWzz//vHbu3KnVq1d7jWE6nfj4eP3nP/9RSkqKtm3bpjvvvNPrLFWDBg2UnJysu+++W0uXLtXevXv15ZdfatGiRZ51bDab+vfvr9GjRys+Pr7YrxkB4EJA2DG5e+65R3/99ZeSkpK8xtc8+eSTat68uZKSktSxY0dFR0ere/fupe7XarVqyZIlOnnypFq3bq17771X48eP91rnX//6lx5++GENGTJEzZo109dff60xY8Z4rdOzZ09df/31uuaaa1SrVq1iL38PDQ3VihUrdPToUbVq1Uq33nqrOnfurGnTppXtzSjg1GDn4sbbdO7cWSEhIXrvvfdUo0YNff7558rMzNTVV1+tFi1a6K233vJ8ZZacnKwpU6bojTfeUJMmTXTTTTdp9+7dnr5mz56tvLw8tWjRQsOHD9dzzz1XqvpefvllVatWTe3bt1e3bt2UlJSk5s2be60zffp03XrrrXrwwQfVuHFjDRw40Ovsl+T+/HNycjRgwICyvkUAYBoWo7Q3bzGxjIwMRUZGKj09vcjg2ezsbO3du1dxcXEKDg72U4XA2Vm7dq06d+6sAwcOnPYsGP/OAVRGpzt+F8TVWIAJORwOHT58WE8//bRuu+22s/66DwDMgK+xABNasGCB6tevr2PHjmnSpEn+LgcA/IqwA5hQ//795XQ6tWXLFtWpU8ff5QCAXxF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2UGoNGjTQlClTSr3+l19+KYvFomPHjpVbTQAAnAlhx4QsFstpp6effvqs+t28ebMGDRpU6vXbt2+vgwcPKjIy8qz2dzYaN24su92u1NTU87ZPAEDFRtgxoYMHD3qmKVOmKCIiwqtt5MiRnnUNw1BeXl6p+q1Vq5ZCQ0NLXUdQUJCio6NlsVjK/BrOxldffaWTJ0/q1ltv1dtvv31e9nk6ubm5/i4BACDCTtkZhpST5Z+plL/ZGh0d7ZkiIyNlsVg88z/++KPCw8P16aefqkWLFrLb7frqq6+0Z88e3XzzzYqKilKVKlXUqlUrffbZZ179Fv4ay2Kx6H/+53/Uo0cPhYaGKj4+XsuWLfMsL/w11ty5c1W1alWtWLFCCQkJqlKliq6//nodPHjQs01eXp6GDRumqlWrqkaNGho1apSSk5NL9Yvss2bN0p133qm77rpLs2fPLrL8t99+U+/evVW9enWFhYWpZcuW2rhxo2f5Rx99pFatWik4OFg1a9ZUjx49vF7r0qVLvfqrWrWq5s6dK0n69ddfZbFY9P777+vqq69WcHCw5s2bpyNHjqh3796qU6eOQkNDlZiYWOSX3V0ulyZNmqSLLrpIdrtd9erV8/yCfKdOnTRkyBCv9Q8fPqygoCCtWrXqjO8JAIAfAi273BPShFj/7PvxP6SgMJ909dhjj2ny5Mlq2LChqlWrpgMHDuiGG27Q+PHjZbfb9c4776hbt27atWuX6tWrV2I/48aN06RJk/Tiiy/qtddeU58+fbRv3z5Vr1692PVPnDihyZMn691335XValXfvn01cuRIzZs3T5L0wgsvaN68eZozZ44SEhL06quvaunSpbrmmmtO+3qOHz+uxYsXa+PGjWrcuLHS09O1du1aXXnllZKkzMxMXX311apTp46WLVum6Ohobd26VS6XS5L0ySefqEePHnriiSf0zjvvKCcnR//3f/93Vu/rSy+9pMsvv1zBwcHKzs5WixYtNGrUKEVEROiTTz7RXXfdpUaNGql169aSpNGjR+utt97SK6+8oiuuuEIHDx7Ujz/+KEm69957NWTIEL300kuy2+2SpPfee0916tRRp06dylwfAFyICDsXqGeeeUbXXnutZ7569epq2rSpZ/7ZZ5/VkiVLtGzZsiJnFgrq37+/evfuLUmaMGGCpk6dqk2bNun6668vdv3c3FzNmDFDjRo1kiQNGTJEzzzzjGf5a6+9ptGjR3vOqkybNq1UoWPhwoWKj49XkyZNJEm9evXSrFmzPGFn/vz5Onz4sDZv3uwJYhdddJFn+/Hjx6tXr14aN26cp63g+1Faw4cP1y233OLVVvBrw6FDh2rFihVatGiRWrdurePHj+vVV1/VtGnTlJycLElq1KiRrrjiCknSLbfcoiFDhujDDz/U7bffLsl9hqx///7n7etBAKjsCDtlFRjqPsPir337SMuWLb3mMzMz9fTTT+uTTz7RwYMHlZeXp5MnT2r//v2n7eeyyy7zPA8LC1NERIQOHTpU4vqhoaGeoCNJMTExnvXT09OVlpbmOeMhSTabTS1atPCcgSnJ7Nmz1bdvX8983759dfXVV+u1115TeHi4UlJSdPnll5d4xiklJUUDBw487T5Ko/D76nQ6NWHCBC1atEi///67cnJy5HA4PGOfdu7cKYfDoc6dOxfbX3BwsOdrudtvv11bt27V999/7/V1IQDg9Ag7ZWWx+OyrJH8KC/N+DSNHjtTKlSs1efJkXXTRRQoJCdGtt96qnJyc0/YTGBjoNW+xWE4bTIpb3yjlWKSS7NixQxs2bNCmTZs0atQoT7vT6dTChQs1cOBAhYSEnLaPMy0vrs7iBiAXfl9ffPFFvfrqq5oyZYoSExMVFham4cOHe97XM+1Xcn+V1axZM/3222+aM2eOOnXqpPr1659xOwCAGwOUIUlat26d+vfvrx49eigxMVHR0dH69ddfz2sNkZGRioqK0ubNmz1tTqdTW7duPe12s2bN0lVXXaVt27YpJSXFM40YMUKzZs2S5D4DlZKSoqNHjxbbx2WXXXbaAb+1atXyGki9e/dunThx4oyvad26dbr55pvVt29fNW3aVA0bNtRPP/3kWR4fH6+QkJDT7jsxMVEtW7bUW2+9pfnz5+vuu+8+434BAH8j7ECS+6D7n//8RykpKdq2bZvuvPPOM351VB6GDh2qiRMn6sMPP9SuXbv00EMP6a+//ipxfEpubq7effdd9e7dW5deeqnXdO+992rjxo364Ycf1Lt3b0VHR6t79+5at26dfvnlF33wwQdav369JOmpp57SggUL9NRTT2nnzp3avn27XnjhBc9+OnXqpGnTpunbb7/VN998o/vvv7/IWarixMfHa+XKlfr666+1c+dO3XfffUpLS/MsDw4O1qhRo/Too4/qnXfe0Z49e7RhwwZPSDvl3nvv1fPPPy/DMLyuEgMAnBlhB5Kkl19+WdWqVVP79u3VrVs3JSUlqXnz5ue9jlGjRql3797q16+f2rVrpypVqigpKUnBwcHFrr9s2TIdOXKk2ACQkJCghIQEzZo1S0FBQfrvf/+r2rVr64YbblBiYqKef/552Ww2SVLHjh21ePFiLVu2TM2aNVOnTp20adMmT18vvfSS6tatqyuvvFJ33nmnRo4cWap7Dj355JNq3ry5kpKS1LFjR0/gKmjMmDF65JFHNHbsWCUkJOiOO+4oMu6pd+/eCggIUO/evUt8LwAAxbMY5zpgwgQyMjIUGRmp9PR0RUREeC3Lzs7W3r17FRcXx0HGD1wulxISEnT77bfr2Wef9Xc5fvPrr7+qUaNG2rx5c7mEUP6dA6iMTnf8LogByqhQ9u3bp//+97+6+uqr5XA4NG3aNO3du1d33nmnv0vzi9zcXB05ckRPPvmk2rZt65ezbQBQ2fE1FioUq9WquXPnqlWrVurQoYO2b9+uzz77TAkJCf4uzS/WrVunmJgYbd68WTNmzPB3OQBQKXFmBxVK3bp1tW7dOn+XUWF07NjxnC/NB4ALHWd2AACAqRF2Som/rmFm/PsGYGaEnTM4dWnyme4kDFRmp/59n/r3DgBmwpidMwgICFBoaKgOHz6swMBAWa3kQ5iLy+XS4cOHFRoaqoAA/pcAwHz4P9sZWCwWxcTEaO/evdq3b5+/ywHKhdVqVb169fgldQCmRNgphaCgIMXHx/NVFkwrKCiIs5YATIuwU0pWq5U7ywIAUAmZ5k+5119/XQ0aNFBwcLDatGnj9btGAADgwmWKsPP+++9rxIgReuqpp7R161Y1bdpUSUlJRX5MEQAAXHhMEXZefvllDRw4UAMGDNAll1yiGTNmKDQ0VLNnz/Z3aQAAwM8q/ZidnJwcbdmyRaNHj/a0Wa1WdenSRevXry92G4fDIYfD4ZlPT0+X5P71VAAAUDmcOm6f6caolT7s/Pnnn3I6nYqKivJqj4qK0o8//ljsNhMnTtS4ceOKtNetW7dcagQAAOXn+PHjioyMLHF5pQ87Z2P06NEaMWKEZ/7YsWOqX7++9u/ff9o3C/6TkZGhunXr6sCBA4qIiPB3OSgGn1HFx2dU8fEZlY1hGDp+/LhiY2NPu16lDzs1a9aUzWZTWlqaV3taWpqio6OL3cZut8tutxdpj4yM5B9XBRcREcFnVMHxGVV8fEYVH59R6ZXmJEWlH6AcFBSkFi1aaNWqVZ42l8ulVatWqV27dn6sDAAAVASV/syOJI0YMULJyclq2bKlWrdurSlTpigrK0sDBgzwd2kAAMDPTBF27rjjDh0+fFhjx45VamqqmjVrpuXLlxcZtFwSu92up556qtivtlAx8BlVfHxGFR+fUcXHZ1Q+LMaZrtcCAACoxCr9mB0AAIDTIewAAABTI+wAAABTI+wAAABTu+DDzuuvv64GDRooODhYbdq00aZNm/xdEvJNnDhRrVq1Unh4uGrXrq3u3btr165d/i4Lp/H888/LYrFo+PDh/i4FBfz+++/q27evatSooZCQECUmJuqbb77xd1nI53Q6NWbMGMXFxSkkJESNGjXSs88+e8bfe0LpXdBh5/3339eIESP01FNPaevWrWratKmSkpJ06NAhf5cGSatXr9bgwYO1YcMGrVy5Urm5ubruuuuUlZXl79JQjM2bN+vNN9/UZZdd5u9SUMBff/2lDh06KDAwUJ9++ql27Nihl156SdWqVfN3acj3wgsvaPr06Zo2bZp27typF154QZMmTdJrr73m79JM44K+9LxNmzZq1aqVpk2bJsl95+W6detq6NCheuyxx/xcHQo7fPiwateurdWrV+uqq67ydzkoIDMzU82bN9cbb7yh5557Ts2aNdOUKVP8XRYkPfbYY1q3bp3Wrl3r71JQgptuuklRUVGaNWuWp61nz54KCQnRe++958fKzOOCPbOTk5OjLVu2qEuXLp42q9WqLl26aP369X6sDCVJT0+XJFWvXt3PlaCwwYMH68Ybb/T67wkVw7Jly9SyZUvddtttql27ti6//HK99dZb/i4LBbRv316rVq3STz/9JEnatm2bvvrqK3Xt2tXPlZmHKe6gfDb+/PNPOZ3OIndZjoqK0o8//uinqlASl8ul4cOHq0OHDrr00kv9XQ4KWLhwobZu3arNmzf7uxQU45dfftH06dM1YsQIPf7449q8ebOGDRumoKAgJScn+7s8yH32LSMjQ40bN5bNZpPT6dT48ePVp08ff5dmGhds2EHlMnjwYH3//ff66quv/F0KCjhw4IAeeughrVy5UsHBwf4uB8VwuVxq2bKlJkyYIEm6/PLL9f3332vGjBmEnQpi0aJFmjdvnubPn68mTZooJSVFw4cPV2xsLJ+Rj1ywYadmzZqy2WxKS0vzak9LS1N0dLSfqkJxhgwZoo8//lhr1qzRP/7xD3+XgwK2bNmiQ4cOqXnz5p42p9OpNWvWaNq0aXI4HLLZbH6sEDExMbrkkku82hISEvTBBx/4qSIU9u9//1uPPfaYevXqJUlKTEzUvn37NHHiRMKOj1ywY3aCgoLUokULrVq1ytPmcrm0atUqtWvXzo+V4RTDMDRkyBAtWbJEn3/+ueLi4vxdEgrp3Lmztm/frpSUFM/UsmVL9enTRykpKQSdCqBDhw5Fbtnw008/qX79+n6qCIWdOHFCVqv34dhms8nlcvmpIvO5YM/sSNKIESOUnJysli1bqnXr1poyZYqysrI0YMAAf5cGub+6mj9/vj788EOFh4crNTVVkhQZGamQkBA/VwdJCg8PLzKGKiwsTDVq1GBsVQXx8MMPq3379powYYJuv/12bdq0STNnztTMmTP9XRrydevWTePHj1e9evXUpEkTffvtt3r55Zd19913+7s007igLz2XpGnTpunFF19UamqqmjVrpqlTp6pNmzb+LguSLBZLse1z5sxR//79z28xKLWOHTty6XkF8/HHH2v06NHavXu34uLiNGLECA0cONDfZSHf8ePHNWbMGC1ZskSHDh1SbGysevfurbFjxyooKMjf5ZnCBR92AACAuV2wY3YAAMCFgbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAHLfxHLp0qX+LgNAOSDsAPC7/v37y2KxFJmuv/56f5cGwAQu6N/GAlBxXH/99ZozZ45Xm91u91M1AMyEMzsAKgS73a7o6GivqVq1apLcXzFNnz5dXbt2VUhIiBo2bKj//d//9dp++/bt6tSpk0JCQlSjRg0NGjRImZmZXuvMnj1bTZo0kd1uV0xMjIYMGeK1/M8//1SPHj0UGhqq+Ph4LVu2zLPsr7/+Up8+fVSrVi2FhIQoPj6+SDgDUDERdgBUCmPGjFHPnj21bds29enTR7169dLOnTslSVlZWUpKSlK1atW0efNmLV68WJ999plXmJk+fboGDx6sQYMGafv27Vq2bJkuuugir32MGzdOt99+u7777jvdcMMN6tOnj44ePerZ/44dO/Tpp59q586dmj59umrWrHn+3gAAZ88AAD9LTk42bDabERYW5jWNHz/eMAzDkGTcf//9Xtu0adPGeOCBBwzDMIyZM2ca1apVMzIzMz3LP/nkE8NqtRqpqamGYRhGbGys8cQTT5RYgyTjySef9MxnZmYakoxPP/3UMAzD6NatmzFgwADfvGAA5xVjdgBUCNdcc42mT5/u1Va9enXP83bt2nkta9eunVJSUiRJO3fuVNOmTRUWFuZZ3qFDB7lcLu3atUsWi0V//PGHOnfufNoaLrvsMs/zsLAwRURE6NChQ5KkBx54QD179tTWrVt13XXXqXv37mrfvv1ZvVYA5xdhB0CFEBYWVuRrJV8JCQkp1XqBgYFe8xaLRS6XS5LUtWtX7du3T//3f/+nlStXqnPnzho8eLAmT57s83oB+BZjdgBUChs2bCgyn5CQIElKSEjQtm3blJWV5Vm+bt06Wa1WXXzxxQoPD1eDBg20atWqc6qhVq1aSk5O1nvvvacpU6Zo5syZ59QfgPODMzsAKgSHw6HU1FSvtoCAAM8g4MWLF6tly5a64oorNG/ePG3atEmzZs2SJPXp00dPPfWUkpOT9fTTT+vw4cMaOnSo7rrrLkVFRUmSnn76ad1///2qXbu2unbtquPHj2vdunUaOnRoqeobO3asWrRooSZNmsjhcOjjjz/2hC0AFRthB0CFsHz5csXExHi1XXzxxfrxxx8lua+UWrhwoR588EHFxMRowYIFuuSSSyRJoaGhWrFihR566CG1atVKoaGh6tmzp15++WVPX8nJycrOztYrr7yikSNHqmbNmrr11ltLXV9QUJBGjx6tX3/9VSEhIbryyiu1cOFCH7xyAOXNYhiG4e8iAOB0LBaLlixZou7du/u7FACVEGN2AACAqRF2AACAqTFmB0CFx7ftAM4FZ3YAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICp/T/xBq92dPhOEQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.array(history.history['val_accuracy'])*100, label=\"Validation Accuracy\")\n",
    "plt.plot(np.array(history.history['accuracy'])*100, label=\"Training Accuracy\")\n",
    "plt.ylabel(\"Accuracy [%]\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylim(0,100)\n",
    "plt.xlim(0,)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:58:52.465157: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node input}}]]\n",
      "2024-02-10 11:58:52.505637: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node input}}]]\n",
      "2024-02-10 11:58:52.520028: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.535308: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node input}}]]\n",
      "2024-02-10 11:58:52.543190: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.558313: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node input}}]]\n",
      "2024-02-10 11:58:52.563883: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.589540: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.597531: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.640946: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node input}}]]\n",
      "2024-02-10 11:58:52.656715: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.664975: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:58:52.737415: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'inputs' with dtype float and shape [?,?,784]\n",
      "\t [[{{node inputs}}]]\n",
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op while saving (showing 1 of 1). These functions will not be directly callable after loading.\n",
      "2024-02-10 11:58:52.827688: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'serving_default_input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node serving_default_input}}]]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: /tmp/tmphnfbn07m/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: /tmp/tmphnfbn07m/assets\n",
      "2024-02-10 11:58:54.017732: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'serving_default_input' with dtype float and shape [?,?,784]\n",
      "\t [[{{node serving_default_input}}]]\n",
      "2024-02-10 11:58:54.885218: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:364] Ignored output_format.\n",
      "2024-02-10 11:58:54.885272: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:367] Ignored drop_control_dependency.\n",
      "2024-02-10 11:58:54.885800: I tensorflow/cc/saved_model/reader.cc:45] Reading SavedModel from: /tmp/tmphnfbn07m\n",
      "2024-02-10 11:58:54.887625: I tensorflow/cc/saved_model/reader.cc:89] Reading meta graph with tags { serve }\n",
      "2024-02-10 11:58:54.887648: I tensorflow/cc/saved_model/reader.cc:130] Reading SavedModel debug info (if present) from: /tmp/tmphnfbn07m\n",
      "2024-02-10 11:58:54.893298: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:353] MLIR V1 optimization pass is not enabled\n",
      "2024-02-10 11:58:54.894224: I tensorflow/cc/saved_model/loader.cc:231] Restoring SavedModel bundle.\n",
      "2024-02-10 11:58:54.925423: I tensorflow/cc/saved_model/loader.cc:215] Running initialization op on SavedModel bundle at path: /tmp/tmphnfbn07m\n",
      "2024-02-10 11:58:54.934342: I tensorflow/cc/saved_model/loader.cc:314] SavedModel load for tags { serve }; Status: success: OK. Took 48544 microseconds.\n"
     ]
    }
   ],
   "source": [
    "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "tflite_model = converter.convert()\n",
    "\n",
    "\n",
    "with open('model.tflite', 'wb') as f:\n",
    "    f.write(tflite_model)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}