ML_Assmt2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# create Layer class\n",
    "class Layer:\n",
    "\n",
    "    # intialize variables in class\n",
    "    def __init__(self):\n",
    "        self.input  = None\n",
    "        self.output = None\n",
    "        \n",
    "    def feed_forward(self, input):\n",
    "        pass      \n",
    "    def backpropagation(self, op_error, alpha):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearLayer(Layer):\n",
    "    def __init__(self, ip_size, op_size, weights_size=0.5):\n",
    "        super().__init__()\n",
    "        \n",
    "   \n",
    "        if weights_size == None:\n",
    "            self.weights = np.zeros((ip_size,op_size))\n",
    "            self.bias = np.zeros((1,op_size))\n",
    "      \n",
    "        elif weights_size == 10:\n",
    "            self.weights = np.random.uniform(-10,10, size=(ip_size,op_size))\n",
    "            self.bias = np.random.uniform(1, op_size) \n",
    "    \n",
    "        elif weights_size == 0.5:\n",
    "            self.weights = np.random.rand(ip_size, op_size) - 0.5\n",
    "            self.bias = np.random.rand(1, op_size) - 0.5\n",
    "\n",
    "   \n",
    "    def feed_forward(self, ip_data):\n",
    "        self.input = ip_data\n",
    "        self.output = np.dot(self.input, self.weights) + self.bias\n",
    "        return self.output\n",
    "\n",
    "\n",
    "    def backpropagation(self, op_error, alpha):\n",
    "        ip_error = np.dot(op_error, self.weights.T)\n",
    "        weights_error = np.dot(self.input.T, op_error)\n",
    "        \n",
    "\n",
    "        self.weights -= alpha * weights_error\n",
    "        self.bias -= alpha * op_error\n",
    "        return ip_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SigmoidLayer(Layer):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "    def feed_forward(self, ip_data):\n",
    "        self.input = ip_data\n",
    "        self.output = 1 / (1 + np.exp(-self.input))\n",
    "        return self.output\n",
    "\n",
    "    def backpropagation(self, op_error, alpha):\n",
    "        return np.exp(-self.input) / ((1 + np.exp(-self.input)) ** 2) * op_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HyperbolidTangentLayer(Layer):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "    def feed_forward(self, ip_data):\n",
    "        self.input = ip_data\n",
    "        self.output = np.tanh(self.input)\n",
    "        return self.output\n",
    "\n",
    "    def backpropagation(self, op_error, alpha):\n",
    "        return (1 - np.tanh(self.input) ** 2) * op_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SoftmaxLayer(Layer):\n",
    "    def __init__(self, ip_size):\n",
    "        super().__init__()\n",
    "        self.ip_size = ip_size\n",
    "    \n",
    "    def feed_forward(self, input):\n",
    "        self.input = input\n",
    "        tmp = np.exp(input)\n",
    "        self.output = tmp / np.sum(tmp)\n",
    "        return self.output\n",
    "    \n",
    "    def backpropagation(self, op_error, alpha):\n",
    "        ip_error = np.zeros(op_error.shape)\n",
    "        out = np.tile(self.output.T, self.ip_size)\n",
    "        return self.output * np.dot(op_error, np.identity(self.ip_size) - out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def mse(y_true, y_pred):\n",
    "    return np.mean(np.power(y_true - y_pred, 2))\n",
    "\n",
    "def mse_prime(y_true, y_pred):\n",
    "    return 2 * (y_pred - y_true) / y_true.size\n",
    "\n",
    "def sse(y_true, y_pred):\n",
    "    return 0.5 * np.sum(np.power(y_true - y_pred, 2))\n",
    "\n",
    "def sse_prime(y_true, y_pred):\n",
    "    return y_pred - y_true\n",
    "\n",
    "def categorical_cross_entropy_loss(target, predictions):\n",
    "    return -np.sum(target * np.log(predictions))\n",
    "\n",
    "def categorical_cross_entropy_grad(target, predictions):\n",
    "    return predictions - target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network:\n",
    "    def __init__(self):\n",
    "        self.hidden_layers = []\n",
    "        self.loss = None\n",
    "        self.loss_prime = None\n",
    "        self.err = []\n",
    "\n",
    "\n",
    "    def add(self, layer):\n",
    "        self.hidden_layers.append(layer)\n",
    "\n",
    "    def use(self, loss, loss_prime):\n",
    "        self.loss = loss\n",
    "        self.loss_prime = loss_prime\n",
    "\n",
    "    def predict(self, ip_data, prob=False):\n",
    "        samples = len(ip_data)\n",
    "        result = []\n",
    "        y_pred = []\n",
    "\n",
    "\n",
    "        for i in range(samples):\n",
    "            output = ip_data[i]\n",
    "            for layer in self.hidden_layers:\n",
    "                output = layer.feed_forward(output)\n",
    "            result.append(output)\n",
    "        if prob:\n",
    "            return result\n",
    "            \n",
    "        if len(result[0][0])==1:\n",
    "            for i in result:\n",
    "                if abs(i[0][0]) >= 0.5:\n",
    "                    y_pred.append(1)\n",
    "                else:\n",
    "                    y_pred.append(0) \n",
    "            return np.array(y_pred)\n",
    "        for val in result:\n",
    "            y_pred.append(np.argmax(val[0], axis = 0))\n",
    "        return np.array(y_pred)\n",
    "\n",
    "\n",
    "    def fit(self, x_train, y_train, step_count, alpha):\n",
    "        samples = len(x_train)\n",
    "\n",
    "        for i in range(step_count):\n",
    "            err = 0\n",
    "            for j in range(samples):\n",
    "                output = x_train[j]\n",
    "                for layer in self.hidden_layers:\n",
    "                    output = layer.feed_forward(output)\n",
    "\n",
    "                err += self.loss(y_train[j], output)\n",
    "\n",
    "                error = self.loss_prime(y_train[j], output)\n",
    "                for layer in reversed(self.hidden_layers):\n",
    "                    error = layer.backpropagation(error, alpha)\n",
    " \n",
    "            err /= samples\n",
    "            self.err.append(err)\n",
    "\n",
    "            \n",
    "    def accuracy(self,y_pred, y_output):\n",
    "        return np.mean(y_pred == y_output)\n",
    "    \n",
    "    def plot(self, lr):\n",
    "        plt.figure(figsize=(15,5))\n",
    "        plt.plot(self.err, '--r')\n",
    "        plt.title(\"Loss vs Step Count (Alpha = {0})\".format(lr))\n",
    "        plt.xlabel(\"Step Count\")\n",
    "        plt.ylabel(\"loss\")\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = np.array([[[0,0]], [[0,1]], [[1,0]], [[1,1]]])\n",
    "y_train = np.array([[[0]], [[1]], [[1]], [[0]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 100.0 %\n"
     ]
    }
   ],
   "source": [
    "xor_network = Network()\n",
    "xor_network.add(LinearLayer(2, 3, weights_size=0.5))\n",
    "xor_network.add(HyperbolidTangentLayer())\n",
    "xor_network.add(LinearLayer(3, 1, weights_size=0.5))\n",
    "xor_network.add(HyperbolidTangentLayer())\n",
    "\n",
    "xor_network.use(mse, mse_prime)\n",
    "lr = 0.01\n",
    "xor_network.fit(x_train, y_train, step_count=1500, alpha=lr)\n",
    "\n",
    "xor_network.plot(lr)\n",
    "\n",
    "y_pred= xor_network.predict(x_train)\n",
    "print(\"Accuracy :\", xor_network.accuracy(y_pred, y_train.reshape(1,-1)[0])*100,\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for reloaded model : 100.0 %\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "with open('xor_network.pkl', 'wb') as output_file:\n",
    "    pickle.dump(xor_network, output_file, pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "with open('xor_network.pkl', 'rb') as input_file:\n",
    "    reloaded_model = pickle.load(input_file)\n",
    "\n",
    "y_pred = reloaded_model.predict(x_train)\n",
    "print(\"Accuracy for reloaded model :\", xor_network.accuracy(y_pred, y_train.reshape(1,-1)[0])*100,\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_one_hot(targets, nb_classes):\n",
    "    res = np.eye(nb_classes)[np.array(targets).reshape(-1)]\n",
    "    return res.reshape(list(targets.shape)+[nb_classes])\n",
    "\n",
    "x_train = np.load('x_train.npy')\n",
    "y_train = np.load('y_train.npy')\n",
    "x_test = np.load('x_test.npy')\n",
    "y_test = np.load('y_test.npy')\n",
    "\n",
    "x_train = x_train.reshape(x_train.shape[0], 1, 28*28)\n",
    "x_train = x_train.astype('float32')\n",
    "x_train /= 255\n",
    "\n",
    "y_train =  get_one_hot(y_train.astype(int), 10)\n",
    "\n",
    "x_test = x_test.reshape(x_test.shape[0], 1, 28*28)\n",
    "x_test = x_test.astype('float32')\n",
    "x_test /= 255\n",
    "y_test =  get_one_hot(y_test.astype(int), 10)\n",
    "\n",
    "def testing_images(model, samples=10):\n",
    "    for test, true in zip(x_test[:samples], y_test[:samples]):\n",
    "        image = np.reshape(test, (28, 28))\n",
    "        plt.imshow(image, cmap='binary')\n",
    "        pred = model.predict(test)\n",
    "        idx_true = np.argmax(true)\n",
    "        plt.title('prediction: {0}, output: {1}'.format(pred[0], idx_true))\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy For Model 1: (94.84) %\n"
     ]
    }
   ],
   "source": [
    "model_1 = Network()\n",
    "model_1.add(LinearLayer(28*28, 100, weights_size=0.5))     \n",
    "model_1.add(HyperbolidTangentLayer())\n",
    "model_1.add(LinearLayer(100, 10, weights_size=0.5)) \n",
    "model_1.add(SoftmaxLayer(10))\n",
    "\n",
    "model_1.use(categorical_cross_entropy_loss, categorical_cross_entropy_grad)\n",
    "lr = 0.1\n",
    "model_1.fit(x_train, y_train, step_count=5, alpha=lr)\n",
    "\n",
    "model_1.plot(lr)\n",
    "\n",
    "y_pred = model_1.predict(x_test)\n",
    "print(\"Accuracy For Model 1: ({0}) %\".format(round(model_1.accuracy(y_pred, np.argmax(y_test, axis = 1))*100,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy For Model 2: (94.42) %\n"
     ]
    }
   ],
   "source": [
    "model_2 = Network()\n",
    "model_2.add(LinearLayer(28*28, 100, weights_size=0.5))     \n",
    "model_2.add(HyperbolidTangentLayer())\n",
    "model_2.add(LinearLayer(100, 50, weights_size=0.5))  \n",
    "model_2.add(HyperbolidTangentLayer())\n",
    "model_2.add(LinearLayer(50, 10, weights_size=0.5)) \n",
    "model_2.add(SoftmaxLayer(10))\n",
    "\n",
    "model_2.use(categorical_cross_entropy_loss, categorical_cross_entropy_grad)\n",
    "lr = 0.01\n",
    "model_2.fit(x_train, y_train, step_count=5, alpha=lr)\n",
    "\n",
    "model_2.plot(lr)\n",
    "\n",
    "y_pred = model_2.predict(x_test)\n",
    "print(\"Accuracy For Model 2: ({0}) %\".format(round(model_2.accuracy(y_pred, np.argmax(y_test, axis = 1))*100,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_3 = Network()\n",
    "model_3.add(LinearLayer(28*28, 100, weights_size=0.5))     \n",
    "model_3.add(HyperbolidTangentLayer())\n",
    "model_3.add(LinearLayer(100, 50, weights_size=0.5))  \n",
    "model_3.add(HyperbolidTangentLayer())\n",
    "model_3.add(LinearLayer(50, 30, weights_size=0.5))  \n",
    "model_3.add(HyperbolidTangentLayer())\n",
    "model_3.add(LinearLayer(30, 10, weights_size=0.5)) \n",
    "model_3.add(SoftmaxLayer(10))\n",
    "\n",
    "model_3.use(categorical_cross_entropy_loss, categorical_cross_entropy_grad)\n",
    "lr = 0.001\n",
    "model_3.fit(x_train, y_train, step_count=5, alpha=lr)\n",
    "\n",
    "model_3.plot(lr)\n",
    "\n",
    "y_pred = model_3.predict(x_test)\n",
    "print(\"Accuracy For Model 3: ({0}) %\".format(round(model_3.accuracy(y_pred, np.argmax(y_test, axis = 1))*100,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_1 = Network()\n",
    "exp_1.add(LinearLayer(28*28, 100, weights_size=None))     \n",
    "exp_1.add(HyperbolidTangentLayer())\n",
    "exp_1.add(LinearLayer(100, 10, weights_size=None)) \n",
    "exp_1.add(SoftmaxLayer(10))\n",
    "\n",
    "exp_1.use(categorical_cross_entropy_loss, categorical_cross_entropy_grad)\n",
    "lr = 1\n",
    "exp_1.fit(x_train, y_train, step_count=5, alpha=lr)\n",
    "\n",
    "exp_1.plot(lr)\n",
    "\n",
    "y_pred = exp_1.predict(x_test)\n",
    "print(\"Accuracy For Experimental Model 1: ({0}) %\".format(round(exp_1.accuracy(y_pred, np.argmax(y_test, axis = 1))*100,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_2 = Network()\n",
    "exp_2.add(LinearLayer(28*28, 100, weights_size=10))     \n",
    "exp_2.add(SigmoidLayer())\n",
    "exp_2.add(LinearLayer(100, 10, weights_size=10)) \n",
    "exp_2.add(SoftmaxLayer(10))\n",
    "\n",
    "exp_2.use(categorical_cross_entropy_loss, categorical_cross_entropy_grad)\n",
    "lr = 0.001\n",
    "exp_2.fit(x_train, y_train, step_count=5, alpha=lr)\n",
    "\n",
    "exp_2.plot(lr)\n",
    "\n",
    "y_pred = exp_2.predict(x_test)\n",
    "print(\"Accuracy For Experimental Model 2: ({0}) %\".format(round(exp_2.accuracy(y_pred, np.argmax(y_test, axis = 1))*100,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}