{
 "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",
    " * błąd średniokwadratowy (*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",
    " * ś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": 43,
   "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": 44,
   "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": 45,
   "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": 46,
   "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": 47,
   "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": 48,
   "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": 49,
   "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": 50,
   "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": 51,
   "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": 52,
   "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": 53,
   "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": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f6877198a304e40b7c159f189c4277a",
       "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": 54,
     "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": {},
   "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": {},
   "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": 55,
   "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": 56,
   "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": 57,
   "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": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-48-09634685a32b>:5: RuntimeWarning: overflow encountered in exp\n",
      "  y = 1.0/(1.0 + np.exp(-x))\n",
      "<ipython-input-57-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": 59,
   "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": 60,
   "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": 61,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e49f6a277b3d4b378df0c46330a07094",
       "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": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "widgets.interact_manual(slide_regularization_example_2, lamb=slider_lambda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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": 62,
   "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": 40,
   "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": 41,
   "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 parametrów: zmniejsza go dla cech występujących częściej, a zwiększa dla występujących rzadziej:\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
}