The_From_Network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "The From Network.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TycqUaMS11S4",
        "outputId": "2b59b25b-f69f-4f06-a3a8-39cfdaeb28f3"
      },
      "source": [
        "%tensorflow_version 2.x\n",
        "import tensorflow as tf\n",
        "print(\"Tensorflow version \" + tf.__version__)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tensorflow version 2.4.1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a-g8tF5m2F9K",
        "outputId": "0bba613c-3733-4980-9aa2-14eee61171a0"
      },
      "source": [
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found GPU at: /device:GPU:0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bd1piiIT2KMp",
        "outputId": "a4bf50a0-aa9a-44c4-f0e3-94503b9ccabe"
      },
      "source": [
        "from tensorflow.python.client import device_lib\n",
        "device_lib.list_local_devices()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[name: \"/device:CPU:0\"\n",
              " device_type: \"CPU\"\n",
              " memory_limit: 268435456\n",
              " locality {\n",
              " }\n",
              " incarnation: 246908465493731548, name: \"/device:GPU:0\"\n",
              " device_type: \"GPU\"\n",
              " memory_limit: 14674281152\n",
              " locality {\n",
              "   bus_id: 1\n",
              "   links {\n",
              "   }\n",
              " }\n",
              " incarnation: 15645767896973485500\n",
              " physical_device_desc: \"device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5\"]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Au6FvqFL2Ppf"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import os \n",
        "from collections import Counter\n",
        "import itertools\n",
        "import shutil\n",
        "import random\n",
        "import glob\n",
        "import warnings\n",
        "warnings.simplefilter(action = 'ignore', category = FutureWarning)\n",
        "%matplotlib inline"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TSfjdGtT2YIX",
        "outputId": "882644b7-03b8-4e90-a795-1fc0352d7075"
      },
      "source": [
        "!pip install python-chess"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: python-chess in /usr/local/lib/python3.7/dist-packages (0.30.1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "19xmUZl92c43"
      },
      "source": [
        "import chess\n",
        "import chess.pgn"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l5ngDLFq2hv7",
        "outputId": "94f97dae-1d15-48ca-a280-ec22d75af810"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/Pdrive')"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/Pdrive; to attempt to forcibly remount, call drive.mount(\"/content/Pdrive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r0Z7b9_32qob"
      },
      "source": [
        "find_num = {'a1': chess.A1, 'a2': chess.A2, 'a3': chess.A3, 'a4': chess.A4, 'a5': chess.A5, 'a6': chess.A6, 'a7': chess.A7,\n",
        "            'a8': chess.A8, 'b1': chess.B1, 'b2': chess.B2, 'b3': chess.B3, 'b4': chess.B4, 'b5': chess.B5, 'b6': chess.B6,\n",
        "            'b7': chess.B7, 'b8': chess.B8, 'c1': chess.C1, 'c2': chess.C2, 'c3': chess.C3, 'c4': chess.C4, 'c5': chess.C5,\n",
        "            'c6': chess.C6, 'c7': chess.C7, 'c8': chess.C8, 'd1': chess.D1, 'd2': chess.D2, 'd3': chess.D3, 'd4': chess.D4, \n",
        "            'd5': chess.D5, 'd6': chess.D6, 'd7': chess.D7, 'd8': chess.D8, 'e1': chess.E1, 'e2': chess.E2, 'e3': chess.E3,\n",
        "            'e4': chess.E4, 'e5': chess.E5, 'e6': chess.E6, 'e7': chess.E7, 'e8': chess.E8, 'f1': chess.F1, 'f2': chess.F2,\n",
        "            'f3': chess.F3, 'f4': chess.F4, 'f5': chess.F5, 'f6': chess.F6, 'f7': chess.F7, 'f8': chess.F8, 'g1': chess.G1,\n",
        "            'g2': chess.G2, 'g3': chess.G3, 'g4': chess.G4, 'g5': chess.G5, 'g6': chess.G6, 'g7': chess.G7, 'g8': chess.G8,\n",
        "            'h1': chess.H1, 'h2': chess.H2, 'h3': chess.H3, 'h4': chess.H4, 'h5': chess.H5, 'h6': chess.H6, 'h7': chess.H7,\n",
        "            'h8': chess.H8}\n",
        "        "
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SnhjqOq42_42"
      },
      "source": [
        "def data_augment(list_in, str_from): \n",
        "    \n",
        "    # augments the board position when it's black's turn to make it appear as if it's white's turn.\n",
        "    # for this, we just need to rotate the board by 180 degrees anti-clock and flip the color of all the pieces.\n",
        "    \n",
        "    list_out = ['null', 'null', 'null', 'null', 'null', 'null', 'null', 'null']\n",
        "    \n",
        "    var = 7\n",
        "    \n",
        "    if len(list_in) == 8:\n",
        "        \n",
        "        for el in list_in:\n",
        "            el_rev = el[::-1]\n",
        "            fin = \"\"\n",
        "            for char in el_rev:\n",
        "                if char.isalpha():\n",
        "                    if char.islower():\n",
        "                        fin += char.upper()\n",
        "                    elif char.isupper():\n",
        "                        fin += char.lower()\n",
        "                elif char.isdigit():\n",
        "                    fin += char\n",
        "            \n",
        "            list_out[var] = fin\n",
        "            var = var - 1\n",
        "              \n",
        "    else:\n",
        "        print('Error: List not compatible')\n",
        "    \n",
        "    fin1 = \"\"\n",
        "    \n",
        "    alpha = list(str_from)\n",
        "    fin1 += chr(8 - ord(alpha[0]) + ord('a') -1 + 97)\n",
        "    fin1 += str(9 - int(alpha[1]))\n",
        "    num = find_num[fin1]\n",
        "    \n",
        "    return list_out, num"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lPI1ptcY3GBT"
      },
      "source": [
        "def count_total_moves(game):\n",
        "    \n",
        "    # counts total number of moves of any game.\n",
        "    \n",
        "    count = 0\n",
        "    for posn in game.mainline():\n",
        "        count += 1 \n",
        "    \n",
        "    return count"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YfyC-eOG3KtK"
      },
      "source": [
        "def fen_to_matrix(string_fen, string_move):\n",
        "    \n",
        "    # for a given board in FEN notation, it converts that to a corresponding 8x8x6 matrix board along with it's output label.\n",
        "    # The output label can be the position from where move was made or the position to where the move was made. It'll be a\n",
        "    # number between 0 to 63 corresponding to the given string- string_move.\n",
        "    \n",
        "    board_matrix = np.zeros((8, 8, 6))\n",
        "    \n",
        "    fen_list = string_fen.split(\" \")[0].split(\"/\")\n",
        "    val_ = 0\n",
        "    \n",
        "    for x in fen_list:\n",
        "        temp_s = \"\"\n",
        "        for y in x:\n",
        "            if y.isalpha():\n",
        "                temp_s += y\n",
        "            elif y.isdigit():\n",
        "                for al_ in range(int(y)):\n",
        "                    temp_s += y\n",
        "                    \n",
        "        fen_list[val_] = temp_s\n",
        "        val_ += 1  \n",
        "        \n",
        "    next_ = string_fen.split(\" \")[1]\n",
        "    \n",
        "    \n",
        "    \n",
        "    if next_ == \"w\":\n",
        "        label = find_num[string_move]\n",
        "        \n",
        "        for i in range(len(fen_list)):\n",
        "            for j in range(len(fen_list[i])):\n",
        "                if fen_list[i][j].isalpha():\n",
        "                    board_matrix[i, j, notation[fen_list[i][j]][0]] = notation[fen_list[i][j]][1]    \n",
        "    elif next_ == \"b\":\n",
        "        fen_list, label = data_augment(fen_list, string_move)\n",
        "        \n",
        "        for i in range(len(fen_list)):\n",
        "            for j in range(len(fen_list[i])):\n",
        "                if fen_list[i][j].isalpha():\n",
        "                    board_matrix[i, j, notation[fen_list[i][j]][0]] = notation[fen_list[i][j]][1]\n",
        "                    \n",
        "    \n",
        "    return board_matrix, label"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ommcOO-w3OgE"
      },
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import StratifiedKFold\n",
        "from collections import Counter"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hJeZln323R4w"
      },
      "source": [
        "def encoding_label(y_in):\n",
        "    \n",
        "    # encodes the output vector (from 0 to 63 in our case) \n",
        "    \n",
        "    encoder = LabelEncoder()\n",
        "    encoder.fit(y_in)\n",
        "    encoded_y = encoder.transform(y_in)\n",
        "    \n",
        "    return encoded_y"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BL-YWzVc3VOj"
      },
      "source": [
        "def tt_split(Xin, yin):\n",
        "    \n",
        "    # does train-test split using stratified KFold cross validation method.\n",
        "    \n",
        "    skf = StratifiedKFold(n_splits = 5, shuffle = True, random_state = 1)    # 80% - 20% split.\n",
        "    \n",
        "    skf.get_n_splits(Xin, yin)\n",
        "    \n",
        "    for train_index, test_index in skf.split(Xin, yin):\n",
        "        X_train, X_test = Xin[train_index], Xin[test_index]\n",
        "        y_train, y_test = yin[train_index], yin[test_index]\n",
        "        \n",
        "    return X_train, X_test, y_train, y_test"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yt2fr1KR3YaQ"
      },
      "source": [
        "path = '/content/Pdrive/MyDrive/Colab Notebooks/FICS_Database.pgn'\n",
        "file_op = open(path)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "01oLIGR03lEC"
      },
      "source": [
        "list_games = []\n",
        "\n",
        "while True:\n",
        "    readd = chess.pgn.read_game(file_op)\n",
        "    if readd is None:\n",
        "        break\n",
        "    \n",
        "    list_games.append(readd)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y75BcQ073pe5",
        "outputId": "197d67a5-08d5-4c00-e9ac-65e740aa243c"
      },
      "source": [
        "print(len(list_games))  # total 5794 games have been taken as the dataset. Each game would contain 60-160 moves on an avg."
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5794\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WwWMpGiF3856"
      },
      "source": [
        "notation = {'p': (0, -1),\n",
        "            'n': (1, -1),\n",
        "            'b': (2, -1),\n",
        "            'r': (3, -1),\n",
        "            'q': (4, -1),\n",
        "            'k': (5, -1),\n",
        "            'P': (0, 1),\n",
        "            'N': (1, 1),\n",
        "            'B': (2, 1),\n",
        "            'R': (3, 1),\n",
        "            'Q': (4, 1),\n",
        "            'K': (5, 1)\n",
        "             }"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YLNtdY4r3_qu"
      },
      "source": [
        "# preparing dataset for the 'from CNN'\n",
        "\n",
        "boards_list = []\n",
        "moves_list = []\n",
        "\n",
        "for gm in list_games:\n",
        "    reg1 = 0\n",
        "    reg2 = 0\n",
        "    countt = count_total_moves(gm)\n",
        "    moves_list_temp = []\n",
        "    \n",
        "    for pos in gm.mainline():\n",
        "        reg1 += 1\n",
        "        if reg1!=1:\n",
        "            moves_list_temp.append(str(pos.move)[0] + str(pos.move)[1]) # the position was appended from where the move was made\n",
        "            \n",
        "    for posi in gm.mainline():\n",
        "        reg2 += 1\n",
        "        if reg2!=countt:\n",
        "            gamma0, gamma1 = fen_to_matrix(posi.board().fen(), moves_list_temp[reg2-1])\n",
        "            boards_list.append(gamma0)\n",
        "            moves_list.append(gamma1)\n",
        "                "
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KE38AstY4DIK"
      },
      "source": [
        "X_fromCNN = np.array(boards_list)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2jtZcaIiJAit"
      },
      "source": [
        "y_fromCNN = np.array(moves_list)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r6YLUz1IJEkU",
        "outputId": "6677b620-592d-4253-8659-eef3c0a6da1e"
      },
      "source": [
        "print(X_fromCNN.shape)\n",
        "print(y_fromCNN.shape)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(806539, 8, 8, 6)\n",
            "(806539,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9igkHXOfSvxd"
      },
      "source": [
        "# Encoding the labels (or the possible outputs) using the above-made function.\n",
        "\n",
        "y_test_from = encoding_label(y_fromCNN)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tv7-MBSujE2v"
      },
      "source": [
        "# Train-Test split:\n",
        "\n",
        "X_train_from, X_test_from, y_train_from, y_test_from = tt_split(np.array(boards_list), y_test_from)"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ua3wxaKFjtp6"
      },
      "source": [
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, Activation, BatchNormalization\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.metrics import categorical_crossentropy\n",
        "from tensorflow.keras.regularizers import l1, l2, l1_l2"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6rhXlG8hka7H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a65c605b-a3d2-4ba1-c8dd-1d8ff6cca4b4"
      },
      "source": [
        "model = Sequential()\n",
        "model.add(Conv2D(filters = 32, kernel_size = (2, 2), activation = 'elu', kernel_regularizer = l2(0.000005), input_shape = (8, 8, 6)))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Dropout(0.15))\n",
        "model.add(Conv2D(filters = 64, kernel_size = (3, 3), activation = 'elu', kernel_regularizer = l2(0.000005)))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Dropout(0.15))\n",
        "model.add(Conv2D(filters = 128, kernel_size = (3, 3), activation = 'elu', kernel_regularizer = l2(0.000005)))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Flatten())\n",
        "model.add(Dense(units = 32, activation = 'relu'))\n",
        "model.add(BatchNormalization())\n",
        "model.add(Dense(units = 64, activation = 'softmax'))\n",
        "\n",
        "model.summary()"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv2d_1 (Conv2D)            (None, 7, 7, 32)          800       \n",
            "_________________________________________________________________\n",
            "batch_normalization (BatchNo (None, 7, 7, 32)          128       \n",
            "_________________________________________________________________\n",
            "dropout (Dropout)            (None, 7, 7, 32)          0         \n",
            "_________________________________________________________________\n",
            "conv2d_2 (Conv2D)            (None, 5, 5, 64)          18496     \n",
            "_________________________________________________________________\n",
            "batch_normalization_1 (Batch (None, 5, 5, 64)          256       \n",
            "_________________________________________________________________\n",
            "dropout_1 (Dropout)          (None, 5, 5, 64)          0         \n",
            "_________________________________________________________________\n",
            "conv2d_3 (Conv2D)            (None, 3, 3, 128)         73856     \n",
            "_________________________________________________________________\n",
            "batch_normalization_2 (Batch (None, 3, 3, 128)         512       \n",
            "_________________________________________________________________\n",
            "dropout_2 (Dropout)          (None, 3, 3, 128)         0         \n",
            "_________________________________________________________________\n",
            "flatten (Flatten)            (None, 1152)              0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 32)                36896     \n",
            "_________________________________________________________________\n",
            "batch_normalization_3 (Batch (None, 32)                128       \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 64)                2112      \n",
            "=================================================================\n",
            "Total params: 133,184\n",
            "Trainable params: 132,672\n",
            "Non-trainable params: 512\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mr1czGyxaXg6",
        "outputId": "264695dc-8a9a-4b0c-821b-22c4d0ce7de8"
      },
      "source": [
        "model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])\n",
        "model.fit(x = X_train_from, y = y_train_from, batch_size = 128, epochs = 20)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/20\n",
            "5041/5041 [==============================] - 22s 4ms/step - loss: 1.5258 - accuracy: 0.4536\n",
            "Epoch 2/20\n",
            "5041/5041 [==============================] - 22s 4ms/step - loss: 1.5217 - accuracy: 0.4545\n",
            "Epoch 3/20\n",
            "5041/5041 [==============================] - 22s 4ms/step - loss: 1.5176 - accuracy: 0.4550\n",
            "Epoch 4/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5156 - accuracy: 0.4536\n",
            "Epoch 5/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5198 - accuracy: 0.4537\n",
            "Epoch 6/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5121 - accuracy: 0.4552\n",
            "Epoch 7/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5130 - accuracy: 0.4560\n",
            "Epoch 8/20\n",
            "5041/5041 [==============================] - 22s 4ms/step - loss: 1.5142 - accuracy: 0.4550\n",
            "Epoch 9/20\n",
            "5041/5041 [==============================] - 22s 4ms/step - loss: 1.5106 - accuracy: 0.4566\n",
            "Epoch 10/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5100 - accuracy: 0.4556\n",
            "Epoch 11/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5051 - accuracy: 0.4579\n",
            "Epoch 12/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5055 - accuracy: 0.4579\n",
            "Epoch 13/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5091 - accuracy: 0.4555\n",
            "Epoch 14/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5039 - accuracy: 0.4578\n",
            "Epoch 15/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5018 - accuracy: 0.4587\n",
            "Epoch 16/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5004 - accuracy: 0.4590\n",
            "Epoch 17/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5005 - accuracy: 0.4585\n",
            "Epoch 18/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.5004 - accuracy: 0.4588\n",
            "Epoch 19/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.4985 - accuracy: 0.4581\n",
            "Epoch 20/20\n",
            "5041/5041 [==============================] - 21s 4ms/step - loss: 1.4975 - accuracy: 0.4583\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7fca6bd23d90>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2fDVERdEgEEr",
        "outputId": "24f0b8c7-f71a-4840-f846-ff429360c992"
      },
      "source": [
        "model.evaluate(X_test_from, y_test_from, batch_size = 128)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1261/1261 [==============================] - 4s 3ms/step - loss: 1.3984 - accuracy: 0.4865\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1.398398756980896, 0.4864884912967682]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQImBFdBh1h8"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}