全7回 + 演習

毎日 20:00~ (初回のみ21:00~)

第1回 6/20: 学習
第2回 6/21: 勾配降下法
第3回 6/23: 自動微分とPyTorch
第4回 6/27: ニューラルネットワークの構造
第5回 6/28: ニューラルネットワークの学習と評価
第6回 6/30: ニューラルネットワークの実装
第7回 7/04: ニューラルネットワーク発展

機械学習は非常に広大な分野 ⇨ 全7回ではちょっと限界がある

今回の講習会ではディープラーニングについて扱います

• ツールを触るだけで原理は全然やらない
• 原理をやるだけで全然使えない

にならないようにどちらもバランス良くやります

第1回: 学習
第2回: 勾配降下法
第3回: 自動微分とPyTorch

第4回: ニューラルネットワークの構造
第5回: ニューラルネットワークの学習と評価
第6回: ニューラルネットワークの実装

第7回: ニューラルネットワーク発展

Pythonを使います

自分のPCにインストール or
Google Colaboratoryなどを利用

Pythonを使った初歩的なプログラミング

• if文, for文, 関数 など
• 外部パッケージの利用

(そこまで高度なことはやりません)

数学の初歩的な知識

• 基本的な行列の演算や操作
• 基本的な微分積分の知識(偏微分など)

abap34

• 情報工学系B2
• Kaggle部部長

内容の議論・チェックなど

• 23B kobakosくん
• 22M YumizSuiさん
• 22M idatenさん
• 22M Silviaseさん

ありがとうございます

Wuff

• テキストを書くとこの画面に流れます
• 匿名なのでお気軽にどうぞ

#workshop/machine-learning/sodan

• traQの相談チャンネル #event/workshop/sodan

ありとあらゆるところにお気軽になんでも書いてください！
timesに書くときはしれっと「機械学習講習会の...が...」みたいにワードを入れてもらえれば拾います！

前提として、大変

1. 講義パートで引っかかったら秒で書き込みましょう！(traQでもwuffでも)
2. 演習パートでは、5分わからなかったら質問してもらって大丈夫です！

もっと大前提として、質問は迷惑ではないです！
(むしろ聞いてもらえているということなので、うれしい)

(ここだけの話、機械学習はめちゃくちゃおもしろい)

全7回、がんばりましょう！！

今日の目次

1. 機械学習 or AI?
2. 二つの変数の関係を予想しよう ~アイスの売り上げ予測~
3. モデルとパラメータ
4. 「いいモデル」とは？　損失関数の登場

今日の目標

機械学習モデルを構築する上での基本的な用語を整理して、
「学習」ということばをきちんと説明できるようになる。

• ChatGPT
  自然な対話応答

• Stable Diffusion
  お絵描き

• GitHub Copilot
  プログラミング

etc...

• AI(人工知能)
  「人間っぽい知能」を実現しようとする分野・あるいは知能そのもの

• 機械学習(Machine Learning, ML)　
  様々な情報から「学習」をして動作するアルゴリズム
  人工知能の一つのかたちと見られることが多い

⬇︎

機械学習 $\subset$ 人工知能
( $\leftrightarrow$ スーパーカー $\subset$ 地上をめっちゃ速く走る )

ここでは一つの定義を紹介しましたが、実際この二つの言葉に明確に定義や合意があるわけではないです。
なので人工知能か人工知能でないか、機械学習かそうではないか、みたいな議論はやや不毛そうです。

• 機械学習(Machine Learning, ML)　
  様々な情報から「学習」をして動作するアルゴリズム

↑ 学習って何？

今日のテーマ:

「学習」を説明できるようになる

• 気温↑　→　売れそう
• 気温↓　→　売れなさそう

「アイスの売り上げ」は「気温」からある程度わかりそう？

< 来月の売り上げが予想できたらどのくらい牛乳仕入れたらいいかわかって嬉しいな。

データは https://okumuralab.org/~okumura/stat/160118.html　から引用

< なんか来月の予想平均気温30度って気象庁が言ってたな。

< !!!!!

< 過去に30℃のときは...

一番簡単な方法: 過去の全く同じ状況を参照する

< ガハハ！これでアイスの売り上げを予測するAIの完成や！

<そのまた来月の予想平均気温は40℃です。

< !?

< 40℃ないやんけ

「予測」 ... 入力から出力を求める
今回は、「入力: 気温」 → 「出力: アイスの売り上げ」

　入力は知ってるものだけとは限らない

← こいつが本当にやらなくてはいけなかったことは...

売り上げ = $f$(気温)となる関数$f$の推定

このような、入力データを受け取り結果を返す$f$をモデルと呼びます。
(厳密に数学的な意味の関数である必要はない)

売り上げ = $f$(気温)となる関数$f$が、

$f$(気温) = $a \times$気温 + $b$

のかたちで表させると仮定して、$a$と$b$を求める。

例) $a = 20$, $b=100$ なら
アイスの売り上げ $= f$(気温) = $20 \times$気温 + $100$

ためしてみる

< わるくないね

ためしてみる2 ... $a = -30$, $b=400$

< 帰れ

$a, b$を変えることでモデルの具体的な形が変わった！

このように各モデルが固有に持ってモデル自身の性質を定める
数を、「パラメータ」という。

⬇︎

は、$f$の構造を決めておけば...

「$f$の推定 $\leftrightarrow$ $f$のパラメータの推定」

• アイスの売り上げを予測するには、気温から売り上げを予測する
  「関数」を構築するのが必要であった。
• 今回は関数の形として $f(x) = ax + b$ (一次関数)を仮定して、
  「関数」を求めることにした。
• この関数は、パラメータとして$a, b$をもち、$a, b$を変えることで
  性質が変わるのがわかった。
• $a,b$を定めることで具体的に関数が定まる。

休憩します！！

• アイスの売り上げを予測するには、気温から売り上げを予測する
  「関数」を構築するのが必要であった。
• 今回は関数の形として $f(x) = ax + b$ (一次関数)を仮定して、
  「関数」を求めることにした。
• この関数は、パラメータとして$a, b$をもち、$a, b$を変えることで
  性質が変わるのがわかった。
• $a,b$を定めることで具体的に関数が定まる。

⬇︎

$a, b$を決めよう！

< わるくないね

< ちょっといい？

「良さ」とはなにか？

↓

「悪くなさ」

↓

「悪さ」とはなにか？

↓

「データと予測の遠さ」！

平均二乗誤差(Mean Squared Error)

$$\dfrac{1}{n}\sum_{i=0}^{n-1} \ (y_i - f(x_i))^2$$

「悪さ」の指標を「損失関数」という

学習 ...

「損失関数」を最小にする$f$のパラメータを見つける

(どんな複雑な$f$でも共通！！！！)

「悪さ」を最小化するのではなく「良さ」を最大化すれば良くない？と思った人もいるかもしれないですね。
実はそれはものすごくいい疑問で、次回以降で明らかになっていきます。
ひとまずは一旦疑問として抱えておいてください。

