Up

wyk/11_rnn.org

@@ -87,7 +87,7 @@ $$s^k = \sigma(W\langle\vec{v}(t^k), \vec{s^{k-1}}\rangle + \vec{b}),$$
 gdzie:
 
 - $\langle\vec{x},\vec{y}\rangle$ to konkatenacja dwóch wektorów,
-- $W \in \mathcal{R}^m \times \mathcal{R}^{n+m} $ — macierz wag,
+- $W \in \mathcal{R}^m \times \mathcal{R}^{n+m}$ — macierz wag,
 - $b \in \mathcal{R}^m$ — wektor obciążeń (/biases/).
 
 Taką sieć RNN można przedstawić schematycznie w następujący sposób:
@@ -181,7 +181,7 @@ selektywnie wygaszać pozycje wektora, np. tutaj wyzerowaliśmy 2. i 5. pozycję
 
 Co więcej, za pomocą bramki możemy selektywnie kontrolować, co
 zapamiętujemy, a co zapominamy. Rozpatrzmy mianowicie wektor zer i
-jedynek $\vec{g} \in \{0,1}^m$, dla stanu (pamięci) $\vec{s}$ i nowej informacji
+jedynek $\vec{g} \in \{0,1\}^m$, dla stanu (pamięci) $\vec{s}$ i nowej informacji
 $\vec{x}$ możemy dokonywać aktualizacji w następujący sposób:
 
 $$\vec{s} \leftarrow \vec{g} \odot \vec{x} + (1 - \vec{g}) \odot \vec{s}$$
@@ -259,7 +259,7 @@ $$\vec{i} = \sigma(W_i\langle\vec{v}(t^k),\vec{h^{k-1}}\rangle)$$
 
 $$\vec{f} = \sigma(W_f\langle\vec{v}(t^k),\vec{h^{k-1}}\rangle)$$
 
-$$\vec{o} = \sigma(W_f\langle\vec{v}(t^k),\vec{h^{k-1}}\rangle)$$
+$$\vec{o} = \sigma(W_o\langle\vec{v}(t^k),\vec{h^{k-1}}\rangle)$$
 
 Jak widać, wzory różnią się tylko macierzami wag $W_*$.
 
@@ -279,10 +279,10 @@ Ostateczne wyjście może być wyliczane na podstawie wektora $\vec{h^k}$:
 
 $$O(\vec{s}) = O(\langle\vec{c},\vec{h}\rangle) = \vec{h}$$
 
-*Pytanie*: Ile wag/parametrów ma sieć RNN o rozmiarze wejścia $n$ i
+*Pytanie*: Ile wag/parametrów ma sieć RNN o rozmiarze wejścia $n$ i rozmiarze warstwy ukrytej $m$?
 
 
 ** Literatura
 
-Yoav Goldberg, /Neural Network Methods for Natural Language
+Yoav Goldberg, /Neural Network Methods for Natural Language Processing/,
-Processing/, Morgan & Claypool Publishers, 2017
+Morgan & Claypool Publishers, 2017

wyk/12_bpe.org

@@ -36,7 +36,7 @@ Ile jest różnych form fleksyjnych w języku polskim? Zobaczmy w słowniku Poli
 
 Tak naprawdę form jest jeszcze więcej, oczywiście PoliMorf nie wyczerpuje zbioru…
 
-*Pytanie* Podaj przykłady „oczywistych” wyrazów, których w PoliMorfie. Jak w sposób systematyczny szukać takich wyrazów?
+*Pytanie* Podaj przykłady „oczywistych” wyrazów, których nie ma w PoliMorfie. Jak w sposób systematyczny szukać takich wyrazów?
 
 Z drugiej strony, w PoliMorfie jest dużo dziwnych, „sztucznych” wyrazów.
 
@@ -244,7 +244,7 @@ momentu traktujemy go jako całostkę (wkładamy go do „pudełka”).
 
 #+RESULTS:
 :results:
-# Out[4]:
+# Out[1]:
 : ['e$', 'to', 'to$', 'be$', 't$', 'th', 'or', 'or$', 'no', 'not$']
 :end:
 
