{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "b5ec3bda-3b19-5b22-eddf-92ebfe3843ae"
      },
      "source": [
        "All import"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "d2e141b0-dcbe-31b4-cf84-8a8eace3dac2"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\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",
        "import matplotlib.pylab as plt\n",
        "from random import shuffle\n",
        "\n",
        "import os\n",
        "import cv2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "6ca5af46-782e-0fdb-0611-23ef6faf1861"
      },
      "source": [
        "Open Data form the train set "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "ece1a90d-1af0-0c5e-b4b4-5ffe899e3a54"
      },
      "outputs": [],
      "source": [
        "train_path = \"../input/train\"\n",
        "\n",
        "ROWS = 64\n",
        "COLS = 64\n",
        "CHANNELS = 3\n",
        "\n",
        "images = [img for img in os.listdir(train_path)]\n",
        "images_dog = [img for img in os.listdir(train_path) if \"dog\" in img]\n",
        "images_cat = [img for img in os.listdir(train_path) if \"cat\" in img]\n",
        "\n",
        "#only taking a subset (less accuracy but faster training)\n",
        "train_dog = images_dog[:1000]\n",
        "train_cat = images_cat[:1000]\n",
        "valid_dog = images_dog[1000:1100]\n",
        "valid_cat = images_cat[1000:1100]\n",
        "\n",
        "train_list = train_dog + train_cat\n",
        "valid_list = valid_dog + valid_cat\n",
        "\n",
        "shuffle(train_list)\n",
        "\n",
        "train = np.ndarray(shape=(len(train_list),ROWS, COLS))\n",
        "train_color = np.ndarray(shape=(len(train_list), ROWS, COLS, CHANNELS), dtype=np.uint8) #, dtype=np.uint8\n",
        "\n",
        "labels = np.ndarray(len(train_list))\n",
        "\n",
        "for i, img_path in enumerate(train_list):\n",
        "    img_color = cv2.imread(os.path.join(train_path, img_path), 1)\n",
        "    img_color = cv2.resize(img_color, (ROWS, COLS), interpolation=cv2.INTER_CUBIC)\n",
        "    img = cv2.cvtColor(img_color, cv2.COLOR_BGR2GRAY)\n",
        "    \n",
        "    train[i] = img\n",
        "    train_color[i] = img_color\n",
        "   \n",
        "    if \"dog\" in img_path:\n",
        "        labels[i] = 0\n",
        "    else:\n",
        "        labels[i] = 1\n",
        "    \n",
        "\n",
        "valid = np.ndarray(shape=(len(valid_list), ROWS, COLS))\n",
        "valid_color = np.ndarray(shape=(len(valid_list), ROWS, COLS, CHANNELS))\n",
        "valid_labels = np.ndarray(len(valid_list))\n",
        "\n",
        "for i, img_path in enumerate(valid_list):\n",
        "    img_color = cv2.imread(os.path.join(train_path, img_path), 1)\n",
        "    img_color = cv2.resize(img_color, (ROWS, COLS), interpolation=cv2.INTER_CUBIC)\n",
        "    img = cv2.cvtColor(img_color, cv2.COLOR_BGR2GRAY)\n",
        "    \n",
        "    valid[i] = img\n",
        "    valid_color[i] = img_color\n",
        "    \n",
        "    if \"dog\" in img_path:\n",
        "        valid_labels[i] = 0\n",
        "    else:\n",
        "        valid_labels[i] = 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "4b303fe1-d2a5-c61b-e77d-3ce9df6dae50"
      },
      "source": [
        "Plot some training samples after prepocessing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "b8bfddac-6262-e054-d22d-56c313bd89c3"
      },
      "source": [
        "### uncorrect labeled dat:\n",
        "- dog.4367.jpg Is a picture of Yahoo! Mail"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "3113259c-4208-a454-0796-9198a383e018"
      },
      "outputs": [],
      "source": [
        "n = 33\n",
        "plt.subplot(1,2,1)\n",
        "plt.imshow(cv2.imread(os.path.join(train_path, train_list[len(train_list)-n])))\n",
        "plt.subplot(1,2,2)\n",
        "plt.imshow(train_color[len(train_list)-n])\n",
        "plt.title(labels[len(train_list)-n])\n",
        "plt.show()\n",
        "\n",
        "for i in range(1):\n",
        "    plt.imshow(train[i], cmap='gray')\n",
        "    plt.title(train_list[i])\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "c293d1e1-70e7-72b1-557b-76d9e0817b18"
      },
      "source": [
        "data normalization (**Feature scaling**)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "5d61840c-0558-6859-6f1b-94771bcc7b71"
      },
      "outputs": [],
      "source": [
        "def average(data):\n",
        "    data = data - 127\n",
        "    data = data/np.max(np.abs(data))\n",
        "    return data\n",
        "def average_color(data):\n",
        "    data = data - 127\n",
        "    data = data / 255\n",
        "    return data\n",
        "\n",
        "\n",
        "#train = average(train)\n",
        "print(train[1,:,:])\n",
        "#train_color = average_color(train_color)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "8fff6c00-c65d-684d-00d0-f56e7e700911"
      },
      "source": [
        "Train a model using **Keras**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "2f6116d0-9bd6-91f3-cc88-d11f8672922f"
      },
      "outputs": [],
      "source": [
        "from keras.models import Sequential\n",
        "from keras.layers import Convolution2D, BatchNormalization\n",
        "from keras.layers import Dense, Activation, Flatten, Dropout, MaxPooling2D\n",
        "from keras.regularizers import l2\n",
        "from keras.utils.np_utils import to_categorical\n",
        "from keras.optimizers import SGD, RMSprop, Adagrad\n",
        "\n",
        "optimizer = SGD(lr=1e-3, momentum=0.0, decay=0.0, nesterov=False)\n",
        "optimizer = RMSprop(lr=1e-4)\n",
        "\n",
        "def convNet():\n",
        "    model = Sequential()\n",
        "\n",
        "    model.add(Convolution2D(32, 3, 3, name='conv1',border_mode='same', activation='relu', input_shape=(ROWS, COLS, CHANNELS), dim_ordering='tf'))\n",
        "    model.add(Convolution2D(32, 3, 3, border_mode='same', activation='relu', dim_ordering='tf'))\n",
        "    model.add(MaxPooling2D(pool_size=(2,2), border_mode='same', dim_ordering='tf'))\n",
        "\n",
        "\n",
        "    model.add(Convolution2D(64, 3, 3, border_mode='same', activation='relu', dim_ordering='tf'))\n",
        "    model.add(Convolution2D(64, 3, 3, border_mode='same', activation='relu', dim_ordering='tf'))\n",
        "    model.add(MaxPooling2D(pool_size=(2,2), border_mode='same', dim_ordering='tf'))\n",
        "\n",
        "\n",
        "    model.add(Convolution2D(128, 3, 3, border_mode='same', activation='relu', dim_ordering='tf'))\n",
        "    model.add(Convolution2D(128, 3, 3, border_mode='same', activation='relu', dim_ordering='tf'))\n",
        "    model.add(MaxPooling2D(pool_size=(2,2), border_mode='same',dim_ordering='tf'))\n",
        "    \n",
        "    model.add(Convolution2D(256, 3, 3, border_mode='same', activation='relu'))\n",
        "    model.add(Convolution2D(256, 3, 3, border_mode='same', activation='relu'))\n",
        "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "\n",
        "\n",
        "    model.add(Flatten())\n",
        "\n",
        "    model.add(Dense(output_dim=256, activation='relu'))\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    model.add(Dense(output_dim=256,  activation='relu'))\n",
        "    model.add(Dropout(0.5))\n",
        "\n",
        "    model.add(Dense(output_dim=2))  #binary classification\n",
        "    model.add(Activation('softmax'))\n",
        "    model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])\n",
        "    return model\n",
        "\n",
        "model = convNet()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "caa54af7-0e7b-f936-ac7b-f28a694633e0"
      },
      "outputs": [],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "d86343f5-79f5-0f66-cc5d-85602fe859b6"
      },
      "source": [
        "ln(2) ~= 0.69314718056"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "793679a3-40c4-63a7-7347-4161853f12f2"
      },
      "source": [
        "### Train model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "d4c52b42-9f01-9e02-94ab-960af3711192"
      },
      "outputs": [],
      "source": [
        "\n",
        "#model.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=1e-8), metrics=['accuracy'])\n",
        "labels_ = to_categorical(labels, 2) #convert labels to a matrix representation \n",
        "train_ = np.resize(train, (len(train), ROWS, COLS, 1))\n",
        "#print(train_[2,:,:,0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "b2175384-ff01-8153-f727-1a4052260f82"
      },
      "outputs": [],
      "source": [
        "n=232\n",
        "plt.imshow(train_color[n,:,:,:])\n",
        "plt.title(labels_[n])\n",
        "print(labels[n])\n",
        "if \"dog\" in train_list[n]:\n",
        "    print(\"dog\")\n",
        "else:\n",
        "    print(\"cat\")\n",
        "print(train_list[n])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "bf850d2b-16a0-98b5-a64f-d2639c4fcdd7"
      },
      "outputs": [],
      "source": [
        "hist = model.fit(train_color, labels_, nb_epoch=10, batch_size=16, validation_split=0.2)\n",
        "print(hist.history)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "34f03590-5e29-71d0-c09e-91a8cd8a5e5b"
      },
      "outputs": [],
      "source": [
        "valid_labels_ = to_categorical(valid_labels, 2)\n",
        "print(np.count_nonzero(valid_labels_))\n",
        "#print(valid_labels_)\n",
        "#valid_ = average(valid)\n",
        "valid_ = np.resize(valid, (len(valid), ROWS, COLS, 1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "17e432da-f570-6a12-aa35-26b492bebf25"
      },
      "source": [
        "Compute the percentage of active neurone"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "1a38702c-6588-9a5d-ae53-7d5d07bfd1f8"
      },
      "outputs": [],
      "source": [
        "from keras.models import Model\n",
        "layer_name = 'conv1'\n",
        "\n",
        "model2 = Model(input=model.input, output=model.get_layer(layer_name).output)\n",
        "\n",
        "inter_output = model2.predict(valid_color)\n",
        "print(inter_output.shape)\n",
        "print(np.count_nonzero(inter_output)/(200.0*32768.0))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "d2f7e435-ddbf-93c0-2787-b9acc64ce0af"
      },
      "source": [
        "Evaluate on validation set and train set"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "db5c675d-23b8-89d7-2703-881b3252255c"
      },
      "outputs": [],
      "source": [
        "\n",
        "pred = model.predict(valid_color)\n",
        "#print(pred)\n",
        "print(\"valid set :\", model.evaluate(valid_color, valid_labels_, verbose=False)[1]*100, \"%\")\n",
        "print(\"--------------------\")\n",
        "print('train set :', model.evaluate(train_color, labels_, verbose=False)[1]*100, '%')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "d214fae9-bf04-a7b6-5acc-c99388f3f589"
      },
      "source": [
        "0.58 with no overfitting loss 0.663"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "bdc23bc6-29d4-1ee6-ccc2-97440171496f"
      },
      "outputs": [],
      "source": [
        ""
      ]
    }
  ],
  "metadata": {
    "_change_revision": 0,
    "_is_fork": false,
    "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.5.2"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}