Mid_ML_HW_1_9.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Mid ML HW_1.9.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/oObelix/DataScience/blob/master/Mid_ML_HW_1_9.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RBrlvvX-d7uP"
      },
      "source": [
        "### Вспомогательный код\n",
        "*Запустите клетку ниже перед началом работы. В него можно даже не смотреть )*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwiTMW5CUuqx"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.cm as cm\n",
        "from matplotlib.colors import ListedColormap, LinearSegmentedColormap, Normalize\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "\n",
        "%matplotlib inline\n",
        "np.random.seed(10)\n",
        "\n",
        "colors = ['red', \"blue\"]\n",
        "labels_cmap = ListedColormap(colors, 2)\n",
        "colors = [(1, 0, 0), (1, 1, 1), (0, 0, 1)]  # R -> W -> B\n",
        "main_cmap = LinearSegmentedColormap.from_list(\"main_scheme\", colors, N=300)\n",
        "\n",
        "def show_data(X, y):\n",
        "    plt.figure(figsize=(5, 5))\n",
        "    plt.scatter(X[:, 0], X[:, 1], s=120, color=labels_cmap(y))\n",
        "    \n",
        "def generate_simple_data(N, a, b, c, max_x=5, max_y=5):\n",
        "    np.random.seed(10)\n",
        "    X = np.random.rand(N, 2)\n",
        "    X[:, 0] = X[:, 0] * max_x\n",
        "    X[:, 1] = X[:, 1] * max_y\n",
        "    y = np.zeros(N)\n",
        "    y[X[:, 0] * a + X[:, 1] * b + c > 0] = 1\n",
        "    #y[X[:, 0] * a + X[:, 1] * b + c < -m]= 0\n",
        "    return X, y\n",
        "\n",
        "def create_neuron(a, b, c, prob_output=False):\n",
        "    if prob_output:\n",
        "        return lambda x: sigmoid(a*x[:, 0] + b*x[:, 1] + c)\n",
        "    else:\n",
        "        return lambda x: a*x[:, 0] + b*x[:, 1] + c\n",
        "\n",
        "def show_descision_boundary(clf, limits, binary=False, X=None, y=None, n_lines=10, show_lines=False,\n",
        "                           figsize=(5, 5), ax=None):\n",
        "    xs, ys = limits\n",
        "    x_min, x_max = xs\n",
        "    y_min, y_max = ys\n",
        "    \n",
        "    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),\n",
        "                         np.arange(y_min, y_max, 0.01))\n",
        "    \n",
        "    if ax is None:\n",
        "        fig = plt.figure(figsize=figsize)\n",
        "        ax = fig.add_subplot(1, 1, 1)\n",
        "    \n",
        "    if binary:\n",
        "        Z = clf.predict_class(np.c_[xx.ravel(), yy.ravel()])\n",
        "        norm = Normalize(vmin=0.,vmax=1.)\n",
        "    else:\n",
        "        Z = clf(np.c_[xx.ravel(), yy.ravel()])\n",
        "        if clf.prob_output:\n",
        "            norm = Normalize(vmin=0.,vmax=1.)\n",
        "        else:\n",
        "            norm = Normalize(vmin=-10.,vmax=10., clip=True)\n",
        "        \n",
        "    Z = Z.reshape(xx.shape)\n",
        "    Z = Z.astype(np.float32)\n",
        "    \n",
        "    ax.contourf(xx, yy, Z, n_lines, alpha=0.4, cmap=main_cmap, norm=norm)\n",
        "    if show_lines:\n",
        "        cp = ax.contour(xx, yy, Z, n_lines)\n",
        "        ax.clabel(cp, inline=True, \n",
        "              fontsize=10, colors=\"green\")\n",
        "    \n",
        "    if y is not None:\n",
        "        X = np.array(X)\n",
        "        y = np.array(y)\n",
        "        ax.scatter(X[:, 0], X[:, 1], s=120, color=labels_cmap(y),\n",
        "                   zorder=4)\n",
        "        \n",
        "\n",
        "def eval_clf(clf, X, y):\n",
        "    acc = accuracy_score(clf.predict_class(X), y)\n",
        "    print(f\"Accuracy {acc}\")\n",
        "    return acc\n",
        "\n",
        "def create_three_axes():\n",
        "    fig = plt.figure(figsize=(20, 6))\n",
        "    grid = plt.GridSpec(2, 5, wspace=1, hspace=0.5)\n",
        "    first_neuron = fig.add_subplot(grid[0, 0])\n",
        "    first_neuron.set_xlabel(\"$x_1$\")\n",
        "    first_neuron.set_ylabel(\"$x_2$\")\n",
        "    first_neuron.set_title(\"Выход первого нейрона\")\n",
        "\n",
        "    second_neuron = fig.add_subplot(grid[1, 0])\n",
        "    second_neuron.set_xlabel(\"$x_1$\")\n",
        "    second_neuron.set_ylabel(\"$x_2$\")\n",
        "    second_neuron.set_title(\"Выход второго нейрона\")\n",
        "\n",
        "    third_neuron_interm = fig.add_subplot(grid[:, 1:3])\n",
        "    third_neuron_interm.set_xlabel(\"$z_1$ (выход первого нейрона)\")\n",
        "    third_neuron_interm.set_ylabel(\"$z_1$ (выход вторго нейрона)\")\n",
        "    third_neuron_interm.set_title(\"Выход третьего нейрона в пространстве первых двух\")\n",
        "\n",
        "    third_neuron_x = fig.add_subplot(grid[:, 3:])\n",
        "    third_neuron_x.set_xlabel(\"$x_1$ (исходные координаты)\")\n",
        "    third_neuron_x.set_ylabel(\"$x_2$ (исходные координаты)\")\n",
        "    third_neuron_x.set_title(\"Выход третьего нейрона в исходных координатах\")\n",
        "\n",
        "    return first_neuron, second_neuron, third_neuron_interm, third_neuron_x\n",
        "\n",
        "def visualize(neural_net, X, y):\n",
        "    n_lines = 5\n",
        "    limits = [[-1, 11], [-1, 11]]\n",
        "\n",
        "    first_neuron, second_neuron, third_neuron_interm, third_neuron_x = create_three_axes()\n",
        "\n",
        "    show_descision_boundary(limits=limits, clf=neural_net.neuron1, binary=True,\n",
        "                                    X=X,\n",
        "                                    y=y, \n",
        "                                    n_lines=1,\n",
        "                                    show_lines=False, ax=first_neuron)\n",
        "\n",
        "    show_descision_boundary(limits=limits, clf=neural_net.neuron2, binary=True,\n",
        "                                    X=X,\n",
        "                                    y=y, \n",
        "                                    n_lines=1,\n",
        "                                    show_lines=False, ax=second_neuron)\n",
        "\n",
        "    show_descision_boundary(limits=[[-0.1, 1.1], [-0.1,1.1]], clf=neural_net.neuron3, binary=True,\n",
        "                                    X=np.vstack([neural_net.neuron1(X), \n",
        "                                                neural_net.neuron2(X)]).T,\n",
        "                                    y=y, \n",
        "                                    n_lines=1,\n",
        "                                    show_lines=False, ax=third_neuron_interm)\n",
        "\n",
        "    show_descision_boundary(limits=limits, clf=neural_net, binary=False,\n",
        "                                    X=X,\n",
        "                                    y=y, \n",
        "                                    n_lines=50,\n",
        "                                    show_lines=False, ax=third_neuron_x)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KPucZvhFEe0V"
      },
      "source": [
        "## (mini) Нейронная сеть\n",
        "\n",
        "В этом практическом задании вам предстоит реализовать нейронную сеть, состоящую из трех нейронов и решающую задачу схожую с описанной в лекции.\n",
        "\n",
        "Мы возьмем за основу класс Neuron, который вы реализовывали ранее, и научимся комбинировать выходы отдельных нейронов для получения более сложной разделяющей границы."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fdBm1c54U-wg"
      },
      "source": [
        "# класс Neuron из прошлой практики\n",
        "def sigmoid(x):\n",
        "    return 1./(1.+np.exp(-x))\n",
        "\n",
        "class Neuron:\n",
        "    \"\"\"\n",
        "    Класс, реализующий нейрон\n",
        "    \"\"\"\n",
        "    def __init__(self, a: float, b: float, c: float, prob_output: bool = True):\n",
        "        \"\"\"\n",
        "        a,b,c -- коэффиценты (веса) нейрона\n",
        "        prob_output -- если True, то, на выходе -- вероятности, если False -- логит\n",
        "\n",
        "        \"\"\"\n",
        "        self.a = a\n",
        "        self.b = b\n",
        "        self.c = c\n",
        "        self.prob_output = prob_output\n",
        "\n",
        "    def calculate_logit(self, x: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        x -- массив размера (N, 2), где N -- количество объектов. \n",
        "             Первый столбец -- признак  x1, второй -- x2.\n",
        "\n",
        "        Данный метод должен возвращать logit = a*x1 + b*x2 + c\n",
        "\n",
        "        \"\"\"  \n",
        "        assert np.ndim(x) == 2 and x.shape[1] == 2\n",
        "        logit = None\n",
        "        logit = self.a * x[:, 0] + self.b * x[:,1] + self.c\n",
        "        return logit\n",
        "\n",
        "    def __call__(self, x: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        x -- массив размера (N, 2), где N -- количество объектов. \n",
        "             Первый столбец -- признак  x1, второй -- x2.\n",
        "\n",
        "        Данный метод должен возвращать logit(x), если self.prob_output=False,\n",
        "        и sigmoid(logit(x)) иначе\n",
        "        \n",
        "        \"\"\"  \n",
        "        assert np.ndim(x) == 2 and x.shape[1] == 2\n",
        "        logit = self.calculate_logit(x)\n",
        "        \n",
        "        if self.prob_output:\n",
        "            output = sigmoid(logit)\n",
        "        else:\n",
        "            output = logit\n",
        "        assert output.shape == (x.shape[0],), f\"Output size must have following shape: {[x.shape[0],]}. Recieved: {output.shape}\"\n",
        "        return output\n",
        "    \n",
        "    def predict_class(self, x: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"\n",
        "        x -- массив размера (N, 2), где N -- количество объектов. \n",
        "             Первый столбец -- признак  x1, второй -- x2.\n",
        "\n",
        "        Данный метод должен возвращать предсказанный класс для \n",
        "        каждого из N объектов -- 0 или 1.\n",
        "\n",
        "        \"\"\"\n",
        "        logit = self.calculate_logit(x)\n",
        "        predicted_classes = (logit > 0.0).astype(np.int32)\n",
        "\n",
        "        assert predicted_classes.shape == (x.shape[0],), f\"Output size must have following shape: {[x.shape[0],]}. Recieved: {output.shape}\"\n",
        "        return predicted_classes\n",
        "\n",
        "    def __repr__(self):\n",
        "        return f\"Neuron description. Weights: a={self.a}, b={self.b}. Bias: c={self.c}.\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pkFgi0lWXtwc"
      },
      "source": [
        "## Задание 1\n",
        "Реализуйте метод calculate_logit класса ThreeNeuronsNeuralNet"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hI7dCi9WFCNK"
      },
      "source": [
        "from typing import List\n",
        "\n",
        "class ThreeNeuronsNeuralNet(Neuron):\n",
        "    \"\"\"\n",
        "    Нейронная сеть из трех нейронов.\n",
        "\n",
        "    \"\"\"\n",
        "    def __init__(self, first_neuron_params: List[float],\n",
        "                       second_neuron_params: List[float],  \n",
        "                       third_neuron_params: List[float]):\n",
        "        \"\"\"\n",
        "        Для конструировани нейронной сети нам потребуются параметры трех нейронов,\n",
        "        которые передаются в трех списках.\n",
        "\n",
        "        Мы наследуемся от класса Neuron, т.к. нам нужно переопределить только \n",
        "        пересчет логитов. Предсказания классов и вероятностей уже реализованы.\n",
        "\n",
        "        \"\"\"\n",
        "        self.prob_output = True # фиксируем вероятностный выход\n",
        "        self.neuron1 = Neuron(*first_neuron_params, prob_output = True) # конструируем первый нейрон, prob_output=True, это важно!\n",
        "        self.neuron2 = Neuron(*second_neuron_params, prob_output = True) # конструируем второй нейрон, prob_output=True, это важно!\n",
        "        self.neuron3 = Neuron(*third_neuron_params, prob_output = self.prob_output) # конструируем третий нейрон\n",
        "\n",
        "    def calculate_logit(self, x):\n",
        "        \"\"\"\n",
        "        x -- массив размера (N, 2), где N -- количество объектов. \n",
        "             Первый столбец -- признак  x1, второй -- x2.\n",
        "             Важно! Это исходные координаты!\n",
        "\n",
        "        Этот метод должен вернуть логит предсказанный всей сетью\n",
        "        Это можно сделать в 4 шага:\n",
        "        1) Получить вероятности синего класса для исходных данных первым \n",
        "           нейроном: вектор длины N -- z1\n",
        "        2) Получить вероятности синего класса для исходных данных вторым\n",
        "           нейроном: вектор длины N -- z2\n",
        "        3) Склеить полученные вероятности: массив размера (N, 2) -- z1z2\n",
        "           * вам может быть полезна функция np.vstack\n",
        "        4) Получить логит(!, calculate_logit) третьего нейрона, примененного к z1z2 -- logit\n",
        "\n",
        "        \"\"\"\n",
        "        z1 = None\n",
        "        z2 = None\n",
        "        z1z2 = None\n",
        "        logit = None\n",
        "\n",
        "        # < YOUR CODE STARTS HERE >\n",
        "        z1 = self.neuron1(x)\n",
        "        z2 = self.neuron2(x)\n",
        "        # z1z2 = self.neuron3(np.vstack((z1, z2)).T)\n",
        "        logit = self.neuron3.calculate_logit(np.vstack((z1, z2)).T)\n",
        "        # < YOUR CODE ENDS HERE >\n",
        "\n",
        "        return logit"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QqCWSXHRYFYl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e165f546-e077-4b22-d9e8-2b4aff6f7fe7"
      },
      "source": [
        "test_net = ThreeNeuronsNeuralNet([1,2,3], [4,5,6], [7,8,9])\n",
        "test_input = np.array([[10, 20], [30, -40]])\n",
        "\n",
        "print(test_net.calculate_logit(test_input))\n",
        "\n",
        "assert np.allclose(test_net.calculate_logit(test_input), np.array([24.,  9.]))\n",
        "print(\"Simple test passed\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[24.  9.]\n",
            "Simple test passed\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKzy8IvfleDa"
      },
      "source": [
        "Теперь посмотрим как выглядит разделяющая поверхность"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6QooEg17h-vS",
        "cellView": "both",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 442
        },
        "outputId": "e9b173b9-b5d5-4d4d-ed22-ba4605f67cf3"
      },
      "source": [
        "a1, b1, c1 = 0.0, -3.0, 15.0\n",
        "a2, b2, c2 = -3.0, 3.0, -2.0 \n",
        "a3, b3, c3 = 1.5, 1.5, -0.65 \n",
        "\n",
        "neural_net = ThreeNeuronsNeuralNet([a1, b1, c1],\n",
        "                                   [a2, b2, c2],\n",
        "                                   [a3, b3, c3])\n",
        "\n",
        "X = np.array([[10, 6], [6, 6], [9, 8], [10, 10],\n",
        "              [10, 4], [4, 4], [4, 6], [8, 9]])\n",
        "y = np.array([0, 0, 0, 0, 1, 1, 1, 1])\n",
        "\n",
        "visualize(neural_net, X, y)\n",
        "\n",
        "if eval_clf(neural_net, X, y) == 1:\n",
        "    print(\"Well done\")\n",
        "else:\n",
        "    print(\"Something went wrong\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy 1.0\n",
            "Well done\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x432 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dNwP4FFDlk6w"
      },
      "source": [
        "## Задание 2 (бонусное)\n",
        "\n",
        "Подберите коэффициенты таким образом, чтобы идеально разделить данные ниже. *Совет: настраивайте параметры по-очереди, начиная с первого нейрона.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "avv5J5VBP-AW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "outputId": "4fb2419b-8d8a-4284-f91f-69d21b307bb1"
      },
      "source": [
        "np.random.seed(10)\n",
        "X = [[1.5  + np.random.rand() - 0.5, x] for x in np.arange(10)]\n",
        "X += [[8.5  + np.random.rand() - 0.5, x] for x in np.arange(10)]\n",
        "X += [[5  + np.random.rand() - 0.5, x] for x in np.arange(10)]\n",
        "X = np.array(X)\n",
        "y = np.zeros(len(X))\n",
        "y[-10:] = 1\n",
        "\n",
        "show_data(X, y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2PMljFGFI2NT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 442
        },
        "outputId": "a93cecda-499c-42e4-fcc8-87193a2d67e9"
      },
      "source": [
        "################################\n",
        "# Меняйте коэффиценты ниже\n",
        "a1, b1, c1 = +1.0, 0.0, -3.0  # нормаль смотрит вправо + отступ от начал координат = -3\n",
        "a2, b2, c2 = -1.0, 0.0, +7.0  # нормаль смотрит влево + отступ = +7\n",
        "a3, b3, c3 = +1.0, 1.0, -1.5  # нормаль вправо вверх под углом 45 градусов с приблизительным отступом между 1 и 2\n",
        "\n",
        "################################\n",
        "neural_net = ThreeNeuronsNeuralNet([a1, b1, c1],\n",
        "                                   [a2, b2, c2],\n",
        "                                   [a3, b3, c3])\n",
        "\n",
        "visualize(neural_net, X, y)\n",
        "\n",
        "if eval_clf(neural_net, X, y) == 1:\n",
        "    print(\"Well done\")\n",
        "else:\n",
        "    print(\"Something went wrong\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy 1.0\n",
            "Well done\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x432 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xkij3zRvnMC"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}