@@ -256,13 +256,17 @@ na którym słownik był wyuczony:
      d = list(d.replace(' ', '$') + '$')
      vocab_set = set(vocab)
 
-     ix = 0
+     modified = True
-     while ix < len(d) - 1:
+     while modified:
-         bigram = d[ix] + d[ix+1]
+         ix = 0
-         if bigram in vocab_set:
+         modified = False
-             d[ix:ix+2] = [bigram]
+         while ix < len(d) - 1:
-         else:
+             bigram = d[ix] + d[ix+1]
-             ix += 1
+             if bigram in vocab_set:
+                 d[ix:ix+2] = [bigram]
+                 modified = True
+             else:
+                 ix += 1
 
      return d
 
@@ -272,7 +276,7 @@ na którym słownik był wyuczony:
 #+RESULTS:
 :results:
 # Out[5]:
-: 'to$ b e$ or$ no t$ to$ b e$ th a t$ i s $ th e$ q u e s t i o n $'
+: 'to$ be$ or$ not$ to$ be$ th a t$ i s $ th e$ q u e s t i o n $'
 :end:
 
 Zauważmy, że oprócz jednostek podwyrazowych zostały izolowane litery,
@@ -289,6 +293,12 @@ Słownik jednostek podwyrazowych można stosować dla dowolnego tekstu:
 ' '.join(apply_bpe_vocab(vocab1, 'tom will be the best'))
 #+END_SRC
 
+#+RESULTS:
+:results:
+# Out[6]:
+: 'to m $ w i l l $ be$ th e$ b e s t$'
+:end:
+
 Jak można zauważyć algorytm BPE daje dwa rodzaje jednostek podwyrazowych:
 
 - jednostki, które mogą doklejane na początku wyrazu;

wyk/13_generative_approach.ipynb

