fitModel.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['gotocodingdarin2', 'gotocodingdarin']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "import random\n",
    "\n",
    "from time import sleep\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os\n",
    "import itertools\n",
    "import tqdm\n",
    "print(os.listdir(\"../input\"))\n",
    "\n",
    "import keras\n",
    "from keras.optimizers import RMSprop\n",
    "from keras.datasets import mnist\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten, BatchNormalization\n",
    "from keras.layers import Conv2D, Conv3D, MaxPooling2D, SeparableConv2D, MaxPool2D\n",
    "from keras import backend as K\n",
    "from keras import regularizers\n",
    "\n",
    "from random import shuffle\n",
    "# Any results you write to the current directory are saved as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_uuid": "4759705c68cfe729b23db93046a89bb5bb4ab608"
   },
   "outputs": [],
   "source": [
    "with open('../input/gotocodingdarin/train-1.renju') as f:\n",
    "    content = f.readlines()\n",
    "# you may also want to remove whitespace characters like `\\n` at the end of each line\n",
    "content = [x.strip() for x in content]\n",
    "content = [x.split(' ') for x in content]\n",
    "shuffle(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_uuid": "aa6e59b3b27ba74889d90a7f96b198c6f63cea93"
   },
   "outputs": [],
   "source": [
    "# def generator(raw_data, batch_size, L=-1):\n",
    "#     if L == -1:\n",
    "#         L = len(raw_data)\n",
    "\n",
    "#     def empty_table():\n",
    "#         x = np.zeros((15, 15, 3))\n",
    "#         for i in range(15):\n",
    "#             for j in range(15):\n",
    "#                 x[i][j][2] = -1\n",
    "#         return x\n",
    "\n",
    "#     cur_game = 0\n",
    "#     cur_move = -1\n",
    "#     cur_player = -1\n",
    "#     cur_table = empty_table()\n",
    "\n",
    "#     while True:\n",
    "#         batch = [[], []]\n",
    "\n",
    "#         while len(batch[0]) != batch_size:\n",
    "#             if (cur_move == -1\n",
    "#                 or raw_data[cur_game][0] != 'black'\n",
    "#                 or cur_move + 2 >= len(raw_data[cur_game])\n",
    "#                 or len(raw_data[cur_game]) < 5\n",
    "#             ):\n",
    "#                 cur_game = (cur_game + 1) % L\n",
    "#                 cur_move = 0\n",
    "#                 cur_table = empty_table()\n",
    "#                 continue\n",
    "\n",
    "#             game = raw_data[cur_game]\n",
    "#             if cur_move == 0:\n",
    "#                 cur_move += 1\n",
    "#                 x, y = translate_chess_coordinates(game[cur_move])\n",
    "#                 if not go(cur_table, x, y, -1):\n",
    "#                     cur_move = -1\n",
    "#                     continue\n",
    "\n",
    "#                 cur_move += 1\n",
    "#                 x, y = translate_chess_coordinates(game[cur_move])\n",
    "#                 if not go(cur_table, x, y, 1):\n",
    "#                     cur_move = -1\n",
    "#                     continue\n",
    "\n",
    "#             to_add = cur_table.copy()\n",
    "\n",
    "#             cur_move += 1\n",
    "#             x, y = translate_chess_coordinates(game[cur_move])\n",
    "#             if not go(cur_table, x, y, -1):\n",
    "#                 cur_move = -1\n",
    "#                 continue\n",
    "\n",
    "#             batch[0].append(to_add)\n",
    "#             batch[1].append(15 * x + y)\n",
    "#             cur_move += 1\n",
    "#             x, y = translate_chess_coordinates(game[cur_move])\n",
    "#             if not go(cur_table, x, y, 1):\n",
    "#                 cur_move = -1\n",
    "#                 continue\n",
    "\n",
    "#         yield np.array(batch[0]), keras.utils.to_categorical(batch[1], 225)\n",
    "\n",
    "\n",
    "# def go(table, x, y, color):\n",
    "#     if table[x][y][0] != 0 or table[x][y][0] != 0:\n",
    "#         return False\n",
    "#     if color == -1:\n",
    "#         table[x][y][0] = -1\n",
    "#     else:\n",
    "#         table[x][y][1] = 1\n",
    "#     return True\n",
    "\n",
    "\n",
    "# def translate_chess_coordinates(coord):\n",
    "#     x = ord(coord[0]) - ord('a')\n",
    "#     if x > ord('i') - ord('a'):\n",
    "#         x -= 1\n",
    "#     y = int(coord[1:]) - 1\n",
    "#     return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "_uuid": "151bc495a3cd25a819b48900e593ed26456c822f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 15, 15, 64)        4864      \n",
      "_________________________________________________________________\n",
      "batch_normalization_1 (Batch (None, 15, 15, 64)        256       \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 15, 15, 32)        51232     \n",
      "_________________________________________________________________\n",
      "batch_normalization_2 (Batch (None, 15, 15, 32)        128       \n",
      "_________________________________________________________________\n",
      "conv2d_3 (Conv2D)            (None, 15, 15, 32)        25632     \n",
      "_________________________________________________________________\n",
      "batch_normalization_3 (Batch (None, 15, 15, 32)        128       \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 15, 15, 32)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 7200)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1024)              7373824   \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 512)               524800    \n",
      "_________________________________________________________________\n",
      "batch_normalization_4 (Batch (None, 512)               2048      \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 225)               115425    \n",
      "=================================================================\n",
      "Total params: 8,098,337\n",
      "Trainable params: 8,097,057\n",
      "Non-trainable params: 1,280\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "model.add(Conv2D(64, kernel_size=(5, 5), padding='same', activation='relu', input_shape=(15, 15, 3)))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Conv2D(32, kernel_size=(5, 5), padding='same', activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Conv2D(32, kernel_size=(5, 5), padding='same', activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(1024, activation='relu'))\n",
    "model.add(Dense(512, activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Dense(225, activation='softmax'))\n",
    "\n",
    "model.compile(loss=keras.losses.categorical_crossentropy,\n",
    "              optimizer=keras.optimizers.Adamax(),\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_uuid": "d0211d7da00fe45543feccaa2365a1829904d45c"
   },
   "outputs": [],
   "source": [
    "# model = Sequential()\n",
    "# model.add(Conv2D(32, kernel_size=(3, 3), padding='same', activation='relu', input_shape=(3, 15, 15)))\n",
    "# model.add(BatchNormalization())\n",
    "# model.add(Conv2D(64, kernel_size=(3, 3), padding='same', activation='relu'))\n",
    "# model.add(Dropout(0.3))\n",
    "# model.add(Flatten())\n",
    "# model.add(Dense(256, activation='relu'))\n",
    "# model.add(BatchNormalization())\n",
    "# model.add(Dense(225, activation='softmax'))\n",
    "\n",
    "# model.compile(loss=keras.losses.categorical_crossentropy,\n",
    "#               optimizer=keras.optimizers.Adamax(),\n",
    "#               metrics=['accuracy'])\n",
    "# save_callback = keras.callbacks.ModelCheckpoint('trained_model',\n",
    "#     monitor='acc',\n",
    "#     verbose=1,\n",
    "# #     save_best_only=True,\n",
    "# #     save_weights_only=False,\n",
    "#     mode='auto',\n",
    "#     period=1,\n",
    "# )\n",
    "\n",
    "# model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "_uuid": "b9ed8c7e43d40bad8dae703e12b451c8a5700fb3"
   },
   "outputs": [],
   "source": [
    "# model = Sequential()\n",
    "\n",
    "# model.add(Conv2D(filters = 32, kernel_size = (3,3),padding = 'Same', \n",
    "#                  activation ='relu', input_shape = (15, 15, 3)))\n",
    "# model.add(Conv2D(filters = 32, kernel_size = (3,3),padding = 'Same', \n",
    "#                  activation ='relu'))\n",
    "# model.add(MaxPool2D(pool_size=(2,2)))\n",
    "# model.add(Dropout(0.25))\n",
    "\n",
    "\n",
    "# model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', \n",
    "#                  activation ='relu'))\n",
    "# model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', \n",
    "#                  activation ='relu'))\n",
    "# model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))\n",
    "# model.add(Dropout(0.25))\n",
    "\n",
    "\n",
    "# model.add(Flatten())\n",
    "# model.add(Dense(1024, activation = \"relu\"))\n",
    "# model.add(Dropout(0.5))\n",
    "# model.add(Dense(225, activation = \"softmax\"))\n",
    "\n",
    "# model.summary()\n",
    "\n",
    "# optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)\n",
    "# model.compile(optimizer = optimizer , loss = \"categorical_crossentropy\", metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_uuid": "6f7623aa630bcaaab580ffb92d70670406f3cd50"
   },
   "outputs": [],
   "source": [
    "def rotate_coordinates(x, y):\n",
    "    return 14 - y, x\n",
    "\n",
    "\n",
    "def rotate_randomly(table, ans_x, ans_y):\n",
    "    k = random.randint(0, 3)\n",
    "    res = np.zeros((15, 15, 3))\n",
    "    for i in range(15):\n",
    "        for j in range(15):\n",
    "            x, y = rotate_coordinates(i, j)\n",
    "            if k >= 1:\n",
    "                x, y = rotate_coordinates(x, y)\n",
    "            if k >= 2:\n",
    "                x, y = rotate_coordinates(x, y)\n",
    "            if k >= 3:\n",
    "                x, y = rotate_coordinates(x, y)\n",
    "            res[x][y][0] = table[i][j][0]\n",
    "            res[x][y][1] = table[i][j][1]\n",
    "            res[i][j][2] = table[0][0][2]\n",
    "    ans_x, ans_y = rotate_coordinates(ans_x, ans_y)\n",
    "    if k >= 1:\n",
    "        ans_x, ans_y = rotate_coordinates(ans_x, ans_y)\n",
    "    if k >= 2:\n",
    "        ans_x, ans_y = rotate_coordinates(ans_x, ans_y)\n",
    "    if k >= 3:\n",
    "        ans_x, ans_y = rotate_coordinates(ans_x, ans_y)\n",
    "    return res, ans_x, ans_y\n",
    "\n",
    "\n",
    "def generator(raw_data, batch_size, data_max_len=-1):\n",
    "    if data_max_len == -1:\n",
    "        data_max_len = len(raw_data)\n",
    "\n",
    "    def empty_table():\n",
    "        x = np.zeros((15, 15, 3))\n",
    "        for i in range(15):\n",
    "            for j in range(15):\n",
    "                x[i][j][2] = -1\n",
    "        return x\n",
    "\n",
    "    cur_game = 0\n",
    "    cur_move = -1\n",
    "    cur_player = -1\n",
    "    cur_table = empty_table()\n",
    "\n",
    "    while True:\n",
    "        batch = [[], []]\n",
    "\n",
    "        while len(batch[0]) != batch_size:\n",
    "            if (cur_move == -1\n",
    "                or raw_data[cur_game][0] != 'black'\n",
    "                or cur_move + 2 >= len(raw_data[cur_game])\n",
    "                or len(raw_data[cur_game]) < 6\n",
    "            ):\n",
    "                cur_game = (cur_game + 1) % data_max_len\n",
    "                cur_move = 0\n",
    "                cur_table = empty_table()\n",
    "                continue\n",
    "\n",
    "            game = raw_data[cur_game]\n",
    "            if cur_move == 0:\n",
    "                cur_move += 1\n",
    "                x, y = translate_chess_coordinates(game[cur_move])\n",
    "                if not go(cur_table, x, y, -1):\n",
    "                    cur_move = -1\n",
    "                    continue\n",
    "\n",
    "                cur_move += 1\n",
    "                x, y = translate_chess_coordinates(game[cur_move])\n",
    "                if not go(cur_table, x, y, 1):\n",
    "                    cur_move = -1\n",
    "                    continue\n",
    "\n",
    "            to_add = cur_table.copy()\n",
    "\n",
    "            cur_move += 1\n",
    "            x, y = translate_chess_coordinates(game[cur_move])\n",
    "            if not go(cur_table, x, y, -1):\n",
    "                cur_move = -1\n",
    "                continue\n",
    "\n",
    "            to_add, x, y = rotate_randomly(to_add, x, y)\n",
    "\n",
    "            batch[0].append(to_add)\n",
    "            batch[1].append(15 * x + y)\n",
    "            cur_move += 1\n",
    "            x, y = translate_chess_coordinates(game[cur_move])\n",
    "            if not go(cur_table, x, y, 1):\n",
    "                cur_move = -1\n",
    "                continue\n",
    "\n",
    "        yield np.array(batch[0]), keras.utils.to_categorical(batch[1], 225)\n",
    "\n",
    "\n",
    "def go(table, x, y, color):\n",
    "    if table[x][y][0] != 0 or table[x][y][1] != 0:\n",
    "        return False\n",
    "    if color == -1:\n",
    "        table[x][y][0] = -1\n",
    "    else:\n",
    "        table[x][y][1] = 1\n",
    "    return True\n",
    "\n",
    "\n",
    "def translate_chess_coordinates(coord):\n",
    "    x = ord(coord[0]) - ord('a')\n",
    "    if x > ord('i') - ord('a'):\n",
    "        x -= 1\n",
    "    y = int(coord[1:]) - 1\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_uuid": "f6c19ad878f269bf51e6389f701f9e1b5a843879"
   },
   "outputs": [],
   "source": [
    "# for G in generator(content, 32):\n",
    "#     game = G[0][6]\n",
    "#     ans = G[1][6]\n",
    "#     print('------------------')\n",
    "#     for i in range(15):\n",
    "#         for j in range(15):\n",
    "#             if (game[i][j][0] != 0):\n",
    "#                 print('black ', i, j)\n",
    "#             if (game[i][j][1] != 0):\n",
    "#                 print('white ', i, j)\n",
    "#     for i in range(225):\n",
    "#         if (ans[i] != 0):\n",
    "#             print('ans: ', i // 15, i % 15)\n",
    "#     print('------------------')\n",
    "#     break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_uuid": "443e8d7d09ce87e53a5851892e391a8845ec5b91"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "Epoch 1/8\n",
      " - 326s - loss: 2.7925 - acc: 0.3147\n",
      "Epoch 2/8\n",
      " - 327s - loss: 2.1957 - acc: 0.4197\n",
      "Epoch 3/8\n",
      " - 327s - loss: 2.0337 - acc: 0.4522\n",
      "Epoch 4/8\n",
      " - 329s - loss: 1.9525 - acc: 0.4722\n",
      "Epoch 5/8\n",
      " - 330s - loss: 1.8837 - acc: 0.4865\n",
      "Epoch 6/8\n",
      " - 330s - loss: 1.8339 - acc: 0.4971\n",
      "Epoch 7/8\n",
      " - 331s - loss: 1.8035 - acc: 0.5053\n",
      "Epoch 8/8\n",
      " - 331s - loss: 1.7623 - acc: 0.5148\n",
      "Epoch 9/16\n",
      " - 332s - loss: 1.7216 - acc: 0.5241\n",
      "Epoch 10/16\n",
      " - 334s - loss: 1.7017 - acc: 0.5289\n",
      "Epoch 11/16\n",
      " - 334s - loss: 1.6647 - acc: 0.5368\n",
      "Epoch 12/16\n",
      " - 334s - loss: 1.6471 - acc: 0.5425\n",
      "Epoch 13/16\n",
      " - 332s - loss: 1.6315 - acc: 0.5464\n",
      "Epoch 14/16\n",
      " - 331s - loss: 1.6129 - acc: 0.5497\n",
      "Epoch 15/16\n",
      " - 333s - loss: 1.6059 - acc: 0.5526\n",
      "Epoch 16/16\n",
      " - 327s - loss: 1.5886 - acc: 0.5561\n",
      "Epoch 17/24\n",
      " - 320s - loss: 1.5665 - acc: 0.5612\n",
      "Epoch 18/24\n",
      " - 311s - loss: 1.5680 - acc: 0.5608\n",
      "Epoch 19/24\n",
      " - 303s - loss: 1.5488 - acc: 0.5653\n",
      "Epoch 20/24\n",
      " - 297s - loss: 1.5435 - acc: 0.5676\n",
      "Epoch 21/24\n",
      " - 296s - loss: 1.5300 - acc: 0.5705\n",
      "Epoch 22/24\n",
      " - 297s - loss: 1.5297 - acc: 0.5705\n",
      "Epoch 23/24\n",
      " - 297s - loss: 1.5300 - acc: 0.5708\n",
      "Epoch 24/24\n",
      " - 294s - loss: 1.5122 - acc: 0.5758\n",
      "Epoch 25/32\n",
      " - 292s - loss: 1.5226 - acc: 0.5734\n",
      "Epoch 26/32\n",
      " - 293s - loss: 1.5200 - acc: 0.5738\n",
      "Epoch 27/32\n",
      " - 290s - loss: 1.4868 - acc: 0.5818\n",
      "Epoch 28/32\n",
      " - 289s - loss: 1.4866 - acc: 0.5836\n",
      "Epoch 29/32\n",
      " - 284s - loss: 1.4839 - acc: 0.5829\n",
      "Epoch 30/32\n",
      " - 286s - loss: 1.4800 - acc: 0.5834\n",
      "Epoch 31/32\n",
      " - 286s - loss: 1.4782 - acc: 0.5852\n",
      "Epoch 32/32\n",
      " - 286s - loss: 1.4631 - acc: 0.5879\n",
      "Epoch 33/40\n",
      " - 285s - loss: 1.4542 - acc: 0.5912\n",
      "Epoch 34/40\n",
      " - 285s - loss: 1.4567 - acc: 0.5903\n",
      "Epoch 35/40\n",
      " - 285s - loss: 1.4435 - acc: 0.5937\n",
      "Epoch 36/40\n",
      " - 281s - loss: 1.4423 - acc: 0.5939\n",
      "Epoch 37/40\n",
      " - 282s - loss: 1.4378 - acc: 0.5943\n",
      "Epoch 38/40\n",
      " - 281s - loss: 1.4285 - acc: 0.5970\n",
      "Epoch 39/40\n",
      " - 281s - loss: 1.4252 - acc: 0.5985\n",
      "Epoch 40/40\n",
      " - 280s - loss: 1.4181 - acc: 0.5999\n",
      "Epoch 41/48\n",
      " - 279s - loss: 1.4169 - acc: 0.6010\n",
      "Epoch 42/48\n",
      " - 280s - loss: 1.4198 - acc: 0.6004\n",
      "Epoch 43/48\n",
      " - 279s - loss: 1.4018 - acc: 0.6050\n",
      "Epoch 44/48\n",
      " - 279s - loss: 1.4055 - acc: 0.6046\n",
      "Epoch 45/48\n",
      " - 279s - loss: 1.3997 - acc: 0.6050\n",
      "Epoch 46/48\n",
      " - 279s - loss: 1.3942 - acc: 0.6060\n",
      "Epoch 47/48\n",
      " - 280s - loss: 1.3973 - acc: 0.6065\n",
      "Epoch 48/48\n",
      " - 318s - loss: 1.3815 - acc: 0.6102\n",
      "Epoch 49/56\n",
      " - 341s - loss: 1.3711 - acc: 0.6128\n",
      "Epoch 50/56\n",
      " - 332s - loss: 1.3858 - acc: 0.6092\n",
      "Epoch 51/56\n",
      " - 328s - loss: 1.3662 - acc: 0.6131\n",
      "Epoch 52/56\n",
      " - 306s - loss: 1.3717 - acc: 0.6129\n",
      "Epoch 53/56\n",
      " - 300s - loss: 1.3644 - acc: 0.6147\n",
      "Epoch 54/56\n",
      " - 298s - loss: 1.3631 - acc: 0.6149\n",
      "Epoch 55/56\n",
      " - 299s - loss: 1.3669 - acc: 0.6144\n",
      "Epoch 56/56\n",
      " - 298s - loss: 1.3513 - acc: 0.6175\n",
      "Epoch 57/64\n",
      " - 300s - loss: 1.3518 - acc: 0.6186\n",
      "Epoch 58/64\n",
      " - 300s - loss: 1.3545 - acc: 0.6178\n",
      "Epoch 59/64\n",
      " - 296s - loss: 1.3432 - acc: 0.6202\n",
      "Epoch 60/64\n",
      " - 299s - loss: 1.3445 - acc: 0.6202\n",
      "Epoch 61/64\n",
      " - 295s - loss: 1.3399 - acc: 0.6207\n",
      "Epoch 62/64\n",
      " - 292s - loss: 1.3377 - acc: 0.6215\n",
      "Epoch 63/64\n",
      " - 294s - loss: 1.3408 - acc: 0.6211\n",
      "Epoch 64/64\n",
      " - 289s - loss: 1.3308 - acc: 0.6245\n",
      "Epoch 65/72\n",
      " - 289s - loss: 1.3274 - acc: 0.6248\n",
      "Epoch 66/72\n",
      " - 289s - loss: 1.3339 - acc: 0.6232\n",
      "Epoch 67/72\n",
      " - 292s - loss: 1.3199 - acc: 0.6254\n",
      "Epoch 68/72\n",
      " - 286s - loss: 1.3237 - acc: 0.6261\n",
      "Epoch 69/72\n",
      " - 294s - loss: 1.3174 - acc: 0.6271\n",
      "Epoch 70/72\n",
      " - 292s - loss: 1.3169 - acc: 0.6277\n",
      "Epoch 71/72\n",
      " - 293s - loss: 1.3232 - acc: 0.6259\n",
      "Epoch 72/72\n",
      " - 289s - loss: 1.3054 - acc: 0.6300\n",
      "Epoch 73/80\n",
      " - 286s - loss: 1.3102 - acc: 0.6292\n",
      "Epoch 74/80\n",
      " - 286s - loss: 1.3155 - acc: 0.6276\n",
      "Epoch 75/80\n",
      " - 285s - loss: 1.3032 - acc: 0.6301\n",
      "Epoch 76/80\n",
      " - 285s - loss: 1.3049 - acc: 0.6310\n",
      "Epoch 77/80\n",
      " - 289s - loss: 1.3022 - acc: 0.6314\n",
      "Epoch 78/80\n",
      " - 288s - loss: 1.3013 - acc: 0.6311\n",
      "Epoch 79/80\n",
      " - 289s - loss: 1.3013 - acc: 0.6316\n",
      "Epoch 80/80\n",
      " - 287s - loss: 1.2906 - acc: 0.6338\n"
     ]
    }
   ],
   "source": [
    "delta = 8\n",
    "for i in range(10):\n",
    "    history = model.fit_generator(\n",
    "        generator(content, 32),\n",
    "        10000,\n",
    "        epochs=i * delta + delta,\n",
    "#         verbose=1,\n",
    "        verbose=2,\n",
    "        initial_epoch=i * delta\n",
    "    )\n",
    "\n",
    "    file = open('info.csv'+str(i * delta), 'w')\n",
    "    file.write(str(history.history))\n",
    "    file.close()\n",
    "\n",
    "    model.save('myModel'+str(i)+'.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_uuid": "31a1e1aa31a6bd4d466f4cd33f71066f27a1e208"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.3101904279589653,\n",
       "  1.315484160682559,\n",
       "  1.3032115691512822,\n",
       "  1.3048694192558528,\n",
       "  1.3021692144751549,\n",
       "  1.3012801799684763,\n",
       "  1.3013017307937145,\n",
       "  1.2906216353833675],\n",
       " 'acc': [0.62919375,\n",
       "  0.62759375,\n",
       "  0.630115625,\n",
       "  0.631025,\n",
       "  0.631390625,\n",
       "  0.6310875,\n",
       "  0.6316375,\n",
       "  0.63380625]}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "_uuid": "4dfc3ec0d3d34a2e4eb910e3961e33b0eadd077f"
   },
   "outputs": [],
   "source": [
    "# for i in range(10):\n",
    "#     history = model.fit_generator(\n",
    "#         generator(content, 32),\n",
    "#         10000,\n",
    "#         epochs=i * 5 + 5,\n",
    "#         verbose=1,\n",
    "#         initial_epoch=i * 5\n",
    "#     )\n",
    "\n",
    "#     file = open('info.csv'+str(i * 5), 'w')\n",
    "#     file.write(str(history))\n",
    "#     file.close()\n",
    "\n",
    "#     model.save('myModel'+str(i)+'.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "_uuid": "84bf8e70e0cdff701757821316f18393b70d9f30"
   },
   "outputs": [],
   "source": [
    "file = open('info', 'w')\n",
    "file.write(str(history.history))\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "_uuid": "4444d5699e90373a36226a9e2f627b401015eff0"
   },
   "outputs": [],
   "source": [
    "model.save('myModel.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "_uuid": "9891805b78121ab0ffa9cc2e153632bf47705248"
   },
   "outputs": [],
   "source": [
    "# model = keras.models.load_model('myModel0.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "_uuid": "69c3f90e3b2747990e88c7043a9674c5915cae84"
   },
   "outputs": [],
   "source": [
    "# from IPython.display import HTML\n",
    "# import pandas as pd\n",
    "# import numpy as np\n",
    "# import base64\n",
    "\n",
    "# # function that takes in a dataframe and creates a text link to  \n",
    "# # download it (will only work for files < 2MB or so)\n",
    "\n",
    "# def create_download_link(df, title = \"Download CSV file\", filename = \"data.csv\"):  \n",
    "#     df = pd.DataFrame(df)\n",
    "#     df.index += 1\n",
    "#     csv = df.to_csv(index=True)\n",
    "#     b64 = base64.b64encode(csv.encode())\n",
    "#     payload = b64.decode()\n",
    "#     html = '<a download=\"{filename}\" href=\"data:text/csv;base64,{payload}\" target=\"_blank\">{title}</a>'\n",
    "#     html = html.format(payload=payload,title=title,filename=filename)\n",
    "#     return HTML(html)\n",
    "\n",
    "# create_download_link(res, filename=\"answer.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "_uuid": "ed6f3cbb2acf9fd05eae95e20bce208763150fd6"
   },
   "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": 1
}