simple deep network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b0cc67ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "353c8e4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data processing\n",
    "\n",
    "# read h5 file and transform to ndarray\n",
    "train = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n",
    "train_x = np.array(train[\"train_set_x\"])/255\n",
    "train_y = np.array(train[\"train_set_y\"])\n",
    "\n",
    "test = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n",
    "test_x = np.array(test[\"test_set_x\"])/255\n",
    "test_y = np.array(test[\"test_set_y\"])\n",
    "\n",
    "# classes\n",
    "classes = np.array(test[\"list_classes\"])\n",
    "\n",
    "# reshape data\n",
    "train_x = train_x.reshape(train_x.shape[0], -1).T\n",
    "train_y = train_y.reshape(1, train_y.shape[0])\n",
    "\n",
    "test_x = test_x.reshape(test_x.shape[0], -1).T\n",
    "test_y = test_y.reshape(1, test_y.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "26eff555",
   "metadata": {},
   "outputs": [],
   "source": [
    "class net:\n",
    "    def __init__(self, layer_dims, m):\n",
    "        self.depth = len(layer_dims)-1\n",
    "        self.layer_dims = layer_dims\n",
    "        self.W = []\n",
    "        self.B= []\n",
    "        self.A = []\n",
    "        for i in range(self.depth):\n",
    "            w = 0.01 * np.random.randn(layer_dims[i+1], layer_dims[i])\n",
    "            self.W.append(w)\n",
    "        for i in range(self.depth):\n",
    "            b = np.zeros((layer_dims[i+1], 1))\n",
    "            self.B.append(b)\n",
    "        for i in range(len(self.layer_dims)):\n",
    "            a = np.zeros((self.layer_dims[i], m))\n",
    "            self.A.append(a)\n",
    "            \n",
    "    def train(self, X, Y, alpha, epochs):\n",
    "        costs = []\n",
    "        for _ in range(epochs):\n",
    "            self.feedforward(X)\n",
    "            self.backpropogate(Y, alpha)\n",
    "            loss = -(np.log(self.A[-1]) @ Y.T + np.log(1-self.A[-1]) @ (1-Y).T) / Y.shape[1]\n",
    "            loss = np.squeeze(loss)\n",
    "            costs.append(loss)\n",
    "            if (_+1) % 100 == 0:\n",
    "                print(f\"loss after {_+1} epochs: {loss}\")\n",
    "        return costs\n",
    "                \n",
    "    def feedforward(self, X):\n",
    "        assert(self.A[0].shape[0] == X.shape[0])\n",
    "        self.A[0] = X\n",
    "        for i in range(1, self.depth):\n",
    "            self.A[i] = self.ReLU(self.W[i-1] @ self.A[i-1] + self.B[i-1])\n",
    "        self.A[-1] = self.sigmoid(self.W[-1] @ self.A[-2] + self.B[-1])\n",
    "            \n",
    "    def backpropogate(self, Y, alpha):\n",
    "        assert(self.A[-1].shape[0] == Y.shape[0])\n",
    "        m = Y.shape[1]\n",
    "        dZ = self.sigmoidback(1, Y, self.A[-1])\n",
    "        dW = dZ @ self.A[-2].T / m\n",
    "        dB = np.sum(dZ) / m\n",
    "        self.W[-1] -= alpha * dW\n",
    "        self.B[-1] -= alpha * dB\n",
    "        if self.depth > 1:\n",
    "            for i in range(self.depth-1, 0, -1):\n",
    "                dZ = self.ReLUback(self.W[i], dZ, self.A[i])\n",
    "                dW = dZ @ self.A[i-1].T / m\n",
    "                dB = np.sum(dZ) / m\n",
    "                self.W[i-1] -= alpha * dW\n",
    "                self.B[i-1] -= alpha * dB\n",
    "                \n",
    "    def predict(self, X):\n",
    "        a = X.copy()\n",
    "        for i in range(self.depth-1):\n",
    "            a = ReLU(self.W[i] @ a + self.B[i])\n",
    "        a = sigmoid(self.W[i+1] @ a + self.B[i+1])\n",
    "        a[a>=0.5] = 1\n",
    "        a[a <0.5] = 0\n",
    "        return a\n",
    "    \n",
    "    @staticmethod\n",
    "    def sigmoid(z):\n",
    "        a = 1/(1+np.exp(-z))\n",
    "        return a\n",
    "    \n",
    "    @staticmethod\n",
    "    def ReLU(z):\n",
    "        a = np.maximum(0, z)\n",
    "        return a\n",
    "    \n",
    "    @staticmethod\n",
    "    def sigmoidback(w, dZ, a):\n",
    "        if w is np.ndarray:\n",
    "            return np.multiply(w.T @ dZ, (1-a)*a)\n",
    "        else:\n",
    "            return a - dZ\n",
    "    \n",
    "    @staticmethod\n",
    "    def ReLUback(w, dZ, a):\n",
    "        return np.multiply(w.T @ dZ, (a != 0).astype(np.int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "6b383deb",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "\n",
    "nn = net([train_x.shape[0], 7, 1], train_x.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "afa747a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss after 100 epochs: 0.6458112522006728\n",
      "loss after 200 epochs: 0.6296483211624426\n",
      "loss after 300 epochs: 0.5937285573412058\n",
      "loss after 400 epochs: 0.5486451356537572\n",
      "loss after 500 epochs: 0.5013317079781118\n",
      "loss after 600 epochs: 0.4605900684620182\n",
      "loss after 700 epochs: 0.4061969287707952\n",
      "loss after 800 epochs: 0.38993461281518393\n",
      "loss after 900 epochs: 0.36113523626361776\n",
      "loss after 1000 epochs: 0.3508802644521435\n",
      "loss after 1100 epochs: 0.27237725471539054\n",
      "loss after 1200 epochs: 0.3225300710155756\n",
      "loss after 1300 epochs: 0.291180298856663\n",
      "loss after 1400 epochs: 0.3811781491060155\n",
      "loss after 1500 epochs: 0.1773811224886809\n",
      "loss after 1600 epochs: 0.11297651057487065\n",
      "loss after 1700 epochs: 0.09758123573041079\n",
      "loss after 1800 epochs: 0.08367167461548308\n",
      "loss after 1900 epochs: 0.07008948633660805\n",
      "loss after 2000 epochs: 0.06073281921905411\n",
      "loss after 2100 epochs: 0.053361036960909214\n",
      "loss after 2200 epochs: 0.04731886958934366\n",
      "loss after 2300 epochs: 0.04088940408453362\n",
      "loss after 2400 epochs: 0.03594742852634363\n",
      "loss after 2500 epochs: 0.0322255190877322\n"
     ]
    }
   ],
   "source": [
    "costs = nn.train(train_x, train_y, alpha=0.008, epochs=2500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "657bf779",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f2a32497d30>]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(costs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "ef90a4ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(net, X):\n",
    "    a = X.copy()\n",
    "    for i in range(net.depth-1):\n",
    "        a = net.ReLU(net.W[i] @ a + net.B[i])\n",
    "    a = net.sigmoid(net.W[i+1] @ a + net.B[i+1])\n",
    "    a[a>=0.5] = 1\n",
    "    a[a< 0.5] = 0\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "1ae70054",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9952153110047847\n"
     ]
    }
   ],
   "source": [
    "pre = predict(nn, train_x)\n",
    "accuracy = np.sum(pre==train_y)/len(pre[0])\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "31d8f65c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.72\n"
     ]
    }
   ],
   "source": [
    "pre = predict(nn, test_x)\n",
    "accuracy = np.sum(pre==test_y)/len(pre[0])\n",
    "print(accuracy)"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}