Matrix3_Day5.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Matrix3_Day5.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "11E3X01B1Xw5RD9ttgA5qCMucrvRvrrAb",
      "authorship_tag": "ABX9TyNdNCxCOYDMqniBwx64DXz2",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/eb-art/DW_road_sign/blob/master/Matrix3_Day5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K7WRTmGI1TUo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "35230c06-eaec-422a-c8d0-c66fd7e65a71"
      },
      "source": [
        "cd '/content/drive/My Drive/Colab Notebooks/matrix/matrix_3/DW_road_sign'"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/drive/My Drive/Colab Notebooks/matrix/matrix_3/DW_road_sign\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QNuFMYZd2aEL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 190
        },
        "outputId": "cecf192e-c646-438d-c0ac-c246083a694f"
      },
      "source": [
        "!pip install hyperopt"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: hyperopt in /usr/local/lib/python3.6/dist-packages (0.1.2)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from hyperopt) (0.16.0)\n",
            "Requirement already satisfied: pymongo in /usr/local/lib/python3.6/dist-packages (from hyperopt) (3.10.1)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.6/dist-packages (from hyperopt) (1.4.1)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from hyperopt) (4.38.0)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.6/dist-packages (from hyperopt) (2.4)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from hyperopt) (1.18.2)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from hyperopt) (1.12.0)\n",
            "Requirement already satisfied: decorator>=4.3.0 in /usr/local/lib/python3.6/dist-packages (from networkx->hyperopt) (4.4.2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DOp-t_zrkpaX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "0bcf32bb-59be-4929-899a-c5e5f49a8a92"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "import os\n",
        "import datetime\n",
        "import matplotlib.pyplot as plt\n",
        "from skimage import color, exposure\n",
        "\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropout\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "from hyperopt import hp, STATUS_OK, tpe, Trials, fmin\n",
        "\n",
        "# Load the TensorBoard notebook extension\n",
        "%load_ext tensorboard"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The tensorboard extension is already loaded. To reload it, use:\n",
            "  %reload_ext tensorboard\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2QyfIOr51WhE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train = pd.read_pickle('data/train.p')\n",
        "test = pd.read_pickle('data/test.p')\n",
        "\n",
        "X_train, y_train = train['features'], train['labels']\n",
        "X_train.shape, y_train.shape\n",
        "\n",
        "X_test, y_test = test['features'], test['labels']\n",
        "X_test.shape, y_test.shape\n",
        "\n",
        "df = pd.read_csv('data/dw_signnames.csv')\n",
        "labels_dict = df.to_dict()['b']\n",
        "\n",
        "if y_train.ndim == 1: y_train = to_categorical(y_train)\n",
        "if y_test.ndim == 1: y_test = to_categorical(y_test)\n",
        "\n",
        "input_shape = X_train.shape[1:]\n",
        "num_classes = y_train.shape[1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d0X4g3Q91dUQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train_model_param(model, X_train, y_train, params_fit={}):\n",
        "  model.compile(loss='categorical_crossentropy', \n",
        "              optimizer = 'Adam',\n",
        "              metrics=['accuracy'])\n",
        "  \n",
        "  log_dir = \"logs/fit/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
        "\n",
        "  #logdir = os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n",
        "  tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)\n",
        "  #tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir,histogram_freq=1)\n",
        "   \n",
        "  model.fit(\n",
        "      X_train, y_train,\n",
        "      batch_size = params_fit.get('batch_size', 128),\n",
        "      epochs = params_fit.get('epochs', 5),\n",
        "      verbose = params_fit.get('verbose', 1),\n",
        "      validation_data = params_fit.get('validation_data', (X_train, y_train)),\n",
        "      callbacks = [tensorboard_callback]\n",
        "  )\n",
        "  return model"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4dK-IrNd26VZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def predict(model_trained, X_test, y_test, scoring = accuracy_score):\n",
        "  \n",
        "  y_pred_prob = model_trained.predict(X_test)\n",
        "  y_pred = np.argmax(y_pred_prob, axis = 1) #szuka wiersz po wierszu\n",
        "\n",
        "  y_test_norm = np.argmax(y_test, axis = 1)\n",
        "\n",
        "  return scoring(y_test_norm, y_pred) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jSoI66V029dN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def get_cnn_v5(input_shape, num_classes):\n",
        "  return Sequential([\n",
        "  Conv2D(filters=32, kernel_size=(3,3), activation='relu', input_shape=input_shape),\n",
        "  Conv2D(filters=32, kernel_size=(3,3), activation='relu', padding='same'),\n",
        "  MaxPool2D(),\n",
        "  Dropout(0.3),\n",
        "  \n",
        "  Conv2D(filters=64, kernel_size=(3,3), activation='relu', padding='same'),\n",
        "  Conv2D(filters=64, kernel_size=(3,3), activation='relu'),\n",
        "  MaxPool2D(),\n",
        "  Dropout(0.3),\n",
        "\n",
        "  Conv2D(filters=64, kernel_size=(3,3), activation='relu', padding='same'),\n",
        "  Conv2D(filters=64, kernel_size=(3,3), activation='relu'),\n",
        "  MaxPool2D(),\n",
        "  Dropout(0.3),\n",
        "\n",
        "  Flatten(),\n",
        "\n",
        "  Dense(1024, activation='relu'),\n",
        "  Dropout(0.3),\n",
        "\n",
        "  Dense(num_classes, activation='softmax')                    \n",
        "])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dFkQ1yck3ERA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#def train_and_predict(model):\n",
        "  #model_trained = train_model_param(model, X_train, y_train) \n",
        "\n",
        "  #return predict(model_trained, X_test, y_test) \n",
        "\n",
        "#train_and_predict(get_cnn_v3(input_shape, num_classes))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J4EfWMOo3b4y",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 224
        },
        "outputId": "cc2acdef-db1a-4779-f88d-48390a9eb102"
      },
      "source": [
        "model = get_cnn_v5(input_shape, num_classes)\n",
        "model_trained = train_model_param(model, X_train, y_train)\n",
        "predict(model_trained, X_test, y_test)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "272/272 [==============================] - 4s 15ms/step - loss: 2.7049 - accuracy: 0.2740 - val_loss: 1.3049 - val_accuracy: 0.5850\n",
            "Epoch 2/5\n",
            "272/272 [==============================] - 4s 14ms/step - loss: 1.0552 - accuracy: 0.6669 - val_loss: 0.3007 - val_accuracy: 0.9050\n",
            "Epoch 3/5\n",
            "272/272 [==============================] - 4s 14ms/step - loss: 0.4659 - accuracy: 0.8545 - val_loss: 0.1529 - val_accuracy: 0.9566\n",
            "Epoch 4/5\n",
            "272/272 [==============================] - 4s 14ms/step - loss: 0.2695 - accuracy: 0.9183 - val_loss: 0.0675 - val_accuracy: 0.9802\n",
            "Epoch 5/5\n",
            "272/272 [==============================] - 4s 14ms/step - loss: 0.1899 - accuracy: 0.9427 - val_loss: 0.0338 - val_accuracy: 0.9905\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9752834467120182"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DAq_Zr-X4zVy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "fa99c13b-9cc3-4a7d-dad5-26abf4ba148d"
      },
      "source": [
        "model_trained.evaluate(X_test, y_test)[1]"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "138/138 [==============================] - 0s 3ms/step - loss: 0.0970 - accuracy: 0.9753\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9752834439277649"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKALRMKo7QgH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def get_model(params):\n",
        "  return Sequential([\n",
        "  Conv2D(filters=32, kernel_size=(3,3), activation='relu', input_shape=input_shape),\n",
        "  Conv2D(filters=32, kernel_size=(3,3), activation='relu', padding='same'),\n",
        "  MaxPool2D(),\n",
        "  Dropout(params['dropout_cnn_block_one']),\n",
        "  \n",
        "  Conv2D(filters=64, kernel_size=(3,3), activation='relu', padding='same'),\n",
        "  Conv2D(filters=64, kernel_size=(3,3), activation='relu'),\n",
        "  MaxPool2D(),\n",
        "  Dropout(params['dropout_cnn_block_two']),\n",
        "\n",
        "  Conv2D(filters=128, kernel_size=(3,3), activation='relu', padding='same'),\n",
        "  Conv2D(filters=128, kernel_size=(3,3), activation='relu'),\n",
        "  MaxPool2D(),\n",
        "  Dropout(params['dropout_cnn_block_three']),\n",
        "\n",
        "  Flatten(),\n",
        "\n",
        "  Dense(1024, activation='relu'),\n",
        "  Dropout(params['dropout_cnn_dense_one']),\n",
        "\n",
        "  Dense(1024, activation='relu'),\n",
        "  Dropout(params['dropout_cnn_dense_two']),\n",
        "\n",
        "  Dense(num_classes, activation='softmax')                    \n",
        "])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dpx_5weu3hlt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def func_obj(params):\n",
        "  model = get_model(params)\n",
        "  model.compile(loss='categorical_crossentropy', \n",
        "              optimizer = 'Adam', metrics=['accuracy'])\n",
        "  model.fit(\n",
        "      X_train, y_train,\n",
        "      batch_size = int(params.get('batch_size', 128)),\n",
        "      epochs = 7,\n",
        "      verbose = 0\n",
        "  )\n",
        "  accuracy = model.evaluate(X_test, y_test,verbose = 0)[1]\n",
        "  #print(params, 'accuracy={}'.format(accuracy))\n",
        "  return {'loss': -accuracy, 'status': STATUS_OK, 'model': model}\n",
        "\n",
        "space = {\n",
        "    'batch_size': hp.quniform('batch_size', 10, 200, 10),\n",
        "    'dropout_cnn_block_one': hp.quniform('dropout_cnn_block_one', 0.3, 0.5, 0.1),\n",
        "    'dropout_cnn_block_two': hp.quniform('dropout_cnn_block_two', 0.3, 0.5, 0.1),\n",
        "    'dropout_cnn_block_three': hp.quniform('dropout_cnn_block_three', 0.3, 0.5, 0.1),\n",
        "    'dropout_cnn_dense_one': hp.quniform('dropout_cnn_dense_one', 0.3, 0.7, 0.1),\n",
        "    'dropout_cnn_dense_two': hp.quniform('dropout_cnn_dense_two', 0.3, 0.7, 0.1),\n",
        "\n",
        "  }\n",
        "\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3I9etrRL6e8a",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5697d2c7-e6b7-4620-a3cf-98b9f5759528"
      },
      "source": [
        "best = fmin(\n",
        "    func_obj,\n",
        "    space,\n",
        "    tpe.suggest,\n",
        "    30,\n",
        "    Trials()\n",
        ")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " 73%|███████▎  | 22/30 [08:29<03:23, 25.46s/it, best loss: -0.980272114276886]"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G62WPzsm8U_Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}