examples/4_model-training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook aims at illustrating the way we can train simple neural network models in current framework."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Mapillary` data will be used as an illustration of this process. Some details about the [dataset labels](./1b_mapillary-label-analysis.ipynb), as well as about the [dataset creation](./1a_mapillary-dataset-presentation.ipynb), are available in previous notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover the model of interest here will be *semantic segmentation*. To get some more details about model handling, please refer to [model creation notebook](./3_neural-network-model-creation.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, some dependencies must be loaded before to begin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rde/.virtualenvs/deepo/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from keras.models import Model\n",
    "from keras.optimizers import Adam\n",
    "from keras import backend, callbacks\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from deeposlandia import utils, dataset, generator, semantic_segmentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in previous notebooks, a range of variables is declared to make further developments easier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATAPATH = \"../data\"\n",
    "DATASET = \"mapillary\"\n",
    "MODEL = \"semantic_segmentation\"\n",
    "IMG_SIZE = 128\n",
    "BATCH_SIZE = 10\n",
    "NB_CHANNELS = 3\n",
    "LR_RATE = 1e-3\n",
    "LR_DECAY = 1e-5\n",
    "NB_EPOCHS=10\n",
    "INSTANCE_NAME = \"demo\"\n",
    "INPUT_FOLDER = utils.prepare_input_folder(DATAPATH, DATASET)\n",
    "INPUT_CONFIG = os.path.join(INPUT_FOLDER, \"config_aggregate.json\")\n",
    "PREPROCESS_FOLDER = utils.prepare_preprocessed_folder(DATAPATH, DATASET, IMG_SIZE, \"aggregated\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset recovering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we recover an existing dataset generated in the [dedicated notebook](./2_generator-creation.ipynb):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_dataset = dataset.MapillaryDataset(IMG_SIZE, INPUT_CONFIG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-08-22 16:29:24,115 :: INFO :: dataset :: load : The dataset has been loaded from ../data/mapillary/preprocessed/128_aggregated/training.json\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "training_dataset.load(PREPROCESS_FOLDER[\"training_config\"])\n",
    "training_dataset.get_nb_images()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we need the dataset two first components, *i.e.* training and validation, we still need to generate a brand new validation dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-08-22 16:29:25,258 :: INFO :: dataset :: save : The dataset has been saved into ../data/mapillary/preprocessed/128_aggregated/validation.json\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "validation_dataset = dataset.MapillaryDataset(IMG_SIZE, INPUT_CONFIG)\n",
    "validation_dataset.populate(PREPROCESS_FOLDER[\"validation\"],\n",
    "                            os.path.join(INPUT_FOLDER, \"validation\"),\n",
    "                            nb_images=10,\n",
    "                            aggregate=True)\n",
    "validation_dataset.save(PREPROCESS_FOLDER[\"validation_config\"])\n",
    "validation_dataset.get_nb_images()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build on-the-fly data generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Starting from this dataset, we can build the generators that will be used during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_config = utils.read_config(PREPROCESS_FOLDER[\"training_config\"])\n",
    "validation_config = utils.read_config(PREPROCESS_FOLDER[\"validation_config\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 100 images belonging to 1 classes.\n",
      "Found 100 images belonging to 1 classes.\n",
      "Found 10 images belonging to 1 classes.\n",
      "Found 10 images belonging to 1 classes.\n"
     ]
    }
   ],
   "source": [
    "train_generator = generator.create_generator(DATASET,\n",
    "                                             MODEL,\n",
    "                                             PREPROCESS_FOLDER[\"training\"],\n",
    "                                             IMG_SIZE,\n",
    "                                             BATCH_SIZE,\n",
    "                                             training_config[\"labels\"])\n",
    "validation_generator = generator.create_generator(DATASET,\n",
    "                                                  MODEL,\n",
    "                                                  PREPROCESS_FOLDER[\"validation\"],\n",
    "                                                  IMG_SIZE,\n",
    "                                                  BATCH_SIZE,\n",
    "                                                  validation_config[\"labels\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From now, data are ready-to-use. We only have to initialize a neural network model. This step is described in a [dedicated notebook](./3_neural-network-model-creation.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First an instance of `SemanticSegmentationNetwork` object must be declared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_labels = len(validation_config['labels'])\n",
    "network = semantic_segmentation.SemanticSegmentationNetwork(INSTANCE_NAME,\n",
    "                                                            IMG_SIZE,\n",
    "                                                            NB_CHANNELS,\n",
    "                                                            nb_labels,\n",
    "                                                            architecture=\"simple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then a Keras model is instanciated starting from the built architecture. The model has to be compiled with given loss function, optimizer and metrics, in order to launch any training process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(network.X, network.Y)\n",
    "model.compile(loss=\"categorical_crossentropy\",\n",
    "              optimizer=Adam(lr=LR_RATE, decay=LR_DECAY),\n",
    "              metrics=[\"acc\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some parameter setting are necessary before to begin training. Namely we have to define the number of training and validation steps (basically the number of image divided by the batch size, in order to define an epoch as the evaluation of every image once)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "steps = training_dataset.get_nb_images() // BATCH_SIZE\n",
    "val_steps = validation_dataset.get_nb_images() // BATCH_SIZE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we define a [Keras checkpoint callbacks](https://keras.io/callbacks/) to save the result of the optimization in a place of our choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_folder = utils.prepare_output_folder(DATAPATH, DATASET, MODEL, INSTANCE_NAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'../data/mapillary/output/semantic_segmentation/checkpoints/demo'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_filename = os.path.join(output_folder, \"checkpoint-epoch-{epoch:03d}.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint = callbacks.ModelCheckpoint(checkpoint_filename,\n",
    "                                       monitor=\"val_loss\",\n",
    "                                       save_best_only=True,\n",
    "                                       save_weights_only=False,\n",
    "                                       mode='auto',\n",
    "                                       period=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally the training process itself is run with training (and optionnally validation) generator(s)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "10/10 [==============================] - 26s 3s/step - loss: 2.3551 - acc: 0.2951 - val_loss: 1.9213 - val_acc: 0.4626\n",
      "Epoch 2/10\n",
      "10/10 [==============================] - 25s 2s/step - loss: 1.7571 - acc: 0.5056 - val_loss: 1.4701 - val_acc: 0.6066\n",
      "Epoch 3/10\n",
      "10/10 [==============================] - 25s 2s/step - loss: 1.5579 - acc: 0.5450 - val_loss: 1.3500 - val_acc: 0.6595\n",
      "Epoch 4/10\n",
      "10/10 [==============================] - 26s 3s/step - loss: 1.4474 - acc: 0.5639 - val_loss: 1.4252 - val_acc: 0.5931\n",
      "Epoch 5/10\n",
      "10/10 [==============================] - 26s 3s/step - loss: 1.4562 - acc: 0.5498 - val_loss: 1.3519 - val_acc: 0.6067\n",
      "Epoch 6/10\n",
      "10/10 [==============================] - 25s 3s/step - loss: 1.4033 - acc: 0.5759 - val_loss: 1.2806 - val_acc: 0.6210\n",
      "Epoch 7/10\n",
      "10/10 [==============================] - 25s 3s/step - loss: 1.3953 - acc: 0.5688 - val_loss: 1.2571 - val_acc: 0.6322\n",
      "Epoch 8/10\n",
      "10/10 [==============================] - 26s 3s/step - loss: 1.3783 - acc: 0.5845 - val_loss: 1.3158 - val_acc: 0.6214\n",
      "Epoch 9/10\n",
      "10/10 [==============================] - 26s 3s/step - loss: 1.3812 - acc: 0.5758 - val_loss: 1.2610 - val_acc: 0.6442\n",
      "Epoch 10/10\n",
      "10/10 [==============================] - 26s 3s/step - loss: 1.3359 - acc: 0.5924 - val_loss: 1.1913 - val_acc: 0.6628\n"
     ]
    }
   ],
   "source": [
    "hist = model.fit_generator(train_generator,\n",
    "                           epochs=NB_EPOCHS,\n",
    "                           steps_per_epoch=steps,\n",
    "                           validation_data=validation_generator,\n",
    "                           validation_steps=val_steps,\n",
    "                           callbacks=[checkpoint])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this step, we have trained a model, and stored the corresponding checkpoints onto the file system. We may display some learning curves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, ax = plt.subplots(1, 2, figsize=(8, 4))\n",
    "ax[0].plot(hist.history['loss'])\n",
    "ax[0].plot(hist.history['val_loss'])\n",
    "ax[0].set_xlabel(\"Training epochs\")\n",
    "ax[0].set_ylabel(\"Categorical crossentropy\")\n",
    "ax[1].plot(hist.history['acc'])\n",
    "ax[1].plot(hist.history['val_acc'])\n",
    "ax[1].set_xlabel(\"Training epochs\")\n",
    "ax[1].set_ylabel(\"Accuracy (%)\")\n",
    "ax[1].legend([\"Training\", \"Validation\"])\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On this short training process, we can see that a very simple model may converge towards interesting results (nothing extraordinary, anyway !)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considering the very low number of images in the training set, we could expect some overfitting, however that is not visible on this short process. The training set is even smaller, that being a possible explanation of the phenomenon."
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}