MLP_from_scratch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MLP from scratch",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6_tqqpsJjxb7",
        "outputId": "81a7c36c-2d9b-4455-cc17-6e2b748182bf"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/mydrive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/mydrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b-eivUQX521-"
      },
      "source": [
        "save_path = \"/content/mydrive/My Drive/ex2deep/\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MuoYm723zan6",
        "outputId": "81294732-2122-4768-d746-f0f5fc2ab9e1"
      },
      "source": [
        "pip install progress"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting progress\n",
            "  Downloading progress-1.6.tar.gz (7.8 kB)\n",
            "Building wheels for collected packages: progress\n",
            "  Building wheel for progress (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for progress: filename=progress-1.6-py3-none-any.whl size=9628 sha256=526c136d061fd5f6f47e6df7606a3af0598b3621f99ac67346c7d957bf69acf1\n",
            "  Stored in directory: /root/.cache/pip/wheels/8e/d7/61/498d8e27dc11e9805b01eb3539e2ee344436fc226daeb5fe87\n",
            "Successfully built progress\n",
            "Installing collected packages: progress\n",
            "Successfully installed progress-1.6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ztd4ws_mf99j"
      },
      "source": [
        "import os\n",
        "import cv2\n",
        "import scipy\n",
        "import numpy as np\n",
        "from tqdm import tqdm\n",
        "from mlxtend.preprocessing import shuffle_arrays_unison\n",
        "import numpy as np\n",
        "from progress.bar import IncrementalBar\n",
        "import sys\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "from sklearn.datasets import make_moons\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QMrwOoCfBefr",
        "outputId": "cffeca04-eaa1-4b79-ae07-19f8a55f4dff"
      },
      "source": [
        "pip install python-mnist"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting python-mnist\n",
            "  Downloading python_mnist-0.7-py2.py3-none-any.whl (9.6 kB)\n",
            "Installing collected packages: python-mnist\n",
            "Successfully installed python-mnist-0.7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ERhueAnIRUCQ"
      },
      "source": [
        "X,y=make_moons(n_samples=500,noise=0.01)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 278
        },
        "id": "V0bx5UKPR3vI",
        "outputId": "3f7e39f0-d9b5-4b57-ad2e-f2dbbb18144c"
      },
      "source": [
        "df=pd.DataFrame(dict(x=X[:,0] , y=X[:,1] , label=y))\n",
        "fig,ax=plt.subplots()\n",
        "colors={0:'red' , 1:'blue'}\n",
        "grouped=df.groupby('label')\n",
        "for key, group in grouped:\n",
        "  group.plot(ax=ax,kind='scatter',x='x',y='y',label=key , color=colors[key])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DxwqfVz7TwXi",
        "outputId": "a5815cfd-6aae-458d-b8d1-0bb5e2738e43"
      },
      "source": [
        "target=df.label\n",
        "df.drop(['label'],axis=1,inplace=True)\n",
        "y=target\n",
        "print(y)\n",
        "X=df\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train,X_test,y_train,y_tets=train_test_split(X,y,test_size=0.2,random_state=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0      0\n",
            "1      0\n",
            "2      0\n",
            "3      0\n",
            "4      0\n",
            "      ..\n",
            "495    0\n",
            "496    0\n",
            "497    1\n",
            "498    1\n",
            "499    0\n",
            "Name: label, Length: 500, dtype: int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mgAEdG1azyN4",
        "outputId": "b15fccb8-91a4-4d17-945a-73fe6829f898"
      },
      "source": [
        "from mnist import MNIST\n",
        "from tensorflow.keras.datasets import fashion_mnist\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "((X_train, y_train), (X_test, y_test)) = fashion_mnist.load_data()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n",
            "32768/29515 [=================================] - 0s 0us/step\n",
            "40960/29515 [=========================================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n",
            "26427392/26421880 [==============================] - 0s 0us/step\n",
            "26435584/26421880 [==============================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n",
            "16384/5148 [===============================================================================================] - 0s 0us/step\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n",
            "4423680/4422102 [==============================] - 0s 0us/step\n",
            "4431872/4422102 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0KWTZxnrz2CX"
      },
      "source": [
        "\n",
        "y_train = to_categorical(y_train)\n",
        "y_test = to_categorical(y_test)\n",
        "X=X_train\n",
        "y=y_train"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kYnES4P32auj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        },
        "outputId": "1d54f41f-6f23-49bb-fee6-6ca275a58203"
      },
      "source": [
        "np.save(save_path+ \"Xarray.npy\", X)\n",
        "np.save(save_path+ \"Yarray.npy\", Y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-9-319eed24cc68>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msave_path\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0;34m\"Xarray.npy\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msave_path\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0;34m\"Yarray.npy\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'Y' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6DnNq4bB5ohL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        },
        "outputId": "a0bed744-ccd8-41e4-ec1b-21fdc1195ef0"
      },
      "source": [
        "X=np.load(save_path+ \"Xarray.npy\")\n",
        "y=np.load(save_path+ \"Yarray.npy\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-c64612b057a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msave_path\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0;34m\"Xarray.npy\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msave_path\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0;34m\"Yarray.npy\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/lib/npyio.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding)\u001b[0m\n\u001b[1;32m    414\u001b[0m             \u001b[0mown_fid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    415\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 416\u001b[0;31m             \u001b[0mfid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menter_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos_fspath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"rb\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    417\u001b[0m             \u001b[0mown_fid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    418\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/content/mydrive/My Drive/ex2deep/Yarray.npy'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zfH_xJLcy9zj"
      },
      "source": [
        "shuffle"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vRN_I8Ti5Squ"
      },
      "source": [
        "X2, y2 = shuffle_arrays_unison(arrays=[X, y])\n",
        "X,y=X2,y2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "27_Bg6GdzQCA"
      },
      "source": [
        "vectorization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nmp-ZAQHbqHz"
      },
      "source": [
        "X_train = X_train.reshape(X_train.shape[0], -1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OIRYZ0lg6Tb1"
      },
      "source": [
        "X_test = X_test.reshape(X_test.shape[0], -1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GuzlF21zzTyK"
      },
      "source": [
        "normalization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WKesE5S4ajiw"
      },
      "source": [
        "X_manual_scaled = (X-X.min(axis=0)) / (X.max(axis=0)-X.min(axis=0))\n",
        "X=X_manual_scaled"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6FNVllH7l67i"
      },
      "source": [
        "train test **split**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q0PzyLOCliH8"
      },
      "source": [
        "train_size = int(0.8 * len(X))\n",
        "x_train = X[:train_size]\n",
        "x_test = X[train_size:]\n",
        "y_train = y[:train_size]\n",
        "y_test = y[train_size:]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4R9dQeqJ4K_E",
        "outputId": "72b18a3d-3bcd-44ce-c527-50c8a4ebc222"
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(60000, 784)"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x9OJ6hmJygE6"
      },
      "source": [
        "# split"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zyui5UKWye7-"
      },
      "source": [
        "\n",
        "class Static_split:\n",
        "    def __init__(self, test_split=0.2):\n",
        "        self.test_split = test_split\n",
        "\n",
        "    def set_data(self, X, y, shuffle=True):\n",
        "        if shuffle == False:\n",
        "            p = np.arange(X.shape[0])\n",
        "        else:\n",
        "            p = np.random.permutation(X.shape[0])\n",
        "\n",
        "        split = int(X.shape[0] * self.test_split)\n",
        "        self.X_test = X[p[:split]]\n",
        "        self.y_test = y[p[:split]]\n",
        "        self.X_train = X[p[split:]]\n",
        "        self.y_train = y[p[split:]]\n",
        "\n",
        "    def get_validation_data(self):\n",
        "        return self.X_test, self.y_test\n",
        "\n",
        "    def get_train_data(self):\n",
        "        return self.X_train, self.y_train\n",
        "\n",
        "\n",
        "class kfold_split:\n",
        "    def __init__(self, k=5):\n",
        "        self.k = k\n",
        "\n",
        "    def set_data(self, X, y, shuffle=True):\n",
        "        if shuffle == False:\n",
        "            p = np.arange(X.shape[0])\n",
        "        else:\n",
        "            p = np.random.permutation(X.shape[0])\n",
        "\n",
        "        self.split = np.random.randint(0, self.k, size=X.shape[0])\n",
        "        self.X = X\n",
        "        self.y = y\n",
        "\n",
        "    def __iter__(self):\n",
        "        return self.__next__()\n",
        "\n",
        "    def __next__(self):\n",
        "        for i in range(self.k):\n",
        "            yield self.X[self.split != i], self.y[self.split != i], self.X[self.split == i], self.y[self.split == i]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cYcGE-M3ylpS"
      },
      "source": [
        "# Layers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TYhRyTT5ynNa"
      },
      "source": [
        "\n",
        "class Dense:\n",
        "    def __init__(self, unit, activation=linear, input_dim=0, trainable=True):\n",
        "        self.unit = unit\n",
        "        self.__name__ = 'Dense'\n",
        "        self.name = \"dense\"\n",
        "        self.trainable = trainable\n",
        "        if type(activation) == str:\n",
        "            if activation.lower() == 'linear':\n",
        "                activation = Linear()\n",
        "            elif activation.lower() == 'sigmoid':\n",
        "                activation = Sigmoid()\n",
        "            elif activation.lower() == 'relu':\n",
        "                activation = Relu()\n",
        "            elif activation.lower() == 'softmax':\n",
        "                activation = Softmax()\n",
        "            elif activation.lower() == 'tanh':\n",
        "                activation = Tanh()\n",
        "            else:\n",
        "                raise Exception(\"Activation function \" + activation + \" not found!\")\n",
        "\n",
        "        self.activation = activation\n",
        "        self.input_dim = input_dim\n",
        "\n",
        "    def set_name(self, name):\n",
        "        self.name = name\n",
        "\n",
        "    def compile(self, input_dim=-1):\n",
        "        if input_dim == -1:\n",
        "            assert self.input_dim != 0\n",
        "        else:\n",
        "            self.input_dim = input_dim\n",
        "\n",
        "        self.W = (np.random.random(size=(self.input_dim + 1, self.unit))) - 0.5\n",
        "        self.W = self.W / (self.W.std() * (input_dim + self.unit) ** 0.5)\n",
        "\n",
        "    def __call__(self, X, activation=True):\n",
        "        if activation:\n",
        "            return self.activation(np.dot(np.hstack((X, np.ones((X.shape[0], 1)))), self.W))\n",
        "        else:\n",
        "            return np.dot(np.hstack((X, np.ones((X.shape[0], 1)))), self.W)\n",
        "\n",
        "    def set_trainable(self, trainable):\n",
        "        self.trainable = trainable\n",
        "\n",
        "    def update(self, dw):\n",
        "        if self.trainable:\n",
        "            self.W = self.W + dw\n",
        "\n",
        "    def reset_weights(self):\n",
        "        self.W = (np.random.random(size=self.W.shape)) - 0.5\n",
        "        self.W = self.W / (self.W.std() * (self.W.shape[0] + self.unit) ** 0.5)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jHf9hPCE1oCG"
      },
      "source": [
        "# Activations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a0In-CMm1mTd"
      },
      "source": [
        "\n",
        "\n",
        "# derivative function, gets function output as input and computer derivative\n",
        "class Linear:\n",
        "    def __init__(self):\n",
        "        self.__name__ = 'linear'\n",
        "\n",
        "    def __call__(self, Z):\n",
        "        return Z\n",
        "\n",
        "    def derivative(self, Z, *args, **kwargs):\n",
        "        return 1\n",
        "\n",
        "\n",
        "class Relu:\n",
        "    def __init__(self):\n",
        "        self.__name__ = 'relu'\n",
        "\n",
        "    def __call__(self, Z):\n",
        "\n",
        "        return Z * (Z > 0)\n",
        "\n",
        "    def derivative(self, Z, *args, **kwargs):\n",
        "        return (Z > 0) * 1\n",
        "\n",
        "\n",
        "class Sigmoid:\n",
        "    def __init__(self):\n",
        "        self.__name__ = 'sigmoid'\n",
        "\n",
        "    def __call__(self, Z):\n",
        "        return 1 / (1 + np.exp(-Z))\n",
        "\n",
        "    def derivative(self, Z, *args, **kwargs):\n",
        "        return Z * (1 - Z)\n",
        "\n",
        "\n",
        "# class Softmax_original:\n",
        "#     def __call__(self, Z, *args, **kwargs):\n",
        "#         exp = np.exp(Z)\n",
        "#         return exp / np.sum(exp, keepdims=True)\n",
        "#\n",
        "#     def derivative(self, Z, *args, **kwargs):\n",
        "#         o = self(Z)\n",
        "#         return o * (1 - o)\n",
        "\n",
        "\n",
        "# stable version of softmax:\n",
        "class Softmax:\n",
        "    def __init__(self):\n",
        "        self.__name__ = 'softmax'\n",
        "\n",
        "    def __call__(self, Z):\n",
        "\n",
        "        e = -np.max(Z, axis=1, keepdims=True)\n",
        "        exp = np.exp(Z + e)\n",
        "        return exp / np.sum(exp, axis=1, keepdims=True)\n",
        "\n",
        "    def derivative(self, Z, *args, **kwargs):\n",
        "        raise Exception('cannot get derivative')\n",
        "\n",
        "\n",
        "class Tanh:\n",
        "    def __init__(self):\n",
        "        self.__name__ = 'tanh'\n",
        "\n",
        "    def __call__(self, Z):\n",
        "        return np.tanh(Z)\n",
        "\n",
        "    def derivative(self, Z, *args, **kwargs):\n",
        "        return 1 - (np.tanh(Z) ** 2)\n",
        "\n",
        "\n",
        "sigmoid = Sigmoid\n",
        "softmax = Softmax\n",
        "relu = Relu\n",
        "linear = Linear\n",
        "tanh = Tanh"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dy2hJEVrypJr"
      },
      "source": [
        "# Losses"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DjjGi3PNyqmj"
      },
      "source": [
        "import numpy as np\n",
        "from scipy.special import logsumexp\n",
        "\n",
        "class Cross_entropy:\n",
        "    def __init__(self, last_layer_activation):\n",
        "        if last_layer_activation == 'sigmoid':\n",
        "            self.get_loss = self.call_sigmoid\n",
        "            self.derivative = self.derivative_sigmoid\n",
        "        elif last_layer_activation == 'softmax':\n",
        "            self.get_loss = self.call_softmax\n",
        "            self.derivative = self.derivative_softmax\n",
        "\n",
        "    def call_sigmoid(self, z, y):\n",
        "        # log(1 / (1 + exp(-z)) = -log(1 + exp(-z)) = -logaddexp(0, -z)\n",
        "        # log(1 - (1 / (1 + exp(-z))) = log(exp(-z) / (1 + exp(-z))) = -z - log(1 + exp(-z)) = -z - logaddexp(0, -z)\n",
        "        # loss = -(y * log(h) + (1 - y) * log (1 - h))\n",
        "        # loss = y * logaddexp(0, -z) + (1 - y) * (z + logaddexp(0, -z))\n",
        "        # loss = y * logaddexp(0, -z) + z + logaddexp(0, -z) - y * z -  y * logaddexp(0, -z))\n",
        "        # loss = z + logaddexp(0, -z) - y * z\n",
        "        # loss = z * (1 - y) + logaddexp(0, -z)\n",
        "\n",
        "        return np.mean(z * (1 - y) + np.logaddexp(0, -z))\n",
        "\n",
        "    def derivative_sigmoid(self, h, y):\n",
        "        return h - y\n",
        "\n",
        "    def call_softmax(self, z, y):\n",
        "        # loss = - sum(y_k * log(h_k))\n",
        "        # h_k = exp(z_k) / sum(exp(z_i))\n",
        "        # loss = - sum(y_k * (z_k - log(sum(exp(z_i)))))\n",
        "\n",
        "        return -np.mean(np.sum(y * (z - logsumexp(z, axis=1, keepdims=True)), axis=1))\n",
        "\n",
        "    def derivative_softmax(self, h, y):\n",
        "        return h - y\n",
        "\n",
        "    def get_loss(self, h, y):\n",
        "        return -np.mean(np.sum(y * np.log(h) + (1 - y) * np.log(1 - h), axis=1))\n",
        "\n",
        "    def derivative(self, h, y):\n",
        "        return (h - y) / (h * (1 - h))\n",
        "\n",
        "    def __call__(self, h, y):\n",
        "        self.get_loss(h, y)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2LlGjRXkyx-0"
      },
      "source": [
        "# Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BAEFZ3jAysn0"
      },
      "source": [
        "\n",
        "class Sequential:\n",
        "    def __init__(self):\n",
        "        self.remove_last_layer_activation = False\n",
        "        self.layers = []\n",
        "        self.loss = None\n",
        "        self.optimizer = None\n",
        "        self.regularization = None\n",
        "        self.layer_counter = 1\n",
        "\n",
        "    def add(self, layer):\n",
        "        layer.set_name('dense_' + str(self.layer_counter))\n",
        "        self.layer_counter += 1\n",
        "        self.layers.append(layer)\n",
        "\n",
        "    def initialize_layers(self):\n",
        "        input_dim = -1\n",
        "        for layer in self.layers:\n",
        "            layer.compile(input_dim)\n",
        "            input_dim = layer.unit\n",
        "\n",
        "    def compile(self, optimizer='SGD', loss='cross_entropy', regularization=None):\n",
        "        if loss.lower() == 'cross_entropy':\n",
        "            self.loss = Cross_entropy(self.layers[-1].activation.__name__)\n",
        "            if self.layers[-1].activation.__name__ == \"sigmoid\" or self.layers[-1].activation.__name__ == \"softmax\":\n",
        "                self.remove_last_layer_activation = True\n",
        "\n",
        "        if type(optimizer) == str:\n",
        "            if optimizer.lower() == 'sgd':\n",
        "                optimizer = SGD()\n",
        "            elif optimizer.lower() == 'momentum_sgd':\n",
        "                optimizer = Momentum_SGD()\n",
        "            elif optimizer.lower() == 'adagrad':\n",
        "                optimizer = Adagrad()\n",
        "            elif optimizer.lower() == 'rmsprop':\n",
        "                optimizer = RMSprop()\n",
        "            elif optimizer.lower() == 'adam':\n",
        "                optimizer = Adam()\n",
        "            else:\n",
        "                raise Exception(\"Optimizer \" + optimizer + \" not found!\")\n",
        "\n",
        "        if regularization is not None and type(regularization) == str:\n",
        "            if regularization.lower() == 'l1':\n",
        "                regularization = L1()\n",
        "            elif regularization.lower() == 'l2':\n",
        "                regularization = L2()\n",
        "\n",
        "        self.regularization = regularization\n",
        "        self.optimizer = optimizer\n",
        "\n",
        "\n",
        "        self.initialize_layers()\n",
        "\n",
        "    def fit(self, X, y, batch_size=32, epoch=1, test_data=None):\n",
        "        assert self.loss is not None\n",
        "\n",
        "        history = {'acc': np.zeros(epoch), 'loss': np.zeros(epoch)}\n",
        "        if test_data is not None:\n",
        "            history['val_acc'] = np.zeros(epoch)\n",
        "            history['val_loss'] = np.zeros(epoch)\n",
        "\n",
        "        for epch in range(epoch):\n",
        "            print('Epoch', epch + 1)\n",
        "            sum_loss = 0\n",
        "            sum_acc = 0\n",
        "            bt_conter = 0\n",
        "\n",
        "            required_batchs = int(X.shape[0] / batch_size + 0.99999999)\n",
        "            bar = IncrementalBar(max=required_batchs,\n",
        "                                 suffix='%(index)d/%(max)d - %(eta)ds')\n",
        "\n",
        "            epoch_shufle = np.random.permutation(X.shape[0])\n",
        "\n",
        "            for bt in range(0, X.shape[0], batch_size):\n",
        "                bt_conter += 1\n",
        "                # single batch:\n",
        "                X_batch = X[epoch_shufle[bt:min(bt + batch_size, X.shape[0])]]\n",
        "                y_batch = y[epoch_shufle[bt:min(bt + batch_size, X.shape[0])]]\n",
        "\n",
        "                layer_output = [X_batch]\n",
        "                for j, layer in enumerate(self.layers):\n",
        "                    layer_output.append(layer(layer_output[-1]))\n",
        "\n",
        "                delta_next = self.loss.derivative(layer_output[-1], y_batch)\n",
        "                if not self.remove_last_layer_activation:\n",
        "                    delta_next *= self.layers[-1].activation.derivative(layer_output[-1])\n",
        "\n",
        "                grad = [0 for i in range(len(self.layers))]\n",
        "                regularization_grad = [0 for i in range(len(self.layers))]\n",
        "                if self.regularization is not None:\n",
        "                    regularization_grad = self.regularization.derivative(self.layers)\n",
        "\n",
        "                for i in range(len(self.layers) - 1, 0, -1):\n",
        "                    delta_prev = np.dot(delta_next, self.layers[i].W.T[:, :-1]) * \\\n",
        "                                 self.layers[i - 1].activation.derivative(layer_output[i])\n",
        "\n",
        "                    delta_wi = np.dot(np.hstack((layer_output[i], np.ones((layer_output[i].shape[0], 1)))).T,\n",
        "                                      delta_next)\n",
        "                    grad[i] = delta_wi / X_batch.shape[0] + regularization_grad[i]\n",
        "\n",
        "                    delta_next = delta_prev\n",
        "\n",
        "                delta_wi = np.dot(np.hstack((layer_output[0], np.ones((layer_output[0].shape[0], 1)))).T, delta_next)\n",
        "                grad[0] = delta_wi / X_batch.shape[0] + regularization_grad[0]\n",
        "\n",
        "                self.optimizer.update(grad, self.layers)\n",
        "\n",
        "                d = self.evaluate(X_batch, y_batch)\n",
        "                loss, acc = d['loss'], d['acc']\n",
        "                sum_acc += acc\n",
        "                sum_loss += loss\n",
        "                bar.next()\n",
        "                sys.stdout.write(\" loss: %f acc: %f\" % (sum_loss / (bt_conter + 1), sum_acc / (bt_conter + 1)))\n",
        "                sys.stdout.flush()\n",
        "\n",
        "            bar.finish()\n",
        "            d = self.evaluate(X, y)\n",
        "            loss, acc = d['loss'], d['acc']\n",
        "            if test_data is not None:\n",
        "                d = self.evaluate(test_data[0], test_data[1])\n",
        "                val_loss, val_acc = d['loss'], d['acc']\n",
        "                history['val_loss'][epch] = val_loss\n",
        "                history['val_acc'][epch] = val_acc\n",
        "                history['loss'][epch] = loss\n",
        "                history['acc'][epch] = acc\n",
        "                print('loss: {} acc: {} val_loss: {} val_acc: {}'.format(loss, acc, val_loss, val_acc))\n",
        "            else:\n",
        "                history['loss'][epch] = loss\n",
        "                history['acc'][epch] = acc\n",
        "                print('loss: {} acc: {}'.format(loss, acc))\n",
        "\n",
        "        return history\n",
        "\n",
        "    def predict(self, X, batch_size=32, last_activation=True):\n",
        "        return np.argmax(self.predict_proba(X, batch_size=batch_size, last_activation=last_activation), axis=1)\n",
        "\n",
        "    def predict_proba(self, X, batch_size=32, last_activation=True):\n",
        "        output = np.zeros((X.shape[0], self.layers[-1].unit))\n",
        "\n",
        "        for i in range(0, X.shape[0], batch_size):\n",
        "            t = X[i:min(i + batch_size, X.shape[0])].copy()\n",
        "            for j, layer in enumerate(self.layers):\n",
        "                t = layer(t, activation=(j != len(self.layers) - 1 or last_activation))\n",
        "\n",
        "            output[i:min(i + batch_size, X.shape[0])] = t\n",
        "\n",
        "        return output\n",
        "\n",
        "    def evaluate(self, X, y, batch_size=32):\n",
        "        if self.loss is not None:\n",
        "            p = self.predict_proba(X, batch_size=batch_size, last_activation=not self.remove_last_layer_activation)\n",
        "            loss = self.loss.get_loss(p, y)\n",
        "            if self.regularization is not None:\n",
        "                loss += self.regularization.cost(self.layers)\n",
        "\n",
        "            if self.remove_last_layer_activation:\n",
        "                p = self.layers[-1].activation(p)\n",
        "\n",
        "            pred = np.argmax(p, axis=1)\n",
        "            y_class = np.argmax(y, axis=1)\n",
        "\n",
        "            acc = np.sum(pred == y_class) / p.shape[0]\n",
        "            return {'loss': loss, 'acc': acc}\n",
        "        else:\n",
        "            p = self.predict_proba(X, batch_size=batch_size)\n",
        "\n",
        "            pred = np.argmax(p, axis=1)\n",
        "            y_class = np.argmax(y, axis=1)\n",
        "\n",
        "            acc = np.sum(pred == y_class) / p.shape[0]\n",
        "            return {'acc': acc}\n",
        "\n",
        "    def summary(self):\n",
        "        print(\"_\" * 65)\n",
        "        print('Layer (type)                 Output Shape              Param #')\n",
        "        print(\"=\" * 65)\n",
        "\n",
        "        layer_type = 'Input'\n",
        "        output_shape = '(None, {})'.format(str(self.layers[0].input_dim))\n",
        "        params = '0'\n",
        "        print('{:<29}'.format(layer_type) +\n",
        "              '{:<26}'.format(output_shape) +\n",
        "              '{}'.format(params))\n",
        "        print(\"-\" * 65)\n",
        "\n",
        "        trainable_params = 0\n",
        "        non_trainable_params = 0\n",
        "\n",
        "        for l in self.layers:\n",
        "            layer_type = l.name + ' ({})'.format(l.__name__)\n",
        "            output_shape = '(None, {})'.format(str(l.unit))\n",
        "            params = '{}'.format(l.W.shape[0] * l.W.shape[1])\n",
        "\n",
        "            if l.trainable:\n",
        "                trainable_params += l.W.shape[0] * l.W.shape[1]\n",
        "            else:\n",
        "                non_trainable_params += l.W.shape[0] * l.W.shape[1]\n",
        "\n",
        "            print('{:<29}'.format(layer_type) +\n",
        "                  '{:<26}'.format(output_shape) +\n",
        "                  '{}'.format(params))\n",
        "            print(\"-\" * 65)\n",
        "\n",
        "        print('Total params:', trainable_params + non_trainable_params)\n",
        "        print('Trainable params:', trainable_params)\n",
        "        print('Non-trainable params:', non_trainable_params)\n",
        "        print(\"_\" * 65)\n",
        "        print('Optimizer : {}'.format(self.optimizer.__name__))\n",
        "        if self.regularization is not None:\n",
        "            print('Regularization : {}'.format(self.regularization.__name__))\n",
        "        print(\"-\" * 65)\n",
        "        print()\n",
        "        print()\n",
        "\n",
        "    def save_weights(self, path):\n",
        "        import os\n",
        "        try:\n",
        "            os.rmdir(path)\n",
        "        except:\n",
        "            pass\n",
        "\n",
        "        os.mkdir(path)\n",
        "\n",
        "        for i, layer in enumerate(self.layers):\n",
        "            np.save(os.path.join(path, str(i) + '.npy'), layer.W)\n",
        "\n",
        "    def load_weights(self, path):\n",
        "        import os\n",
        "        assert len(os.listdir(path)) == len(self.layers)\n",
        "\n",
        "        for i, layer in enumerate(self.layers):\n",
        "            self.layers[i].W = np.load(os.path.join(path, str(i) + '.npy'))\n",
        "\n",
        "    def reset_weights(self):\n",
        "        for layer in self.layers:\n",
        "            layer.reset_weights()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Boiz2OrRy_qu"
      },
      "source": [
        "# Optimizer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4VLDzRxhy-FF"
      },
      "source": [
        "\n",
        "\n",
        "class SGD:\n",
        "    def __init__(self, lr=0.01):\n",
        "        self.lr = lr\n",
        "        self.__name__ = 'SGD'\n",
        "\n",
        "    def update(self, grads, layers):\n",
        "\n",
        "        for layer, delta in zip(layers, grads):\n",
        "            layer.update(-delta * self.lr)\n",
        "\n",
        "\n",
        "class Momentum_SGD(SGD):\n",
        "    def __init__(self, lr=0.01, momentum=0.9):\n",
        "        super().__init__(lr)\n",
        "        self.momentum = momentum\n",
        "\n",
        "        # Helping attribute\n",
        "        self.velocity = None\n",
        "\n",
        "        self.__name__ = 'Momentum_SGD'\n",
        "\n",
        "    def update(self, grads, layers):\n",
        "\n",
        "\n",
        "        if self.velocity == None:\n",
        "            self.velocity = [np.zeros(layer.W.shape) for layer in layers]\n",
        "        for i in range(len(layers)):\n",
        "            self.velocity[i]= self.momentum  * self.velocity[i]+ (-1* grads[i] * self.lr)\n",
        "            layers[i].update(self.velocity[i])\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "class Adagrad:\n",
        "    def __init__(self, lr=0.01):\n",
        "        self.global_lr = lr\n",
        "        self.epsilon = 1e-7\n",
        "        self.velocity = None\n",
        "        self.accumulated_gradient = None\n",
        "\n",
        "        self.__name__ = 'AdaGrad'\n",
        "\n",
        "    def update(self, grads, layers):\n",
        "\n",
        "        if self.accumulated_gradient == None:\n",
        "            self.accumulated_gradient = [np.zeros(layer.W.shape) for layer in layers]\n",
        "        for i in range(len(layers)):\n",
        "            self.accumulated_gradient[i]+= grads[i] * grads[i] \n",
        "            layers[i].update(self.global_lr* -grads[i] / (self.epsilon + np.sqrt(self.accumulated_gradient[i])))\n",
        "\n",
        "\n",
        "\n",
        "class RMSprop:\n",
        "    def __init__(self, lr=0.001, rho=0.9):\n",
        "        self.global_lr = lr\n",
        "        self.rho = rho\n",
        "        self.epsilon = 1e-7\n",
        "\n",
        "        # Helping attribute\n",
        "        self.velocity = None\n",
        "        self.accumulated_gradient = None\n",
        "\n",
        "        self.__name__ = 'RMSprop'\n",
        "\n",
        "    def update(self, grads, layers):\n",
        "\n",
        "        if self.accumulated_gradient == None:\n",
        "            self.accumulated_gradient = [np.zeros(layer.W.shape) for layer in layers]\n",
        "        for i in range(len(layers)):\n",
        "            self.accumulated_gradient[i]= self.rho * self.accumulated_gradient[i] + (1- self.rho) *grads[i] * grads[i] \n",
        "            layers[i].update(self.global_lr* -grads[i] / ( np.sqrt(self.epsilon + self.accumulated_gradient[i])))\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "class Adam(Adagrad):\n",
        "    def __init__(self, lr=0.001, rho_1=0.9, rho_2=0.999):\n",
        "        self.global_lr = lr\n",
        "        self.rho_1 = rho_1\n",
        "        self.rho_2 = rho_2\n",
        "\n",
        "        # Helping attribute\n",
        "        self.first_moment_estimate = None\n",
        "        self.second_moment_estimate = None\n",
        "        self.t = 0\n",
        "        self.__name__ = 'Adam'\n",
        "\n",
        "    def update(self, grads, layers):\n",
        "\n",
        "\n",
        "        if self.first_moment_estimate == None:\n",
        "            self.first_moment_estimate = [np.zeros(layer.W.shape) for layer in layers]\n",
        "            \n",
        "        if self.second_moment_estimate == None:\n",
        "            self.second_moment_estimate = [np.zeros(layer.W.shape) for layer in layers]\n",
        "        for i in range(len(layers)):\n",
        "            self.first_moment_estimate[i]= self.rho_1 * self.first_moment_estimate[i] + (1- self.rho_1)* grads[i]\n",
        "            self.second_moment_estimate[i]= self.rho_2 * self.second_moment_estimate[i] + (1- self.rho_2)* grads[i]* grads[i]  \n",
        "            s = self.first_moment_estimate[i] / (1 - self.rho_1**(t))\n",
        "            r = self.second_moment_estimate[i] / (1 - self.rho_2**(t))\n",
        "            layers[i].update(self.global_lr * -s / ( np.sqrt(self.epsilon + r)))\n",
        "\n",
        "        # define RMSprop update rule here.\n",
        "\n",
        "\n",
        "sgd = SGD\n",
        "momentom_sgd = Momentum_SGD\n",
        "adagrad = Adagrad\n",
        "rmsprop = RMSprop\n",
        "adam = Adam"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XvWRvSP8zFIR"
      },
      "source": [
        "# Regularization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kkVwbTM_zHVj"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class L2:\n",
        "    def __init__(self, lam=0.001):\n",
        "        self.lam = lam\n",
        "        self.__name__ = 'L2 Regularization'\n",
        "\n",
        "    def cost(self, layers):\n",
        "\n",
        "        for i in range(len(layers)):\n",
        "            cost += np.sum(np.square(l.W[:-1, :]))\n",
        "        return 1/2*cost * self.lam\n",
        "\n",
        "\n",
        "    def derivative(self, layers):\n",
        "\n",
        "        derivative = []\n",
        "        for i in range(len(layers)):\n",
        "          derivative[i] = np.Vstack(layers[i].W[:-1, :], np.zeros(layers[i].W.shape[1]))\n",
        "        return [derivative[i] * self.lam for l in layers]\n",
        "\n",
        "\n",
        "\n",
        "class L1:\n",
        "    def __init__(self, lam=0.001):\n",
        "        self.lam = lam\n",
        "        self.__name__ = 'L1 Regularization'\n",
        "\n",
        "    def cost(self, layers):\n",
        "\n",
        "\n",
        "        for i in range(len(layers)):\n",
        "            cost += np.sum(np.abs(l.W[:-1, :]))\n",
        "        return 1/2* cost * self.lam\n",
        "\n",
        "\n",
        "\n",
        "    def derivative(self, layers):\n",
        "\n",
        "        derivative = []\n",
        "        for i in range(len(layers)):\n",
        "           derivative[i] = np.vstack(np.sign(l.W[:-1, :]), np.zeros(layers[i].W.shape[1]))\n",
        "        return [derivative[i] * self.lam for l in layers]\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jmAOjAZ0zJ_i"
      },
      "source": [
        "# Test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cEPIkY1cfheg",
        "outputId": "73a3decd-faca-4f35-df3f-7e6baf6a20f4"
      },
      "source": [
        "X_train.size"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "800"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nz4R13uxgr_1",
        "outputId": "59b69f11-b276-4688-ef3e-3869104ace85"
      },
      "source": [
        "y_train"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "238    0\n",
              "438    1\n",
              "475    1\n",
              "58     0\n",
              "380    0\n",
              "      ..\n",
              "255    0\n",
              "72     1\n",
              "396    0\n",
              "235    1\n",
              "37     0\n",
              "Name: label, Length: 400, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ojGG1MS3ls32",
        "outputId": "beb6e852-e482-4f92-9528-fe17695945b3"
      },
      "source": [
        "y_train"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "238    0\n",
              "438    1\n",
              "475    1\n",
              "58     0\n",
              "380    0\n",
              "      ..\n",
              "255    0\n",
              "72     1\n",
              "396    0\n",
              "235    1\n",
              "37     0\n",
              "Name: label, Length: 400, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 414
        },
        "id": "IioFAVoFmK9u",
        "outputId": "8419d885-db16-4f7f-cfae-2cf70ced5004"
      },
      "source": [
        "X_train"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>x</th>\n",
              "      <th>y</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>238</th>\n",
              "      <td>-0.821493</td>\n",
              "      <td>0.547618</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>438</th>\n",
              "      <td>0.163143</td>\n",
              "      <td>-0.074734</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>475</th>\n",
              "      <td>0.090651</td>\n",
              "      <td>0.066048</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>58</th>\n",
              "      <td>0.148381</td>\n",
              "      <td>0.996551</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>380</th>\n",
              "      <td>-0.992718</td>\n",
              "      <td>0.090162</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>255</th>\n",
              "      <td>-0.666454</td>\n",
              "      <td>0.733842</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>72</th>\n",
              "      <td>1.990226</td>\n",
              "      <td>0.417914</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>396</th>\n",
              "      <td>-0.936054</td>\n",
              "      <td>0.342217</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>235</th>\n",
              "      <td>0.688008</td>\n",
              "      <td>-0.443998</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>37</th>\n",
              "      <td>0.996593</td>\n",
              "      <td>0.033100</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>400 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "            x         y\n",
              "238 -0.821493  0.547618\n",
              "438  0.163143 -0.074734\n",
              "475  0.090651  0.066048\n",
              "58   0.148381  0.996551\n",
              "380 -0.992718  0.090162\n",
              "..        ...       ...\n",
              "255 -0.666454  0.733842\n",
              "72   1.990226  0.417914\n",
              "396 -0.936054  0.342217\n",
              "235  0.688008 -0.443998\n",
              "37   0.996593  0.033100\n",
              "\n",
              "[400 rows x 2 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PCxfbaOar3jk",
        "outputId": "9c035346-3b80-48ae-c0bf-13be54749dc2"
      },
      "source": [
        "seed = 7\n",
        "np.random.seed(seed)\n",
        "\n",
        "# generate two datasets and print their shape\n",
        "X,y = make_moons(n_samples = 6000, noise = 0.08)\n",
        "print('X:\\t{}' .format(X.shape))\n",
        "print('y:\\t{}' .format(y.shape))\n",
        "print(type(X))\n",
        "print(type(y))\n",
        "\n",
        "# split data into train and test set\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X:\t(6000, 2)\n",
            "y:\t(6000,)\n",
            "<class 'numpy.ndarray'>\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 496
        },
        "id": "_R3Zm6VmsA9T",
        "outputId": "a29d01bb-56cb-4775-e98d-e2b86fc1d771"
      },
      "source": [
        "plt.figure(figsize=(12,8))\n",
        "plt.scatter(X_train[:,0],X_train[:,1], color = 'b', label = 'class X_train')\n",
        "plt.scatter(X_test[:,0],X_test[:,1], color = 'r', label = 'class X_test')\n",
        "plt.xlabel('feature1')\n",
        "plt.ylabel('feature2')\n",
        "plt.legend()\n",
        "plt.axis('equal')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ay0v_B8FyBJK",
        "outputId": "f323849a-0b9d-43c0-fcbc-6b8495a624e3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4800, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 736
        },
        "id": "W5XlU-jQzJmR",
        "outputId": "34cea86c-8a2e-4bbb-f084-1aa18e77555f"
      },
      "source": [
        "# this code is an example of how to use Models\n",
        "X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "X_test = X_test.reshape(X_test.shape[0], -1)\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Dense(100, 'relu', input_dim=X_train.shape[1]))  # firs layer, 400 neurons with relu activation function\n",
        "#model.add(Dense(200, 'sigmoid'))  # second layer, 200 neurons with sigmoid activation function\n",
        "#model.add(Dense(100, 'tanh'))  # third layer, 100 neurons with tanh activation function\n",
        "#model.add(Dense(50, 'linear'))  # fourth layer, 50 neurons with linear activation function\n",
        "model.add(Dense(1, 'sigmoid'))  # fifth layer, 10 neurons with softmax activation function (output)\n",
        "\n",
        "model.compile(loss='cross_entropy', optimizer='sgd', regularization=None)\n",
        "\n",
        "model.summary()\n",
        "\n",
        "history = model.fit(X_train, y_train, epoch=10, batch_size=64, test_data=(X_test, y_test))\n",
        "\n",
        "plt.figure()\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('acc')\n",
        "plt.plot(history['acc'], 'b-o', label='Train')\n",
        "plt.plot(history['val_acc'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.title('loss')\n",
        "plt.plot(history['loss'], 'b-o', label='Train')\n",
        "plt.plot(history['val_loss'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #\n",
            "=================================================================\n",
            "Input                        (None, 2)                 0\n",
            "-----------------------------------------------------------------\n",
            "dense_1 (Dense)              (None, 100)               300\n",
            "-----------------------------------------------------------------\n",
            "dense_2 (Dense)              (None, 1)                 101\n",
            "-----------------------------------------------------------------\n",
            "Total params: 401\n",
            "Trainable params: 401\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Optimizer : SGD\n",
            "-----------------------------------------------------------------\n",
            "\n",
            "\n",
            "Epoch 1\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-83-66d8cefddc09>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mhistory\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m64\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-22-d8082f355b2e>\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, batch_size, epoch, test_data)\u001b[0m\n\u001b[1;32m     92\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m                 \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 94\u001b[0;31m                     \u001b[0mdelta_prev\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelta_next\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mW\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m                                  \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mderivative\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     96\u001b[0m                     delta_wi = np.dot(np.hstack((layer_output[i], np.ones((layer_output[i].shape[0], 1)))).T,\n",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: shapes (64,64) and (1,100) not aligned: 64 (dim 1) != 1 (dim 0)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YyeIMzzpuPP8"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dZlIWXc2s9Kw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g7lP7EF4o_2k",
        "outputId": "b06d299e-c51c-444d-df92-b0fb13a2ec63"
      },
      "source": [
        "X_train.shape,"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4020, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9FQY0nIff8vK"
      },
      "source": [
        "# this code is an example of how to use Models\n",
        "\n",
        "split=Static_split()\n",
        "split.set_data(X,y)\n",
        "X_train,y_train=split.get_train_data()\n",
        "X_validation,y_validation=split.get_validation_data()\n",
        "X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "X_validation = X_validation.reshape(X_validation.shape[0], -1)\n",
        "model = Sequential()\n",
        "model.add(Dense(100, 'relu', input_dim=X_train.shape[1]))  # firs layer, 400 neurons with relu activation function\n",
        "#model.add(Dense(200, 'sigmoid'))  # second layer, 200 neurons with sigmoid activation function\n",
        "#model.add(Dense(100, 'tanh'))  # third layer, 100 neurons with tanh activation function\n",
        "#model.add(Dense(50, 'linear'))  # fourth layer, 50 neurons with linear activation function\n",
        "model.add(Dense(10, 'softmax'))  # fifth layer, 10 neurons with softmax activation function (output)\n",
        "\n",
        "model.compile(loss='cross_entropy', optimizer='sgd', regularization=None)\n",
        "\n",
        "model.summary()\n",
        "\n",
        "history = model.fit(X_train, y_train, epoch=10, batch_size=64, test_data=(X_validation, y_validation))\n",
        "\n",
        "plt.figure()\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('acc')\n",
        "plt.plot(history['acc'], 'b-o', label='Train')\n",
        "plt.plot(history['val_acc'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.title('loss')\n",
        "plt.plot(history['loss'], 'b-o', label='Train')\n",
        "plt.plot(history['val_loss'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dUMyhh2ldoPq"
      },
      "source": [
        "# this code is an example of how to use Models\n",
        "\n",
        "split=Static_split()\n",
        "split.set_data(X,y)\n",
        "X_train,y_train=split.get_train_data()\n",
        "X_validation,y_validation=split.get_validation_data()\n",
        "X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "X_validation = X_validation.reshape(X_validation.shape[0], -1)\n",
        "model = Sequential()\n",
        "model.add(Dense(200, 'relu', input_dim=X_train.shape[1]))  # firs layer, 400 neurons with relu activation function\n",
        "\n",
        "model.add(Dense(10, 'softmax'))  # fifth layer, 10 neurons with softmax activation function (output)\n",
        "\n",
        "model.compile(loss='cross_entropy', optimizer='sgd', regularization=None)\n",
        "\n",
        "model.summary()\n",
        "\n",
        "history = model.fit(X_train, y_train, epoch=10, batch_size=64, test_data=(X_validation, y_validation))\n",
        "\n",
        "plt.figure()\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('acc')\n",
        "plt.plot(history['acc'], 'b-o', label='Train')\n",
        "plt.plot(history['val_acc'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.title('loss')\n",
        "plt.plot(history['loss'], 'b-o', label='Train')\n",
        "plt.plot(history['val_loss'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wybyP7tgRL6_"
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 707
        },
        "id": "rI-QmsAsQrYP",
        "outputId": "d02b8ab0-fff7-4f62-e02d-5efaf9c17821"
      },
      "source": [
        "# this code is an example of how to use Models\n",
        "\n",
        "split=Static_split()\n",
        "split.set_data(X,y)\n",
        "X_train,y_train=split.get_train_data()\n",
        "X_validation,y_validation=split.get_validation_data()\n",
        "X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "X_validation = X_validation.reshape(X_validation.shape[0], -1)\n",
        "model = Sequential()\n",
        "model.add(Dense(50, 'relu', input_dim=X_train.shape[1]))  # firs layer, 400 neurons with relu activation function\n",
        "\n",
        "model.add(Dense(10, 'softmax'))  # fifth layer, 10 neurons with softmax activation function (output)\n",
        "\n",
        "model.compile(loss='cross_entropy', optimizer='sgd', regularization=None)\n",
        "\n",
        "model.summary()\n",
        "\n",
        "history = model.fit(X_train, y_train, epoch=10, batch_size=64, test_data=(X_validation, y_validation))\n",
        "\n",
        "plt.figure()\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('acc')\n",
        "plt.plot(history['acc'], 'b-o', label='Train')\n",
        "plt.plot(history['val_acc'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.title('loss')\n",
        "plt.plot(history['loss'], 'b-o', label='Train')\n",
        "plt.plot(history['val_loss'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #\n",
            "=================================================================\n",
            "Input                        (None, 2)                 0\n",
            "-----------------------------------------------------------------\n",
            "dense_1 (Dense)              (None, 50)                150\n",
            "-----------------------------------------------------------------\n",
            "dense_2 (Dense)              (None, 10)                510\n",
            "-----------------------------------------------------------------\n",
            "Total params: 660\n",
            "Trainable params: 660\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Optimizer : SGD\n",
            "-----------------------------------------------------------------\n",
            "\n",
            "\n",
            "Epoch 1\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-81-2b6d7f219485>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mhistory\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m64\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_validation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_validation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-22-d8082f355b2e>\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, batch_size, epoch, test_data)\u001b[0m\n\u001b[1;32m     82\u001b[0m                     \u001b[0mlayer_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 84\u001b[0;31m                 \u001b[0mdelta_next\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mderivative\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_batch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     85\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove_last_layer_activation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     86\u001b[0m                     \u001b[0mdelta_next\u001b[0m \u001b[0;34m*=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mderivative\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-21-de1730a7bfd6>\u001b[0m in \u001b[0;36mderivative_softmax\u001b[0;34m(self, h, y)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mderivative_softmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mh\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (64,10) (64,) "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "94r6IyKncKOH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 707
        },
        "outputId": "cc2818a1-67b8-4862-f85a-b917c1f0f215"
      },
      "source": [
        "# this code is an example of how to use Models\n",
        "\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Dense(100, 'relu', input_dim=X_train.shape[1]))  # firs layer, 400 neurons with relu activation function\n",
        "#model.add(Dense(200, 'sigmoid'))  # second layer, 200 neurons with sigmoid activation function\n",
        "#model.add(Dense(100, 'tanh'))  # third layer, 100 neurons with tanh activation function\n",
        "#model.add(Dense(50, 'linear'))  # fourth layer, 50 neurons with linear activation function\n",
        "model.add(Dense(10, 'softmax'))  # fifth layer, 10 neurons with softmax activation function (output)\n",
        "\n",
        "model.compile(loss='cross_entropy', optimizer='sgd', regularization=None)\n",
        "\n",
        "model.summary()\n",
        "\n",
        "history = model.fit(X_train, y_train, epoch=10, batch_size=64, test_data=(X_test, y_test))\n",
        "\n",
        "plt.figure()\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('acc')\n",
        "plt.plot(history['acc'], 'b-o', label='Train')\n",
        "plt.plot(history['val_acc'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('loss')\n",
        "plt.plot(history['loss'], 'b-o', label='Train')\n",
        "plt.plot(history['val_loss'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #\n",
            "=================================================================\n",
            "Input                        (None, 2)                 0\n",
            "-----------------------------------------------------------------\n",
            "dense_1 (Dense)              (None, 100)               300\n",
            "-----------------------------------------------------------------\n",
            "dense_2 (Dense)              (None, 10)                1010\n",
            "-----------------------------------------------------------------\n",
            "Total params: 1310\n",
            "Trainable params: 1310\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Optimizer : SGD\n",
            "-----------------------------------------------------------------\n",
            "\n",
            "\n",
            "Epoch 1\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-80-5f280338c8ce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mhistory\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m64\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-22-d8082f355b2e>\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, batch_size, epoch, test_data)\u001b[0m\n\u001b[1;32m     82\u001b[0m                     \u001b[0mlayer_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 84\u001b[0;31m                 \u001b[0mdelta_next\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mderivative\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_batch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     85\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove_last_layer_activation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     86\u001b[0m                     \u001b[0mdelta_next\u001b[0m \u001b[0;34m*=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mactivation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mderivative\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-21-de1730a7bfd6>\u001b[0m in \u001b[0;36mderivative_softmax\u001b[0;34m(self, h, y)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mderivative_softmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mh\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (64,10) (64,) "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vgDiwj1O7Qp6"
      },
      "source": [
        "plt.figure()\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('acc')\n",
        "plt.plot(history['acc'], 'b-o', label='Train')\n",
        "plt.plot(history['val_acc'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.title('loss')\n",
        "plt.plot(history['loss'], 'b-o', label='Train')\n",
        "plt.plot(history['val_loss'], 'r--o', label='Test')\n",
        "plt.grid()\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}