損失は何の関数？

各$x_i, y_i$は変数みたいな見た目だが、損失関数を考えるときは定数

$$L(???) = \dfrac{1}{n}\sum_{i=0}^{n-1} \ (y_i - f(x_i))^2$$

$$L(a, b) = \dfrac{1}{n}\sum_{i=0}^{n-1} \ (y_i - f(x_i; a, b))^2$$

(※当然例外もあります)

$L(20, 100) = 40268.55$

$L(25, 80) = 23445.075$

　こっちの方がよかった！

$L(a, b) = 16482.246499700002$

いや

それ

どう

やったの

• アイスの売り上げを予測するには、気温から売り上げを予測する
  「関数」を構築するのが必要であった。
• 今回は関数の形として $f(x) = ax + b$ (一次関数)を仮定して、
  「関数」を求めることにした。
• この関数は、パラメータとして$a, b$をもち、$a, b$を変えることで
  性質が変わるのがわかった。
• $a,b$を定めることで具体的に関数が定まる。
• このパラメータを決める基準として、「悪さ」の基準である損失関数を定めた。
• 損失関数の値を最小化する$a, b$を決めることを「学習」と呼ぶ。

1. 平均二乗誤差を計算するpythonのプログラムを実装してください。(不正な入力は来ないという想定でokです)

def mean_squared_error(y, pred):
  # ...
  # ここに書く
  # ...

# アイスの売り上げは実際100個, 200個, 300個だった
y = [100, 200, 300]

# 150個, 220個, 300個と予測
pred = [150, 220, 300]


print('mse:', mean_squared_error(y, pred))

2. (1.)で実装した平均二乗誤差を使って、損失を$a, b$の関数として書いてください。

def loss(a, b):
  x = [25, 30, 35]
  y = [80, 90, 100]
  # ...
  # ここに書く
  # ...

print('loss:', loss(3, 1))

def mean_squared_error(y, pred):
    n = len(y)
    s = 0
    for i in range(n):
        s += (y[i] - pred[i])**2
    return s / n

y = [100, 200, 300]
pred = [150, 220, 300]

print('mse:', mean_squared_error(y, pred))
# mse: 966.6666666666666

def loss(a, b):
    x = [25, 30, 35]
    y = [80, 90, 100]
    pred = []
    for x_i in x:
        pred.append(a * x_i + b)
    return mean_squared_error(y, pred)

print('loss:', loss(3, 1))
# loss: 17.666666666666668

# リスト内包表記を使ったバージョン
def loss(a, b):
    x = [25, 30, 35]
    y = [80, 90, 100]
    pred = [a * x_i + b for x_i in x]
    return mean_squared_error(y, pred)

• アイスの売り上げを予測するには、気温から売り上げを予測する
  「関数」を構築するのが必要であった。
• 今回は関数の形として $f(x) = ax + b$ (一次関数)を仮定して、
  「関数」を求めることにした。
• この関数は、パラメータとして$a, b$をもち、$a, b$を変えることで
  性質が変わるのがわかった。
• $a,b$を定めることで具体的に関数が定まる。
• このパラメータを決める基準として、「悪さ」の基準である損失関数を定めた。
• 損失関数の値を最小化する$a, b$を決めることを「学習」と呼ぶ。

問題

問題

解答

$\ \ f(x) = (x + 2)^2 + 2$ より、 $x = -2$

• 平方完成で解けた

プログラムに起こすと...

def solve(a, b, c):
  return -b / (2 * a)

関数を与えられたら、簡単な数学の操作（紙と鉛筆だけ)で解けた！

プログラムのことばで書くと、二次関数の最小値を取る $x$ を求める関数は
定数時間で動作するということ。

第二問

解:

$$f'(x) = 2x - e^{-x}$$

より最小値を与える$x_{\min}$の必要条件は

$$2x_{\min} - e^{-x_{\min}} = 0$$

:thinking_face:

？

いいたかったこと
→ このレベルの単純な関数でも、
最小値を与える式を構成するのはむずかしい

損失

$$L(a, b) = \dfrac{1}{n}\sum_{i=0}^{n-1} \ (y_i - f(x_i; a, b))^2$$

を最小化したかった。

1. 厳密に最小値を得る必要があるか？
2. $f$はどんな関数か？

⬇︎

1. 厳密に最小値を得る必要はない
2. $f$は非常に複雑になりうる

1. 厳密に最小値を得る必要はない

数学の答案で最小値 1 になるところを 1.001と答えたら当然

機械学習では、誤差 1% と 1.001%は事実上同じ

2. $f$は非常に複雑になりうる

第一回では $f(x) = ax + b$の形を考えたが...

$$L(W_1, W_2, W_3, \bm{b_1}, \bm{b_2}, \bm{b_3}) = \dfrac{1}{n}\sum \ (\bm{y} - W_3\sigma (W_2\sigma (W_1\bm{x} + \bm{b_1}) + \bm{b_2}) + \bm{b_3} ) )^2$$

$$\sigma(x) = \dfrac{1}{1 + e^{-x}}$$

(というか、普段我々が使っている数学の記号では書けなくなる)

微分係数の定義

$$f'(x) = \lim_{h \to 0} \dfrac{f(x + h) - f(x)}{h}$$

微分係数

• 微分係数 $f'(x)$ は、
  $x$における接線の傾き

  ⬇︎

  $-f'(x)$方向に関数を少し動かすと、関数の値はすこし小さくなる

例) $f(x) = x^2$

$x = 3$ で $f(3) = 9, \ f'(3) = 6$

$\therefore -f'(x)$ は負の方向

↓

すこし負の方向に$x$を動かしてみる

$f(2.9) = 8.41<9$

　小さくなった

例) $f(x) = x^2$

$x = 2.9$ で $f(2.9) = 8.41, \ f'(2.9) = 5.8$

$\therefore -f'(x)$ は負の方向

↓

すこし負の方向に$x$を動かしてみる

$f(2.8) = 7.84 <8.41$

　小さくなった

これを繰り返すことで小さい値まで到達できそう！

• ちゃんと定式化します

正確にはこれは最急降下法と呼ばれるアルゴリズムで、「勾配降下法」は勾配を使った最適化手法の総称として用いられることが多いと思います。ですがここでは「勾配降下法」という手法をきっちりと把握して欲しいのであえてこう呼びます。(そこまで目くじらを立てる人はいないと思いますし、勾配降下法あるいは勾配法と言われたらたいていの人がこれを思い浮かべると思います。)

マイナーチェンジが大量にある...
(実際に使われるやつは第五回で予定)

$$x_{n+1} = x_n - \eta f'(x_n)$$

抑えておきたいこと

1. 値が $-f'(x)$ の方向に更新される
2. 学習率によって更新幅を制御する

1. 値が $-f'(x)$ の方向に更新される

さっきの説明の通りです。

2. 学習率によって更新幅を制御する

微分係数はあくまで「その点の情報」

傾向が成り立つのはその周辺だけ