@@ -1 +1,113 @@
-{"cells":[{"cell_type":"markdown","metadata":{},"source":["## Ekstrakcja informacji a podejście generatywne\n\n"]},{"cell_type":"markdown","metadata":{},"source":["### Podejście generatywne\n\n"]},{"cell_type":"markdown","metadata":{},"source":["Do tej pory zadanie ekstrakcji informacji traktowaliśmy jako zadanie etykietowania sekwencji, tzn. uczyliśmy system zaznaczać tokeny składające się na ekstrahowane informacje.\n\n![img](./ie-seqlab.png)\n\nMożliwe jest inne podeście, **generatywne**, w którym podchodzimy do problemu ekstrakcji informacji jak do swego rodzaju **tłumaczenia maszynowego** — „tłumaczymy” tekst (wraz z pytaniem lub etykietą) na informację.\n\n![img](./ie-gener.png)\n\nTo podejście może się wydawać trudniejsze niż etykietowanie sekwencji, ale wystarczająco zaawansowanej architekturze sieci, jest wykonalne.\n\nZalety:\n\n-   informacja nie musi być dosłownie zapisana w tekście, ekstraktor może nauczyć się również normalizacji czy parafrazowania,\n-   nie wprowadzamy wielu kroków przetwarzania (gdzie błędy mogą się\n    namnażać), system działa na zasadzie *end-to-end*.\n\n"]},{"cell_type":"markdown","metadata":{},"source":["### Atencja\n\n"]},{"cell_type":"markdown","metadata":{},"source":["Pierwsze systemu neuronowego tłumaczenia maszynowego używały siecie LSTM. Dopiero jednak dodanie tzw. atencji (*attention*) umożliwiło duży przeskok jakościowy. Najpierw atencję dodano do sieci rekurencyjnych, później powstały sieci oparte *wyłącznie* na atencji — modele Transformer.\n\nIdea atencji polega na tym, że sieć może kierować selektywnie „snop” uwagi na wyrazy na wejściu lub do tej pory wygenerowane wyrazy.\n\nMechanizm atencji korzysta z:\n\n-   z poprzedniego stanu sieci $\\vec{s^{k-1}}$ (to jest „miejsce”, z którego „kierujemy” atencję),\n-   z wektora reprezentującego słowo $\\vec{v}(t_i)$ (to jest „miejsce”, na które kierujemy atencję), gdzie\n    $\\vec{v}(t_i)$ to reprezentacja wektorowa wyrazu $t_i$ (statyczny embedding lub reprezentacja wektorowa\n    z poprzedniej warstwy dla sieci wielowarstwowej),\n\naby wytworzyć wektor kontekstu $\\vec{\\xi^k}$ (który z kolei będzie w jakiś sposób wnosił wkład do wyliczenia nowej wartości stanu $\\vec{s^k}$ lub wyjścia $y^k$.\n\nNajpierw wyliczymy skalarne wartości atencji, tzn. liczby, które będą sygnalizowały, jak bardzo wektor $\\vec{v}(t_i)$ „pasuje” do $\\vec{s^{k-1}}$, w najprostszej wersji można po prostu skorzystać z iloczynu skalarnego (o ile $n=m$),\n\n$$a(\\vec{s^{k-1}}, \\vec{v}(t_i)) = \\vec{s^{k-1}}\\vec{v}(t_i).$$\n\n**Pytanie**: co jeśli $n$ nie jest równe $m$, tzn. rozmiar embeddingu nie jest równy rozmiarowi wektora stanu?\n\nW przypadku sieci LSTM korzysta się częściej z bardziej skomplikowanego wzoru zawierającego dodatkowe wyuczalne wagi:\n\n$$a(\\vec{s^{k-1}}, \\vec{v}(t_i)) = \\vec{w_a}\\operatorname{tanh}(W_a\\vec{s^{k-1}} + U_a\\vec{v}(t_i))$$\n\n**Pytanie**: jakie rozmiary mają macierze $W_a$, $U_a$ i wektor $w_a$?\n\nPowtórzmy, że wartości $a$ są wartościami skalarnymi, natomiast nie są one znormalizowane (nie sumują się do jedynki), normalizujemy je używając schematu podobnego do softmaxa:\n\n$$\\alpha_{i} = \\frac{e^{a(\\vec{s^{k-1}}, \\vec{v}(t_i))}}{\\sum_j e^{a(\\vec{s^{k-1}}, \\vec{v}(t_j))}}$$\n\nWektor kontekstu $\\vec{\\xi^k}$ będzie po prostu średnią ważoną wektorowych reprezentacji słów:\n\n$$\\vec{\\xi^k} = \\sum_i \\alpha_i\\vec{v}(t_i)$$\n\n**Pytanie**: zasadniczo atencja jest środkiem do celu (żeby sieć się sprawniej uczyła), czy można atencja sama w sobie może być do czegoś przydatna?\n\n"]}],"metadata":{"org":null,"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.5.2"}},"nbformat":4,"nbformat_minor":0}
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Ekstrakcja informacji a podejście generatywne\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Podejście generatywne\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Do tej pory zadanie ekstrakcji informacji traktowaliśmy jako zadanie etykietowania sekwencji, tzn. uczyliśmy system zaznaczać tokeny składające się na ekstrahowane informacje.\n",
+    "\n",
+    "![img](./ie-seqlab.png)\n",
+    "\n",
+    "Możliwe jest inne podeście, **generatywne**, w którym podchodzimy do problemu ekstrakcji informacji jak do swego rodzaju **tłumaczenia maszynowego** — „tłumaczymy” tekst (wraz z pytaniem lub etykietą) na informację.\n",
+    "\n",
+    "![img](./ie-gener.png)\n",
+    "\n",
+    "To podejście może się wydawać trudniejsze niż etykietowanie sekwencji, ale wystarczająco zaawansowanej architekturze sieci, jest wykonalne.\n",
+    "\n",
+    "Zalety:\n",
+    "\n",
+    "-   informacja nie musi być dosłownie zapisana w tekście, ekstraktor może nauczyć się również normalizacji czy parafrazowania,\n",
+    "-   nie wprowadzamy wielu kroków przetwarzania (gdzie błędy mogą się\n",
+    "    namnażać), system działa na zasadzie *end-to-end*.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Atencja\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pierwsze systemu neuronowego tłumaczenia maszynowego używały siecie LSTM. Dopiero jednak dodanie tzw. atencji (*attention*) umożliwiło duży przeskok jakościowy. Najpierw atencję dodano do sieci rekurencyjnych, później powstały sieci oparte *wyłącznie* na atencji — modele Transformer.\n",
+    "\n",
+    "Idea atencji polega na tym, że sieć może kierować selektywnie „snop” uwagi na wyrazy na wejściu lub do tej pory wygenerowane wyrazy.\n",
+    "\n",
+    "Mechanizm atencji korzysta z:\n",
+    "\n",
+    "-   z poprzedniego stanu sieci $\\vec{s^{k-1}}$ (to jest „miejsce”, z którego „kierujemy” atencję),\n",
+    "-   z wektora reprezentującego słowo $\\vec{v}(t_i)$ (to jest „miejsce”, na które kierujemy atencję), gdzie\n",
+    "    $\\vec{v}(t_i)$ to reprezentacja wektorowa wyrazu $t_i$ (statyczny embedding lub reprezentacja wektorowa\n",
+    "    z poprzedniej warstwy dla sieci wielowarstwowej),\n",
+    "\n",
+    "aby wytworzyć wektor kontekstu $\\vec{\\xi^k}$ (który z kolei będzie w jakiś sposób wnosił wkład do wyliczenia nowej wartości stanu $\\vec{s^k}$ lub wyjścia $y^k$.\n",
+    "\n",
+    "Najpierw wyliczymy skalarne wartości atencji, tzn. liczby, które będą sygnalizowały, jak bardzo wektor $\\vec{v}(t_i)$ „pasuje” do $\\vec{s^{k-1}}$, w najprostszej wersji można po prostu skorzystać z iloczynu skalarnego (o ile $n=m$),\n",
+    "\n",
+    "$$a(\\vec{s^{k-1}}, \\vec{v}(t_i)) = \\vec{s^{k-1}}\\vec{v}(t_i).$$\n",
+    "\n",
+    "**Pytanie**: co jeśli $n$ nie jest równe $m$, tzn. rozmiar embeddingu nie jest równy rozmiarowi wektora stanu?\n",
+    "\n",
+    "W przypadku sieci LSTM korzysta się częściej z bardziej skomplikowanego wzoru zawierającego dodatkowe wyuczalne wagi:\n",
+    "\n",
+    "$$a(\\vec{s^{k-1}}, \\vec{v}(t_i)) = \\vec{w_a}\\operatorname{tanh}(W_a\\vec{s^{k-1}} + U_a\\vec{v}(t_i))$$\n",
+    "\n",
+    "**Pytanie**: jakie rozmiary mają macierze $W_a$, $U_a$ i wektor $w_a$?\n",
+    "\n",
+    "Powtórzmy, że wartości $a$ są wartościami skalarnymi, natomiast nie są one znormalizowane (nie sumują się do jedynki), normalizujemy je używając schematu podobnego do softmaxa:\n",
+    "\n",
+    "$$\\alpha_{i} = \\frac{e^{a(\\vec{s^{k-1}}, \\vec{v}(t_i))}}{\\sum_j e^{a(\\vec{s^{k-1}}, \\vec{v}(t_j))}}$$\n",
+    "\n",
+    "Wektor kontekstu $\\vec{\\xi^k}$ będzie po prostu średnią ważoną wektorowych reprezentacji słów:\n",
+    "\n",
+    "$$\\vec{\\xi^k} = \\sum_i \\alpha_i\\vec{v}(t_i)$$\n",
+    "\n",
+    "**Pytanie**: zasadniczo atencja jest środkiem do celu (żeby sieć się sprawniej uczyła), czy można atencja sama w sobie może być do czegoś przydatna?\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.9.2"
+  },
+  "org": null
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}