4.1-compare-models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.1 Compare models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/atila.alr/.local/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import report\n",
    "import block_sampler\n",
    "import batch_encoder\n",
    "import callbacks\n",
    "from dataset import Dataset\n",
    "\n",
    "from tensorflow.keras.layers import Input, Conv1D, MaxPooling1D, LSTM, Dense, Activation, TimeDistributed, Flatten, Dot, Softmax, Lambda, RepeatVector, Multiply, Permute, Reshape, BatchNormalization\n",
    "from tensorflow.keras.callbacks import EarlyStopping, TensorBoard\n",
    "from trainer import TrainResults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('1.14.0', '2.2.4-tf')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__, tf.keras.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.test.is_gpu_available(), tf.test.is_built_with_cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_dataset_folder='govdocs1/sample200'\n",
    "minimum=200\n",
    "maximum=200\n",
    "result_dir = 'results/4.1-compare-models'\n",
    "os.makedirs(result_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "rawset = Dataset.new_from_folders(raw_dataset_folder).filter_min_max(minimum, maximum)\n",
    "rawset = rawset.filter(lambda x: rawset.category_from(x) not in ['text', 'unk'])\n",
    "rawset.rebuild_categories()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tset, vset = rawset.rnd_split_fraction_by_category(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def D(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Flatten()(last)\n",
    "    last = Dense(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LD(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = LSTM(32)(last)\n",
    "    last = Dense(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LL(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = LSTM(32, return_sequences=True)(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CD(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(64,(64,),strides=8)(last)\n",
    "    last = Flatten()(last)\n",
    "    last = Dense(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CM(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(classes, (32,), strides=1)(last)\n",
    "    last = MaxPooling1D(pool_size=481, strides=1)(last)\n",
    "    last = Flatten()(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CCM(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(classes, (32,), strides=1)(last)\n",
    "    last = Conv1D(classes, (2,), strides=2)(last)\n",
    "    last = MaxPooling1D(pool_size=240, strides=1)(last)\n",
    "    last = Flatten()(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CL(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(classes, (32,), strides=32)(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CML(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(32, (32,), strides=32)(last)\n",
    "    last = MaxPooling1D(pool_size=2, strides=2, data_format='channels_first')(last)    \n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CLL(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(32, (32,), strides=32)(last)\n",
    "    last = LSTM(64, return_sequences=True)(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CLD(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(256, (16,), strides=16)(last)\n",
    "    last = LSTM(128)(last)\n",
    "    last = Dense(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CCL(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(128, (8,), strides=8)(last)\n",
    "    last = Conv1D(64, (8,), strides=8)(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CCLL(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(128, (8,), strides=8)(last)\n",
    "    last = Conv1D(64, (8,), strides=8)(last)\n",
    "    last = LSTM(64, return_sequences=True)(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CMCML(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(128, (8,), strides=8)(last)\n",
    "    last = MaxPooling1D(pool_size=2, strides=2, data_format='channels_first')(last)\n",
    "    last = Conv1D(64, (8,), strides=8)(last)\n",
    "    last = MaxPooling1D(pool_size=2, strides=2, data_format='channels_first')(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CMCMLL(classes, len_byte_vector):\n",
    "    last = l0 = Input(shape=(512,len_byte_vector))\n",
    "    last = Conv1D(128, (8,), strides=8)(last)\n",
    "    last = MaxPooling1D(pool_size=2, strides=2, data_format='channels_first')(last)\n",
    "    last = Conv1D(64, (8,), strides=8)(last)\n",
    "    last = MaxPooling1D(pool_size=2, strides=2, data_format='channels_first')(last)\n",
    "    last = LSTM(64, return_sequences=True)(last)\n",
    "    last = LSTM(classes)(last)\n",
    "    last = Activation('softmax')(last)\n",
    "    name = sys._getframe().f_code.co_name\n",
    "    model = tf.keras.Model([l0], last, name=name)\n",
    "    model.compile(loss=tf.keras.losses.categorical_crossentropy,\n",
    "        optimizer=tf.keras.optimizers.Adam(),\n",
    "        metrics=['binary_accuracy', 'categorical_accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
     ]
    }
   ],
   "source": [
    "classes = 28\n",
    "len_byte_vector=256\n",
    "mymodels = [\n",
    "    D(classes, len_byte_vector),\n",
    "\n",
    "    CD(classes, len_byte_vector),\n",
    "    CM(classes, len_byte_vector),\n",
    "    CCM(classes, len_byte_vector),\n",
    "    \n",
    "    CL(classes, len_byte_vector),\n",
    "    CML(classes, len_byte_vector),\n",
    "    CLL(classes, len_byte_vector),\n",
    "    CLD(classes, len_byte_vector),\n",
    "    \n",
    "    CCL(classes, len_byte_vector),\n",
    "    CCLL(classes, len_byte_vector),\n",
    "    CMCML(classes, len_byte_vector),\n",
    "    CMCMLL(classes, len_byte_vector),\n",
    "\n",
    "    LD(classes, len_byte_vector),\n",
    "    LL(classes, len_byte_vector),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTrainer:\n",
    "    def __init__(self,\n",
    "                 model,\n",
    "                 group_by='by_file',\n",
    "                 xs_encoder='8bits_11',\n",
    "                 validation_steps=10,\n",
    "                 steps_per_epoch=28,\n",
    "                 epochs=10000000,\n",
    "                 max_seconds=None,\n",
    "                 batch_size=100,\n",
    "                 min_delta=1e-03,\n",
    "                 patience=10,\n",
    "                 blockSampler=block_sampler.BlockSampler,\n",
    "                 batchEncoder=batch_encoder.BatchEncoder):\n",
    "        self.model = model\n",
    "        self.group_by = group_by\n",
    "        self.xs_encoder = xs_encoder\n",
    "        self.validation_steps = validation_steps\n",
    "        self.steps_per_epoch = steps_per_epoch\n",
    "        self.epochs = epochs\n",
    "        self.max_seconds = max_seconds\n",
    "        self.batch_size = batch_size\n",
    "        self.min_delta = min_delta\n",
    "        self.patience = patience\n",
    "        self.blockSampler = blockSampler\n",
    "        self.batchEncoder = batchEncoder\n",
    "\n",
    "    def train(self, tset, vset):\n",
    "        tsampler = self.blockSampler(tset, group_by=self.group_by)\n",
    "        tbenc = self.batchEncoder(tsampler, self.batch_size,\n",
    "                                  xs_encoder=self.xs_encoder)\n",
    "\n",
    "        vsampler = self.blockSampler(vset, group_by=self.group_by)\n",
    "        vbenc = self.batchEncoder(vsampler, self.batch_size,\n",
    "                                  xs_encoder=self.xs_encoder)\n",
    "\n",
    "        model = self.model\n",
    "\n",
    "        timeIt = callbacks.TimeIt()\n",
    "\n",
    "        history = model.fit_generator(iter(tbenc),\n",
    "                                      validation_data=iter(vbenc),\n",
    "                                      validation_steps=self.validation_steps,\n",
    "                                      steps_per_epoch=self.steps_per_epoch,\n",
    "                                      epochs=self.epochs,\n",
    "                                      verbose=0,\n",
    "                                      callbacks=[\n",
    "            timeIt,\n",
    "            # callbacks.SaveModel(os.path.join(result_dir, model.name + '.h5')),\n",
    "#             callbacks.TimeLimit(self.max_seconds),\n",
    "            EarlyStopping(monitor='val_categorical_accuracy',\n",
    "                          min_delta=self.min_delta, patience=self.patience),\n",
    "            TensorBoard(\n",
    "                log_dir=os.path.join(result_dir, model.name),\n",
    "            ),\n",
    "        ],\n",
    "#             use_multiprocessing=False,\n",
    "#             workers=0,\n",
    "        )\n",
    "        return TrainResults(\n",
    "            model=model,\n",
    "            history=history,\n",
    "            metrics=['val_binary_accuracy', 'val_categorical_accuracy'],\n",
    "            elapsed=timeIt.elapsed,\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n",
      "549.7506058216095 0.485\n",
      "CD\n",
      "385.2922339439392 0.4875\n",
      "CM\n",
      "2325.2000629901886 0.54071426\n",
      "CCM\n",
      "1843.226009607315 0.5282143\n",
      "CL\n",
      "WARNING:tensorflow:From /home/atila.alr/.local/lib/python3.6/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "310.27105164527893 0.35285714\n",
      "CML\n",
      "451.94711780548096 0.34535715\n",
      "CLL\n",
      "388.72077798843384 0.37857142\n",
      "CLD\n",
      "538.7505917549133 0.5325\n",
      "CCL\n",
      "437.44722723960876 0.3967857\n",
      "CCLL\n",
      "316.5933949947357 0.36964285\n",
      "CMCML\n",
      "493.28907561302185 0.37392858\n",
      "CMCMLL\n",
      "631.7264068126678 0.39571428\n",
      "LD\n",
      "1355.3999061584473 0.23321429\n",
      "LL\n",
      "740.2854459285736 0.09607143\n"
     ]
    }
   ],
   "source": [
    "r = report.Reporter2(result_dir + '/models.tsv')\n",
    "for model in mymodels:\n",
    "    print(model.name)\n",
    "    result = MyTrainer(\n",
    "        model,\n",
    "        xs_encoder='one_hot',\n",
    "        batch_size=100,\n",
    "        steps_per_epoch=28,\n",
    "        validation_steps=28,\n",
    "        patience=10,\n",
    "    ).train(tset, vset)\n",
    "    print(result.elapsed, result.history.history['val_categorical_accuracy'][-1])\n",
    "    r.line(name=result.model.name,\n",
    "           elapsed=result.elapsed,\n",
    "           **report.report_epochs(**result._asdict()),\n",
    "           **report.report_metrics(result.history, result.metrics),\n",
    "          )\n",
    "\n",
    "r.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>elapsed</th>\n",
       "      <th>Epochs</th>\n",
       "      <th>val_binary_accuracy</th>\n",
       "      <th>val_categorical_accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>13</td>\n",
       "      <td>LL</td>\n",
       "      <td>740.285446</td>\n",
       "      <td>21</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.096071</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>12</td>\n",
       "      <td>LD</td>\n",
       "      <td>1355.399906</td>\n",
       "      <td>65</td>\n",
       "      <td>0.965383</td>\n",
       "      <td>0.233214</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>CML</td>\n",
       "      <td>451.947118</td>\n",
       "      <td>48</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.345357</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>CL</td>\n",
       "      <td>310.271052</td>\n",
       "      <td>32</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.352857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>CCLL</td>\n",
       "      <td>316.593395</td>\n",
       "      <td>33</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.369643</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>CMCML</td>\n",
       "      <td>493.289076</td>\n",
       "      <td>53</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.373929</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>CLL</td>\n",
       "      <td>388.720778</td>\n",
       "      <td>42</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.378571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>11</td>\n",
       "      <td>CMCMLL</td>\n",
       "      <td>631.726407</td>\n",
       "      <td>67</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.395714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>CCL</td>\n",
       "      <td>437.447227</td>\n",
       "      <td>47</td>\n",
       "      <td>0.964286</td>\n",
       "      <td>0.396786</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>D</td>\n",
       "      <td>549.750606</td>\n",
       "      <td>47</td>\n",
       "      <td>0.973610</td>\n",
       "      <td>0.485000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>CD</td>\n",
       "      <td>385.292234</td>\n",
       "      <td>25</td>\n",
       "      <td>0.973763</td>\n",
       "      <td>0.487500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>CCM</td>\n",
       "      <td>1843.226010</td>\n",
       "      <td>60</td>\n",
       "      <td>0.977564</td>\n",
       "      <td>0.528214</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>CLD</td>\n",
       "      <td>538.750592</td>\n",
       "      <td>45</td>\n",
       "      <td>0.976454</td>\n",
       "      <td>0.532500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>CM</td>\n",
       "      <td>2325.200063</td>\n",
       "      <td>76</td>\n",
       "      <td>0.976760</td>\n",
       "      <td>0.540714</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      name      elapsed  Epochs  val_binary_accuracy  val_categorical_accuracy\n",
       "13      LL   740.285446      21             0.964286                  0.096071\n",
       "12      LD  1355.399906      65             0.965383                  0.233214\n",
       "5      CML   451.947118      48             0.964286                  0.345357\n",
       "4       CL   310.271052      32             0.964286                  0.352857\n",
       "9     CCLL   316.593395      33             0.964286                  0.369643\n",
       "10   CMCML   493.289076      53             0.964286                  0.373929\n",
       "6      CLL   388.720778      42             0.964286                  0.378571\n",
       "11  CMCMLL   631.726407      67             0.964286                  0.395714\n",
       "8      CCL   437.447227      47             0.964286                  0.396786\n",
       "0        D   549.750606      47             0.973610                  0.485000\n",
       "1       CD   385.292234      25             0.973763                  0.487500\n",
       "3      CCM  1843.226010      60             0.977564                  0.528214\n",
       "7      CLD   538.750592      45             0.976454                  0.532500\n",
       "2       CM  2325.200063      76             0.976760                  0.540714"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data3 = pd.read_csv(result_dir + '/models.tsv', sep='\\t')\n",
    "data3 = data3.sort_values('val_categorical_accuracy')\n",
    "data3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name                              CM\n",
       "elapsed                       2325.2\n",
       "Epochs                            76\n",
       "val_binary_accuracy          0.97676\n",
       "val_categorical_accuracy    0.540714\n",
       "Name: 2, dtype: object"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data3.iloc[13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.ticker import MultipleLocator\n",
    "fig, ax = plt.subplots(figsize=(12,6))\n",
    "ax.yaxis.set_minor_locator(MultipleLocator(0.1))\n",
    "# plt.grid(linestyle='--', which='minor')\n",
    "ax.bar(data3['name'], data3['val_categorical_accuracy'], fill=False)\n",
    "plt.xticks(rotation='vertical')\n",
    "plt.ylim((0, 1))\n",
    "plt.ylabel('validation accuracy', fontsize=16)\n",
    "plt.xlabel('models', fontsize=16)\n",
    "ax.tick_params(labelsize=14)\n",
    "for i,idx in enumerate(data3.index):\n",
    "    row = data3.iloc[i]\n",
    "    v = row['val_categorical_accuracy']\n",
    "    e = row['Epochs']\n",
    "    tm = row['elapsed']\n",
    "    t = ax.annotate('%0.2f acc.\\n%d epochs'%(v,e), (i-0.3, v+0.19),fontsize=14)\n",
    "    t.set_rotation(90)\n",
    "    if i==0:\n",
    "        t = ax.annotate('%d m'%(tm/60), (i-0.1, v-0.01),fontsize=14)\n",
    "    else:\n",
    "        t = ax.annotate('%d m'%(tm/60), (i-0.1, v-0.04),fontsize=14)\n",
    "    t.set_rotation(90)    "
   ]
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}