⬇︎

ちょっとずつ更新していく必要がある

⬇︎

小さな値 学習率 $\eta$ をかけることで少しずつ更新する

その式を(解析的に)解いた結果が何であるか知らなくても、
導関数さえ求められれば解を探しにいける！

収束性や局所最適解の話をしたい人がいると思いますが、グッと堪えてしばしお待ちください...

$f(x) = x^2$

初期値として、$x_0 = 3$
学習率として、$\eta = 0.1$ を設定。(この二つは自分で決める！)

$x_1 = x_0 - \eta f'(x_0) = 3 - 0.1 \times 6 = 2.4$
$x_2 = x_1 - \eta f'(x_1) = 2.4 - 0.1 \times 4.8 = 1.92$
$x_3 = x_2 - \eta f'(x_2) = 1.92 - 0.1 \times 3.84 = 1.536$
$\cdots$
$x_{100} = 0.0000000006111107929$

最小値を与える $x = 0$ に非常に近い値が得られた！

第二問

$f'(x) = 2x - e^{-x}$

初期値として $x = 3$, 学習率として $\eta = 0.0005$ を設定。

$x_1 = 2.997024893534184$
$\cdots$
$x_{10000} = 0.3517383210080008$

ヨシ！

from math import exp

x = 3
# （注意: $\eta$は、学習率(learning rate)の略である lr としています。）
lr = 0.0005

# 最小化したい関数
def f(x):
  return x ** 2 + exp(-x)

# fのxでの微分係数
def grad(x):
    return 2 * x - exp(-x)

$x_{n+1} = x_n - \eta f'(x_n)$ をコードに起こす

for i in range(10001):
    # 更新式
    x = x - lr * grad(x)
    if i % 1000 == 0:
        print('x_', i, '=', x , ', f(x) =', f(x))

x_ 0 = 2.997024893534184 , f(x) = 9.032093623218246
x_ 1000 = 1.1617489280037716 , f(x) = 1.6625989669983947
x_ 2000 = 0.5760466279295902 , f(x) = 0.8939459518186053
x_ 3000 = 0.4109554481889124 , f(x) = 0.8319008499233866
...
x_ 9000 = 0.3517515401706734 , f(x) = 0.8271840265571999
x_ 10000 = 0.3517383210080008 , f(x) = 0.8271840261562484

配布ソースコード:
gradient_decent.ipynb

では勾配降下法の様子を可視化できるLoggerというクラスを用意

最適化の様子をgifで見ることができます(内容は後述)

ここまで紹介した関数は、実はすべて勾配降下法が非常にうまくいく関数
(凸関数と呼ばれる関数)

勾配降下法があまりうまくいかない関数もある

例) $f(x) = \dfrac{x^2}{10} + 10 \sin \left(\dfrac{x^2}{4} \right)$

局所最適解 ... 付近では最小値(全体の最小値とは限らない)
大域最適解 ... 全体で最小値

単純な勾配降下法では、局所最適解に陥ってしまう
⇨ なるべく局所最適解にならないよう色々と工夫(詳しくは第5回)

• 最急降下法

$$x_{n+1} = x_n - \eta f'(x_n)$$

• Momentum

$$v_{n+1} = \alpha v_n - \eta f'(x_n) \\$$

$$x_{n+1} = x_n + v_{n+1}$$

工夫して「陥りにくく」なってるだけで陥りはします。

多変数関数の場合は、微分係数→勾配ベクトル　に置き換えればOK

$$\bm{x_{n+1}} = \bm{x_n} - \eta \nabla f(\bm{x_n})$$

勾配ベクトルとは、各変数の偏微分係数を並べたものです。
例えば、$f(x, y) = x^2 + y^2$ の勾配ベクトルは $(2x, 2y)$ となります。
これを$\nabla f(x, y)$ と書きます。
一年生はちょうど微分積分学第一でやるころ？かと思ったので大きくは扱いませんでしたが、
一変数の場合できちんと理解できていれば問題はないはずです。

第三問

微分したくなさすぎる

(ここ以降では深層学習の学習の話をします)

さまざまな関数を最小化するアルゴリズムは勾配降下法だけではない
(焼きなまし法など)

⬇︎

これらでは学習はうまくいかないのか？

結論: あまりうまくいかない(とされている)

そもそも... 深層学習モデルのような膨大なパラメータを持つモデルの損失関数をうまく小さくすることは、
現代の理論では非常に難しいと思われている

⬇︎

「え、でも世の中いろんなモデルがうまく行ってますよね。。。」

⬇︎

実はなぜうまく行っているのか誰もわかっていない

• なぜ確率的勾配降下法(第五回でやります)は他の手法と違いうまく収束するのか？
• なぜ膨大なパラメータを持つモデルの学習がうまくいくのか？

↓

• 膨大なパラメータを持つモデルはかえって学習しやすくなる？
• 確率的勾配降下法の勾配の変動は損失関数が小さい点に集中する？

【基調講演】『深層学習の原理の理解に向けた理論の試み』 今泉 允聡（東大)
https://www.slideshare.net/MLSE/ss-237278350

深層学習の原理に迫る https://www.iwanami.co.jp/book/b570597.html

1. 勾配降下法を使った線形回帰(一変数ver)

以下(次ページ)のようなデータがあります。

(来店者数) = $a \times$ (広告費)

という関係があると仮定したとき、損失(平均二乗誤差)を最小にする$a$を勾配降下法によって求めることで、広告費から来店者数を予測するモデルを学習させてください。

pythonにコピペする用:

x = [10, 2, 5, 10, 10, 5]
y = [12, 4, 8, 12, 11, 4]

損失関数を$a$について微分します。

$$\dfrac{\partial}{\partial a} \sum_{i=1}^n (y_i - ax_i)^2 = -2 \sum_{i=1}^n x_i(y_i - ax_i)$$

あとはPythonで実装すればいいです。

# 損失関数
def loss(a):
    n = len(x)
    s = 0
    for i in range(n):
        s += (y[i] - a * x[i])**2
    
    return s / n

次のページへ

# 損失関数の勾配
def dloss(a):
    s = 0
    for i in range(n):
        s += -2 * x[i] * y[i] + 2 * a * x[i]**2
    
    return s / n


# 勾配降下法
x = -4 # これは任意(うまくいくものを選ぶ)
lr = 0.001  # これも任意(うまくいくものを選ぶ)
for i in range(100):
    x -= lr * g(x)
    print(x, '|', loss(x))

次へ

ちなみに、配布したソースコードのgradient_decent関数を使うと学習の様子が見れます。

logger = gradient_decent(loss, dloss, 50, -4, lr=0.001, x_range=np.linspace(-10, 10, 100))
logger.gif("linreg.gif", fps=10)
preview("linreg.gif")

今日は講義内で演習もします

