{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Uczenie maszynowe\n",
    "# 3. Ewaluacja, regularyzacja, optymalizacja"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.1. Metodologia testowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "W uczeniu maszynowym bardzo ważna jest ewaluacja budowanego modelu. Dlatego dobrze jest podzielić posiadane dane na odrębne zbiory – osobny zbiór danych do uczenia i osobny do testowania. W niektórych przypadkach potrzeba będzie dodatkowo wyodrębnić tzw. zbiór walidacyjny."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zbiór uczący a zbiór testowy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Na zbiorze uczącym (treningowym) uczymy algorytmy, a na zbiorze testowym sprawdzamy ich poprawność.\n",
    "* Zbiór uczący powinien być kilkukrotnie większy od testowego (np. 4:1, 9:1 itp.).\n",
    "* Zbiór testowy często jest nieznany.\n",
    "* Należy unikać mieszania danych testowych i treningowych – nie wolno „zanieczyszczać” danych treningowych danymi testowymi!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Czasami potrzebujemy dobrać parametry modelu, np. $\\alpha$ – który zbiór wykorzystać do tego celu?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zbiór walidacyjny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Do doboru parametrów najlepiej użyć jeszcze innego zbioru – jest to tzw. **zbiór walidacyjny**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    " * Zbiór walidacyjny powinien mieć wielkość zbliżoną do wielkości zbioru testowego, czyli np. dane można podzielić na te trzy zbiory w proporcjach 3:1:1, 8:1:1 itp."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Walidacja krzyżowa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Którą część danych wydzielić jako zbiór walidacyjny tak, żeby było „najlepiej”?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    " * Niech każda partia danych pełni tę rolę naprzemiennie!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img width=\"100%\" src=\"https://chrisjmccormick.files.wordpress.com/2013/07/10_fold_cv.png\"/>\n",
    "Żródło: https://chrisjmccormick.wordpress.com/2013/07/31/k-fold-cross-validation-with-matlab-code/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Walidacja krzyżowa\n",
    "\n",
    "* Podziel dane $D = \\left\\{ (x^{(1)}, y^{(1)}), \\ldots, (x^{(m)}, y^{(m)})\\right\\} $ na $N$ rozłącznych zbiorów $T_1,\\ldots,T_N$\n",
    "* Dla $i=1,\\ldots,N$, wykonaj:\n",
    "    * Użyj $T_i$ do walidacji i zbiór $S_i$ do trenowania, gdzie $S_i = D \\smallsetminus T_i$. \n",
    "    * Zapisz model $\\theta_i$.\n",
    "* Akumuluj wyniki dla modeli $\\theta_i$ dla zbiorów $T_i$.\n",
    "* Ustalaj parametry uczenia na akumulowanych wynikach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Walidacja krzyżowa – wskazówki\n",
    "\n",
    "* Zazwyczaj ustala się $N$ w przedziale od $4$ do $10$, tzw. $N$-krotna walidacja krzyżowa (*$N$-fold cross validation*). \n",
    "* Zbiór $D$ warto zrandomizować przed podziałem.\n",
    "* W jaki sposób akumulować wyniki dla wszystkich zbiórow $T_i$?\n",
    "* Po ustaleniu parametrów dla każdego $T_i$, trenujemy model na całych danych treningowych z ustalonymi parametrami.\n",
    "* Testujemy na zbiorze testowym (jeśli nim dysponujemy)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### _Leave-one-out_\n",
    "\n",
    "Jest to szczególny przypadek walidacji krzyżowej, w której $N = m$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Jaki jest rozmiar pojedynczego zbioru $T_i$?\n",
    "* Jakie są zalety i wady tej metody?\n",
    "* Kiedy może być przydatna?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zbiór walidujący a algorytmy optymalizacji\n",
    "\n",
    "* Gdy błąd rośnie na zbiorze uczącym, mamy źle dobrany parametr $\\alpha$. Należy go wtedy zmniejszyć.\n",
    "* Gdy błąd zmniejsza się na zbiorze trenującym, ale rośnie na zbiorze walidującym, mamy do czynienia ze zjawiskiem **nadmiernego dopasowania** (*overfitting*).\n",
    "* Należy wtedy przerwać optymalizację. Automatyzacja tego procesu to _early stopping_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.2. Miary jakości"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Aby przeprowadzić ewaluację modelu, musimy wybrać **miarę** (**metrykę**), jakiej będziemy używać.\n",
    "\n",
    "Jakiej miary użyc najlepiej?\n",
    " * To zależy od rodzaju zadania.\n",
    " * Innych metryk używa się do regresji, a innych do klasyfikacji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Metryki dla zadań regresji\n",
    "\n",
    "Dla zadań regresji możemy zastosować np.:\n",
    " * pierwiastek z błędu średniokwadratowego (*root-mean-square error*, RMSE):\n",
    "   $$ \\mathrm{RMSE} \\, = \\, \\sqrt{ \\frac{1}{m} \\sum_{i=1}^{m} \\left( \\hat{y}^{(i)} - y^{(i)} \\right)^2 } $$\n",
    " * błąd średniokwadratowy (*mean-square error*, MSE):\n",
    "   $$ \\mathrm{MSE} \\, = \\, \\frac{1}{m} \\sum_{i=1}^{m} \\left( \\hat{y}^{(i)} - y^{(i)} \\right)^2 $$\n",
    " * średni błąd bezwzględny (*mean absolute error*, MAE):\n",
    "   $$ \\mathrm{MAE} \\, = \\, \\frac{1}{m} \\sum_{i=1}^{m} \\left| \\hat{y}^{(i)} - y^{(i)} \\right| $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "W powyższych wzorach $y^{(i)}$ oznacza **oczekiwaną** wartości zmiennej $y$ w $i$-tym przykładzie, a $\\hat{y}^{(i)}$ oznacza wartość zmiennej $y$ w $i$-tym przykładzie wyliczoną (**przewidzianą**) przez nasz model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Metryki dla zadań klasyfikacji\n",
    "\n",
    "Aby przedstawić kilka najpopularniejszych metryk stosowanych dla zadań klasyfikacyjnych, posłużmy się następującym przykładem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Przydatne importy\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas\n",
    "import random\n",
    "import seaborn\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def powerme(x1,x2,n):\n",
    "    \"\"\"Funkcja, która generuje n potęg dla zmiennych x1 i x2 oraz ich iloczynów\"\"\"\n",
    "    X = []\n",
    "    for m in range(n+1):\n",
    "        for i in range(m+1):\n",
    "            X.append(np.multiply(np.power(x1,i),np.power(x2,(m-i))))\n",
    "    return np.hstack(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def plot_data_for_classification(X, Y, xlabel=None, ylabel=None, Y_predicted=[], highlight=None):\n",
    "    \"\"\"Wykres danych dla zadania klasyfikacji\"\"\"\n",
    "    fig = plt.figure(figsize=(16*.6, 9*.6))\n",
    "    ax = fig.add_subplot(111)\n",
    "    fig.subplots_adjust(left=0.1, right=0.9, bottom=0.1, top=0.9)\n",
    "    X = X.tolist()\n",
    "    Y = Y.tolist()\n",
    "    X1n = [x[1] for x, y in zip(X, Y) if y[0] == 0]\n",
    "    X1p = [x[1] for x, y in zip(X, Y) if y[0] == 1]\n",
    "    X2n = [x[2] for x, y in zip(X, Y) if y[0] == 0]\n",
    "    X2p = [x[2] for x, y in zip(X, Y) if y[0] == 1]\n",
    "    \n",
    "    if len(Y_predicted) > 0:\n",
    "        Y_predicted = Y_predicted.tolist()\n",
    "        X1tn = [x[1] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 0 and yp[0] == 0]\n",
    "        X1fn = [x[1] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 1 and yp[0] == 0]\n",
    "        X1tp = [x[1] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 1 and yp[0] == 1]\n",
    "        X1fp = [x[1] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 0 and yp[0] == 1]\n",
    "        X2tn = [x[2] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 0 and yp[0] == 0]\n",
    "        X2fn = [x[2] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 1 and yp[0] == 0]\n",
    "        X2tp = [x[2] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 1 and yp[0] == 1]\n",
    "        X2fp = [x[2] for x, y, yp in zip(X, Y, Y_predicted) if y[0] == 0 and yp[0] == 1]\n",
    "    \n",
    "        if highlight == 'tn':\n",
    "            ax.scatter(X1tn, X2tn, c='r', marker='x', s=100, label='Dane')\n",
    "            ax.scatter(X1fn, X2fn, c='k', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1tp, X2tp, c='k', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1fp, X2fp, c='k', marker='x', s=50, label='Dane')\n",
    "        elif highlight == 'fn':\n",
    "            ax.scatter(X1tn, X2tn, c='k', marker='x', s=50, label='Dane')\n",
    "            ax.scatter(X1fn, X2fn, c='g', marker='o', s=100, label='Dane')\n",
    "            ax.scatter(X1tp, X2tp, c='k', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1fp, X2fp, c='k', marker='x', s=50, label='Dane')\n",
    "        elif highlight == 'tp':\n",
    "            ax.scatter(X1tn, X2tn, c='k', marker='x', s=50, label='Dane')\n",
    "            ax.scatter(X1fn, X2fn, c='k', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1tp, X2tp, c='g', marker='o', s=100, label='Dane')\n",
    "            ax.scatter(X1fp, X2fp, c='k', marker='x', s=50, label='Dane')\n",
    "        elif highlight == 'fp':\n",
    "            ax.scatter(X1tn, X2tn, c='k', marker='x', s=50, label='Dane')\n",
    "            ax.scatter(X1fn, X2fn, c='k', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1tp, X2tp, c='k', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1fp, X2fp, c='r', marker='x', s=100, label='Dane')\n",
    "        else:\n",
    "            ax.scatter(X1tn, X2tn, c='r', marker='x', s=50, label='Dane')\n",
    "            ax.scatter(X1fn, X2fn, c='g', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1tp, X2tp, c='g', marker='o', s=50, label='Dane')\n",
    "            ax.scatter(X1fp, X2fp, c='r', marker='x', s=50, label='Dane')\n",
    "\n",
    "    else:\n",
    "        ax.scatter(X1n, X2n, c='r', marker='x', s=50, label='Dane')\n",
    "        ax.scatter(X1p, X2p, c='g', marker='o', s=50, label='Dane')\n",
    "    \n",
    "    if xlabel:\n",
    "        ax.set_xlabel(xlabel)\n",
    "    if ylabel:\n",
    "        ax.set_ylabel(ylabel)\n",
    "        \n",
    "    ax.margins(.05, .05)\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Wczytanie danych\n",
    "import pandas\n",
    "import numpy as np\n",
    "\n",
    "alldata = pandas.read_csv('data-metrics.tsv', sep='\\t')\n",
    "data = np.matrix(alldata)\n",
    "\n",
    "m, n_plus_1 = data.shape\n",
    "n = n_plus_1 - 1\n",
    "\n",
    "X2 = powerme(data[:, 1], data[:, 2], n)\n",
    "Y2 = np.matrix(data[:, 0]).reshape(m, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data_for_classification(X2, Y2, xlabel=r'$x_1$', ylabel=r'$x_2$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def safeSigmoid(x, eps=0):\n",
    "    \"\"\"Funkcja sigmoidalna zmodyfikowana w taki sposób, \n",
    "    żeby wartości zawsze były odległe od asymptot o co najmniej eps\n",
    "    \"\"\"\n",
    "    y = 1.0/(1.0 + np.exp(-x))\n",
    "    if eps > 0:\n",
    "        y[y < eps] = eps\n",
    "        y[y > 1 - eps] = 1 - eps\n",
    "    return y\n",
    "\n",
    "def h(theta, X, eps=0.0):\n",
    "    \"\"\"Funkcja hipotezy (regresja logistyczna)\"\"\"\n",
    "    return safeSigmoid(X*theta, eps)\n",
    "\n",
    "def J(h,theta,X,y, lamb=0):\n",
    "    \"\"\"Funkcja kosztu dla regresji logistycznej\"\"\"\n",
    "    m = len(y)\n",
    "    f = h(theta, X, eps=10**-7)\n",
    "    j = -np.sum(np.multiply(y, np.log(f)) + \n",
    "                np.multiply(1 - y, np.log(1 - f)), axis=0)/m\n",
    "    if lamb > 0:\n",
    "        j += lamb/(2*m) * np.sum(np.power(theta[1:],2))\n",
    "    return j\n",
    "\n",
    "def dJ(h,theta,X,y,lamb=0):\n",
    "    \"\"\"Gradient funkcji kosztu\"\"\"\n",
    "    g = 1.0/y.shape[0]*(X.T*(h(theta,X)-y))\n",
    "    if lamb > 0:\n",
    "        g[1:] += lamb/float(y.shape[0]) * theta[1:] \n",
    "    return g\n",
    "\n",
    "def classifyBi(theta, X):\n",
    "    \"\"\"Funkcja predykcji - klasyfikacja dwuklasowa\"\"\"\n",
    "    prob = h(theta, X)\n",
    "    return prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def GD(h, fJ, fdJ, theta, X, y, alpha=0.01, eps=10**-3, maxSteps=10000):\n",
    "    \"\"\"Metoda gradientu prostego dla regresji logistycznej\"\"\"\n",
    "    errorCurr = fJ(h, theta, X, y)\n",
    "    errors = [[errorCurr, theta]]\n",
    "    while True:\n",
    "        # oblicz nowe theta\n",
    "        theta = theta - alpha * fdJ(h, theta, X, y)\n",
    "        # raportuj poziom błędu\n",
    "        errorCurr, errorPrev = fJ(h, theta, X, y), errorCurr\n",
    "        # kryteria stopu\n",
    "        if abs(errorPrev - errorCurr) <= eps:\n",
    "            break\n",
    "        if len(errors) > maxSteps:\n",
    "            break\n",
    "        errors.append([errorCurr, theta]) \n",
    "    return theta, errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "theta = [[ 1.37136167]\n",
      " [ 0.90128948]\n",
      " [ 0.54708112]\n",
      " [-5.9929264 ]\n",
      " [ 2.64435168]\n",
      " [-4.27978238]]\n"
     ]
    }
   ],
   "source": [
    "# Uruchomienie metody gradientu prostego dla regresji logistycznej\n",
    "theta_start = np.matrix(np.zeros(X2.shape[1])).reshape(X2.shape[1],1)\n",
    "theta, errors = GD(h, J, dJ, theta_start, X2, Y2, \n",
    "                       alpha=0.1, eps=10**-7, maxSteps=10000)\n",
    "print('theta = {}'.format(theta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def plot_decision_boundary(fig, theta, X):\n",
    "    \"\"\"Wykres granicy klas\"\"\"\n",
    "    ax = fig.axes[0]\n",
    "    xx, yy = np.meshgrid(np.arange(-1.0, 1.0, 0.02),\n",
    "                         np.arange(-1.0, 1.0, 0.02))\n",
    "    l = len(xx.ravel())\n",
    "    C = powerme(xx.reshape(l, 1), yy.reshape(l, 1), n)\n",
    "    z = classifyBi(theta, C).reshape(int(np.sqrt(l)), int(np.sqrt(l)))\n",
    "\n",
    "    plt.contour(xx, yy, z, levels=[0.5], lw=3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Y_expected = Y2.astype(int)\n",
    "Y_predicted = (classifyBi(theta, X2) > 0.5).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Przygotowanie interaktywnego wykresu\n",
    "\n",
    "dropdown_highlight = widgets.Dropdown(options=['all', 'tp', 'fp', 'tn', 'fn'], value='all', description='highlight')\n",
    "\n",
    "def interactive_classification(highlight):\n",
    "    fig = plot_data_for_classification(X2, Y2, xlabel=r'$x_1$', ylabel=r'$x_2$',\n",
    "                                       Y_predicted=Y_predicted, highlight=highlight)\n",
    "    plot_decision_boundary(fig, theta, X2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c123102aea949478ef94b1b25f5e125",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='highlight', options=('all', 'tp', 'fp', 'tn', 'fn'), value='all'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.interactive_classification(highlight)>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "widgets.interact(interactive_classification, highlight=dropdown_highlight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zadanie klasyfikacyjne z powyższego przykładu polega na przypisaniu punktów do jednej z dwóch kategorii:\n",
    " 0. <font color=\"red\">czerwone krzyżyki</font>\n",
    " 1. <font color=\"green\">zielone kółka</font>\n",
    "\n",
    "W tym celu zastosowano regresję logistyczną."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "W rezultacie otrzymano model, który dzieli płaszczyznę na dwa obszary:\n",
    " 0. <font color=\"red\">na zewnątrz granatowej krzywej</font>\n",
    " 1. <font color=\"green\">wewnątrz granatowej krzywej</font>\n",
    " \n",
    "Model przewiduje klasę <font color=\"red\">0 („czerwoną”)</font> dla punktów znajdujący się w obszarze na zewnątrz krzywej, natomiast klasę <font color=\"green\">1 („zieloną”)</font> dla punktów znajdujących sie w obszarze wewnąrz krzywej."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Wszysktie obserwacje możemy podzielić zatem na cztery grupy:\n",
    " * **true positives (TP)** – prawidłowo sklasyfikowane pozytywne przykłady (<font color=\"green\">zielone kółka</font> w <font color=\"green\">wewnętrznym obszarze</font>)\n",
    " * **true negatives (TN)** – prawidłowo sklasyfikowane negatywne przykłady (<font color=\"red\">czerwone krzyżyki</font> w <font color=\"red\">zewnętrznym obszarze</font>)\n",
    " * **false positives (FP)** – negatywne przykłady sklasyfikowane jako pozytywne (<font color=\"red\">czerwone krzyżyki</font> w <font color=\"green\">wewnętrznym obszarze</font>)\n",
    " * **false negatives (FN)** – pozytywne przykłady sklasyfikowane jako negatywne (<font color=\"green\">zielone kółka</font> w <font color=\"red\">zewnętrznym obszarze</font>)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Innymi słowy:\n",
    "\n",
    "<img width=\"50%\" src=\"https://blog.aimultiple.com/wp-content/uploads/2019/07/positive-negative-true-false-matrix.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TP = 5\n",
      "TN = 35\n",
      "FP = 3\n",
      "FN = 6\n"
     ]
    }
   ],
   "source": [
    "# Obliczmy TP, TN, FP i FN\n",
    "\n",
    "tp = 0\n",
    "tn = 0\n",
    "fp = 0\n",
    "fn = 0\n",
    "\n",
    "for i in range(len(Y_expected)):\n",
    "    if Y_expected[i] == 1 and Y_predicted[i] == 1:\n",
    "        tp += 1\n",
    "    elif Y_expected[i] == 0 and Y_predicted[i] == 0:\n",
    "        tn += 1\n",
    "    elif Y_expected[i] == 0 and Y_predicted[i] == 1:\n",
    "        fp += 1\n",
    "    elif Y_expected[i] == 1 and Y_predicted[i] == 0:\n",
    "        fn += 1\n",
    "        \n",
    "print('TP =', tp)\n",
    "print('TN =', tn)\n",
    "print('FP =', fp)\n",
    "print('FN =', fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Możemy teraz zdefiniować następujące metryki:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Dokładność (*accuracy*)\n",
    "$$ \\mbox{accuracy} = \\frac{\\mbox{przypadki poprawnie sklasyfikowane}}{\\mbox{wszystkie przypadki}} = \\frac{TP + TN}{TP + TN + FP + FN} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Dokładność otrzymujemy przez podzielenie liczby przypadków poprawnie sklasyfikowanych przez liczbę wszystkich przypadków:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8163265306122449\n"
     ]
    }
   ],
   "source": [
    "accuracy = (tp + tn) / (tp + tn + fp + fn)\n",
    "print('Accuracy:', accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Uwaga:** Nie zawsze dokładność będzie dobrą miarą, zwłaszcza gdy klasy są bardzo asymetryczne!\n",
    "\n",
    "*Przykład:* Wyobraźmy sobie test na koronawirusa, który **zawsze** zwraca wynik negatywny. Jaką przydatność będzie miał taki test w praktyce? Żadną. A jaka będzie jego *dokładność*? Policzmy:\n",
    "$$ \\mbox{accuracy} \\, = \\, \\frac{\\mbox{szacowana liczba osób zdrowych na świecie}}{\\mbox{populacja Ziemi}} \\, \\approx \\, \\frac{7\\,700\\,000\\,000 - 600\\,000}{7\\,700\\,000\\,000} \\, \\approx \\, 0.99992 $$\n",
    "(zaokrąglone dane z 27 marca 2020)\n",
    "\n",
    "Powyższy wynik jest tak wysoki, ponieważ zdecydowana większość osób na świecie nie jest zakażona, więc biorąc losowego Ziemianina możemy w ciemno strzelać, że nie ma koronawirusa.\n",
    "\n",
    "W tym przypadku duża różnica w liczności obu zbiorów (zakażeni/niezakażeni) powoduje, że *accuracy* nie jest dobrą metryką.\n",
    "\n",
    "Dlatego dysponujemy również innymi metrykami:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Precyzja (*precision*)\n",
    "$$ \\mbox{precision} = \\frac{TP}{TP + FP} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0.625\n"
     ]
    }
   ],
   "source": [
    "precision = tp / (tp + fp)\n",
    "print('Precision:', precision)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Precyzja określa, jaka część przykładów sklasyfikowanych jako pozytywne to faktycznie przykłady pozytywne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Pokrycie (czułość, *recall*)\n",
    "$$ \\mbox{recall} = \\frac{TP}{TP + FN} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.45454545454545453\n"
     ]
    }
   ],
   "source": [
    "recall = tp / (tp + fn)\n",
    "print('Recall:', recall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Pokrycie mówi nam, jaka część przykładów pozytywnych została poprawnie sklasyfikowana."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### *$F$-measure* (*$F$-score*)\n",
    "$$ F = \\frac{2 \\cdot \\mbox{precision} \\cdot \\mbox{recall}}{\\mbox{precision} + \\mbox{recall}} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F-score: 0.5263157894736842\n"
     ]
    }
   ],
   "source": [
    "fscore = (2 * precision * recall) / (precision + recall)\n",
    "print('F-score:', fscore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "$F$-_measure_ jest kompromisem między precyzją a pokryciem (a ściślej: jest średnią harmoniczną precyzji i pokrycia)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$F$-_measure_ jest szczególnym przypadkiem ogólniejszej miary:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*$F_\\beta$-measure*:\n",
    "$$ F_\\beta = \\frac{(1 + \\beta) \\cdot \\mbox{precision} \\cdot \\mbox{recall}}{\\beta^2 \\cdot \\mbox{precision} + \\mbox{recall}} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dla $\\beta = 1$ otrzymujemy:\n",
    "$$ F_1 \\, = \\, \\frac{(1 + 1) \\cdot \\mbox{precision} \\cdot \\mbox{recall}}{1^2 \\cdot \\mbox{precision} + \\mbox{recall}} \\, = \\, \\frac{2 \\cdot \\mbox{precision} \\cdot \\mbox{recall}}{\\mbox{precision} + \\mbox{recall}} \\, = \\, F $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.3. Obserwacje odstające"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Obserwacje odstające** (*outliers*) – to wszelkie obserwacje posiadające nietypową wartość.\n",
    "\n",
    "Mogą być na przykład rezultatem błędnego pomiaru albo pomyłki przy wprowadzaniu danych do bazy, ale nie tylko.\n",
    "\n",
    "Obserwacje odstające mogą niekiedy znacząco wpłynąć na parametry modelu, dlatego ważne jest, żeby takie obserwacje odrzucić zanim przystąpi się do tworzenia modelu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "W poniższym przykładzie można zobaczyć wpływ obserwacji odstających na wynik modelowania na przykładzie danych dotyczących cen mieszkań zebranych z ogłoszeń na portalu Gratka.pl: tutaj przykładem obserwacji odstającej może być ogłoszenie, w którym podano cenę w tys. zł zamiast ceny w zł."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Przydatne funkcje\n",
    "\n",
    "def h_linear(Theta, x):\n",
    "    \"\"\"Funkcja regresji liniowej\"\"\"\n",
    "    return x * Theta\n",
    "\n",
    "def linear_regression(theta):\n",
    "    \"\"\"Ta funkcja zwraca funkcję regresji liniowej dla danego wektora parametrów theta\"\"\"\n",
    "    return lambda x: h_linear(theta, x)\n",
    "\n",
    "def cost(theta, X, y):\n",
    "    \"\"\"Wersja macierzowa funkcji kosztu\"\"\"\n",
    "    m = len(y)\n",
    "    J = 1.0 / (2.0 * m) * ((X * theta - y).T * (X * theta - y))\n",
    "    return J.item()\n",
    "\n",
    "def gradient(theta, X, y):\n",
    "    \"\"\"Wersja macierzowa gradientu funkcji kosztu\"\"\"\n",
    "    return 1.0 / len(y) * (X.T * (X * theta - y)) \n",
    "\n",
    "def gradient_descent(fJ, fdJ, theta, X, y, alpha=0.1, eps=10**-5):\n",
    "    \"\"\"Algorytm gradientu prostego (wersja macierzowa)\"\"\"\n",
    "    current_cost = fJ(theta, X, y)\n",
    "    logs = [[current_cost, theta]]\n",
    "    while True:\n",
    "        theta = theta - alpha * fdJ(theta, X, y)\n",
    "        current_cost, prev_cost = fJ(theta, X, y), current_cost\n",
    "        if abs(prev_cost - current_cost) > 10**15:\n",
    "            print('Algorithm does not converge!')\n",
    "            break\n",
    "        if abs(prev_cost - current_cost) <= eps:\n",
    "            break\n",
    "        logs.append([current_cost, theta]) \n",
    "    return theta, logs\n",
    "\n",
    "def plot_data(X, y, xlabel, ylabel):\n",
    "    \"\"\"Wykres danych (wersja macierzowa)\"\"\"\n",
    "    fig = plt.figure(figsize=(16*.6, 9*.6))\n",
    "    ax = fig.add_subplot(111)\n",
    "    fig.subplots_adjust(left=0.1, right=0.9, bottom=0.1, top=0.9)\n",
    "    ax.scatter([X[:, 1]], [y], c='r', s=50, label='Dane')\n",
    "    \n",
    "    ax.set_xlabel(xlabel)\n",
    "    ax.set_ylabel(ylabel)\n",
    "    ax.margins(.05, .05)\n",
    "    plt.ylim(y.min() - 1, y.max() + 1)\n",
    "    plt.xlim(np.min(X[:, 1]) - 1, np.max(X[:, 1]) + 1)\n",
    "    return fig\n",
    "\n",
    "def plot_regression(fig, fun, theta, X):\n",
    "    \"\"\"Wykres krzywej regresji (wersja macierzowa)\"\"\"\n",
    "    ax = fig.axes[0]\n",
    "    x0 = np.min(X[:, 1]) - 1.0\n",
    "    x1 = np.max(X[:, 1]) + 1.0\n",
    "    L = [x0, x1]\n",
    "    LX = np.matrix([1, x0, 1, x1]).reshape(2, 2)\n",
    "    ax.plot(L, fun(theta, LX), linewidth='2',\n",
    "            label=(r'$y={theta0:.2}{op}{theta1:.2}x$'.format(\n",
    "                theta0=float(theta[0][0]),\n",
    "                theta1=(float(theta[1][0]) if theta[1][0] >= 0 else float(-theta[1][0])),\n",
    "                op='+' if theta[1][0] >= 0 else '-')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Wczytanie danych (mieszkania) przy pomocy biblioteki pandas\n",
    "\n",
    "alldata = pandas.read_csv('data_flats_with_outliers.tsv', sep='\\t',\n",
    "                         names=['price', 'isNew', 'rooms', 'floor', 'location', 'sqrMetres'])\n",
    "data = np.matrix(alldata[['price', 'sqrMetres']])\n",
    "\n",
    "m, n_plus_1 = data.shape\n",
    "n = n_plus_1 - 1\n",
    "Xn = data[:, 0:n]\n",
    "\n",
    "Xo = np.matrix(np.concatenate((np.ones((m, 1)), Xn), axis=1)).reshape(m, n + 1)\n",
    "yo = np.matrix(data[:, -1]).reshape(m, 1)\n",
    "\n",
    "Xo /= np.amax(Xo, axis=0)\n",
    "yo /= np.amax(yo, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data(Xo, yo, xlabel=u'metraż', ylabel=u'cena')\n",
    "theta_start = np.matrix([0.0, 0.0]).reshape(2, 1)\n",
    "theta, logs = gradient_descent(cost, gradient, theta_start, Xo, yo, alpha=0.01)\n",
    "plot_regression(fig, h_linear, theta, Xo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Na powyższym przykładzie obserwacja odstająca jawi sie jako pojedynczy punkt po prawej stronie wykresu. Widzimy, że otrzymana krzywa regresji zamiast odwzorowywać ogólny trend, próbuje „dopasować się” do tej pojedynczej obserwacji.\n",
    "\n",
    "Dlatego taką obserwację należy usunąć ze zbioru danych (zobacz ponizej)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Odrzućmy obserwacje odstające\n",
    "alldata_no_outliers = [\n",
    "    (index, item) for index, item in alldata.iterrows() \n",
    "    if item.price > 100 and item.sqrMetres > 10]\n",
    "\n",
    "alldata_no_outliers = alldata.loc[(alldata['price'] > 100) & (alldata['sqrMetres'] > 100)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "data = np.matrix(alldata_no_outliers[['price', 'sqrMetres']])\n",
    "\n",
    "m, n_plus_1 = data.shape\n",
    "n = n_plus_1 - 1\n",
    "Xn = data[:, 0:n]\n",
    "\n",
    "Xo = np.matrix(np.concatenate((np.ones((m, 1)), Xn), axis=1)).reshape(m, n + 1)\n",
    "yo = np.matrix(data[:, -1]).reshape(m, 1)\n",
    "\n",
    "Xo /= np.amax(Xo, axis=0)\n",
    "yo /= np.amax(yo, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data(Xo, yo, xlabel=u'metraż', ylabel=u'cena')\n",
    "theta_start = np.matrix([0.0, 0.0]).reshape(2, 1)\n",
    "theta, logs = gradient_descent(cost, gradient, theta_start, Xo, yo, alpha=0.01)\n",
    "plot_regression(fig, h_linear, theta, Xo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Na powyższym wykresie widać, że po odrzuceniu obserwacji odstających otrzymujemy dużo bardziej „wiarygodną” krzywą regresji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.4. Problem nadmiernego dopasowania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Obciążenie a wariancja"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Dane do prostego przykładu\n",
    "\n",
    "data = np.matrix([\n",
    "        [0.0, 0.0],\n",
    "        [0.5, 1.8],\n",
    "        [1.0, 4.8],\n",
    "        [1.6, 7.2],\n",
    "        [2.6, 8.8],\n",
    "        [3.0, 9.0],\n",
    "    ])\n",
    "\n",
    "m, n_plus_1 = data.shape\n",
    "n = n_plus_1 - 1\n",
    "Xn1 = data[:, 0:n]\n",
    "Xn1 /= np.amax(Xn1, axis=0)\n",
    "Xn2 = np.power(Xn1, 2) \n",
    "Xn2 /= np.amax(Xn2, axis=0)\n",
    "Xn3 = np.power(Xn1, 3) \n",
    "Xn3 /= np.amax(Xn3, axis=0)\n",
    "Xn4 = np.power(Xn1, 4) \n",
    "Xn4 /= np.amax(Xn4, axis=0)\n",
    "Xn5 = np.power(Xn1, 5) \n",
    "Xn5 /= np.amax(Xn5, axis=0)\n",
    "\n",
    "X1 = np.matrix(np.concatenate((np.ones((m, 1)), Xn1), axis=1)).reshape(m, n + 1)\n",
    "X2 = np.matrix(np.concatenate((np.ones((m, 1)), Xn1, Xn2), axis=1)).reshape(m, 2 * n + 1)\n",
    "X5 = np.matrix(np.concatenate((np.ones((m, 1)), Xn1, Xn2, Xn3, Xn4, Xn5), axis=1)).reshape(m, 5 * n + 1)\n",
    "y = np.matrix(data[:, -1]).reshape(m, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data(X1, y, xlabel='x', ylabel='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Funkcja regresji wielomianowej\n",
    "\n",
    "def h_poly(Theta, x):\n",
    "    \"\"\"Funkcja wielomianowa\"\"\"\n",
    "    return sum(theta * np.power(x, i) for i, theta in enumerate(Theta.tolist()))\n",
    "\n",
    "def polynomial_regression(theta):\n",
    "    \"\"\"Funkcja regresji wielomianowej\"\"\"\n",
    "    return lambda x: h_poly(theta, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def plot_fun(fig, fun, X):\n",
    "    \"\"\"Wykres funkcji `fun`\"\"\"\n",
    "    ax = fig.axes[0]\n",
    "    x0 = np.min(X[:, 1]) - 1.0\n",
    "    x1 = np.max(X[:, 1]) + 1.0\n",
    "    Arg = np.arange(x0, x1, 0.1)\n",
    "    Val = fun(Arg)\n",
    "    return ax.plot(Arg, Val, linewidth='2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22ab32eac70>]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data(X1, y, xlabel='x', ylabel='y')\n",
    "theta_start = np.matrix([0, 0]).reshape(2, 1)\n",
    "theta, _ = gradient_descent(cost, gradient, theta_start, X1, y, eps=0.00001)\n",
    "plot_fun(fig, polynomial_regression(theta), X1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Ten model ma duże **obciążenie** (**błąd systematyczny**, *bias*) – zachodzi **niedostateczne dopasowanie** (*underfitting*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22ab32723d0>]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data(X2, y, xlabel='x', ylabel='y')\n",
    "theta_start = np.matrix([0, 0, 0]).reshape(3, 1)\n",
    "theta, _ = gradient_descent(cost, gradient, theta_start, X2, y, eps=0.000001)\n",
    "plot_fun(fig, polynomial_regression(theta), X1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ten model jest odpowiednio dopasowany."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x22ab32cebe0>]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 691.2x388.8 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_data(X5, y, xlabel='x', ylabel='y')\n",
    "theta_start = np.matrix([0, 0, 0, 0, 0, 0]).reshape(6, 1)\n",
    "theta, _ = gradient_descent(cost, gradient, theta_start, X5, y, alpha=0.5, eps=10**-7)\n",
    "plot_fun(fig, polynomial_regression(theta), X1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ten model ma dużą **wariancję** (*variance*) – zachodzi **nadmierne dopasowanie** (*overfitting*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "(Zwróć uwagę na dziwny kształt krzywej w lewej części wykresu – to m.in. efekt nadmiernego dopasowania)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Nadmierne dopasowanie występuje, gdy model ma zbyt dużo stopni swobody w stosunku do ilości danych wejściowych.\n",
    "\n",
    "Jest to zjawisko niepożądane.\n",
    "\n",
    "Możemy obrazowo powiedzieć, że nadmierne dopasowanie występuje, gdy model zaczyna modelować szum/zakłócenia w danych zamiast ich „głównego nurtu”. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Zobacz też: https://pl.wikipedia.org/wiki/Nadmierne_dopasowanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img style=\"margin:auto\" width=\"90%\" src=\"fit.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Obciążenie (błąd systematyczny, *bias*)\n",
    "\n",
    "* Wynika z błędnych założeń co do algorytmu uczącego się.\n",
    "* Duże obciążenie powoduje niedostateczne dopasowanie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Wariancja (*variance*)\n",
    "\n",
    "* Wynika z nadwrażliwości na niewielkie fluktuacje w zbiorze uczącym.\n",
    "* Wysoka wariancja może spowodować nadmierne dopasowanie (modelując szum zamiast sygnału)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img style=\"margin:auto\" width=\"60%\" src=\"bias2.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img style=\"margin:auto\" width=\"60%\" src=\"curves.jpg\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.5. Regularyzacja"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def SGD(h, fJ, fdJ, theta, X, Y, \n",
    "        alpha=0.001, maxEpochs=1.0, batchSize=100, \n",
    "        adaGrad=False, logError=False, validate=0.0, valStep=100, lamb=0, trainsetsize=1.0):\n",
    "    \"\"\"Stochastic Gradient Descent - stochastyczna wersja metody gradientu prostego\n",
    "    \"\"\"\n",
    "    errorsX, errorsY = [], []\n",
    "    errorsVX, errorsVY = [], []\n",
    "    \n",
    "    XT, YT = X, Y\n",
    "    \n",
    "    m_end=int(trainsetsize*len(X))\n",
    "    \n",
    "    if validate > 0:\n",
    "        mv = int(X.shape[0] * validate)\n",
    "        XV, YV = X[:mv], Y[:mv] \n",
    "        XT, YT = X[mv:m_end], Y[mv:m_end] \n",
    "    m, n = XT.shape\n",
    "\n",
    "    start, end = 0, batchSize\n",
    "    maxSteps = (m * float(maxEpochs)) / batchSize\n",
    "    \n",
    "    if adaGrad:\n",
    "        hgrad = np.matrix(np.zeros(n)).reshape(n,1)\n",
    "    \n",
    "    for i in range(int(maxSteps)):\n",
    "        XBatch, YBatch =  XT[start:end,:], YT[start:end,:]\n",
    "\n",
    "        grad = fdJ(h, theta, XBatch, YBatch, lamb=lamb)\n",
    "        if adaGrad:\n",
    "            hgrad += np.multiply(grad, grad)\n",
    "            Gt = 1.0 / (10**-7 + np.sqrt(hgrad))\n",
    "            theta = theta - np.multiply(alpha * Gt, grad)\n",
    "        else:\n",
    "            theta = theta - alpha * grad\n",
    "        \n",
    "        if logError:\n",
    "            errorsX.append(float(i*batchSize)/m)\n",
    "            errorsY.append(fJ(h, theta, XBatch, YBatch).item())\n",
    "            if validate > 0 and i % valStep == 0:\n",
    "                errorsVX.append(float(i*batchSize)/m)\n",
    "                errorsVY.append(fJ(h, theta, XV, YV).item())\n",
    "        \n",
    "        if start + batchSize < m:\n",
    "            start += batchSize\n",
    "        else:\n",
    "            start = 0\n",
    "        end = min(start + batchSize, m)\n",
    "    return theta, (errorsX, errorsY, errorsVX, errorsVY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# Przygotowanie danych do przykładu regularyzacji\n",
    "\n",
    "n = 6\n",
    "\n",
    "data = np.matrix(np.loadtxt(\"ex2data2.txt\", delimiter=\",\"))\n",
    "np.random.shuffle(data)\n",
    "\n",
    "X = powerme(data[:,0], data[:,1], n)\n",
    "Y = data[:,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def draw_regularization_example(X, Y, lamb=0, alpha=1, adaGrad=True, maxEpochs=2500, validate=0.25):\n",
    "    \"\"\"Rusuje przykład regularyzacji\"\"\"\n",
    "    plt.figure(figsize=(16,8))\n",
    "    plt.subplot(121)\n",
    "    plt.scatter(X[:, 2].tolist(), X[:, 1].tolist(),\n",
    "                c=Y.tolist(),\n",
    "                s=100, cmap=plt.cm.get_cmap('prism'));\n",
    "\n",
    "    theta = np.matrix(np.zeros(X.shape[1])).reshape(X.shape[1],1)\n",
    "    thetaBest, err = SGD(h, J, dJ, theta, X, Y, alpha=alpha, adaGrad=adaGrad, maxEpochs=maxEpochs, batchSize=100, \n",
    "                         logError=True, validate=validate, valStep=1, lamb=lamb)\n",
    "\n",
    "    xx, yy = np.meshgrid(np.arange(-1.5, 1.5, 0.02),\n",
    "                         np.arange(-1.5, 1.5, 0.02))\n",
    "    l = len(xx.ravel())\n",
    "    C = powerme(xx.reshape(l, 1),yy.reshape(l, 1), n)\n",
    "    z = classifyBi(thetaBest, C).reshape(int(np.sqrt(l)), int(np.sqrt(l)))\n",
    "\n",
    "    plt.contour(xx, yy, z, levels=[0.5], lw=3);\n",
    "    plt.ylim(-1,1.2);\n",
    "    plt.xlim(-1,1.2);\n",
    "    plt.legend();\n",
    "    plt.subplot(122)\n",
    "    plt.plot(err[0],err[1], lw=3, label=\"Training error\")\n",
    "    if validate > 0:\n",
    "        plt.plot(err[2],err[3], lw=3, label=\"Validation error\");\n",
    "    plt.legend()\n",
    "    plt.ylim(0.2,0.8);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-7-09634685a32b>:5: RuntimeWarning: overflow encountered in exp\n",
      "  y = 1.0/(1.0 + np.exp(-x))\n",
      "<ipython-input-16-f0220c89a5e3>:19: UserWarning: The following kwargs were not used by contour: 'lw'\n",
      "  plt.contour(xx, yy, z, levels=[0.5], lw=3);\n",
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_regularization_example(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Regularyzacja\n",
    "\n",
    "Regularyzacja jest metodą zapobiegania zjawisku nadmiernego dopasowania (*overfitting*) poprzez odpowiednie zmodyfikowanie funkcji kosztu.\n",
    "\n",
    "Do funkcji kosztu dodawane jest specjalne wyrażenie (**wyrazenie regularyzacyjne** – zaznaczone na czerwono w poniższych wzorach), będące „karą” za ekstremalne wartości parametrów $\\theta$.\n",
    "\n",
    "W ten sposób preferowane są wektory $\\theta$ z mniejszymi wartosciami parametrów – mają automatycznie niższy koszt.\n",
    "\n",
    "Jak silną regularyzację chcemy zastosować? Możemy o tym zadecydować, dobierajac odpowiednio **parametr regularyzacji** $\\lambda$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Regularyzacja dla regresji liniowej – funkcja kosztu\n",
    "\n",
    "$$\n",
    "J(\\theta) \\, = \\, \\dfrac{1}{2m} \\left( \\displaystyle\\sum_{i=1}^{m} h_\\theta(x^{(i)}) - y^{(i)} \\color{red}{ + \\lambda \\displaystyle\\sum_{j=1}^{n} \\theta^2_j } \\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* $\\lambda$ – parametr regularyzacji\n",
    "* jeżeli $\\lambda$ jest zbyt mały, skutkuje to nadmiernym dopasowaniem\n",
    "* jeżeli $\\lambda$ jest zbyt duży, skutkuje to niedostatecznym dopasowaniem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Regularyzacja dla regresji liniowej – gradient\n",
    "\n",
    "$$\\small\n",
    "\\begin{array}{llll}\n",
    "\\dfrac{\\partial J(\\theta)}{\\partial \\theta_0} &=& \\dfrac{1}{m}\\displaystyle\\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)})-y^{(i)} \\right) x^{(i)}_0 & \\textrm{dla $j = 0$ }\\\\\n",
    "\\dfrac{\\partial J(\\theta)}{\\partial \\theta_j} &=& \\dfrac{1}{m}\\displaystyle\\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)})-y^{(i)} \\right) x^{(i)}_j \\color{red}{+ \\dfrac{\\lambda}{m}\\theta_j} & \\textrm{dla $j = 1, 2, \\ldots, n $} \\\\\n",
    "\\end{array} \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Regularyzacja dla regresji logistycznej – funkcja kosztu\n",
    "\n",
    "$$\n",
    "\\begin{array}{rtl}\n",
    "J(\\theta) & = & -\\dfrac{1}{m} \\left( \\displaystyle\\sum_{i=1}^{m} y^{(i)} \\log h_\\theta(x^{(i)}) + \\left( 1-y^{(i)} \\right) \\log \\left( 1-h_\\theta(x^{(i)}) \\right) \\right) \\\\\n",
    "& & \\color{red}{ + \\dfrac{\\lambda}{2m} \\displaystyle\\sum_{j=1}^{n} \\theta^2_j } \\\\\n",
    "\\end{array}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Regularyzacja dla regresji logistycznej – gradient\n",
    "\n",
    "$$\\small\n",
    "\\begin{array}{llll}\n",
    "\\dfrac{\\partial J(\\theta)}{\\partial \\theta_0} &=& \\dfrac{1}{m}\\displaystyle\\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)})-y^{(i)} \\right) x^{(i)}_0 & \\textrm{dla $j = 0$ }\\\\\n",
    "\\dfrac{\\partial J(\\theta)}{\\partial \\theta_j} &=& \\dfrac{1}{m}\\displaystyle\\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)})-y^{(i)} \\right) x^{(i)}_j \\color{red}{+ \\dfrac{\\lambda}{m}\\theta_j} & \\textrm{dla $j = 1, 2, \\ldots, n $} \\\\\n",
    "\\end{array} \n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Implementacja metody regularyzacji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def J_(h,theta,X,y,lamb=0):\n",
    "    \"\"\"Funkcja kosztu z regularyzacją\"\"\"\n",
    "    m = float(len(y))\n",
    "    f = h(theta, X, eps=10**-7)\n",
    "    j = 1.0/m \\\n",
    "        * -np.sum(np.multiply(y, np.log(f)) + \n",
    "                  np.multiply(1 - y, np.log(1 - f)), axis=0) \\\n",
    "        + lamb/(2*m) * np.sum(np.power(theta[1:] ,2))\n",
    "    return j\n",
    "\n",
    "def dJ_(h,theta,X,y,lamb=0):\n",
    "    \"\"\"Gradient funkcji kosztu z regularyzacją\"\"\"\n",
    "    m = float(y.shape[0])\n",
    "    g = 1.0/y.shape[0]*(X.T*(h(theta,X)-y))\n",
    "    g[1:] += lamb/m * theta[1:]\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "slider_lambda = widgets.FloatSlider(min=0.0, max=0.5, step=0.005, value=0.01, description=r'$\\lambda$', width=300)\n",
    "\n",
    "def slide_regularization_example_2(lamb):\n",
    "    draw_regularization_example(X, Y, lamb=lamb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "31bdaaf0f30746aaa35b7342ef3c3b46",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.01, description='$\\\\lambda$', max=0.5, step=0.005), Button(descripti…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.slide_regularization_example_2(lamb)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "widgets.interact_manual(slide_regularization_example_2, lamb=slider_lambda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def cost_lambda_fun(lamb):\n",
    "    \"\"\"Koszt w zależności od parametru regularyzacji lambda\"\"\"\n",
    "    theta = np.matrix(np.zeros(X.shape[1])).reshape(X.shape[1],1)\n",
    "    thetaBest, err = SGD(h, J, dJ, theta, X, Y, alpha=1, adaGrad=True, maxEpochs=2500, batchSize=100, \n",
    "                         logError=True, validate=0.25, valStep=1, lamb=lamb)\n",
    "    return err[1][-1], err[3][-1]\n",
    "\n",
    "def plot_cost_lambda():\n",
    "    \"\"\"Wykres kosztu w zależności od parametru regularyzacji lambda\"\"\"\n",
    "    plt.figure(figsize=(16,8))\n",
    "    ax = plt.subplot(111)\n",
    "    Lambda = np.arange(0.0, 1.0, 0.01)\n",
    "    Costs = [cost_lambda_fun(lamb) for lamb in Lambda]\n",
    "    CostTrain = [cost[0] for cost in Costs]\n",
    "    CostCV = [cost[1] for cost in Costs]\n",
    "    plt.plot(Lambda, CostTrain, lw=3, label='training error')\n",
    "    plt.plot(Lambda, CostCV, lw=3, label='validation error')\n",
    "    ax.set_xlabel(r'$\\lambda$')\n",
    "    ax.set_ylabel(u'cost')\n",
    "    plt.legend()\n",
    "    plt.ylim(0.2,0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_cost_lambda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.6. Krzywa uczenia się"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Krzywa uczenia pozwala sprawdzić, czy uczenie przebiega poprawnie.\n",
    "* Krzywa uczenia to wykres zależności między wielkością zbioru treningowego a wartością funkcji kosztu.\n",
    "* Wraz ze wzrostem wielkości zbioru treningowego wartość funkcji kosztu na zbiorze treningowym rośnie.\n",
    "* Wraz ze wzrostem wielkości zbioru treningowego wartość funkcji kosztu na zbiorze walidacyjnym maleje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def cost_trainsetsize_fun(m):\n",
    "    \"\"\"Koszt w zależności od wielkości zbioru uczącego\"\"\"\n",
    "    theta = np.matrix(np.zeros(X.shape[1])).reshape(X.shape[1],1)\n",
    "    thetaBest, err = SGD(h, J, dJ, theta, X, Y, alpha=1, adaGrad=True, maxEpochs=2500, batchSize=100, \n",
    "                         logError=True, validate=0.25, valStep=1, lamb=0.01, trainsetsize=m)\n",
    "    return err[1][-1], err[3][-1]\n",
    "\n",
    "def plot_learning_curve():\n",
    "    \"\"\"Wykres krzywej uczenia się\"\"\"\n",
    "    plt.figure(figsize=(16,8))\n",
    "    ax = plt.subplot(111)\n",
    "    M = np.arange(0.3, 1.0, 0.05)\n",
    "    Costs = [cost_trainsetsize_fun(m) for m in M]\n",
    "    CostTrain = [cost[0] for cost in Costs]\n",
    "    CostCV = [cost[1] for cost in Costs]\n",
    "    plt.plot(M, CostTrain, lw=3, label='training error')\n",
    "    plt.plot(M, CostCV, lw=3, label='validation error')\n",
    "    ax.set_xlabel(u'trainset size')\n",
    "    ax.set_ylabel(u'cost')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Krzywa uczenia a obciążenie i wariancja\n",
    "\n",
    "Wykreślenie krzywej uczenia pomaga diagnozować nadmierne i niedostateczne dopasowanie:\n",
    "\n",
    "<img width=\"100%\" src=\"learning-curves.png\"/>\n",
    "\n",
    "Źródło: http://www.ritchieng.com/machinelearning-learning-curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    " * Gdy model jest nadmiernie dopasowany, zebranie większej ilości danych uczących może pomóc.\n",
    " * Gdy model jest niedostatecznie dopasowany, pomóc może zwiększenie liczby stopni swobody modelu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learning_curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.7. Warianty metody gradientu prostego\n",
    "\n",
    "* Batch gradient descent\n",
    "* Stochastic gradient descent\n",
    "* Mini-batch gradient descent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### _Batch gradient descent_\n",
    "\n",
    "* Klasyczna wersja metody gradientu prostego\n",
    "* Obliczamy gradient funkcji kosztu względem całego zbioru treningowego:\n",
    "  $$ \\theta := \\theta - \\alpha \\cdot \\nabla_\\theta J(\\theta) $$\n",
    "* Dlatego może działać bardzo powoli\n",
    "* Nie można dodawać nowych przykładów na bieżąco w trakcie trenowania modelu (*online learning*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### *Stochastic gradient descent* (SGD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Algorytm\n",
    "\n",
    "Powtórz określoną liczbę razy (liczba epok):\n",
    "  1. Randomizuj dane treningowe\n",
    "  1. Powtórz dla każdego przykładu $i = 1, 2, \\ldots, m$:\n",
    "    $$ \\theta := \\theta - \\alpha \\cdot \\nabla_\\theta \\, J \\! \\left( \\theta, x^{(i)}, y^{(i)} \\right) $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Randomizacja danych** to losowe potasowanie przykładów uczących (wraz z odpowiedziami)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### SGD - zalety\n",
    "\n",
    "* Dużo szybszy niż _batch gradient descent_\n",
    "* Można dodawać nowe przykłady na bieżąco w trakcie trenowania (*online learning*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### SGD\n",
    "\n",
    "* Częsta aktualizacja parametrów z dużą wariancją:\n",
    "\n",
    "<img src=\"http://ruder.io/content/images/2016/09/sgd_fluctuation.png\" style=\"margin: auto;\" width=\"50%\" />\n",
    "\n",
    "* Z jednej strony dzięki temu nie utyka w złych minimach lokalnych, ale z drugiej strony może „wyskoczyć” z dobrego minimum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### _Mini-batch gradient descent_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Algorytm\n",
    "\n",
    "1. Ustal rozmiar \"paczki/wsadu\" (*batch*) $b \\leq m$.\n",
    "2. Powtórz określoną liczbę razy (liczba epok):\n",
    "  1. Powtórz dla każdego batcha (czyli dla $i = 1, 1 + b, 1 + 2 b, \\ldots$):\n",
    "  $$ \\theta := \\theta - \\alpha \\cdot \\nabla_\\theta \\, J \\left( \\theta, x^{(i : i+b)}, y^{(i : i+b)} \\right) $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### _Mini-batch gradient descent_\n",
    "\n",
    "* Kompromis między _batch gradient descent_ i SGD\n",
    "* Stabilniejsza zbieżność dzięki redukcji wariancji aktualizacji parametrów\n",
    "* Szybszy niż klasyczny _batch gradient descent_\n",
    "* Typowa wielkość batcha: między kilka a kilkaset przykładów\n",
    "  * Im większy batch, tym bliżej do BGD; im mniejszy batch, tym bliżej do SGD\n",
    "  * BGD i SGD można traktować jako odmiany MBGD dla $b = m$ i $b = 1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# Mini-batch gradient descent - przykładowa implementacja\n",
    "\n",
    "def MiniBatchSGD(h, fJ, fdJ, theta, X, y, \n",
    "        alpha=0.001, maxEpochs=1.0, batchSize=100, \n",
    "        logError=True):\n",
    "    errorsX, errorsY = [], []\n",
    "    \n",
    "    m, n = X.shape\n",
    "    start, end = 0, batchSize\n",
    "    \n",
    "    maxSteps = (m * float(maxEpochs)) / batchSize\n",
    "    for i in range(int(maxSteps)):\n",
    "        XBatch, yBatch =  X[start:end,:], y[start:end,:]\n",
    "\n",
    "        theta = theta - alpha * fdJ(h, theta, XBatch, yBatch)\n",
    "        \n",
    "        if logError:\n",
    "            errorsX.append(float(i*batchSize)/m)\n",
    "            errorsY.append(fJ(h, theta, XBatch, yBatch).item())\n",
    "        \n",
    "        if start + batchSize < m:\n",
    "            start += batchSize\n",
    "        else:\n",
    "            start = 0\n",
    "        end = min(start + batchSize, m)\n",
    "        \n",
    "    return theta, (errorsX, errorsY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Porównanie uśrednionych krzywych uczenia na przykładzie klasyfikacji dwuklasowej zbioru [MNIST](https://en.wikipedia.org/wiki/MNIST_database):\n",
    "\n",
    "<img src=\"sgd-comparison.png\" width=\"70%\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Wady klasycznej metody gradientu prostego, czyli dlaczego potrzebujemy optymalizacji\n",
    "\n",
    "* Trudno dobrać właściwą szybkość uczenia (*learning rate*)\n",
    "* Jedna ustalona wartość stałej uczenia się dla wszystkich parametrów\n",
    "* Funkcja kosztu dla sieci neuronowych nie jest wypukła, więc uczenie może utknąć w złym minimum lokalnym lub punkcie siodłowym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.8. Algorytmy optymalizacji metody gradientu\n",
    "\n",
    "* Momentum\n",
    "* Nesterov Accelerated Gradient\n",
    "* Adagrad\n",
    "* Adadelta\n",
    "* RMSprop\n",
    "* Adam\n",
    "* Nadam\n",
    "* AMSGrad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Momentum\n",
    "\n",
    "* SGD źle radzi sobie w „wąwozach” funkcji kosztu\n",
    "* Momentum rozwiązuje ten problem przez dodanie współczynnika $\\gamma$, który można trakować jako „pęd” spadającej piłki:\n",
    "  $$ v_t := \\gamma \\, v_{t-1} + \\alpha \\, \\nabla_\\theta J(\\theta) $$\n",
    "  $$ \\theta := \\theta - v_t $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Przyspiesony gradient Nesterova (*Nesterov Accelerated Gradient*, NAG)\n",
    "\n",
    "* Momentum czasami powoduje niekontrolowane rozpędzanie się piłki, przez co staje się „mniej sterowna”\n",
    "* Nesterov do piłki posiadającej pęd dodaje „hamulec”, który spowalnia piłkę przed wzniesieniem:\n",
    "  $$ v_t := \\gamma \\, v_{t-1} + \\alpha \\, \\nabla_\\theta J(\\theta - \\gamma \\, v_{t-1}) $$\n",
    "  $$ \\theta := \\theta - v_t $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Adagrad\n",
    "\n",
    "* “<b>Ada</b>ptive <b>grad</b>ient”\n",
    "* Adagrad dostosowuje współczynnik uczenia (*learning rate*) do wartości parametrów modelu\n",
    "* Świetny do trenowania na rzadkich (*sparse*) zbiorach danych\n",
    "* Wada: współczynnik uczenia może czasami gwałtownie maleć\n",
    "* Wyniki badań pokazują, że często **starannie** dobrane $\\alpha$ daje lepsze wyniki na zbiorze testowym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Adadelta i RMSprop\n",
    "* Warianty algorytmu Adagrad, które radzą sobie z problemem gwałtownych zmian współczynnika uczenia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Adam\n",
    "\n",
    "* “<b>Ada</b>ptive <b>m</b>oment estimation”\n",
    "* Łączy zalety algorytmów RMSprop i Momentum\n",
    "* Można go porównać do piłki mającej ciężar i opór\n",
    "* Obecnie jeden z najpopularniejszych algorytmów optymalizacji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Nadam\n",
    "* “<b>N</b>esterov-accelerated <b>ada</b>ptive <b>m</b>oment estimation”\n",
    "* Łączy zalety algorytmów Adam i Nesterov Accelerated Gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### AMSGrad\n",
    "* Wariant algorytmu Adam lepiej dostosowany do zadań takich jak rozpoznawanie obiektów czy tłumaczenie maszynowe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"contours_evaluation_optimizers.gif\" style=\"margin: auto;\" width=\"80%\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"saddle_point_evaluation_optimizers.gif\" style=\"margin: auto;\" width=\"80%\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3.9. Metody zbiorcze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    " * **Metody zbiorcze** (*ensemble methods*) używają połączonych sił wielu modeli uczenia maszynowego w celu uzyskania lepszej skuteczności niż mogłaby być osiągnięta przez każdy z tych modeli z osobna."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    " * Na metodę zbiorczą składa się:\n",
    "   * dobór modeli\n",
    "   * sposób agregacji wyników"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    " * Warto zastosować randomizację, czyli przetasować zbiór uczący przed trenowaniem każdego modelu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Uśrednianie prawdopodobieństw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Przykład\n",
    "\n",
    "Mamy 3 modele, które dla klas $c=1, 2, 3, 4, 5$ zwróciły prawdopodobieństwa:\n",
    "\n",
    "* $M_1$: [0.10, 0.40, **0.50**, 0.00, 0.00]\n",
    "* $M_2$: [0.10, **0.60**, 0.20, 0.00, 0.10]\n",
    "* $M_3$: [0.10, 0.30, **0.40**, 0.00, 0.20]\n",
    "\n",
    "Która klasa zostanie wybrana według średnich prawdopodobieństw dla każdej klasy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Średnie prawdopodobieństwo: [0.10, **0.43**, 0.36, 0.00, 0.10]\n",
    "\n",
    "Została wybrana klasa $c = 2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Głosowanie klas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Przykład\n",
    "\n",
    "Mamy 3 modele, które dla klas $c=1, 2, 3, 4, 5$ zwróciły prawdopodobieństwa:\n",
    "\n",
    "* $M_1$: [0.10, 0.40, **0.50**, 0.00, 0.00]\n",
    "* $M_2$: [0.10, **0.60**, 0.20, 0.00, 0.10]\n",
    "* $M_3$: [0.10, 0.30, **0.40**, 0.00, 0.20]\n",
    "\n",
    "Która klasa zostanie wybrana według głosowania?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Liczba głosów: [0, 1, **2**, 0, 0]\n",
    "\n",
    "Została wybrana klasa $c = 3$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Inne metody zbiorcze\n",
    "\n",
    " * Bagging\n",
    " * Boostng\n",
    " * Stacking\n",
    " \n",
    "https://towardsdatascience.com/ensemble-methods-bagging-boosting-and-stacking-c9214a10a205"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.8.3"
  },
  "livereveal": {
   "start_slideshow_at": "selected",
   "theme": "white"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}