numpy-nn/experiments.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Полносвязная нейросеть на numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from layers import ReLU, Tanh, Sigmoid, Dense, LogSoftmax\n",
    "from loss import NLL, grad_NLL\n",
    "from numericgrad import num_grad\n",
    "\n",
    "import numpy as np\n",
    "from scipy.optimize import minimize"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Проверка правильности реализованных градиентов"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NLL loss"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сравним аналитический и численный градиенты лосса NLL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2   # batch size\n",
    "d = 10  # units num\n",
    "target = np.random.choice(d, size=n)\n",
    "batch = np.random.uniform(-1, 1, n*d).reshape((n, d))\n",
    "\n",
    "# analytical formula\n",
    "lsm = LogSoftmax(d)\n",
    "acts = lsm.forward(batch)\n",
    "loss = NLL(acts, target)\n",
    "grads = lsm.backward(grad_NLL(acts, target))[0]\n",
    "\n",
    "# numerical estimation\n",
    "num_grads = num_grad(lambda x: NLL(lsm.forward(x), target), batch)\n",
    "\n",
    "assert np.allclose(grads, num_grads, rtol=1e-3, atol=0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ReLU"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сравним аналитический и численный градиенты функции\n",
    "$$ f(y) = \\sum_i y_i, \\quad y = ReLU(x) $$\n",
    "по входу функции ReLU. На вход `relu.backward()` нужно подать\n",
    "$$\n",
    "\\frac{\\partial f}{\\partial y}=\\mathbb{1}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 10  # batch size\n",
    "d = 12  # input size\n",
    "relu = ReLU()\n",
    "points = np.linspace(-1, 1, n * d).reshape((n,d))\n",
    "\n",
    "# analytical formula\n",
    "f = relu.forward(points).sum(axis=1)\n",
    "grads = relu.backward(np.ones((n, d)))\n",
    "\n",
    "# numerical estimation\n",
    "num_grads = num_grad(lambda x: relu.forward(x).sum(), points)\n",
    "\n",
    "assert np.allclose(grads[0], num_grads, rtol=1e-3, atol=0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear Layer"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сравним аналитический и численный градиенты лосса NLL по входу полносвязного слоя "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 10  # batch size\n",
    "d = 12  # input size\n",
    "m = 32  # output size\n",
    "linear = Dense(d, m)\n",
    "points = np.linspace(-1, 1, n * d).reshape((n, d))\n",
    "\n",
    "# analytical formula\n",
    "f = linear.forward(points).sum(axis=1)\n",
    "grads = linear.backward(np.ones((n, m)))\n",
    "\n",
    "# numerical estimation\n",
    "num_grads = num_grad(lambda x: linear.forward(x).sum(), points)\n",
    "\n",
    "assert np.allclose(grads[0], num_grads, rtol=1e-3, atol=0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обучение сети"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Загрузка данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1347, 64), (450, 64))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X, y = load_digits(return_X_y=True)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Утилиты для обучения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_network(input_size, hidden_layers_size, output_size, n_layers=3, activation_class=ReLU):\n",
    "    network = []\n",
    "\n",
    "    for layer_idx in range(n_layers):\n",
    "        # Compute sizes of current linear layer\n",
    "        layer_in = input_size if layer_idx == 0 else hidden_layers_size\n",
    "        layer_out = output_size if layer_idx == n_layers - 1 else hidden_layers_size\n",
    "        \n",
    "        # Add linear layer to the network\n",
    "        network.append(Dense(layer_in, layer_out))\n",
    "\n",
    "        # Add activation after each layer except the last one\n",
    "        if layer_idx != n_layers - 1:\n",
    "            network.append(activation_class())\n",
    "\n",
    "    # Add LogSoftmax layer to the network\n",
    "    network.append(LogSoftmax(output_size))\n",
    "\n",
    "    return network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward(network, X):\n",
    "    \"\"\"\n",
    "    Perform forward pass through the network.\n",
    "    \n",
    "    network: list of layers\n",
    "    X: raw data, shape (batch, features_num)\n",
    "\n",
    "    output: shape (batch, out_features_num)\n",
    "    \"\"\"\n",
    "    x = X.copy()\n",
    "    for layer in network:\n",
    "      x = layer.forward(x)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(network, X):\n",
    "    \"\"\"\n",
    "    Returns predictions for each object in X.\n",
    "    \n",
    "    network: list of layers\n",
    "    X: raw data, shape (batch, features_num)\n",
    "\n",
    "    output: array of classes, each from 0 to 9\n",
    "            shape (batch,)\n",
    "    \"\"\"\n",
    "    return forward(network, X).argmax(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_weights(network):\n",
    "    weights = []\n",
    "    for layer in network:\n",
    "        for param in layer.params:\n",
    "            weights += param.ravel().tolist()\n",
    "    return np.array(weights)\n",
    "\n",
    "\n",
    "def set_weights(weights, network):\n",
    "    i = 0\n",
    "    for layer in network:\n",
    "        for param in layer.params:\n",
    "            l = param.size\n",
    "            param[:] = weights[i:i+l].reshape(param.shape)\n",
    "            i += l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_loss_grad(weights, args):\n",
    "    \"\"\"\n",
    "    takes current weights and computes cross-entropy and gradients\n",
    "    weights shape: [num_parameters]\n",
    "    output 1: loss (scalar)\n",
    "    output 2: gradint w.r.t. weights, shape: [num_parameters]\n",
    "    \"\"\"\n",
    "    network, X, y = args\n",
    "\n",
    "    # forward pass\n",
    "    set_weights(weights, network)\n",
    "    y_pred = forward(network, X)\n",
    "    \n",
    "    # compute loss\n",
    "    loss = NLL(y_pred, y)\n",
    "    \n",
    "    # compute loss grad\n",
    "    grad_output = grad_NLL(y_pred, y)\n",
    "\n",
    "    # backward pass\n",
    "    grads = []\n",
    "    for layer in network[::-1]:\n",
    "      grad_output, grad_params = layer.backward(grad_output)\n",
    "      grads = grad_params + grads\n",
    "\n",
    "    # to numpy\n",
    "    grads = np.concatenate(grads)\n",
    "\n",
    "    return loss, grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Callback:\n",
    "    def __init__(self, network, X_train, y_train, X_test, y_test, print=False):\n",
    "        self.network = network\n",
    "        self.X_train = X_train\n",
    "        self.X_test = X_test\n",
    "        self.y_train = y_train\n",
    "        self.y_test = y_test\n",
    "        self.print = print\n",
    "        self.train_acc = []\n",
    "        self.test_acc = []\n",
    "        \n",
    "    def call(self, weights):\n",
    "        \"\"\"\n",
    "        Computes quality on train and test set with given weights\n",
    "        and saves to self.train_acc and self.test_acc.\n",
    "        If self.print is True, also prints these 2 values\n",
    "        \"\"\"\n",
    "        set_weights(weights, self.network)\n",
    "        train_pred = predict(self.network, self.X_train)\n",
    "        test_pred = predict(self.network, self.X_test)\n",
    "        acc1 = (train_pred == self.y_train).mean()\n",
    "        acc2 = (test_pred == self.y_test).mean()\n",
    "        self.train_acc.append(acc1)\n",
    "        self.test_acc.append(acc2)\n",
    "        if self.print:\n",
    "          print(f'train acc: {acc1:.3f}, test acc: {acc2:.3f}')\n",
    "        if acc2 > max(self.test_acc):\n",
    "          self.weights = weights.copy()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Обучение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Dense(64, 32), Relu(), Dense(32, 32), Relu(), Dense(32, 10), LogSoftmax(10)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_size = X_train.shape[1]\n",
    "hidden_layers_size = 32\n",
    "output_size = 10\n",
    "\n",
    "network = make_network(input_size, hidden_layers_size, output_size, 3, ReLU)\n",
    "network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train acc: 0.106, test acc: 0.084\n",
      "train acc: 0.113, test acc: 0.093\n",
      "train acc: 0.116, test acc: 0.093\n",
      "train acc: 0.151, test acc: 0.127\n",
      "train acc: 0.352, test acc: 0.331\n",
      "train acc: 0.351, test acc: 0.358\n",
      "train acc: 0.472, test acc: 0.476\n",
      "train acc: 0.441, test acc: 0.431\n",
      "train acc: 0.578, test acc: 0.551\n",
      "train acc: 0.572, test acc: 0.571\n",
      "train acc: 0.683, test acc: 0.642\n",
      "train acc: 0.719, test acc: 0.687\n",
      "train acc: 0.745, test acc: 0.711\n",
      "train acc: 0.786, test acc: 0.756\n",
      "train acc: 0.783, test acc: 0.742\n",
      "train acc: 0.800, test acc: 0.784\n",
      "train acc: 0.836, test acc: 0.811\n",
      "train acc: 0.854, test acc: 0.833\n",
      "train acc: 0.872, test acc: 0.869\n",
      "train acc: 0.875, test acc: 0.864\n",
      "train acc: 0.884, test acc: 0.880\n",
      "train acc: 0.889, test acc: 0.893\n",
      "train acc: 0.907, test acc: 0.900\n",
      "train acc: 0.922, test acc: 0.907\n",
      "train acc: 0.931, test acc: 0.909\n",
      "train acc: 0.938, test acc: 0.916\n",
      "train acc: 0.945, test acc: 0.927\n",
      "train acc: 0.950, test acc: 0.933\n",
      "train acc: 0.953, test acc: 0.933\n",
      "train acc: 0.956, test acc: 0.927\n",
      "train acc: 0.958, test acc: 0.931\n",
      "train acc: 0.960, test acc: 0.927\n",
      "train acc: 0.962, test acc: 0.933\n",
      "train acc: 0.963, test acc: 0.938\n",
      "train acc: 0.970, test acc: 0.936\n",
      "train acc: 0.973, test acc: 0.949\n",
      "train acc: 0.973, test acc: 0.944\n",
      "train acc: 0.981, test acc: 0.942\n",
      "train acc: 0.982, test acc: 0.942\n",
      "train acc: 0.978, test acc: 0.956\n",
      "train acc: 0.981, test acc: 0.956\n",
      "train acc: 0.984, test acc: 0.956\n",
      "train acc: 0.989, test acc: 0.951\n",
      "train acc: 0.989, test acc: 0.953\n",
      "train acc: 0.991, test acc: 0.951\n",
      "train acc: 0.992, test acc: 0.953\n",
      "train acc: 0.993, test acc: 0.953\n",
      "train acc: 0.993, test acc: 0.953\n",
      "train acc: 0.994, test acc: 0.953\n",
      "train acc: 0.995, test acc: 0.956\n",
      "train acc: 0.996, test acc: 0.960\n",
      "train acc: 0.997, test acc: 0.960\n",
      "train acc: 0.998, test acc: 0.960\n",
      "train acc: 0.999, test acc: 0.956\n",
      "train acc: 0.999, test acc: 0.958\n",
      "train acc: 0.999, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 0.999, test acc: 0.953\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.953\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.953\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.960\n",
      "train acc: 1.000, test acc: 0.960\n",
      "train acc: 1.000, test acc: 0.960\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.958\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.953\n",
      "train acc: 1.000, test acc: 0.953\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n",
      "train acc: 1.000, test acc: 0.956\n"
     ]
    }
   ],
   "source": [
    "cb = Callback(network, X_train, y_train, X_test, y_test, print=True)\n",
    "\n",
    "res = minimize(\n",
    "    compute_loss_grad, get_weights(network),\n",
    "    args=[network, X_train, y_train],\n",
    "    method=\"L-BFGS-B\",\n",
    "    jac=True,\n",
    "    callback=cb.call\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результаты обучения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "      fun: 5.486432177332547e-07\n",
       " hess_inv: <3466x3466 LbfgsInvHessProduct with dtype=float64>\n",
       "      jac: array([ 0.00000000e+00, -1.85217990e-08, -2.23786698e-07, ...,\n",
       "        4.19404816e-08, -1.00136642e-07, -4.78528109e-08])\n",
       "  message: 'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
       "     nfev: 101\n",
       "      nit: 89\n",
       "     njev: 101\n",
       "   status: 0\n",
       "  success: True\n",
       "        x: array([-1.63268799e-03,  1.26299985e-02, -1.03791955e-02, ...,\n",
       "       -9.61990132e-01, -1.92585200e+00, -4.21117316e-01])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NLL (Train / Test)\t: 0.000 / 1.071\n",
      "Accuracy (Train / Test)\t: 1.000 / 0.956\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "set_weights(res['x'], network)\n",
    "train_pred = forward(network, X_train)\n",
    "test_pred = forward(network, X_test)\n",
    "nll_train = NLL(train_pred, y_train)\n",
    "nll_test = NLL(test_pred, y_test)\n",
    "print(f'NLL (Train / Test)\\t: {nll_train:.3f} / {nll_test:.3f}')\n",
    "acc_train = (train_pred.argmax(axis=1) == y_train).mean()\n",
    "acc_test = (test_pred.argmax(axis=1) == y_test).mean()\n",
    "print(f'Accuracy (Train / Test)\\t: {acc_train:.3f} / {acc_test:.3f}')\n",
    "\n",
    "plt.plot(cb.train_acc, label=\"train acc\")\n",
    "plt.plot(cb.test_acc, label=\"test acc\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Эксперименты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score(network, res):\n",
    "  set_weights(res['x'], network)\n",
    "  train_pred = predict(network, X_train)\n",
    "  test_pred = predict(network, X_test)\n",
    "  acc_train = (train_pred == y_train).mean()\n",
    "  acc_test = (test_pred == y_test).mean()\n",
    "  return acc_train, acc_test"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Число слоёв"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, какое качество достигает сеть в зависимости от числа слоёв."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# configs\n",
    "n_layers = 5\n",
    "n_tries = 5\n",
    "accs_train = np.zeros((n_layers, n_tries))\n",
    "accs_test = np.zeros((n_layers, n_tries))\n",
    "\n",
    "input_size = X_train.shape[1]\n",
    "hidden_layers_size = 32\n",
    "output_size = 10\n",
    "\n",
    "# experiments\n",
    "for i in range(n_layers):\n",
    "  for j in range(n_tries):\n",
    "    network = make_network(input_size, hidden_layers_size, output_size, i+1, ReLU)\n",
    "    res = minimize(\n",
    "        compute_loss_grad, get_weights(network),\n",
    "        args=[network, X_train, y_train],\n",
    "        method=\"L-BFGS-B\", \n",
    "        jac=True,\n",
    "    )\n",
    "    accs_train[i,j], accs_test[i,j] = score(network, res)\n",
    "\n",
    "# visualization\n",
    "fig, axes = plt.subplots(2, 1, figsize=(6, 5))\n",
    "\n",
    "axes[0].boxplot(accs_train.T, showfliers=False)\n",
    "axes[1].boxplot(accs_test.T, showfliers=False)\n",
    "\n",
    "axes[0].set_xlabel(\"Number of layers\")\n",
    "axes[1].set_xlabel(\"Number of layers\")\n",
    "\n",
    "axes[0].set_ylabel(\"Train accuracy\")\n",
    "axes[1].set_ylabel(\"Test accuracy\")\n",
    "\n",
    "axes[0].set_title(\"Train quality in 5 runs\")\n",
    "axes[1].set_title(\"Test quality in 5 runs\")\n",
    "\n",
    "axes[0].grid(True)\n",
    "axes[1].grid(True)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мысли:\n",
    "- на обучении качество всегда 100-процентное\n",
    "- на тесте качество унимодально по числу слоёв: максимум достигается при трех слоях\n",
    "- результаты всегда одинаково неустойчивы при 2, 4, 5 слоях\n",
    "- линейная модель дает качество хуже"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Инициализация весов"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, как инициализация весов влияет скорость и качество обучения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_network(network, initialization):\n",
    "    for layer in network:\n",
    "        if isinstance(layer, Dense):\n",
    "            output_units, input_units = layer.weights.shape\n",
    "            if initialization == 'Kaiming':\n",
    "                layer.weights = np.random.normal(\n",
    "                    loc=0,\n",
    "                    scale=np.sqrt(2/input_units),\n",
    "                    size=(output_units, input_units))\n",
    "            elif initialization == 'Xavier':\n",
    "                layer.weights = np.random.uniform(\n",
    "                    low=-1/np.sqrt(input_units),\n",
    "                    high=1/np.sqrt(input_units),\n",
    "                    size=(output_units, input_units))\n",
    "                pass\n",
    "            else:\n",
    "                # In case `initialization` represents a standard deviation\n",
    "                layer.weights = np.random.randn(output_units, input_units) * initialization\n",
    "            layer.biases = np.zeros_like(layer.biases)\n",
    "            \n",
    "            layer.params = [layer.weights, layer.biases]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# config\n",
    "init_vars = [5e-3, 1e-2, 1e-1, 'Kaiming', 'Xavier']\n",
    "\n",
    "n_inits = 5\n",
    "n_tries = 5\n",
    "accs_train = np.zeros((n_inits, n_tries))\n",
    "accs_test = np.zeros((n_inits, n_tries))\n",
    "\n",
    "input_size = X_train.shape[1]\n",
    "hidden_layers_size = 32\n",
    "output_size = 10\n",
    "\n",
    "# experiments\n",
    "for i, init in enumerate(init_vars):\n",
    "  for j in range(n_tries):\n",
    "    network = make_network(input_size, hidden_layers_size, output_size, 4, ReLU)\n",
    "    initialize_network(network, init)\n",
    "    res = minimize(\n",
    "        compute_loss_grad, get_weights(network),\n",
    "        args=[network, X_train, y_train],\n",
    "        method=\"L-BFGS-B\", \n",
    "        jac=True,\n",
    "    )\n",
    "    accs_train[i,j], accs_test[i,j] = score(network, res)\n",
    "\n",
    "# visualization\n",
    "init_vars_for_plot = [(x if isinstance(x, str) else fr\"$\\sigma = {x}$\") for x in init_vars]\n",
    "\n",
    "plt.boxplot(accs_test.T, labels=init_vars_for_plot, showfliers=False)\n",
    "\n",
    "plt.title(\"Test quality in 5 runs  (4 layers)\")\n",
    "plt.xlabel(\"Initialization\")\n",
    "plt.ylabel(\"Test accuracy\")\n",
    "plt.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функции активации"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, как выбор функции активации влияет на качество"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# config\n",
    "act_func_vars = [ReLU, Tanh, Sigmoid]\n",
    "init_for_act_funcs = ['Kaiming', 'Xavier', 'Xavier']\n",
    "\n",
    "n_acts = len(act_func_vars)\n",
    "n_tries = 5\n",
    "accs_train = np.zeros((n_acts, n_tries))\n",
    "accs_test = np.zeros((n_acts, n_tries))\n",
    "\n",
    "input_size = X_train.shape[1]\n",
    "hidden_layers_size = 32\n",
    "output_size = 10\n",
    "\n",
    "# experiments\n",
    "for i, act in enumerate(act_func_vars):\n",
    "  for j in range(n_tries):\n",
    "    network = make_network(input_size, hidden_layers_size, output_size, 3, act)\n",
    "    initialize_network(network, init_for_act_funcs[i])\n",
    "    res = minimize(\n",
    "        compute_loss_grad, get_weights(network),\n",
    "        args=[network, X_train, y_train],\n",
    "        method=\"L-BFGS-B\", \n",
    "        jac=True,\n",
    "    )\n",
    "    accs_train[i,j], accs_test[i,j] = score(network, res)\n",
    "\n",
    "# visualization\n",
    "plt.boxplot(accs_test.T,\n",
    "           labels=[act.__repr__(act) for act in act_func_vars],\n",
    "           showfliers=False)\n",
    "\n",
    "plt.title(\"Test quality in 5 runs\")\n",
    "plt.xlabel(\"Activation function\")\n",
    "plt.ylabel(\"Test accuracy\")\n",
    "plt.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}