• 損失関数の最小化を考える上で、一般の関数の最小化を考えることにした
• 損失関数の厳密な最小値を求める必要はなく、また損失関数は非常に複雑になりうるので、広い範囲の関数に対してそこそこ上手くいく方法を考えることにした
• たいていの関数に対して、導関数を求めることさえできればそれなりに小さい値を探しに行けるようになった
• 逆に、「導関数」は自分で求める必要がある

第三問

2. $f$は非常に複雑になりうる

第一回では $f(x) = ax + b$の形を考えたが...

$$L(W_1, W_2, W_3, \bm{b_1}, \bm{b_2}, \bm{b_3}) = \dfrac{1}{n}\sum \ (\bm{y} - W_3\sigma (W_2\sigma (W_1\bm{x} + \bm{b_1}) + \bm{b_2}) + \bm{b_3} ) )^2$$

$$\sigma(x) = \dfrac{1}{1 + e^{-x}}$$

(というか、普段我々が使っている数学の記号では書けなくなる)

人間が微分を行うのは限界がある
⇨ コンピュータにやらせよう！

正確には「自動微分」は、コンピュータに自動で微分を行わせる手法のうち、関数を単純な関数の合成と見て、特に連鎖律を利用して、陽に導関数を求めることなく微分を行う手法を指します(より狭義に、back propagationを用いるもののみを指すこともあるようです)。　詳しくは、資料末の発展事項を参照してください。

• PyTorchの導入
• PyTorchを使った自動微分
• 自動微分を使った勾配降下法の実装
• 発展的話題: コンピュータに微分をやらせる試み
  • ~自動微分のアルゴリズム~

結論: PyTorchを使うと微分ができる.

>>> x = torch.tensor(2.0, requires_grad=True)
>>> def f(x):
...     return x ** 2 + 4 * x + 3
... 
>>> y = f(x)
>>> y.backward()
>>> x.grad
tensor(8.)

($f(x) = x^2 + 4x + 3$の$x = 2$における微分係数$8$)

ニューラルネットワーク・ディープラーニングのさまざまな派生系の

• 基本的に構成する部品
• 部品に対してやる作業

は大体同じ！

例) 新しい車を開発するときも、部品(ネジ、タイヤ、エンジンの部品...)は大体同じ、組み立ても大体同じ

⇨ 毎回同じことをみんながそれぞれやるのは面倒
⇨ 共通の「基盤」を提供するソフトウェアの需要がある

• TensorFlow
  • (主に)Googleが開発したフレームワーク
  • 産業界で人気(が、最近はPyTorchに押され気味)
• PyTorch
  • Facebookが開発したフレームワーク
  • 研究界で人気(最近はみんなこれ？)
• Keras
  • TensorFlowを使いやすくしたラッパー
  • とにかくサッと実装できる

個人的には、最近Googleが力を入れているjax/flaxに注目しています。関数型プログラミングの考え方を取り入れていて、最近人気が出始めています。

どれがいいの？
⇨ PyTorchを使っておけば間違いない(と、思います)

(赤: PyTorch, 青: TensorFlow)

今回はPyTorchを使います！

• C++, CUDAバックエンドの高速な実行
• 非常に柔軟な記述
• 充実した周辺ライブラリ
• サンプル実装の充実 (← 重要!!)

大体の有名フレームワークにそこまで致命的な速度差はなく、記述に関しては好みによるところも多いです。PyTorchの差別化ポイントは、有名モデルの実装サンプルが大体存在するという点です。
実際に論文を読んで実装するのは骨の折れる作業なので、サンプルが充実していのはとても大きな利点です。

数学の「数」に対応するオブジェクトとして、
PyTorchでは

Tensor型: 高効率で勾配を保持できる多次元配列

を使う

⬇︎ 多次元配列とは？

スカラ・ベクトル(配列)・行列 ... の一般化

• スカラ: 0次元配列
• ベクトル: 1次元配列
• 行列: 2次元配列

v = [1, 2, 3]

A = [[1, 2, 3], 
     [4, 5, 6],
     [7, 8, 9]]

T = [[[1, 2, 3], [4, 5, 6]], 
     [[7, 8, 9], [10, 11, 12]]]

>>> x = torch.tensor(2.0, requires_grad=True)

2.0というスカラを保持するTensor型のオブジェクトを作成
(数 $x = 2.0$を定義)

>>> x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

[1.0, 2.0, 3.0]というベクトルを保持するTensor型のオブジェクトを作成
(数 $\vec{x} = (1.0, 2.0, 3.0)$を定義)

かつては自動微分にはVariableという名前の型が使われていて、(現在はTensor型に統合された)　Tensorと数学の変数の概念にある程度の対応があることがわかります。

torch.tensor(data, requires_grad=False)

• data: 保持するデータ(配列っぽいものならなんでも)
  • リスト、タプル、NumPy配列、スカラ、...
• requires_grad: 勾配(gradient)を保持するかどうかのフラグ
  • デフォルトはFalse
  • 勾配の計算(自動微分)を行う場合はTrueにする

>>> x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)

[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]という行列を保持するTensor型のオブジェクトを作成
(数 $X = \begin{pmatrix} 1.0 & 2.0 & 3.0 \\ 4.0 & 5.0 & 6.0 \end{pmatrix}$を定義)

(requires_grad=Trueとすれば、勾配計算が可能なTensor型を作成できる)

これらを勾配計算が可能なTensor型として表現してください。

1. $x = 3.0$
2. $\vec{x} = (3.0, 4.0, 5.0)$
3. $X = \begin{pmatrix} 3.0 & 4.0 & 5.0 \\ 6.0 & 7.0 & 8.0 \end{pmatrix}$

(このページの内容は、実際にやらなくてもやり方がわかればOKです)

↓ 問題の続き次のページへ

(実際にやってください)

4. 整数 $x = 3$を勾配計算が可能なTensor型として表現することを試みてください。また、その結果を確認して説明できるようにしてください。
5. 1から100までの値を並べた10x10行列、つまり

$$X = \begin{pmatrix} 1 & 2 & \cdots & 10 \\ 11 & 12 & \cdots & 20 \\ \vdots & \vdots & \ddots & \vdots \\ 91 & 92 & \cdots & 100 \end{pmatrix}$$

を勾配計算が可能なTensor型として表現してください。(次ページヒント)

1, 2, 3: 講義資料を遡って、torch.tensorの第一引数と作成されるTensor型の対応を見比べてみましょう。

4: Pythonのエラーは、

~~たくさん書いてある~
~~Error: {ここにエラーの概要} 

という形式です。"~~Error"というところのすぐ後に書いてある概要を確認してみましょう。

5: 3が解けたのであれば、torch.tensorの第一引数にどのようなオブジェクトをが来るべきかはわかるはずです。あとはそのリストの構築方法を考えましょう。

1~3.

# 1
x = torch.tensor(3.0, requires_grad=True)
# 2
x = torch.tensor([3.0, 4.0, 5.0], requires_grad=True)
# 3
x = torch.tensor([[3.0, 4.0, 5.0], [6.0, 7.0, 8.0]], requires_grad=True)

次のページへ

x = torch.tensor(3, requires_grad=True)

