train_models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <b> <u>Jammer Classification: </u> </b>\n",
    "### Example Notebook Showing how you can train and save the modeles!\n",
    "### Step1: Import All Dependencies!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install the dependencies from the requirements.txt\n",
    "\n",
    "!pip install -q -r requirements.txt\n",
    "\n",
    "# Import tensor flow and keras\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow import keras\n",
    "\n",
    "# tensorflow hub is used to load the models\n",
    "!pip install -q tensorflow_hub\n",
    "import tensorflow_hub as hub\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Import Matplot lib, Library to plot the results and graphs\n",
    "import matplotlib.pylab as plt \n",
    "\n",
    "# Argument parser to set variables\n",
    "import options\n",
    "\n",
    "# import dataloader\n",
    "from util import dataLoader\n",
    "\n",
    "# import generate model module\n",
    "from CNN import generate_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the Functions for Training and Plotting logs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_logs(history):\n",
    "    print(history.history)\n",
    "    acc = history.history['accuracy']\n",
    "    \n",
    "\n",
    "    loss = history.history['loss']\n",
    "    \n",
    "\n",
    "    plt.figure(figsize=(8, 8))\n",
    "    plt.subplot(2, 1, 1)\n",
    "    plt.plot(acc, label='Training Accuracy')\n",
    "    plt.legend(loc='lower right')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.ylim([min(plt.ylim()),1])\n",
    "    plt.title('Training Accuracy')\n",
    "\n",
    "    plt.subplot(2, 1, 2)\n",
    "    plt.plot(loss, label='Training Loss')\n",
    "    plt.legend(loc='upper right')\n",
    "    plt.ylabel('Categorical Cross Entropy')\n",
    "    plt.ylim([0,max(plt.ylim())])\n",
    "    plt.title('Training Loss')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#use Pre Trained Models for Fine Tuning\n",
    "def usePreTrain(args):\n",
    "    # Generate Data Loader\n",
    "    dataloader = dataLoader.DataLoader(args)\n",
    "    train_data_gen, val_data_gen = dataloader.dataGenerator()\n",
    "    \n",
    "    #genrateModel\n",
    "    generateModel = generate_model.Generate_model(args, dataloader.num_classes)\n",
    "    model = generateModel.preTrainedModel()\n",
    "    \n",
    "    # Fit your Training Data\n",
    "    history = model.fit(train_data_gen, epochs=args.num_epochs, verbose=2,shuffle = True,\n",
    "                        steps_per_epoch= dataloader.num_train_images // args.batch_size,\n",
    "                  )\n",
    "    #     history = model.fit_generator(\n",
    "    #                     train_data_gen,\n",
    "    #                     steps_per_epoch=dataloader.num_train_images // args.batch_size,\n",
    "    #                     epochs=args.num_epochs,\n",
    "    #                     validation_data=val_data_gen,\n",
    "    #                     validation_steps=dataloader.num_val_images // args.batch_size\n",
    "    #                 )\n",
    "\n",
    "    # Save the Model\n",
    "    keras.experimental.export_saved_model(model, args.save_dir)\n",
    "    \n",
    "    #Plot the Training Logs\n",
    "    plot_logs(history)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step2: Setup all Required Variables\n",
    "\n",
    "##### Delete sys.argv(req for ipython Kernels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to parse Argument from options.py\n",
    "import sys; sys.argv=['']; del sys\n",
    "args = options.parseArguments()\n",
    "\n",
    "#Set the mode to train or usePreTrain\n",
    "args.mode = \"usePreTrain\"\n",
    "args.freeze_feature_layers = True\n",
    "\n",
    "# Pre-Trained model to use\n",
    "args.pre_trained_model_name = \"inception_v3\"\n",
    "args.model_url = \"https://tfhub.dev/google/tf2-preview/{}/feature_vector/4\".format(args.pre_trained_model_name)\n",
    "\n",
    "# Set the Dataset Directory\n",
    "args.input_dir = \"/media/aadmin/SamsungSSD/PROJECT-DATA/SIGENCE/Train_Val_Test/dataset/\"\n",
    "\n",
    "# Set the image Dimensions and batch size according to the pre-trained model's requirement Check it on tf-hub\n",
    "args.img_h = args.img_w = 299\n",
    "args.batch_size = 50\n",
    "args.num_epochs = 15\n",
    "\n",
    "# Set the load directory, where trained models and graphs are saved\n",
    "args.save_dir = \"./checkpoints/4_Classes/\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Start Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing DataLoader ...\n",
      "Looking for the data at --> /media/aadmin/SamsungSSD/PROJECT-DATA/SIGENCE/Train_Val_Test/dataset/\n",
      "Classes : ['01_ChirpJammerSignals', '02_ChirpUnknownSignals', '03_InterferenceSignals', '04_NarrowBandSignals'] -----------\n",
      "Training Data Loader\n",
      "Found 7600 images belonging to 4 classes.\n",
      "Validation Data Loader\n",
      "Found 400 images belonging to 4 classes.\n",
      "Do Fine Tuning of feature layers :  False\n",
      "Building model from -->  https://tfhub.dev/google/tf2-preview/inception_v3/feature_vector/4\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "keras_layer (KerasLayer)     (None, 2048)              21802784  \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 2048)              0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 4)                 8196      \n",
      "=================================================================\n",
      "Total params: 21,810,980\n",
      "Trainable params: 8,196\n",
      "Non-trainable params: 21,802,784\n",
      "_________________________________________________________________\n",
      "Using SGD Optimizer for training\n",
      "Train on 7600 samples\n",
      "Epoch 1/15\n",
      "7600/7600 - 212s - loss: 0.6283 - accuracy: 0.8739\n",
      "Epoch 2/15\n",
      "7600/7600 - 196s - loss: 0.5357 - accuracy: 0.9207\n",
      "Epoch 3/15\n",
      "7600/7600 - 193s - loss: 0.5164 - accuracy: 0.9332\n",
      "Epoch 4/15\n",
      "7600/7600 - 194s - loss: 0.5058 - accuracy: 0.9375\n",
      "Epoch 5/15\n",
      "7600/7600 - 195s - loss: 0.5004 - accuracy: 0.9408\n",
      "Epoch 6/15\n",
      "7600/7600 - 196s - loss: 0.4921 - accuracy: 0.9434\n",
      "Epoch 7/15\n",
      "7600/7600 - 197s - loss: 0.4929 - accuracy: 0.9408\n",
      "Epoch 8/15\n",
      "7600/7600 - 197s - loss: 0.4873 - accuracy: 0.9463\n",
      "Epoch 9/15\n",
      "7600/7600 - 198s - loss: 0.4842 - accuracy: 0.9482\n",
      "Epoch 10/15\n",
      "7600/7600 - 198s - loss: 0.4826 - accuracy: 0.9480\n",
      "Epoch 11/15\n",
      "7600/7600 - 196s - loss: 0.4799 - accuracy: 0.9493\n",
      "Epoch 12/15\n",
      "7600/7600 - 197s - loss: 0.4795 - accuracy: 0.9504\n",
      "Epoch 13/15\n",
      "7600/7600 - 197s - loss: 0.4757 - accuracy: 0.9501\n",
      "Epoch 14/15\n",
      "7600/7600 - 196s - loss: 0.4756 - accuracy: 0.9501\n",
      "Epoch 15/15\n",
      "7600/7600 - 195s - loss: 0.4747 - accuracy: 0.9534\n",
      "WARNING:tensorflow:From <ipython-input-3-97fa4081abaa>:24: export_saved_model (from tensorflow.python.keras.saving.saved_model_experimental) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `model.save(..., save_format=\"tf\")` or `tf.keras.models.save_model(..., save_format=\"tf\")`.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-3-97fa4081abaa>:24: export_saved_model (from tensorflow.python.keras.saving.saved_model_experimental) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `model.save(..., save_format=\"tf\")` or `tf.keras.models.save_model(..., save_format=\"tf\")`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/aadmin/MyProjects/JammerClassification/env/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1781: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/aadmin/MyProjects/JammerClassification/env/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1781: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/aadmin/MyProjects/JammerClassification/env/lib/python3.7/site-packages/tensorflow_core/python/saved_model/signature_def_utils_impl.py:253: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/aadmin/MyProjects/JammerClassification/env/lib/python3.7/site-packages/tensorflow_core/python/saved_model/signature_def_utils_impl.py:253: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Predict: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Predict: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Train: ['train']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Train: ['train']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Eval: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Eval: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Export includes no default signature!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Export includes no default signature!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Issue encountered when serializing variables.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'list' object has no attribute 'name'\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Issue encountered when serializing variables.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'list' object has no attribute 'name'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to save.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to save.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to write.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to write.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Predict: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Predict: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Train: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Train: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Eval: ['eval']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Eval: ['eval']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Export includes no default signature!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Export includes no default signature!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Issue encountered when serializing variables.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'list' object has no attribute 'name'\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Issue encountered when serializing variables.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'list' object has no attribute 'name'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to save.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to save.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to write.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to write.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.decay\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.decay\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.learning_rate\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.learning_rate\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.momentum\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.momentum\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer's state 'momentum' for (root).layer_with_weights-1.kernel\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer's state 'momentum' for (root).layer_with_weights-1.kernel\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer's state 'momentum' for (root).layer_with_weights-1.bias\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer's state 'momentum' for (root).layer_with_weights-1.bias\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:A checkpoint was restored (e.g. tf.train.Checkpoint.restore or tf.keras.Model.load_weights) but not all checkpointed values were used. See above for specific issues. Use expect_partial() on the load status object, e.g. tf.train.Checkpoint.restore(...).expect_partial(), to silence these warnings, or use assert_consumed() to make the check explicit. See https://www.tensorflow.org/alpha/guide/checkpoints#loading_mechanics for details.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:A checkpoint was restored (e.g. tf.train.Checkpoint.restore or tf.keras.Model.load_weights) but not all checkpointed values were used. See above for specific issues. Use expect_partial() on the load status object, e.g. tf.train.Checkpoint.restore(...).expect_partial(), to silence these warnings, or use assert_consumed() to make the check explicit. See https://www.tensorflow.org/alpha/guide/checkpoints#loading_mechanics for details.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Predict: ['serving_default']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Train: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Train: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Eval: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Signatures INCLUDED in export for Eval: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Issue encountered when serializing variables.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'list' object has no attribute 'name'\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Issue encountered when serializing variables.\n",
      "Type is unsupported, or the types of the items don't match field type in CollectionDef. Note this is a warning and probably safe to ignore.\n",
      "'list' object has no attribute 'name'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to save.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to save.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to write.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:No assets to write.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:SavedModel written to: ./checkpoints/4_Classes/saved_model.pb\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:SavedModel written to: ./checkpoints/4_Classes/saved_model.pb\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'loss': [0.6282644787509191, 0.5357317285318124, 0.5164474921399042, 0.5057966262102127, 0.5003540937445665, 0.4920848613899005, 0.4929088183531636, 0.487291743880824, 0.4841701200133876, 0.48257780173107195, 0.47985994345263433, 0.4795371503814271, 0.47573955298254367, 0.47556165664603833, 0.47470332603705556], 'accuracy': [0.8739474, 0.9206579, 0.9331579, 0.9375, 0.94078946, 0.94342107, 0.94078946, 0.94631577, 0.9481579, 0.9480263, 0.94934213, 0.95039475, 0.9501316, 0.9501316, 0.95342106]}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if args.mode == \"usePreTrain\":\n",
    "    usePreTrain(args)\n",
    "\n",
    "elif args.mode==\"train\":\n",
    "    train(args)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}