09

wyk/09_Rekurencyjny_model_jezyka.ipynb

@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model języka oparty na rekurencyjnej sieci neuronowej\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Podejście rekurencyjne\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Na poprzednim wykładzie rozpatrywaliśmy różne funkcje\n",
+    "$A(w_1,\\dots,w_{i-1})$, dzięki którym możliwe było „skompresowanie” ciągu słów\n",
+    "(a właściwie ich zanurzeń) o dowolnej długości w wektor o stałej długości.\n",
+    "\n",
+    "Funkcję $A$ moglibyśmy zdefiniować w inny sposób, w sposób ****rekurencyjny****.\n",
+    "\n",
+    "Otóż moglibyśmy zdekomponować funkcję $A$ do\n",
+    "\n",
+    "-   pewnego stanu początkowego $\\vec{s_0} \\in \\mathcal{R}^p$,\n",
+    "-   pewnej funkcji rekurencyjnej $R : \\mathcal{R}^p \\times \\mathcal{R}^m \\rightarrow \\mathcal{R}^p$.\n",
+    "\n",
+    "Wówczas funkcję $A$ można będzie zdefiniować rekurencyjnie jako:\n",
+    "\n",
+    "$$A(w_1,\\dots,w_t) = R(A(w_1,\\dots,w_{t-1}), E(w_t)),$$\n",
+    "\n",
+    "przy czym dla ciągu pustego:\n",
+    "\n",
+    "$$A(\\epsilon) = \\vec{s_0}$$\n",
+    "\n",
+    "Przypomnijmy, że $m$ to rozmiar zanurzenia (embeddingu). Z kolei $p$ to rozmiar wektora stanu\n",
+    "(często $p=m$, ale nie jest to konieczne).\n",
+    "\n",
+    "Przy takim podejściu rekurencyjnym wprowadzamy niejako „strzałkę\n",
+    "czasu”, możemy mówić o przetwarzaniu krok po kroku.\n",
+    "\n",
+    "W wypadku modelowania języka możemy końcowy wektor stanu zrzutować do wektora o rozmiarze słownika\n",
+    "i zastosować softmax:\n",
+    "\n",
+    "$$\\vec{y} = \\operatorname{softmax}(CA(w_1,\\dots,w_{i-1})),$$\n",
+    "\n",
+    "gdzie $C$ jest wyuczalną macierzą o rozmiarze $|V| \\times p$.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Worek słów zdefiniowany rekurencyjnie\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nietrudno zdefiniować model „worka słów” w taki rekurencyjny sposób:\n",
+    "\n",
+    "-   $p=m$,\n",
+    "-   $\\vec{s_0} = [0,\\dots,0]$,\n",
+    "-   $R(\\vec{s}, \\vec{x}) = \\vec{s} + \\vec{x}.$\n",
+    "\n",
+    "Dodawanie (również wektorowe) jest operacją przemienną i łączną, więc\n",
+    "to rekurencyjne spojrzenie niewiele tu wnosi. Można jednak zastosować\n",
+    "inną funkcję $R$, która nie jest przemienna — w ten sposób wyjdziemy poza\n",
+    "nieuporządkowany worek słów.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Związek z programowaniem funkcyjnym\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Zauważmy, że stosowane tutaj podejście jest tożsame z zastosowaniem funkcji typu `fold`\n",
+    "w językach funkcyjnych:\n",
+    "\n",
+    "![img](./09_Rekurencyjny_model_jezyka/fold.png \"Opis funkcji foldl w języku Haskell\")\n",
+    "\n",
+    "W Pythonie odpowiednik `fold` jest funkcja `reduce` z pakietu `functools`:\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "18"
+     ]
+    }
+   ],
+   "source": [
+    "from functools import reduce\n",
+    "\n",
+    "def product(ns):\n",
+    "  return reduce(lambda a, b: a * b, ns, 1)\n",
+    "\n",
+    "product([2, 3, 1, 3])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sieci rekurencyjne\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "W jaki sposób „złamać” przemienność i wprowadzić porządek? Jedną z\n",
+    "najprostszych operacji nieprzemiennych jest konkatenacja — możemy\n",
+    "dokonać konkatenacji wektora stanu i bieżącego stanu, a następnie\n",
+    "zastosować jakąś prostą operację (na wyjściu musimy mieć wektor o\n",
+    "rozmiarze $p$, nie $p + m$!), dobrze przy okazji „złamać” też\n",
+    "liniowość operacji. Możemy po prostu zastosować rzutowanie (mnożenie\n",
+    "przez macierz) i jakąś prostą funkcję aktywacji (na przykład sigmoidę):\n",
+    "\n",
+    "$$R(\\vec{s}, \\vec{e}) = \\sigma(W[\\vec{s},\\vec{e}] + \\vec{b}).$$\n",
+    "\n",
+    "Dodatkowo jeszcze wprowadziliśmy wektor obciążeń $\\vec{b}$, a zatem wyuczalne wagi obejmują:\n",
+    "\n",
+    "-   macierz $W \\in \\mathcal{R}^p \\times \\mathcal{R}^{p+m}$,\n",
+    "-   wektor obciążeń  $b \\in \\mathcal{R}^p$.\n",
+    "\n",
+    "Olbrzymią zaletą sieci rekurencyjnych jest fakt, że liczba wag nie zależy od rozmiaru wejścia!\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Zwykła sieć rekurencyjna\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wyżej zdefiniową sieć nazywamy „zwykłą” siecią rekurencyjną (*Vanilla RNN*).\n",
+    "\n",
+    "**Uwaga**: przez RNN czasami rozumie się taką „zwykłą” sieć\n",
+    "rekurencyjną, a czasami szerszą klasę sieci rekurencyjnych\n",
+    "obejmujących również sieci GRU czy LSTM (zob. poniżej).\n",
+    "\n",
+    "![img](./09_Rekurencyjny_model_jezyka/rnn.drawio.png \"Schemat prostego modelu języka opartego na zwykłej sieci rekurencyjnych\")\n",
+    "\n",
+    "**Uwaga**: powyższy schemat nie obejmuje już „całego” działania sieci,\n",
+    " tylko pojedynczy krok czasowy.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Praktyczna niestosowalność prostych sieci RNN\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Niestety w praktyce proste sieci RNN sprawiają duże trudności jeśli\n",
+    "chodzi o propagację wsteczną — pojawia się zjawisko zanikającego\n",
+    "(rzadziej: eksplodującego) gradientu. Dlatego zaproponowano różne\n",
+    "modyfikacje sieci RNN. Zacznijmy od omówienia stosunkowo prostej sieci GRU.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sieć GRU\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "GRU (*Gated Recurrent Unit*) to sieć z dwiema ****bramkami**** (*gates*):\n",
+    "\n",
+    "-   bramką resetu (*reset gate*) $\\Gamma_\\gamma \\in \\mathcal{R}^p$ — która określa, w jakim\n",
+    "    stopniu sieć ma pamiętać albo zapominać stan z poprzedniego kroku,\n",
+    "-   bramką aktualizacji (*update gate*) $\\Gamma_u \\in \\mathcal{R}^p$ — która określa wpływ\n",
+    "    bieżącego wyrazu na zmianę stanu.\n",
+    "\n",
+    "Tak więc w skrajnym przypadku:\n",
+    "\n",
+    "-   jeśli $\\Gamma_\\gamma = [0,\\dots,0]$, sieć całkowicie zapomina\n",
+    "    informację płynącą z poprzednich wyrazów,\n",
+    "-   jeśli $\\Gamma_u = [0,\\dots,0]$, sieć nie bierze pod uwagę\n",
+    "    bieżącego wyrazu.\n",
+    "\n",
+    "Zauważmy, że bramki mogą selektywnie, na każdej pozycji wektora stanu,\n",
+    "sterować przepływem informacji. Na przykład $\\Gamma_\\gamma =\n",
+    "[0,1,\\dots,1]$ oznacza, że pierwsza pozycja wektora stanu jest\n",
+    "zapominana, a pozostałe — wnoszą wkład w całości.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Wzory\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Najpierw zdefiniujmy pośredni stan $\\vec{\\xi} \\in \\mathcal{R}^p$:\n",
+    "\n",
+    "$$\\vec{\\xi_t} = \\operatorname{tanh}(W_{\\xi}[\\Gamma_\\gamma \\bullet c_{t-1}, E(w_t)] + b_{\\xi}),$$\n",
+    "\n",
+    "gdzie $\\bullet$ oznacza iloczyn Hadamarda (nie iloczyn skalarny!) dwóch wektorów:\n",
+    "\n",
+    "$$[x_1,\\dots,x_n] \\bullet [y_1,\\dots,y_n] = [x_1 y_1,\\dots,x_n y_n].$$\n",
+    "\n",
+    "Obliczanie $\\vec{\\xi_t}$ bardzo przypomina zwykłą sieć rekurencyjną,\n",
+    "jedyna różnica polega na tym, że za pomocą bramki $\\Gamma_\\gamma$\n",
+    "modulujemy wpływ poprzedniego stanu.\n",
+    "\n",
+    "Ostateczna wartość stanu jest średnią ważoną poprzedniego stanu i bieżącego stanu pośredniego:\n",
+    "\n",
+    "$$\\vec{c_t} = \\Gamma_u \\bullet \\vec{\\xi_t} + (1 - \\Gamma_u) \\bullet \\vec{c_{t-1}}.$$\n",
+    "\n",
+    "Skąd się biorą bramki $\\Gamma_\\gamma$ i $\\Gamma_u$? Również z poprzedniego stanu i z biężacego wyrazu.\n",
+    "\n",
+    "$$\\Gamma_\\gamma = \\sigma(W_\\gamma[\\vec{c_{t-1}},E(w_t)] + b_\\gamma),$$\n",
+    "\n",
+    "$$\\Gamma_u = \\sigma(W_u[\\vec{c_{t-1}},E(w_t)] + b_u),$$\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3"
+  },
+  "org": null
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}