Numpy_ML_implementation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Numpy ML implementation.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOi7qWSlFgPzZLx6qA6yf0r",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/maxmatical/fast.ai/blob/master/Numpy_ML_implementation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ROV9WcRb67c-"
      },
      "source": [
        "# Neural Networks (and logistic regression)\n",
        "https://quantdare.com/create-your-own-deep-learning-framework-using-numpy/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JgWdMk4N72Sc"
      },
      "source": [
        "from abc import ABC, abstractmethod\n",
        "from typing import List, Optional, Tuple\n",
        "from enum import Enum, auto\n",
        "import numpy as np\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gQklA5J6ncGH"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Iafz777k8WKG"
      },
      "source": [
        "# A\n",
        "a =[0, 0, 1, 1, 0, 0,\n",
        "   0, 1, 0, 0, 1, 0,\n",
        "   1, 1, 1, 1, 1, 1,\n",
        "   1, 0, 0, 0, 0, 1,\n",
        "   1, 0, 0, 0, 0, 1]\n",
        "# B\n",
        "b =[0, 1, 1, 1, 1, 0,\n",
        "   0, 1, 0, 0, 1, 0,\n",
        "   0, 1, 1, 1, 1, 0,\n",
        "   0, 1, 0, 0, 1, 0,\n",
        "   0, 1, 1, 1, 1, 0]\n",
        "# C\n",
        "c =[0, 1, 1, 1, 1, 0,\n",
        "   0, 1, 0, 0, 0, 0,\n",
        "   0, 1, 0, 0, 0, 0,\n",
        "   0, 1, 0, 0, 0, 0,\n",
        "   0, 1, 1, 1, 1, 0]\n",
        "\n",
        "# Creating labels\n",
        "# y =[[1, 0, 0],\n",
        "#    [0, 1, 0],\n",
        "#    [0, 0, 1]]\n",
        "\n",
        "y = [1,2,3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8le60oSe8ZSF",
        "outputId": "334d0153-7204-4023-c591-3a973666b248"
      },
      "source": [
        "x =np.array([a, b, c])\n",
        "  \n",
        "  \n",
        "# Labels are also converted into NumPy array\n",
        "y = np.array(y)\n",
        "  \n",
        "  \n",
        "print(x, \"\\n\\n\", y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 0 1 1 0 0 0 1 0 0 1 0 1 1 1 1 1 1 1 0 0 0 0 1 1 0 0 0 0 1]\n",
            " [0 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 1 0]\n",
            " [0 1 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0]] \n",
            "\n",
            " [1 2 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A1CTuaQaOY2U"
      },
      "source": [
        "**Make sure `y` is (n, 1)!!!**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vbMsZARi8cLj",
        "outputId": "ea812b8a-a5a2-47c1-b772-42a91035e88b"
      },
      "source": [
        "x.shape, y.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((3, 30), (3,))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5EoFaSILwhnn"
      },
      "source": [
        "# abstract class\n",
        "class Layer(ABC):\n",
        "\n",
        "    @abstractmethod\n",
        "    def forward(self, input):\n",
        "        pass\n",
        "\n",
        "    @abstractmethod\n",
        "    def backward(self, input):\n",
        "        pass\n",
        "\n",
        "\n",
        "class LayerType(Enum):\n",
        "    # to keep track of layer types in NN\n",
        "    # layer type determines what is returned in the backward pass\n",
        "    linear = auto()\n",
        "    relu = auto()\n",
        "    sigmoid = auto()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qTDCayCcOc5Z"
      },
      "source": [
        "# linear layer\n",
        "class Linear(Layer):\n",
        "    def __init__(self, in_dim: int, out_dim: int):\n",
        "        self.weights = np.random.normal(size=(in_dim, out_dim)) \n",
        "        self.biases = np.random.rand(1, out_dim)\n",
        "        # keep track of layer type for computing gradients\n",
        "        self.type = \"linear\"\n",
        "\n",
        "    def forward(self, input: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        output is n_row x out_dim\n",
        "        # input into the layer is activations from previous layer\n",
        "        # keep track of previous activations for back prop\n",
        "        \"\"\"\n",
        "        self.prev_activations = input \n",
        "        return np.matmul(input, self.weights) + self.biases\n",
        "\n",
        "    def backward(self, dA: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n",
        "        \"\"\"\n",
        "        dA is shape (n_row, out_dim)\n",
        "\n",
        "        by chain rule, dW is just equals to dA dot product with previous activations\n",
        "        dW is shape (in_dim, out_dim)\n",
        "        so need to do (in_dim, n_rows)@(n_row, out_dim) -> transpose acts\n",
        "\n",
        "        dB is shape (1, out_dim)\n",
        "\n",
        "        error should be shape (n_row, in_dim) -> (n_row, out_dim) @ (out_dim, in_dim)\n",
        "        \"\"\"\n",
        "        n_row, out_dim = dA.shape[0], dA.shape[1]\n",
        "        dW = np.dot(self.prev_activations.T, dA) \n",
        "        dB = dA.mean(axis=0, keepdims=True) # average across rows (where dim = 0) to get dB\n",
        "        assert dB.shape == (1, out_dim)\n",
        "        # error = np.dot(self.weights, dA.T) \n",
        "        error = np.dot(dA, self.weights.T) # propagate error backwords by multiplying dA by weights\n",
        "        # print(\"linear error shape\", error.shape)\n",
        "        return error, dW, dB\n",
        "\n",
        "    def update(self, dW: np.ndarray, dB: np.ndarray, lr: float):\n",
        "        # update the weights and biases given gradients and lr\n",
        "        self.weights -= lr * dW\n",
        "        self.biases -= lr * dB\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S3mbrKnL6ofe",
        "outputId": "90945c33-b647-4f05-fb9a-826b7a857473"
      },
      "source": [
        "l = Linear(30, 4)\n",
        "pred = l.forward(x)\n",
        "pred"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-1.60224555,  8.00845447,  2.41411131,  5.23822594],\n",
              "       [ 0.36815769,  2.46644677,  6.74448148,  5.19347536],\n",
              "       [-1.4326639 ,  1.3993949 ,  6.57858832,  1.8957478 ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sH3VvyEiA-Ib",
        "outputId": "78768a81-629d-4550-cc91-dab09f146c96"
      },
      "source": [
        "pred.mean(axis=0, keepdims=True) # since pred has same shape as dA, use to test"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.88891725,  3.95809871,  5.24572703,  4.1091497 ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fcDj-9pNzJZB"
      },
      "source": [
        "# activations\n",
        "class ReLU(Layer):\n",
        "    def __init__(self):\n",
        "        # keep track of layer type for computing gradients\n",
        "        self.type = \"relu\"\n",
        "    \n",
        "\n",
        "    def forward(self, input: np.ndarray) -> np.ndarray:\n",
        "        # keep track of activations for backprop\n",
        "        self.activations = np.maximum(0, input) \n",
        "        return self.activations\n",
        "\n",
        "\n",
        "    def backward(self, error: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        gradient of relu is 1 if self.activation > 0, 0 otherwise\n",
        "\n",
        "        # gradients = np.copy(self.activations)\n",
        "        # gradients[self.activations > 0] = 1\n",
        "        # gradients[self.activations <= 0] = 0\n",
        "        # return error * gradients\n",
        "\n",
        "        alternatively, use heaviside function\n",
        "\n",
        "        activations is (row, out_dim)\n",
        "        so error should be (row, out_dim)\n",
        "\n",
        "        \"\"\"\n",
        "        # print(\"relu error shape\", error.shape)\n",
        "        return error * np.heaviside(self.activations, 0)\n",
        "        \n",
        "\n",
        "class Sigmoid(Layer):\n",
        "    def __init__(self):\n",
        "        # keep track of layer type for computing gradients\n",
        "        self.type = \"sigmoid\"\n",
        "\n",
        "\n",
        "    def forward(self, input: np.ndarray) -> np.ndarray:\n",
        "        # keep track of activations for gradient calc in backward pass\n",
        "        self.activations = 1/(1 + np.exp(-input))\n",
        "        return self.activations\n",
        "\n",
        "\n",
        "    def backward(self, error: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        derivative of sigmoid function is sig*(1-sig)\n",
        "        note error, activations, and output shape are the same size\n",
        "\n",
        "        activations is (row, out_dim)\n",
        "        so error should be (row, out_dim) and output is (row, out_dim)\n",
        "        \"\"\"\n",
        "        sig = self.activations\n",
        "        out = error * sig * (1 - sig)\n",
        "        return error * sig * (1 - sig)\n",
        "\n",
        "\n",
        "class Softmax(Layer):\n",
        "    def __init__(self):\n",
        "        self.type = \"softmax\"\n",
        "    \n",
        "    def forward(self, input: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"        \n",
        "        # keep track of activations for gradient calc in backward pass\n",
        "        # e^x/sum(e^x)\n",
        "\n",
        "        alternatively: for large numbers, use np.exp(input-np.max(input))\n",
        "        for numerical stability\n",
        "        \"\"\"\n",
        "        exp = np.exp(input)\n",
        "        self.activations = exp/np.sum(exp)\n",
        "        return self.activations\n",
        "\n",
        "    def backward(self, error: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        derivative of softmax (for a vector) is \n",
        "\n",
        "        https://stackoverflow.com/a/40576872\n",
        "        if i == j:\n",
        "            gradients[i, j] = self.activations[i]*(1-self.activations[i])\n",
        "        else:\n",
        "            gradients[i, j] = -self.activations[i] * self.activations[j]\n",
        "\n",
        "        then return error * gradients\n",
        "\n",
        "        note error, activations, and output shape are the same size\n",
        "\n",
        "        alternatively:\n",
        "\n",
        "        SM = self.activations.reshape((-1,1))\n",
        "        jac = np.diagflat(self.activations) - np.dot(SM, SM.T)\n",
        "        return error * jac\n",
        "        \"\"\"\n",
        "        #initialize matrix same shape as error matrix\n",
        "        gradients = np.zeros(self.activations.shape) \n",
        "        for i in range(self.activations.shape[0]):\n",
        "            for j in range(self.activations.shape[1]):\n",
        "                if i == j:\n",
        "                    gradients[i, j] = self.activations[i, i]*(1-self.activations[i, i])\n",
        "                else:\n",
        "                    gradients[i, j] = -self.activations[i, i] * self.activations[i, j]\n",
        "                \"\"\"\n",
        "                self.activation[i, i] since i=th row\n",
        "\n",
        "                \"\"\"\n",
        "        return error * gradients\n",
        "\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Vn-BPWnO6dH",
        "outputId": "93afad56-6720-41ce-d5f5-f44e66dcf389"
      },
      "source": [
        "relu = ReLU()\n",
        "relu.forward(pred).shape, relu.backward(pred).shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((3, 4), (3, 4))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3gL_R2HApRsp",
        "outputId": "0b3f3b7f-ff7d-4632-ead6-a037ad6b6119"
      },
      "source": [
        "sig = Sigmoid()\n",
        "sig.forward(pred).shape, sig.backward(pred).shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((3, 4), (3, 4))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cKaoOccepJq3",
        "outputId": "d042fec7-a726-4513-ed22-18e71723d13f"
      },
      "source": [
        "softmax = Softmax()\n",
        "softmax.forward(pred).shape, softmax.backward(pred).shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((3, 4), (3, 4))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eu4NSoNw0MN5"
      },
      "source": [
        "derivative of BCE loss\n",
        "\n",
        "\n",
        "![bce derive.png](data:image/png;base64,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)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YJRxZ5u_22Gp"
      },
      "source": [
        "# loss functions\n",
        "class LossType(Enum):\n",
        "    mse = auto()\n",
        "    bce = auto()\n",
        "\n",
        "\n",
        "class MSE(Layer):\n",
        "    def __init__(self, pred, y):\n",
        "        self.pred = pred\n",
        "        self.y = y\n",
        "        assert self.pred.shape == self.y.shape, \"error, shape mismatch between pred and y\"\n",
        "\n",
        "    def forward(self) -> float:\n",
        "        return np.power(self.pred - self.y, 2).mean()\n",
        "\n",
        "\n",
        "    def backward(self) -> np.ndarray:\n",
        "        # shape is (n_row, out_dim)\n",
        "        # need to keep same dimensions as pred and y\n",
        "        # to get loss wrt to each output\n",
        "        # since the 2 is a constant factor, we can leave out\n",
        "        # (equivalent to multiplying lr by 2)\n",
        "        return self.pred - self.y\n",
        "\n",
        "\n",
        "class BCE(Layer):\n",
        "    def __init__(self, pred, y):\n",
        "        self.pred = pred\n",
        "        self.y = y\n",
        "        self.n = len(self.y)\n",
        "        assert self.pred.shape == self.y.shape, \"error, shape mismatch between pred and y\"\n",
        "\n",
        "\n",
        "    def forward(self) -> float:\n",
        "        loss = np.nansum(-self.y * np.log(self.pred) - (1 - self.y) * np.log(1 - self.pred)) / self.n\n",
        "        # loss and np.squeeze(loss) should be the same\n",
        "        return np.squeeze(loss) \n",
        "\n",
        "\n",
        "    def backward(self) -> np.ndarray:\n",
        "        # return shape is (n_row, out_dim)\n",
        "        return (-(self.y / self.pred) + ((1 - self.y) / (1 - self.pred))) / self.n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-tB_TU8B0UE",
        "outputId": "ae2a97cb-2b48-4a62-b247-9143c551fb7c"
      },
      "source": [
        "mse = MSE(y+5, y)\n",
        "mse.backward()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 5, 5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QtS0SSVcBfoC",
        "outputId": "6a6cec61-8667-4e15-ac01-2769d0829150"
      },
      "source": [
        "bce = BCE(y+5, y)\n",
        "bce.forward()\n",
        "bce.backward()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:34: RuntimeWarning: invalid value encountered in log\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.05555556, -0.03968254, -0.0297619 ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aAk9GXKGwCvA"
      },
      "source": [
        "class Model:\n",
        "    def __init__(self, in_dim: int, layers: Optional[List[int]], out_dim: int, loss_fn: str):\n",
        "        self.in_dim = in_dim # get input dimension for matmul, = X.shape[1]\n",
        "        self.layers=[]\n",
        "        self.loss_fn = loss_fn\n",
        "        assert self.loss_fn in [l.name for l in LossType], f\"error, loss {self.loss_fn} not recognized\"\n",
        "\n",
        "        if layers:\n",
        "            \"\"\"if layers not given, is equivalent to linear/logistic regression\n",
        "            \"\"\"\n",
        "            for l in layers:\n",
        "                # each layer is a feedforward + relu\n",
        "                self.layers.append(Linear(self.in_dim, l))\n",
        "                self.layers.append(ReLU())\n",
        "                self.in_dim = l\n",
        "        # add final classifier layer + activation\n",
        "        self.layers.append(Linear(self.in_dim, out_dim))\n",
        "        # final_act_fn = Identity() if self.loss_fn == LossType.mse.name else Sigmoid()\n",
        "        # self.layers.append(final_act_fn)\n",
        "        if self.loss_fn == LossType.bce.name:\n",
        "            self.layers.append(Sigmoid())\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, input: np.ndarray) -> np.ndarray:\n",
        "        for l in self.layers:\n",
        "            input = l.forward(input)\n",
        "        return input\n",
        "        \n",
        "\n",
        "    def backward(self, pred: np.ndarray, y: np.ndarray, lr: float):\n",
        "        loss_func = MSE(pred, y) if self.loss_fn == LossType.mse.name else BCE(pred, y)\n",
        "        loss = loss_func.forward()\n",
        "        # compute gradients\n",
        "        gradient = loss_func.backward()\n",
        "\n",
        "        # backprop through the layers:\n",
        "        for i, l in reversed(list(enumerate(self.layers))):\n",
        "            if l.type != LayerType.linear.name:\n",
        "                # if not linear layer, just calculate the gradient and \n",
        "                # pass to the previous layer\n",
        "                gradient = self.layers[i].backward(gradient)\n",
        "            else:\n",
        "                gradient, dW, dB = self.layers[i].backward(gradient)\n",
        "                self.layers[i].update(dW, dB, lr)\n",
        "        return loss # keep track of loss\n",
        "\n",
        "\n",
        "    def fit(self, input: np.ndarray, y: np.ndarray, n_epochs: int, lr: float):\n",
        "        for _ in range(n_epochs):\n",
        "            out = self.forward(input)\n",
        "            loss = self.backward(out, y, lr)\n",
        "            print(f\"loss {self.loss_fn} = {loss}\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Fi0fzZj6YLV",
        "outputId": "668b39ff-d944-4b5b-a748-63a10b4f96da"
      },
      "source": [
        "nn = Model(in_dim=30, layers = [4,5,6], out_dim = 1, loss_fn=\"mse\")\n",
        "out = nn.forward(x)\n",
        "out"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.98813086],\n",
              "       [-0.98813086],\n",
              "       [-0.98813086]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mnS1YCkhKJov"
      },
      "source": [
        "y = y.reshape(-1, 1) # reshape y to match pred.shape aka (rows, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U2E5qUsqJ75q",
        "outputId": "93b2d57b-4cf1-426c-923d-bd8afc2724b2"
      },
      "source": [
        "out.shape, y.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((3, 1), (3, 1))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mEftamXm_DWe",
        "outputId": "cb2e33d0-659c-48e7-a8ec-0db86fbbc8f4"
      },
      "source": [
        "nn.backward(out, y, lr=0.001)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9.59559267854637"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_gZoc3wHD2hR",
        "outputId": "c931101a-726b-40c9-e05d-2d8309e5a443"
      },
      "source": [
        "nn.fit(x, y, n_epochs=10, lr=0.001)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "loss mse = 9.328794059684448\n",
            "loss mse = 9.070584089558691\n",
            "loss mse = 8.820636147502897\n",
            "loss mse = 8.578639361758258\n",
            "loss mse = 8.34429766277912\n",
            "loss mse = 8.117328903285243\n",
            "loss mse = 7.897464039748857\n",
            "loss mse = 7.684446370475576\n",
            "loss mse = 7.47803082586245\n",
            "loss mse = 7.277983306799958\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YkAv0UFVEjNw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7dfec4a-6704-4bef-b6dc-b5b06ec2a656"
      },
      "source": [
        "\"\"\"\n",
        "linear/logistic regression is equivalent to MLP\n",
        "just without any hidden layers\n",
        "\"\"\"\n",
        "log_reg = Model(in_dim=30, layers = None, out_dim = 1, loss_fn=\"bce\")\n",
        "log_reg.fit(x, y, n_epochs=10, lr=0.001)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "loss bce = 5.943150344205013\n",
            "loss bce = 5.9032142035089485\n",
            "loss bce = 5.8633151758108975\n",
            "loss bce = 5.823453901849782\n",
            "loss bce = 5.783631030785172\n",
            "loss bce = 5.743847220206206\n",
            "loss bce = 5.7041031361361485\n",
            "loss bce = 5.664399453032353\n",
            "loss bce = 5.624736853781546\n",
            "loss bce = 5.5851160296901625\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5pHGuwJqFk0q"
      },
      "source": [
        "# Decision Tree/ Random Forests\n",
        "\n",
        "https://forums.fast.ai/t/unofficial-lesson-7-classnotes/7955"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5NvDbRT0EpiC"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qjJ2d4jvMWcO"
      },
      "source": [
        "# KNN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAzBooIPMXGn"
      },
      "source": [
        "class KNN:\n",
        "    def __init__(self, k = 1):\n",
        "        self.k = k\n",
        "\n",
        "    def fit(self, x, y):\n",
        "        \"\"\"Train the classifier (here simply save training data)\n",
        "\n",
        "        x -- feature vectors (N x D)\n",
        "        y -- labels (N x 1)\n",
        "        \"\"\"\n",
        "        self.x_train = x\n",
        "        self.y_train = y\n",
        "        self.n_classes = np.amax(self.y_train)+1 # labels go from 0,..,n, so add +1\n",
        "\n",
        "    @staticmethod \n",
        "    def calculate_distance(x1, x2):\n",
        "        \"\"\"\n",
        "        calculate the euclidian distance\n",
        "        = sqrt(sum( (x1 - x2)^2 ))\n",
        "        \"\"\"\n",
        "        return np.sqrt(np.sum(np.square(x1-x2), axis=1))\n",
        "\n",
        "    def predict(self, x_test):\n",
        "        \"\"\"\n",
        "        loop over all x_test\n",
        "        calculate array of euclidian distance between x_train and x\n",
        "        get y for the topk neighbors\n",
        "        get the argmax value (aka class with most counts)\n",
        "        append to preds\n",
        "\n",
        "        \"\"\"\n",
        "        preds = []\n",
        "        for x in x_test:\n",
        "            dist = self.calculate_distance(self.x_train, x_test)\n",
        "            # keep count of y_preds\n",
        "            y_pred_counts = np.zeros(self.n_classes, dtype=np.int)\n",
        "\n",
        "            # find k closest neighbors\n",
        "            # use argsort to return the indices of that sorted array\n",
        "            # and take top k of the arg sort array\n",
        "            for neighbor_id in np.argsort(dist)[:self.k]:\n",
        "                # get the y value of that neighbor\n",
        "                neighbor_y = self.y_train[neighbor_id]\n",
        "                # add to y_pred_counts\n",
        "                y_pred_counts[neighbor_y] += 1\n",
        "\n",
        "                preds.append(np.argmax(y_pred_counts))\n",
        "\n",
        "        return preds\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OeWRwMWnr6Q-"
      },
      "source": [
        "# SVM\n",
        "https://www.python-engineer.com/courses/mlfromscratch/07_svm/?fbclid=IwAR2N_pwNT50cl7x3qW7RF5uhXgbSVL_H6BKqmNTv8iciJbtvYKN24ShDA28\n",
        "\n",
        "https://medium.com/@saishruthi.tn/support-vector-machine-using-numpy-846f83f4183d\n",
        "\n",
        "**Alternatively** think of SVM as a NN with hinge loss and L1 regularization\n",
        " - maximum margin hyperplane is just hinge loss + L1 regularization\n",
        " - take `sign(pred)` asfinal prediction\n",
        "\n",
        "https://twitter.com/jeremyphoward/status/1215875259364102144?s=09&fbclid=IwAR1Vbq0WjO53tzmwywZ0zVgB5_XtiCCDtDfkMpqEEJG6SAitreY8BTJPEh0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jakVL0bqEglZ"
      },
      "source": [
        "note svm update function is\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBQOFAWxtB7u"
      },
      "source": [
        "## NN style\n",
        "class HingeLoss(Layer):\n",
        "    \"\"\"\n",
        "    https://discuss.pytorch.org/t/is-there-standard-hinge-loss-in-pytorch/5590/5\n",
        "    \"\"\"\n",
        "    def __init__(self, pred: np.ndarray, y: np.ndarray):\n",
        "        self.pred = pred\n",
        "        self.y = y\n",
        "        assert self.pred.shape == self.y.shape, \"error, shape mismatch between pred and y\"\n",
        "\n",
        "\n",
        "    def forward(self) -> float:\n",
        "        \"\"\"\n",
        "        loss is max(0, 1- y*pred)\n",
        "\n",
        "        where y = {-1, 1}\n",
        "        \"\"\"\n",
        "        self.loss = 1-np.multiply(pred, y)\n",
        "        self.loss[self.loss < 0 ] = 0 \n",
        "        return self.loss.mean()\n",
        "\n",
        "\n",
        "    def backward(self) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        derivative of 1-y*pred wrt pred = -y\n",
        "        multiply that by heaviside function since max(0, 1-y*pred)\n",
        "        \"\"\"\n",
        "        return np.multiply(np.heaviside(self.loss, 0), self.y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FoeKyztgtr6n"
      },
      "source": [
        "y = np.array([-1, 1, 1, -1])\n",
        "pred = np.array([-0.5, 0.5, -0.5, -1.5])\n",
        "l = HingeLoss(pred, y)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rMTuw6bot7GI",
        "outputId": "472861fe-9373-438e-b1eb-e9bace20c4c1"
      },
      "source": [
        "l.forward()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.625"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vBYHpOTZt-Rc",
        "outputId": "6ea4c01c-d58f-4e10-d568-fca2c3fb4919"
      },
      "source": [
        "l.backward()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-1.,  1.,  1., -0.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NDlDXyRmuWFw"
      },
      "source": [
        "# SVM class (in NN style)\n",
        "\n",
        "class SVM:\n",
        "    def __init__(self, in_dim:int, gamma: float = 0.01):\n",
        "        self.gamma = gamma # regularizing param\n",
        "        self.in_dim = in_dim\n",
        "\n",
        "        # initialize weights and biases\n",
        "        self.w = np.random.normal(size=(self.in_dim, 1))\n",
        "        self.b = np.random.rand(1, 1)\n",
        "\n",
        "    def forward(self, input: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        self.w  needs to be (n_col, 1)\n",
        "        so np.matmul(x, self.w) is shape (n_row, n_col)*(n_col, 1) => (n_row, 1)\n",
        "        \"\"\"\n",
        "        self.previous_activations = input # keep track of previous activations\n",
        "        n_rows, n_cols = input.shape[0], input.shape[1]\n",
        "        assert n_cols == self.in_dim, \"dimension mismatch, input n_cols does not match in_dim\"\n",
        "        # print(input.shape, self.w.shape)\n",
        "        # print(np.matmul(input, self.w).shape)\n",
        "        return np.matmul(input, self.w) - self.b\n",
        "\n",
        "    def backward(self, pred: np.ndarray, y: np.ndarray, lr: float):\n",
        "        loss_func = HingeLoss(pred, y)\n",
        "        loss = loss_func.forward()\n",
        "        # compute gradients\n",
        "        gradient = loss_func.backward()\n",
        "        dW = np.dot(self.previous_activations.T, gradient)\n",
        "        # print(\"gradient shape\", gradient.shape)\n",
        "        # print(\"dW shape\", dW.shape)\n",
        "\n",
        "        # update values of self.w and self.b\n",
        "        # similar to NN, self.activations for self.w is just x\n",
        "        self.w -= lr*(dW-2*self.gamma*self.w)\n",
        "        \"\"\"\n",
        "        for dB, dB = dA.mean(axis=1, keepdims=True)\n",
        "        dA is the incoming error, which is just error\n",
        "        \"\"\"\n",
        "        dB = gradient.mean(axis=0, keepdims=True)\n",
        "        # print(\"dB shape\", dB.shape)\n",
        "        self.b -= lr*dB\n",
        "\n",
        "\n",
        "    def fit(self, x: np.ndarray, y: np.ndarray, n_epochs: int, lr: float):\n",
        "        for _ in range(n_epochs):\n",
        "            pred = self.forward(x)\n",
        "            self.backward(pred, y, lr)\n",
        "\n",
        "    def predict(self, x_test: np.ndarray, return_class: bool = True):\n",
        "        preds = np.matmul(x_test, self.w) - self.b\n",
        "        return np.sign(preds) if return_class else preds\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I9OpBmtG393n",
        "outputId": "22241019-21a9-4c90-f6d5-913700d3453d"
      },
      "source": [
        "svm = SVM(in_dim = 30)\n",
        "y = np.array([-1, 1, 1]).reshape(-1,1) # make sure it's reshaped!!!\n",
        "print(y.shape)\n",
        "pred = svm.forward(x)\n",
        "pred"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(3, 1)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[6.31374379],\n",
              "       [3.69875184],\n",
              "       [4.62464398]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2WsSxCjL_lBU",
        "outputId": "6b88e3ef-47df-4e67-b7d6-43c781fea1ad"
      },
      "source": [
        "l = HingeLoss(pred, y.reshape(-1,1))\n",
        "l.forward()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.437914596258581"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ihgzZ6Qs_rwU",
        "outputId": "2d84a695-7874-45af-e862-0c16b3b57af5"
      },
      "source": [
        "l.loss"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[7.31374379],\n",
              "       [0.        ],\n",
              "       [0.        ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "78ij2q117c6n"
      },
      "source": [
        "svm.backward(pred, y, lr=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RtCUPu5iE3Xd"
      },
      "source": [
        "svm.fit(x, y, 10, 0.01)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l046lVKPGkzP",
        "outputId": "2567b0c5-3ce3-4f01-eba1-1062a92bc428"
      },
      "source": [
        "svm.predict(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.],\n",
              "       [1.],\n",
              "       [1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mdLf_VeUGpZH"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KzrmJqlCwRS2"
      },
      "source": [
        "# K means \n",
        "\n",
        "https://blog.paperspace.com/speed-up-kmeans-numpy-vectorization-broadcasting-profiling/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kjfGCk4cwSrN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}