と入力してみると、

"RuntimeError: Only Tensors of floating point and complex dtype can require gradients"となります。これは、勾配が計算可能なのは浮動小数点数と複素数のみであるということを意味しています。

次のページへ

1. (解答例)　一番素直なやつ

>>> matrix = []
>>> for i in range(10):
...     row = []
...     for j in range(10 * i + 1, 10 * i + 11):
...         row.append(float(j))
...     matrix.append(row)
...
>>> torch.tensor(matrix, requires_grad=True)

6. (解答例2) 一番素直なやつ 内包表記ver

>>> x = torch.tensor([[float(i) for i in range(10 * j + 1, 10 * j + 11)] for j in range(10)]

他にも別解はたくさんありますが、書き方に関わらず作れればここまでの内容は理解できているので)

Tensor型は、「数」なので当然各種演算が可能

x = torch.tensor(2.0, requires_grad=True)

• 四則演算

x + 2 
# -> tensor(4., grad_fn=<AddBackward0>)

x * 2
# -> tensor(4., grad_fn=<MulBackward0>)

各種 数学的な(?) 関数も利用可能

torch.sqrt(x)
# -> tensor(1.4142, grad_fn=<SqrtBackward0>)

torch.sin(x)    
# -> tensor(0.9093, grad_fn=<SinBackward0>)

torch.exp(x)
# -> tensor(7.3891, grad_fn=<ExpBackward0>)

ここまでの内容は別にPyTorchを使わなくてもできること
PyTorchは、計算と共に勾配の計算ができる！

requires_grad=TrueであるTensor型に対して計算を行うと、行われた演算が記録されたTensorができる.

x = torch.tensor(2.0, requires_grad=True)

足し算をする。

y = x + 2

⬇︎

print(y)

これの出力は、
tensor(4., grad_fn=<AddBackward0>)
⇨ Addという演算がyに記録されている！

普通のPythonの数値では、

x = 2
y = x + 2
print(y) # -> 4.0

yがどこから来たのかはわからない(値として$4.0$を持っているだけ)

PyTorchは、backward関数をつかって記録された演算を辿ることで、勾配を計算できる

x = torch.tensor(2.0, requires_grad=True)
y = x + 2

⬇︎

y.backward()

⬇︎

print(x.grad) # -> tensor(1.)

1. 変数(Tensor型)の定義
2. 計算
3. backward()

# 1. 変数(Tensor型)の定義
x = torch.tensor(2.0, requires_grad=True)
# 2. 計算
y = x + 2
# 3. backward()
y.backward()

すると、x.gradに計算された勾配が格納される。

なぜこんな設計なのか気になった人は、講義が終わったら資料末の「発展的話題: 自動微分のアルゴリズム」を読んでみてください。現段階では、今回はこのセットで計算できる！ということを覚えてもらえればokです。

定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward(), 定義→計算→backw
定義→計算→backward(), 定義→計算→backward() 定義→計算→backw

例1) $f(x) = sin((x + 2) + (1 + e^{x^2}))$　の微分

x = torch.tensor(2.0, requires_grad=True)
y = y = torch.sin((x + 2) + (1 + torch.exp(x ** 2))) 
y.backward()
print(x.grad()) # -> tensor(-218.4625)

例2) $y = x^2, z = 2y + 3$ の微分($\frac{dz}{dx}$)

x = torch.tensor(2.0, requires_grad=True)
y = x ** 2
z = 2 * y + 3
z.backward()
print(x.grad) # -> tensor(8.)  ... backward()した変数に対する勾配！(この場合はz)

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = 2 * x[0] + 3 * x[1] + 4 * x[2]
y.backward()
print(x.grad) # -> tensor([2., 3., 4.])

$$\vec{x} = (x_1, x_2, x_3)^\mathsf{T} \\$$

$$y = 2x_1 + 3x_2 + 4x_3$$

$$\frac{dy}{d\vec{x}} = \left(\frac{dy}{dx_1}, \frac{dy}{dx_2}, \frac{dy}{dx_3}\right)^\mathsf{T} = (2, 3, 4)^\mathsf{T}$$

と対応

A = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
y = torch.sum(A)
y.backward()
print(A.grad) # -> tensor([[1., 1., 1.],
              #          [1., 1., 1.]])

$$A = \begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{pmatrix}, \ y = \sum_{i=1}^2 \sum_{j=1}^3 a_{ij} = 21$$

$$\frac{dy}{dA} = \begin{pmatrix} \frac{dy}{da_{11}} & \frac{dy}{da_{12}} & \frac{dy}{da_{13}} \\ \frac{dy}{da_{21}} & \frac{dy}{da_{22}} & \frac{dy}{da_{23}} \end{pmatrix} = \begin{pmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \end{pmatrix}$$

と対応

x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)
z = 2 * x + 4 * y
z.backward()
print(x.grad) # -> tensor(2.)
print(y.grad) # -> tensor(4.)

$$z = 2x + 4y \\$$

$$\dfrac{\partial z}{\partial x} = 2, \ \dfrac{\partial z}{\partial y} = 4$$

に対応

x = torch.tensor(2.0, requires_grad=True)
def f(x):
    return x + 3
def g(x):
    return torch.sin(x) + torch.cos(x ** 2)

if rand() < 0.5:
    y = f(x)
else:
    y = g(x)

ポイント: 実際に適用される演算は、実行してみないとわからないが、適用される演算はどう転んでも微分可能な演算なのでOK.
(if文があるから, for文があるから, 自分が定義した関数に渡したから...ということは関係なく、実際に適用される演算のみが問題になる)

抑えてほしいポイント

• 任意の(勾配が定義できる)計算をTensor型に対して適用すれば、常に自動微分可能
• 定義→計算→backward() の流れ
• ベクトル、行列など任意のTensor型について微分可能。多変数関数の場合も同様
• 「実際に適用される演算」さえ微分可能ならOK

1. $y = x^2 + 2x + 1$ の$x = 3.0$における微分係数をPyTorchを使って求めよ。

2. $y = f(\vec{x}) = {x_1}^2 + {x_2}^2 + {x_3}^2$の
   $\vec{x} = (1.0, 2.0, 3.0)^\mathsf{T}$における勾配をPyTorchを使って求めよ。

3. $W = \begin{pmatrix} 1.0 & 2.0 & 3.0 \\ 4.0 & 5.0 & 6.0 \end{pmatrix}$, $\vec{x_1} = (1.0, 2.0)$, $\vec{x_2} = (1.0, 2.0, 3.0)^\mathsf{T}$に対して、$y = f(W, \vec{x_1}, \vec{x_2}) = \vec{x_1}W\vec{x_2}$の勾配をPyTorchを使って求めよ。なお、行列積はtorch.matmul関数で利用できる。

(次ページヒント)

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 2 * x + 1
y.backward()
print(x.grad) # -> tensor(8.)

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x[0] ** 2 + x[1] ** 2 + x[2] ** 2
y.backward()
print(x.grad) # -> tensor([2., 4., 6.])

W = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], requires_grad=True)
x1 = torch.tensor([[1.0, 2.0]], requires_grad=True)
x2 = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = torch.matmul(torch.matmul(x1, W), x2)
y.backward()
print(W.grad)   
print(x1.grad)
print(x2.grad)

$f(x) = x^2 + e^{-x}$の勾配降下法による最小値の探索

from math import exp

x = 3
lr = 0.0005

# xでの微分係数
def grad(x):
    return 2 * x - exp(-x)

for i in range(10001):
    # 更新式
    x = x - lr * grad(x)
    if i % 1000 == 0:
        print('x_', i, '=', x)

これまでは、導関数gradを我々が計算しなければいけなかった
⇨自動微分で置き換えられる！

import torch

x = torch.tensor(3.0, requires_grad=True)

def f(x):
    return x ** 2 + torch.exp(-x)

for i in range(10001):
    y = f(x)
    y.backward()
    x = x - lr * x.grad

実際に動かすにあたっては軽微な修正が必要ですが、スペースが足りないのでここには載せていません。
詳しくは配布のソースコードを参照してください。

今ならこいつを倒せるはず

1. 複雑な関数

$$f(x) = \dfrac{-\log(\dfrac{1}{1 + e^{-x}} + 1)}{(x^2 + 1)}$$

の最小値を、PyTorchを用いて勾配降下法を実装することで求めてください。

実装にあたっては、配布ソースコードのPyTorchによる勾配降下法」の項を参照してください。

(次ページ次の問題)

2. アイスの問題 ver2

$$f(x; a, b) = ax + b$$

とします。アイスの売り上げと気温の関係は、リンク先からコピーできます。それぞれのデータが$(x_i, y_i)$として与えられているとき、

$$L(a, b) = \sum_{i=1}^{n} (y_i - f(x_i; a, b))^2$$

を最小にする$a, b$をPyTorchを用いて勾配降下法を実装することで求めてください。(次ページ次の問題)

3. 損失関数

第一回の講義資料では次のような文章がありました。

「「悪さ」を最小化するのではなく「良さ」を最大化すれば良くない？と思った人もいるかもしれないですね。
実はそれはものすごくいい疑問で、次回以降で明らかになっていきます。
ひとまずは一旦疑問として抱えておいてください。」

これに対する答えを考えてみてください。
より具体的に、たとえば「明日は晴れかどうか予測する」、という問題に対して例えば「正解率」を最大化することを考えた場合、どのような点で困るか考えてください。

(次ページヒント)

1, 2.配布ソースコードの該当箇所を確認してよく見比べてください。

3. 勾配降下法を使った学習ではパラメータによる損失(今回の場合は損失ではないですが)の微分を考えていました。つまり、パラメータが微小に変化したときに、損失がどれだけ変化するかを考えていました。今回の場合はこの値はどうなるでしょうか？

1. サンプルコードを参照
2. サンプルコードを参照

出力は最終的に「晴れ」or「晴れじゃない」のいずれかに割り振られる。したがって、パラメータが微小に変化したとしても、出力は変化しない。つまり、ほとんどの場合で微分係数が0になってしまう。これでは勾配降下法の枠組みで学習を進めることができない。

これらが気になる人向け

• そもそもどうやって微分をしているのか？
• backward()関数はどういう働きをしているのか？
• どうして定義→計算→backward()みたいな使い方をするのか？

めちゃx2余談です

ポイント:
最適化の文脈では、基本的にほしいものは「微分係数」であって
「導関数」である必要はない

人間が微分をする場合...

例) $f(x) = x^2 + 2x + 1$の$x = 3.0$における微分係数を求めろ

↓

$\underline{f'(x) = 2x + 2}$だから、$f'(3.0) = 8.0$

PyTorchでは...

例) $f(x) = x^2 + 2x + 1$の$x = 3.0$における微分係数を求めろ

↓

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 2 * x + 1
y.backward()
x.grad # -> tensor(8.)

陽に導関数を求めておらず、直接導関数を求めている

どうやって？

コンピュータで微分を求めるアルゴリズムの分類

1. 数値微分
2. 数式微分・記号微分
3. 自動微分

微分の定義式から直接近似する。

$$f'(x) = \lim_{h \to 0} \dfrac{f(x + h) - f(x)}{h}$$

⬇︎ そのままPythonに

def diff(f, x, h=1e-4):
    return (f(x + h) - f(x)) / h

コンピュータ上で直接極限の計算をするのは大変なので、
代わりに小さい値$h$(上では$0.001$)を使って近似する。

利点

• 実装が簡単
• (計算可能なら)どんな関数でも微分できる

欠点

• 計算量が入力変数の数に比例する
• 誤差が出やすい
  • $h$をどんどん小さくすればより高精度に計算できるわけではない(浮動小数点数の計算に伴う誤差の影響により一定以上ではむしろ悪化する)

数式微分・記号微分

演算は、計算グラフと呼ばれる有向非巡回グラフで表せる。

$y = 3x + 4$ →

$goldstain(x, y) = (1 + (x + y + 1)^2 (19 - 14x + 3x^2 - 14y + 6xy + 3y^2)) (30 + (2x - 3y)^2 (18 - 32x + 12x^2 + 48y - 36xy + 27y^2))$

→

計算グラフに直せば、

式の操作
$\leftrightarrow$　計算グラフの操作

計算グラフなど式を適切に表したデータ構造から
直接導関数を求める手法を数式微分や記号微分と呼ぶ。

利点

• (理論的な範囲では)　誤差が出ない
• 直接導関数を得られる

欠点

• 下手くそな実装は爆発する
  • 応用領域では式は容易に非常に複雑になる。(例えば損失はデータ数の分だけ項がある総和として表されるし、尤度関数は標本の数の総積)
  • 例えば積の微分では項が二つに分裂したりする。
    ⇨ 項の数が「大爆発」して、現実的ではなくなる
• 「プログラム」から導関数を得るのはかなりレベルの高い技術
  • ニューラルネットワークなどの実装では制御構文などを含めた「普通の」プログラムも微分したくなる
  • if文, for文, try/except ...　ここから微分する元の関数を得るのは結構大変

自動微分

• 連鎖律(Chain rule)を利用した微分アルゴリズム

(講義資料にもあるように、自動で微分を求めるアルゴリズムの一種が「自動微分」)

$$\frac{dz}{dx} = \frac{dz}{dy} \frac{dy}{dx}$$

のこと

例) $z = (x + y)^2$の$x = 3, y = 2$における勾配

$a = add(x, y), z = square(a)$である。
(つまり、基本的な関数$add$と$square$の合成である)

$$\frac{\partial z}{\partial x} = \frac{\partial z}{\partial z} \frac{\partial z}{\partial a}\frac{\partial a}{\partial x} = 1 \times 2a \times 1 = 10$$

$$\frac{\partial z}{\partial y} = \frac{\partial z}{\partial z} \frac{\partial z}{\partial a}\frac{\partial a}{\partial y} = 1 \times 2a \times 1 = 10$$

