NN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tasks: Implement other units eg: relu\n",
    "\n",
    "       Implement other cost fns and make it easy to interchange them\n",
    "       \n",
    "       Extend to multiclass network\n",
    "       \n",
    "       Implement batch normalisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn import datasets\n",
    "import sklearn\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "class tanh_activation:\n",
    "    def __init__(self,model,reg_lambda):\n",
    "        self.model = model\n",
    "        self.reg_lambda = reg_lambda\n",
    "        \n",
    "    def tanh(self,x):\n",
    "        return (1  - np.exp(-2*x)) / (1  + np.exp(-2*x))\n",
    "    \n",
    "    def softmax(self,x):\n",
    "        return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        z1 = x.dot(model.W1) + model.b1\n",
    "        a1 = self.tanh(z1)\n",
    "        z2 = a1.dot(model.W2) + model.b2\n",
    "        probs = self.softmax(z2) ## softmax for 2 class classification\n",
    "        return probs,a1\n",
    "    \n",
    "    def back(self,probs,a1):\n",
    "        #a1 = tanh(wx+b)\n",
    "\n",
    "        # cost wrt output\n",
    "        delta3 = probs\n",
    "        delta3[range(model.num_examples), model.output_data] -= 1\n",
    "        dW2 = (a1.T).dot(delta3)\n",
    "        db2 = np.sum(delta3, axis=0, keepdims=True)\n",
    "        \n",
    "        # output wrt weights\n",
    "        delta2 = delta3.dot(model.W2.T) * (1 - np.power(a1, 2))\n",
    "        dW1 = np.dot(model.input_data.T, delta2)\n",
    "        db1 = np.sum(delta2, axis=0)\n",
    "        dW2 += self.reg_lambda * model.W2\n",
    "        dW1 += self.reg_lambda * model.W1\n",
    "        return dW1,db1,dW2,db2\n",
    "    \n",
    "    \n",
    "class relu_activation:\n",
    "    \n",
    "    def __init__(self,model,reg_lambda):\n",
    "        self.model = model\n",
    "        self.reg_lambda = reg_lambda\n",
    "        \n",
    "    def softmax(self,x):\n",
    "        return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)\n",
    "    \n",
    "    def relu(self,x):\n",
    "        return x * (x > 0)\n",
    "\n",
    "    def drelu(self,x):\n",
    "        return 1. * (x > 0)\n",
    "    \n",
    "    def forward(self,x):\n",
    "        z1 = x.dot(model.W1) + model.b1\n",
    "        a1 = self.relu(z1)\n",
    "        z2 = a1.dot(model.W2)+model.b2\n",
    "        probs = self.softmax(z2)\n",
    "        return probs,a1\n",
    "    \n",
    "     # Back propagate derivates though the network    \n",
    "    def back(self,probs,a1):\n",
    "        raise Exception (\"Unimplemented method\")\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "class sigmoid_activation:\n",
    "    \n",
    "    def __init__(self,model,reg_lambda):\n",
    "        self.model = model \n",
    "        self.reg_lambda = reg_lambda\n",
    "    \n",
    "    # Softmax function\n",
    "    def softmax(self,x):\n",
    "        return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)\n",
    "    \n",
    "    # Sigmoid function\n",
    "    def sigmoid(self,x):\n",
    "        return 1/(1+np.exp(-x))\n",
    "    \n",
    "    # Forward propagate though the network\n",
    "    def forward(self,x):\n",
    "        z1 = x.dot(model.W1) + model.b1\n",
    "        a1 = self.sigmoid(z1)\n",
    "        z2 = a1.dot(model.W2)+model.b2\n",
    "        probs = self.softmax(z2)\n",
    "        return probs,a1\n",
    "        \n",
    "    # Back propagate derivates though the network    \n",
    "    def back(self,probs,a1):\n",
    "        # a1 = sigmoid(wx+b)\n",
    "        \n",
    "        # cost wrt output\n",
    "        delta3 = probs\n",
    "        delta3[range(model.num_examples), model.output_data] -= 1\n",
    "        dW2 = (a1.T).dot(delta3)\n",
    "        db2 = np.sum(delta3, axis=0, keepdims=True)\n",
    "        \n",
    "        \n",
    "        # output wrt weights\n",
    "        delta2 = delta3.dot(model.W2.T) * (a1*(1-a1))\n",
    "        \n",
    "        dW1 = np.dot(model.input_data.T, delta2)\n",
    "        db1 = np.sum(delta2, axis=0)\n",
    "        \n",
    "        # L2 regularisation on the hidden units\n",
    "        dW2 += self.reg_lambda * np.sum(model.W2**2)\n",
    "        dW1 += self.reg_lambda * np.sum(model.W1**2)\n",
    "        return dW1,db1,dW2,db2\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class simple_descent:\n",
    "    def __init__(self,learning_rate):\n",
    "        self.learning_rate = learning_rate\n",
    "        \n",
    "    def learn(self,dfn,_):\n",
    "        return self.learning_rate * dfn\n",
    "\n",
    "        \n",
    "class momentum_rule:\n",
    "    \n",
    "    def __init__(self,learning_rate,previous = 0,momentum = 0.9):\n",
    "        self.momentum = momentum\n",
    "        self.learning_rate = learning_rate\n",
    "        self.previous_updates =  {\"w1\":previous,\n",
    "                                  \"b1\":previous,\n",
    "                                  \"w2\":previous,\n",
    "                                  \"b2\":previous}       \n",
    "    \n",
    "        \n",
    "    def learn(self,dfn,indentification):\n",
    "        v = self.momentum*self.previous_updates[indentification] + self.learning_rate*dfn\n",
    "        self.previous_updates[indentification] = v\n",
    "        return v\n",
    "\n",
    "class adam_rule:\n",
    "    \n",
    "    def __init__(self,learning_rate,previous=0,beta1=0.9,beta2=0.999,epsilon=1e-08,counter=1):\n",
    "        self.learning_rate = learning_rate\n",
    "        self.beta1 = beta1\n",
    "        self.beta2 = beta2\n",
    "        self.epsilon = epsilon\n",
    "        self.previous_m_updates =  {\"w1\":previous,\n",
    "                                    \"b1\":previous,\n",
    "                                    \"w2\":previous,\n",
    "                                    \"b2\":previous}   \n",
    "        self.previous_v_updates =  {\"w1\":previous,\n",
    "                                    \"b1\":previous,\n",
    "                                    \"w2\":previous,\n",
    "                                    \"b2\":previous}\n",
    "        self.counter = counter\n",
    "        \n",
    "    def learn(self,dfn,indentification):\n",
    "        m_t = self.beta1 * self.previous_m_updates[indentification] + (1-self.beta1)*dfn\n",
    "        m = m_t /(1-(self.beta1**self.counter))\n",
    "        v_t = self.beta2 * self.previous_v_updates[indentification] + (1-self.beta2)*(dfn**2)\n",
    "        v = v_t/ (1-(self.beta2**self.counter))\n",
    "        self.counter = self.counter+1\n",
    "        return (self.learning_rate * m) / ((np.sqrt(v) + self.epsilon))\n",
    "            \n",
    "\n",
    "class RMSprop_rule:\n",
    "    \n",
    "    def __init__(self,learning_rate,previous = np.array([0]),epsilon=1e-8):\n",
    "        self.learning_rate = learning_rate\n",
    "        self.epsilon = epsilon\n",
    "        self.previous_g =  {\"w1\":previous,\n",
    "                            \"b1\":previous,\n",
    "                            \"w2\":previous,\n",
    "                            \"b2\":previous} \n",
    "        \n",
    "    def learn(self,dfn,identification):\n",
    "        raise Exception(\"Unimplemented method\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NN:\n",
    "    def __init__(self,nn_hdim,reg_lambda,learning_rate):\n",
    "        self.learning_rate = learning_rate\n",
    "        self.nn_hdim = nn_hdim\n",
    "        self.reg_lambda = reg_lambda\n",
    "\n",
    "        \n",
    "    def print_network_shapes(self):\n",
    "        print(\"Input dim:\",self.nn_input_dim)\n",
    "        print(\"Hidden dim:\",self.nn_hdim)\n",
    "        print(\"Output dim:\",self.nn_output_dim)\n",
    "        \n",
    "    def forwardprop(self,x):\n",
    "        probs,a1 = self.activation.forward(x)\n",
    "        return probs,a1\n",
    "\n",
    "    \n",
    "    def backprop(self,probs,a1):\n",
    "        dW1,db1,dW2,db2 = self.activation.back(probs,a1)\n",
    "        return dW1,db1,dW2,db2\n",
    "        \n",
    "            \n",
    "    def update(self,dW1,db1,dW2,db2): #gradient descent step\n",
    "        self.W1 += -self.rule.learn(dW1,'w1')\n",
    "        self.b1 += -self.rule.learn(db1,'b1')\n",
    "        self.W2 += -self.rule.learn(dW2,'w2')\n",
    "        self.b2 += -self.rule.learn(db2,'b2')\n",
    "        \n",
    "    def activation(self,tanh=False,sigmoid=False):\n",
    "        if sum(np.array([tanh,sigmoid]))>1:\n",
    "            raise Exception(\"Only 1 learning activation function allowed\")\n",
    "        if tanh:\n",
    "            self.activation = tanh_activation(model,self.reg_lambda)\n",
    "        elif sigmoid:\n",
    "            self.activation = sigmoid_activation(model,self.reg_lambda)\n",
    "             \n",
    "    \n",
    "    def learning_rule(self,simple_descent=False,momentum=False,adam=False,RMSprop=False):\n",
    "        if sum(np.array([simple_descent,momentum,adam]))>1:\n",
    "            raise Exception(\"Only 1 learning rule allowed\")\n",
    "        if simple_descent:\n",
    "            self.rule = simple_descent(self.learning_rate) #basic gradient descent\n",
    "        elif momentum:\n",
    "            momentum_coeff=0.9\n",
    "            self.rule = momentum_rule(self.learning_rate,momentum = momentum_coeff)\n",
    "        elif adam:\n",
    "            self.rule = adam_rule(self.learning_rate)\n",
    "        elif RMSprop:\n",
    "            self.rule = RMSprop_rule(self.learning_rate)\n",
    "\n",
    "             \n",
    "    def initialise(self,X,y):\n",
    "        self.nn_input_dim = X.shape[1]\n",
    "        self.nn_output_dim = y.shape[0]\n",
    "        self.input_data = X\n",
    "        self.output_data = y\n",
    "        self.num_examples = len(X)\n",
    "        self.W1 = np.random.randn(self.nn_input_dim, self.nn_hdim) / np.sqrt(self.nn_input_dim)\n",
    "        self.b1 = np.zeros((1, self.nn_hdim))\n",
    "        self.W2 = np.random.randn(self.nn_hdim, self.nn_output_dim) / np.sqrt(self.nn_hdim)\n",
    "        self.b2 = np.zeros((1, self.nn_output_dim))\n",
    "        \n",
    "    def calculate_loss(self): # works as network progation, might aswell return the output aswell and update the self method\n",
    "        probs,a1 = self.forwardprop(model.input_data)\n",
    "        # Calculating the loss\n",
    "        corect_logprobs = -np.log(probs[range(self.num_examples), model.output_data]) #negative cross entropy\n",
    "        data_loss = np.sum(corect_logprobs)\n",
    "        # Add regulatization term to loss (optional)\n",
    "        data_loss += self.reg_lambda/2 * (np.sum(np.square(self.W1)) + np.sum(np.square(self.W2)))\n",
    "        return 1./self.num_examples * data_loss\n",
    "    \n",
    "    def predict(self,X_test):\n",
    "        # Forward propagation\n",
    "        probs,_ = self.forwardprop(X_test)\n",
    "        return np.argmax(probs, axis=1)\n",
    "\n",
    "    \n",
    "    def accuracy(self,predictions,y_test):\n",
    "        count = len(np.where(predictions==y_test)[0])\n",
    "        accuracy = (count/len(predictions))*100\n",
    "        return accuracy\n",
    "        \n",
    "        \n",
    "    def fit(self, epochs=20000, print_loss=True):\n",
    "        for i in range(epochs):\n",
    "            probs,a1 = self.forwardprop(model.input_data)\n",
    "            dW1,db1,dW2,db2 = self.backprop(probs,a1)\n",
    "            self.update(dW1,db1,dW2,db2)\n",
    "\n",
    "            \n",
    "            if print_loss and i % 1000 == 0:\n",
    "                print (\"Loss after iteration %i: %f\" %(i, self.calculate_loss()))\n",
    "\n",
    "\n",
    "        print(\"Training completed\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss after iteration 0: 5.673525\n",
      "Loss after iteration 1000: 0.335602\n",
      "Loss after iteration 2000: 0.292850\n",
      "Loss after iteration 3000: 0.205469\n",
      "Loss after iteration 4000: 0.159219\n",
      "Loss after iteration 5000: 0.137287\n",
      "Loss after iteration 6000: 0.124917\n",
      "Loss after iteration 7000: 0.117077\n",
      "Loss after iteration 8000: 0.111741\n",
      "Loss after iteration 9000: 0.107922\n",
      "Training completed\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "X, y = sklearn.datasets.make_moons(200, noise=0.20)\n",
    "plt.scatter(X[:,0], X[:,1], s=40, c=y, cmap=plt.cm.Spectral)\n",
    "\n",
    "X_train = X[:150]\n",
    "Y_train = y[:150]\n",
    "\n",
    "X_test = X[150:]\n",
    "Y_test = y[150:]\n",
    "\n",
    "model = NN(nn_hdim = 20,reg_lambda = 0.0001, learning_rate = 0.0001)\n",
    "model.initialise(X_train,Y_train)\n",
    "model.activation(sigmoid=True)\n",
    "model.learning_rule(momentum=True) #currently cant change the learning rule paramenters, think of a way to do this \n",
    "# without making the fns too bulky\n",
    "model.fit(epochs = 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test)\n",
    "accuracy = model.accuracy(predictions,Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y_test predictions: [1 1 0 0 1 0 1 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 1 1 0 0 0 0 1 0 1 1 1 0 0\n",
      " 1 0 0 0 0 0 0 1 0 1 1 0 1]\n",
      "Accuracy: 98.0\n"
     ]
    }
   ],
   "source": [
    "print(\"Y_test predictions:\",predictions)\n",
    "print(\"Accuracy:\",accuracy)"
   ]
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}