Assignment03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary classification based on 3 layers neural network\n",
    "#### author: Kim Jeong Min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### load images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.pylab as pl\n",
    "\n",
    "\n",
    "transform = transforms.Compose([#transforms.Resize((256,256)),  \n",
    "                                transforms.Grayscale(),\t\t# the code transforms.Graysclae() is for changing the size [3,100,100] to [1, 100, 100] (notice : [channel, height, width] )\n",
    "                                transforms.ToTensor(),])\n",
    "\n",
    "\n",
    "#train_data_path = 'relative path of training data set'\n",
    "train_data_path = 'horse-or-human/train'\n",
    "trainset = torchvision.datasets.ImageFolder(root=train_data_path, transform=transform)\n",
    "# change the valuse of batch_size, num_workers for your program\n",
    "# if shuffle=True, the data reshuffled at every epoch \n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=1, shuffle=False, num_workers=1)  \n",
    "\n",
    "\n",
    "validation_data_path = 'horse-or-human/validation'\n",
    "valset = torchvision.datasets.ImageFolder(root=validation_data_path, transform=transform)\n",
    "# change the valuse of batch_size, num_workers for your program\n",
    "valloader = torch.utils.data.DataLoader(valset, batch_size=1, shuffle=False, num_workers=1)  \n",
    "\n",
    "IMAGE_VECTOR_SIZE = 10000\n",
    "\n",
    "train_data = np.empty((IMAGE_VECTOR_SIZE,0))\n",
    "train_label = np.empty((0,1))\n",
    "validation_data = np.empty((IMAGE_VECTOR_SIZE,0))\n",
    "validation_label = np.empty((0,1))\n",
    "\n",
    "# load training images of the batch size for every iteration\n",
    "for i, data in enumerate(trainloader):\n",
    "    # inputs is the image\n",
    "    # labels is the class of the image\n",
    "    inputs, labels = data\n",
    "    # if you don't change the image size, it will be [batch_size, 1, 100, 100]\n",
    "    train_data = np.hstack((train_data, np.reshape(inputs, (10000,1))))\n",
    "    # if labels is horse it returns tensor[0,0,0] else it returns tensor[1,1,1]\n",
    "    # human: 1, horse: 0\n",
    "    train_label = np.append(train_label, 1 if sum(labels)>0 else 0)  \n",
    "\n",
    "# load validation images of the batch size for every iteration\n",
    "for i, data in enumerate(valloader):\n",
    "    # inputs is the image\n",
    "    # labels is the class of the image\n",
    "    inputs, labels = data\n",
    "    # if you don't change the image size, it will be [batch_size, 1, 100, 100]\n",
    "    validation_data = np.hstack((validation_data, np.reshape(inputs, (10000,1))))\n",
    "    # if labels is horse it returns tensor[0,0,0] else it returns tensor[1,1,1]\n",
    "    # human: 1, horse: 0\n",
    "    validation_label = np.append(validation_label, 1 if sum(labels)>0 else 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### add a row(np.ones) in data matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_num = len(train_data[0])\n",
    "validation_data_num = len(validation_data[0])\n",
    "train_offset_ones = np.ones((1,train_data_num))\n",
    "validation_offset_ones = np.ones((1,validation_data_num))\n",
    "\n",
    "train_set = np.insert(train_data, IMAGE_VECTOR_SIZE, train_offset_ones, 0)\n",
    "validation_set = np.insert(validation_data, IMAGE_VECTOR_SIZE, validation_offset_ones, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    return 1 / (1 + np.exp(-z))\n",
    "\n",
    "def sigmoid_backward(da, z):\n",
    "    sig = sigmoid(z)\n",
    "    return da * sig * (1 - sig)\n",
    "\n",
    "def get_acc(discri, label):\n",
    "    prediction = np.round(discri)\n",
    "    equality = np.equal(prediction, label)\n",
    "    return sum(equality[0]) / len(equality[0])\n",
    "\n",
    "def get_loss(discri, label):\n",
    "    return np.average(-label*np.log(discri) - (1-label)*np.log(np.ones(discri.shape)-discri))\n",
    "\n",
    "def add_offset_row(matrix):\n",
    "    return np.insert(matrix, len(matrix), np.ones((1,len(matrix[0]))), 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### neural network structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_DIM = IMAGE_VECTOR_SIZE\n",
    "SECOND_DIM = 20\n",
    "THIRD_DIM = 5\n",
    "OUTPUT_DIM = 1\n",
    "\n",
    "# add 1 offset dimension to input\n",
    "nn_struct = [\n",
    "    {'in_dim': INPUT_DIM + 1, 'out_dim': SECOND_DIM},\n",
    "    {'in_dim': SECOND_DIM + 1, 'out_dim': THIRD_DIM},\n",
    "    {'in_dim': THIRD_DIM + 1, 'out_dim': OUTPUT_DIM}\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### gradient descent on vectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nn_struct[0]['W'] = np.random.rand(INPUT_DIM + 1, SECOND_DIM)\n",
    "nn_struct[1]['W'] = np.random.rand(SECOND_DIM + 1, THIRD_DIM)\n",
    "nn_struct[2]['W'] = np.random.rand(THIRD_DIM + 1, OUTPUT_DIM)\n",
    "N = train_data_num\n",
    "\n",
    "MAX_ITER = 2000\n",
    "LR = 0.00002\n",
    "\n",
    "train_acc = list()\n",
    "validation_acc = list()\n",
    "train_loss = list()\n",
    "validation_loss = list()\n",
    "\n",
    "prev_loss = 0\n",
    "\n",
    "for iter_num in range(0, MAX_ITER):\n",
    "    # forward propagation\n",
    "    discri = train_data\n",
    "    validation_discri = validation_data\n",
    "    P = list()\n",
    "    for layer in nn_struct:\n",
    "        P.append(discri)\n",
    "        discri = add_offset_row(discri)\n",
    "        validation_discri = add_offset_row(validation_discri)\n",
    "        discri = sigmoid(np.dot(np.transpose(layer['W']), discri))\n",
    "        validation_discri = sigmoid(np.dot(np.transpose(layer['W']), validation_discri))\n",
    "    \n",
    "    # back propagation\n",
    "    y = train_label\n",
    "    yhat = discri\n",
    "    \n",
    "    w2_ = nn_struct[2]['W'][:-1, :]\n",
    "    w1_ = nn_struct[1]['W'][:-1, :]\n",
    "    p2_ = add_offset_row(P[2])\n",
    "    p1_ = add_offset_row(P[1])\n",
    "    p0_ = add_offset_row(P[0])    \n",
    "    \n",
    "    y_ = -y * (1-yhat) + yhat *(1-y)\n",
    "    dw2 = np.dot(y_, p2_.T)\n",
    "    q_ = np.dot(w2_, y_) * P[2] * (1-P[2])\n",
    "    dw1 = np.dot(q_, p1_.T)\n",
    "    p_ = np.dot(w1_, q_) * P[1] * (1-P[1])\n",
    "    dw0 = np.dot(p_, p0_.T)\n",
    "    \n",
    "    nn_struct[0]['W'] = nn_struct[0]['W'] - LR * dw0.T\n",
    "    nn_struct[1]['W'] = nn_struct[1]['W'] - LR * dw1.T\n",
    "    nn_struct[2]['W'] = nn_struct[2]['W'] - LR * dw2.T\n",
    "    \n",
    "    # get accuracy, loss\n",
    "    train_acc.append(get_acc(discri, train_label))\n",
    "    loss = get_loss(discri, train_label)\n",
    "    train_loss.append(loss)\n",
    "    validation_acc.append(get_acc(validation_discri, validation_label))\n",
    "    validation_loss.append(get_loss(validation_discri, validation_label))\n",
    "    \n",
    "    #check end conditon\n",
    "    if abs(prev_loss - loss) < 0.000001:\n",
    "        break\n",
    "    prev_loss = loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### plot Accuracy, Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_acc, color='#ff0000', label='Train Accuracy')\n",
    "plt.plot(validation_acc, color='#0000ff', label='Validation Accuracy')\n",
    "plt.legend(['Train Accuracy','Validation Accuracy'])\n",
    "plt.title('Accuracy')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(train_loss, color='#ff0000', label='Train Accuracy')\n",
    "plt.plot(validation_loss, color='#0000ff', label='Validation Accuracy')\n",
    "plt.legend(['Train Loss','Validation Loss'])\n",
    "plt.title('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### plot result table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx, ny = 3, 3\n",
    "data = (('dataset', 'loss', 'accuracy'), ('train', str(round(train_loss[-1],4)), str(round(train_acc[-1],4))), ('validation', str(round(validation_loss[-1],4)), str(round(validation_acc[-1],4))))\n",
    "pl.figure()\n",
    "tb = pl.table(cellText=data, loc=(0,0), cellLoc='center')\n",
    "\n",
    "tc = tb.properties()['child_artists']\n",
    "for cell in tc: \n",
    "    cell.set_height(1/ny)\n",
    "    cell.set_width(1/nx)\n",
    "\n",
    "ax = pl.gca()\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}