とすれば計算できる。

ここで使ったのは...

$\frac{\partial z}{\partial a} = 2a, \frac{\partial a}{\partial y} = 1$という知識

これらは、基本的な関数の微分
⇨ 基本的な関数の導関数さえ定義しておけばこれらの関数の組み合わせのどんな複雑な関数でも微分できる。

1. (25)のノードに注目して。勾配を1で初期化する。
2. Squareのノードに進む。
3. Squareの微分は$(x^2)' = 2x$。入力は5なので、$2 \times 5 = 10$を勾配($=1$)にかける
4. Addのノードに進む。
5. Addの微分は$x, y$どちらについても1なので、$x, y$の勾配は$10 \times 1 = 10$となる。

$$\frac{\partial z}{\partial x} = \underline{\frac{\partial z}{\partial z} \frac{\partial z}{\partial a}}\frac{\partial a}{\partial x} = 1 \times 2a \times 1 = 10$$

$$\frac{\partial z}{\partial y} = \underline{\frac{\partial z}{\partial z} \frac{\partial z}{\partial a}}\frac{\partial a}{\partial y} = 1 \times 2a \times 1 = 10$$

共通部の計算は共通化できていた。(初期化部分とSquareの微分に対応)

そして、計算は通常の計算とグラフを逆に辿る(逆伝播(back propagation))の二回で済んだ！

利点

• 計算の効率が非常に良い
  • 計算回数は出力変数の数に比例する。
    ⇨ 機械学習は、大量のパラメータを変数として出力は損失(一つの実数)になることが多いので、圧倒的に効率がいい

• PyTorchのTensor型に演算をおこなうと、「演算と同時に計算グラフが作られていく」
• y.backwardを呼び出すことで、yを起点としてグラフを逆に辿り出す

PyTorch上の計算グラフは、torchvizというライブラリを使うと可視化できる。

x = torch.tensor([1., 2., 3.], requires_grad=True)
y = torch.sin(torch.sum(x) + 2)
make_dot(y)

このように演算と同時に計算グラフを構築するスタイルをdefine-by-runと呼び、これに対して
計算グラフを先に構築してから演算を行うスタイルをdefine-and-runと呼びます。
かつては共存していましたが、今では多くのフレームワークがdefine-by-runを主要なスタイルとして採用しています。実行時に計算グラフを構築する方が圧倒的に柔軟性があるからです。

ここまでで説明したのは、グラフを出力から「逆にたどる」自動微分
⇨ 特にreverseモードの自動微分などと呼ばれる

逆に、forwardモードの自動微分と呼ばれる手法もある

二重数と呼ばれる数を使った実装が有名

⬇︎

実数の範囲内では、

$$x^2 = 0 \Leftrightarrow x = 0$$

ここで、新しく

$$\varepsilon^2 = 0$$

なる数 $\varepsilon \neq 0$を考えて、実数にこれを加えた集合の演算を考える
(虚数を考えたときと同じ展開)

そこで複素数を考えたときと全く同様に、
$z = a + b\varepsilon$という形の数を考える($a, b \in \mathbb{R}$)

このような形で表される数を二重数と呼ぶことにする

$\varepsilon^2 = 0$に注意すれば、

$$\begin{align*} (a + b\varepsilon) + (c + d\varepsilon) &= (a + c) + (b + d)\varepsilon \\ (a + b\varepsilon) \times (c + d\varepsilon) &= (ac) + (ad + bc)\varepsilon \\ \end{align*}$$

とするのが良さそう

すると、実係数多項式

$$f(x) = a_nx^n + a_{n-1}x^{n-1} + \cdots + a_1x + a_0$$

に対して、

$$f(x + b\varepsilon) = f(x) + bf'(x)\varepsilon$$

となることがわかる
やや雑ですが、微分可能ならテイラー展開することで結局実係数多項式にできるので実係数多項式の微分が正しく計算できるのであれば、微分可能な関数全てに対してうまくいきそう

https://en.wikipedia.org/wiki/Automatic_differentiation#Two_types_of_automatic_differentiationから

reverseモード同様、基本的な関数に対して二重数の演算を定義しておき、その合成として計算。

$$f(x + b\varepsilon) = f(x) + bf'(x)\varepsilon$$

をもう一度見れば、$f(x + b\varepsilon)$の計算それ自体が$f$の$x$における微分係数を求める演算と対応している！

普通の関数の計算は計算グラフを入力から「順」に辿っていく
(順伝播, forward propagation) ことに他ならない

➡︎ forwardモードの自動微分

• 代表的なアプローチとして、数値微分、数式微分、自動微分があった
• 数値微分は誤差が出やすく、記号微分は柔軟な計算をしようとすると大変
• 自動微分は高速でとくにreverseモードの自動微分は機械学習において圧倒的に有用であった

もっと興味がある人は

ゼロから作るDeep Learning ❸: https://www.oreilly.co.jp/books/9784873119069/
や、
https://arxiv.org/abs/1502.05767 (自動微分全般の話)
https://arxiv.org/abs/1810.07951 (「ソースコードから微分する」話)
などを読んでみてください。

第一回 「学習」
第二回 「勾配降下法」
第三回 「自動微分」

1. 予測をするには、「モデル」を作る必要があった
2. モデルのパラメータを決めるために、パラメータの関数である損失関数を導入した
3. 損失関数を最小にするパラメータを求めるために勾配降下法を導入した
4. 自動微分によって手で微分する必要がなくなった [← 今ココ！]

われわれができるようになったこと

データさえあれば...誤差を小さくするパラメータを

• 例え複雑な式でも
• 例え自分で導関数を見つけられなくても

求められるようになった！
(== 学習ができるようになった！)

ここまでは$f(x) = ax + b$ のかたちを仮定してきた

⇨ われわれの学習手法はこの仮定に依存しているか？

我々の手法(自動微分と勾配降下法による学習)で満たすべき条件は、

$L(a, b)$が $a, b$ について微分可能である

ことのみ！

⇨ この条件を満たす関数なら文字通りどんなものでも学習できる！

今日のおはなし

損失関数

$$L(a, b) = \sum_{i=0}^{n-1} (y_i - \underline{f(x_i)})^2$$

の$f$を変えよう

$f(x) = ax + b$　は、$a, b$をどんなに変えても常に直線
⇨ 直線以外の関係を表現できない

$f(x) = ax^2 + bx + c$ でも動く

$f(x) = \sin(ax + b)$ でも動く

$f(x) = e^{ax + b}$ でも動く

⇨ 直線以外を表現することはできるが

• 二次曲線
• sin
• 指数関数

しか表現できない...

⇨ これらのパラメータどんなにいじっても

みたいなのは表現できない

アイデア1: 関数を合成する

$\sin(x), \cos(x), x^2 + x, e^x \cdots$ はそれぞれ単体だと単純な関数だが、
合成してみると....？

アイデア2: 和をとる

