01_Model-Training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:56:23.651294: 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:56:24.746750: 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",
    "\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",
    "\n",
    "\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 0x7f1d7ac5f790>"
      ]
     },
     "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": [
    {
     "data": {
      "text/plain": [
       "(784,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, None, 5)           3925      \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, None, 10)          60        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 3,985\n",
      "Trainable params: 3,985\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:56:27.501367: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 31142 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:56:28.725396: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7f1af8069ae0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2024-02-10 11:56:28.725457: I tensorflow/compiler/xla/service/service.cc:177]   StreamExecutor device (0): Tesla V100-SXM2-32GB, Compute Capability 7.0\n",
      "2024-02-10 11:56:28.738238: 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:56:28.777838: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:424] Loaded cuDNN version 8600\n",
      "2024-02-10 11:56:28.948821: 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 [==============================] - 4s 6ms/step - loss: 1.2259 - accuracy: 0.5848 - val_loss: 0.7959 - val_accuracy: 0.7652\n",
      "Epoch 2/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.7331 - accuracy: 0.7838 - val_loss: 0.6773 - val_accuracy: 0.8055\n",
      "Epoch 3/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.6699 - accuracy: 0.8047 - val_loss: 0.6421 - val_accuracy: 0.8177\n",
      "Epoch 4/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.6417 - accuracy: 0.8133 - val_loss: 0.6247 - val_accuracy: 0.8243\n",
      "Epoch 5/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.6222 - accuracy: 0.8201 - val_loss: 0.6063 - val_accuracy: 0.8309\n",
      "Epoch 6/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.6088 - accuracy: 0.8255 - val_loss: 0.6149 - val_accuracy: 0.8228\n",
      "Epoch 7/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.5991 - accuracy: 0.8275 - val_loss: 0.5979 - val_accuracy: 0.8322\n",
      "Epoch 8/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.5911 - accuracy: 0.8296 - val_loss: 0.5926 - val_accuracy: 0.8339\n",
      "Epoch 9/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.5864 - accuracy: 0.8322 - val_loss: 0.5845 - val_accuracy: 0.8379\n",
      "Epoch 10/10\n",
      "469/469 [==============================] - 2s 5ms/step - loss: 0.5787 - accuracy: 0.8342 - val_loss: 0.5755 - val_accuracy: 0.8388\n"
     ]
    }
   ],
   "source": [
    "########## HYPER PARAMETERS\n",
    "batch_size = 128\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.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": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 1ms/step\n",
      "\n",
      " Summary of the precision, recall, F1 score for each class:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.84      0.86      0.85       980\n",
      "           1       0.93      0.94      0.94      1135\n",
      "           2       0.86      0.85      0.86      1032\n",
      "           3       0.84      0.75      0.79      1010\n",
      "           4       0.84      0.92      0.88       982\n",
      "           5       0.70      0.68      0.69       892\n",
      "           6       0.88      0.85      0.86       958\n",
      "           7       0.86      0.89      0.88      1028\n",
      "           8       0.78      0.78      0.78       974\n",
      "           9       0.81      0.83      0.82      1009\n",
      "\n",
      "    accuracy                           0.84     10000\n",
      "   macro avg       0.84      0.84      0.84     10000\n",
      "weighted avg       0.84      0.84      0.84     10000\n",
      "\n",
      "\n",
      " Confusion matrix: \n",
      "[[ 843    4   16   24    1   24    0   25   29   14]\n",
      " [   3 1072    5    1    1    0   20    1   30    2]\n",
      " [  27   15  874   31    9    3   33    8   30    2]\n",
      " [  41    1   54  758    2  107    2   23   12   10]\n",
      " [   0    1    4    3  903    4   18    6    3   40]\n",
      " [  19    6   13   63   22  609   16   21   72   51]\n",
      " [   3   22   23    4   30   18  814    5   31    8]\n",
      " [  21    8   19    7   14    1    3  918    1   36]\n",
      " [  31   21    2    9   16   85   21    2  757   30]\n",
      " [  18    1    1    1   72   13    0   55    8  840]]\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": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f1dd42285d0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "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": "markdown",
   "metadata": {},
   "source": [
    "# Save the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:57:52.653821: 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:57:52.707532: 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:57:52.723625: 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:57:52.737307: 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:57:52.748417: 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:57:52.761799: 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:57:52.770178: 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:57:52.778202: 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 [?,?,5]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:57:52.789542: 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:57:52.800132: 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:57:52.854865: 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:57:52.871672: 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:57:52.882869: 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:57:52.991487: 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:57:53.020495: 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 [?,?,5]\n",
      "\t [[{{node inputs}}]]\n",
      "2024-02-10 11:57:53.083029: 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/tmpeg8gkqi6/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-10 11:57:54.264720: 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:57:55.062684: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:364] Ignored output_format.\n",
      "2024-02-10 11:57:55.062717: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:367] Ignored drop_control_dependency.\n",
      "2024-02-10 11:57:55.063701: I tensorflow/cc/saved_model/reader.cc:45] Reading SavedModel from: /tmp/tmpeg8gkqi6\n",
      "2024-02-10 11:57:55.064987: I tensorflow/cc/saved_model/reader.cc:89] Reading meta graph with tags { serve }\n",
      "2024-02-10 11:57:55.065006: I tensorflow/cc/saved_model/reader.cc:130] Reading SavedModel debug info (if present) from: /tmp/tmpeg8gkqi6\n",
      "2024-02-10 11:57:55.071102: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:353] MLIR V1 optimization pass is not enabled\n",
      "2024-02-10 11:57:55.072036: I tensorflow/cc/saved_model/loader.cc:231] Restoring SavedModel bundle.\n",
      "2024-02-10 11:57:55.102749: I tensorflow/cc/saved_model/loader.cc:215] Running initialization op on SavedModel bundle at path: /tmp/tmpeg8gkqi6\n",
      "2024-02-10 11:57:55.112084: I tensorflow/cc/saved_model/loader.cc:314] SavedModel load for tags { serve }; Status: success: OK. Took 48385 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
}