⇨ ベースにした三角関数の和をとると...

< 実質ASMR

わりと簡単めの関数の

1. 合成

2. 和

を考えたら結構複雑なやつも表現できる

パラメータとして
$\bm{a} = (a_1, a_2, a_3, a_4, a_5)$,
$\bm{b} = (b_1, b_2, b_3, b_4, b_5)$,
$\bm{c} = (c_1, c_2, c_3, c_4, c_5)$
をもつ

$$f(x) = \sum_{i=1}^5 a_i \sin(b_i x + c_i)$$

⇩

$a = (0.04, 0.78, 0.09, 0.63, 0.01), \\ b = (0.94, 0.43, 0.25, 0.19, 0.41), \\ c = (0.01, 0.65, 0.87, 0.61, 0.81)$ のとき

$a = (0.83, 0.27, 0.84, 0.28, 0.14), \\ b = (0.71, 0.47, 0.56, 0.39, 0.94), \\ c = (0.08, 0.92, 0.16, 0.44, 0.21)$　のとき

「基になる関数」にどのような関数を選ぶべきか？

• 三角関数?
• 多項式関数?
• 指数関数?
• もっと別の関数?
  ...

これまでの我々のアプローチを思い出すと、
「変化させるのが可能なところはパラメータにして、学習で求める」

「基になる関数」もパラメータに

よって変化するようにしよう

• 最近流行りの機械学習モデルは基本的にニューラルネットワークをつかっている

• ある程度以上複雑な問題では、たいていの場合ニューラルネットワークが最も精度が出やすい

例) 画像分類, 音声分類, 画像生成, 対話 ...

基本単位: レイヤー

ニューラルネットワークは、「レイヤー(層)」と呼ばれる関数の合成によって構成されるモデル

基本単位: レイヤー

• 入力層
  入力を受け取るレイヤー

• 出力層
  出力を出力するレイヤー

• 中間層(隠れ層, hidden layer)
  それ以外のレイヤー

データの流れは、
入力層　→ 中間層　→ 中間層　→ ...　→ 出力層

もっとも普遍的・基本のレイヤー

$W \in \mathbb{R}^{m \times n}, \ b \in \mathbb{R}^m$ と ($m, n$は適当に定めた自然数)
全結合層が固有にもつ「活性化関数」を用いて

入力として$\bm{x} \in \mathbb{R}^n$を受け取り、

$\sigma \left(W \bm{x} + \bm{b} \right)$ を出力する。

1. $n$個の入力を受け取り、$m$個出力する

2. 複雑な関数を表現するアイデア...

   • アイデア1. 合成
   • アイデア2. 和をとる

   をする

1. $n$個の入力を受け取り、$m$個出力する

「$W \in \mathbb{R}^{m \times n}, \ b \in \mathbb{R}^m$ と ($m, n$は適当に定めた自然数)
全結合層が固有にもつ「活性化関数」を用いて

入力として$\bm{x} \in \mathbb{R}^n$を受け取り、
$\sigma \left(W \bm{x} + \bm{b} \right)$ を出力する」

2. 複雑な関数を表現するアイデア...

   • アイデア1. 合成
   • アイデア2. 和をとる

   をする

非線形関数

• シグモイド関数
  $\sigma(x) = \dfrac{1}{1 + \exp(-x)}$

• ReLU関数
  $\mathrm{relu}(x) = \max(0, x)$

• tanh関数
  $\tanh(x) = \dfrac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}$

合成を繰り返す
⇨ 複雑な関数を表現

$m$個の出力のひとつに注目してみる

$\bm{y} = \sigma \left(W \bm{x} + \bm{b} \right)$ ⇨ $y_i = \sigma \left( \displaystyle{\sum_{j} W_{ij} x_j + b_i} \right)$

$y_i = \sigma \left( \displaystyle{\sum_{j} W_{ij} x_j + b_i} \right)$

は、

とおなじことをしている

$y_i = \sigma \left( \displaystyle{\sum_{j} W_{ij} x_j + b_i} \right)$

$x_j$はそれまでの層で$\sigma$を通した、非線形な関数

$\sigma \left( \displaystyle{\sum_{j} W_{ij} x_j + b_i} \right)$

➡︎ 非線形関数の重みつき和
➡︎ 複雑な非線形関数を表現できる！ + さらにそれを非線形関数に通す

演算を$d$ 回繰り返す
($n$ 次元ベクトル → $m_1$, → $m_2$, → $\cdots$, → $m_d$ 次元ベクトルへと
変換されながら計算が進んでいく)

$$\bm{y}^{(1)} = \sigma \left(W^{(1)} \bm{x} + \bm{b}^{(1)} \right)$$

$$\bm{y}^{(2)} = \sigma \left(W^{(2)} \bm{y}^{(1)} + \bm{b}^{(2)} \right)$$

$$\cdots$$

$$\bm{y}^{(d)} = \sigma \left(W^{(d)} \bm{y}^{(d-1)} + \bm{b}^{(n)} \right)$$

$$\bm{y} = \mathrm{id} \left(W^{(o)} \bm{y}^{(d)} + \bm{b}^{(o)} \right)$$

$$y = \displaystyle{\sum_{j} w^{(o)}_{j} y^{(d)}_j + b^{(d)}}$$

ここで、

「基になる関数」もパラメータに

よって変化するようにしよう

とくに、全結合層のみからなるニューラルネットワークを
多層パーセプトロン (Multi Layer Perceptron, MLP) という

$f(x) = ax + b$　⇨ ニューラルネットへ

< どれくらい表現能力が変わったのか？

結論

直線 ⇨ 任意の関数

(注) 正確な表現ではありません！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

今回の講習会できちんとこの辺を論じると第300回までいくこと間違いなしなのでかなりアバウトな話になっていますので、きちんと議論がしたくて興味がある人は　(https://qiita.com/mochimochidog/items/ca04bf3df7071041561a) などに詳しくまとまっているので、読んでみてください。

• 我々の学習手法は、$f(x) = ax + b$というモデルの構造自体に直接依存しているわけではなかった

• そして、$f(x) = ax + b$というモデルの構造では直線しか表現することができないので、違う形を考えることにした

• 「基になる」簡単な関数の、合成と和を考えることでかなり複雑な関数も表現できることがわかった

• 「基になる」関数の選び方を考える上で、この関数自体もパラメータによって変化させるモデルとして、ニューラルネットワークを導入した

• ニューラルネットワークは任意の関数を表現できることがわかった

第5回 ニューラルネットワークの学習と評価

• He, Xavierの初期化
• 確率的勾配降下法
• 損失関数
• オプティマイザ
• バリデーションと性能評価
• ハイパーパラメータ

Next ⇨ 第6回　ニューラルネットワークの実装

• ニューラルネットワークがなんでも表現できるぜ！！という主張は、
  条件を変えていろいろある
• ここでは一番有名(たぶん)なもの[1]について直感的な証明をする

[1]https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.441.7873&rep=rep1&type=pdf