ラビットチャレンジ #11 深層学習Day1

ニューラルネットワークの全体像

• 明示的なプログラムの代わりに多数の中間層を持つニューラルネットワークを用いて、入力値から目的とする出力値に変換するを数学モデルを構築すること
• 最終的に重みとバイアスを最適化したい

ニューラルネットワークでできること

回帰

• 連続する実数値を取る関数の近似
  • 回帰分析
    • 線形回帰
    • 回帰木
    • ランダムフォレスト
    • ニューラルネットワーク

分類

• 離散的な結果を予想するための分析
  • 分類分析
    • ベイズ分類
    • ロジスティック回帰
    • 決定木
    • ランダムフォレスト
    • ニューラルネットワーク

Section1 入力層～中間層

• 入力層から中間層を表すと下記のようになる

• 入力が犬の画像だと仮定すると、下記のように考えられる

  • $x_1$が体の大きさ
  • $x_2$が髭の長さ
  • $X_3$が色
  • $x_4$が耳の大きさ

• 入力層とは言葉の通りニューラルネットワークへの入力データ（そのまま）

• 入力層には扱わないほうがいいデータもあり、下記のようなデータは入力層としてとるべきではない

  • 欠損値が多いデータ
  • 誤差の大きいデータ
  • 出力そのもの、出力を加工した情報
  • 連続性の無いデータ（背番号とか）
  • 無意味な数が割り当てられているデータ

• 中間層は入力層からデータを渡される層

  • そのまま入力層からデータを渡されるのではなく重みやバイアスを与える

• 入力$x_i(i=1,2,3,4)$に重み$w_i$をかけたものにバイアスを足したものが中間層に出力される($u$)

• つまり、下記のように考えられる

  • $W=[w_1,w_2,w_3,w_4]^T$
  • $X=[x_1,x_2,x_3,x_4]^T$
  • $u=WX+b$

• 中間層の活性化関数$f(x)$によって$u$から$z$に変換されて中間層から出力される

• ここで活性化関数を恒等関数とすると$u=z$となる

u = np.dot(x,W) + b

実装演習

# 順伝播（単層・単ユニット）

def print_vec(text, vec):
    print("*** " + text + " ***")
    print(vec)
    print("")

# 重み
W = np.array([[0.1], [0.2]])

print_vec("重み", W)

# バイアス
b = 0.5

print_vec("バイアス", b)

# 入力値
x = np.array([2, 3])
print_vec("入力", x)

# 総入力
u = np.dot(x, W) + b
print_vec("総入力", u)

# 中間層出力
z = functions.relu(u)
print_vec("中間層出力", z)

# *** 重み ***
# [[0.1]
#  [0.2]]

# *** バイアス ***
# 0.5

# *** 入力 ***
# [2 3]

# *** 総入力 ***
# [1.3]

# *** 中間層出力 ***
# [1.3]

• 上のプログラムを図で表すと下のような感じ

Section2 活性化関数

• ニューラルネットワークにおいて、次の層への出力の大きさを決める非線形の関数
• 入力値の値によって、次の層への信号のON/OFFや強弱を定める働きをもつ

中間層でよく使われる活性化関数

• ReLU関数
• ステップ関数
• シグモイド関数

それぞれの関数の説明は下記

ReLU関数

• 今最も使われている活性化関数
• 勾配消失問題の回避とスパース化に貢献することで良い成果をもたらしている

• 数式
  

• サンプルコード

def relu(x):
    return np.maximum(0, x)

ステップ関数

• しきい値を超えたら発火する関数
• 出力は常に１か０
• パーセプトロン（ニューラルネットワークの前身）で利用された関数
• 課題として0 -1間の間を表現できず、線形分離可能なものしか学習できなかった

• 数式

• サンプルコード

def step_function(x):
    if x > 0:
        return 1
    else:
        return 0

シグモイド関数

• 0 ~ 1の間を緩やかに変化する関数
• ステップ関数では0 or 1しかない状態に対し、信号の強弱を伝えられるようになり、予想ニューラルネットワーク普及のきっかけとなった

• 数式

• サンプルコード

def sigmoid(x):
    return 1/(1 + np.exp(-x)

全結合NN-単層・複数ノード

Section3 出力層

• 出力層とは求めている結果を出力する層のこと（数字だったり、分類だったり、分類でも何割の確率の分類等）
• 出力層で結果を出力して終わりではない
• どれだけ精度の高い出力をだせているか評価する必要がある
• 出力層で出力された値がどれくらいあっているかを表すために 誤差関数が使用される
• 出力された値を誤差関数を使って評価する
• 誤差の計算に使われる関数（誤差関数）には平均二乗誤差がよく使われる

• 2乗する理由
  • 引き算で負の値もあり得るため、2乗して誤差を正の値になるようにする
• 1/2する理由
  • 誤差逆伝搬の計算で、誤差関数の微分を用いるが、その際の計算式を簡単にするため

出力層で使用される活性化関数

• 出力層と中間層の違い

  • 値の強弱
    • 中間層︓しきい値の前後で信号の強弱を調整
    • 出力層︓信号の大きさ（比率）はそのままに変換
  • 確率出力
    • 分類問題の場合、出力層の出力は0 ~ 1 の範囲に限定し、総和を１とする必要がある

• 以上のことから中間層と出力層で使う活性化関数が異なる

• 活性化関数と誤差関数の使い分け

出力層でよく使われる活性化関数

* ソフトマックス関数
* 恒等写像
* シグモイド関数

ソフトマックス関数

def softmax(x):
    if x.ndim == 2:
        x = x.T
        x = x -np.max(x, axis=0)
        y = np.exp(x) /np.sum(np.exp(x), axis=0)
        return y.T
    x = x -np.max(x) #オーバーフロー対策
    return np.exp(x) / np.sum(np.exp(x))

• ① 出力

softmax(x)

• ② $e$の入力乗

np.exp(x)

• ③ $e$のすべての入力乗の合計

np.sum(np.exp(x), axis=0)
# または
np.sum(np.exp(x))

誤差関数

二乗誤差

def mean_squared_error(d, y):
    return np.mean(np.square(d -y)) / 2

交差エントロピー誤差

• ①

cross_entropy_error(d, y)

• ②

-np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size

def cross_entropy_error(d, y):
    if y.ndim== 1:
        d= d.reshape(1, d.size)
        y= y.reshape(1, y.size)
        # 教師データがone-hot-vectorの場合、正解ラベルのインデックスに変換
        if d.size== y.size:
            d= d.argmax(axis=1)
            batch_size= y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size

実装演習

• Section2の内容も含みます

# ウェイトとバイアスを設定
# ネートワークを作成
def init_network():
    print("##### ネットワークの初期化 #####")

    network = {}
    network['W1'] = np.array([
        [0.1, 0.3, 0.5],
        [0.2, 0.4, 0.6]
    ])

    network['W2'] = np.array([
        [0.1, 0.4],
        [0.2, 0.5],
        [0.3, 0.6]
    ])

    network['b1'] = np.array([0.1, 0.2, 0.3])
    network['b2'] = np.array([0.1, 0.2])
    
    print_vec("重み1", network['W1'])
    print_vec("重み2", network['W2'])
    print_vec("バイアス1", network['b1'])
    print_vec("バイアス2", network['b2'])

    return network

# 順伝播
def forward(network, x):
    print("##### 順伝播開始 #####")

    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']
    
    u1 = np.dot(x, W1) + b1
    # 中間層の活性化関数
    # ReLU関数
    z1 = functions.relu(u1)
    u2 = np.dot(z1, W2) + b2
    y = functions.softmax(u2)
    
    print_vec("総入力1", u1)
    print_vec("中間層出力1", z1)
    print_vec("総入力2", u2)
    print_vec("出力1", y)
    print("出力合計: " + str(np.sum(y)))

    return y, z1

# 誤差逆伝播
def backward(x, d, z1, y):
    print("\n##### 誤差逆伝播開始 #####")

    grad = {}

    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']
    #  出力層でのデルタ
    delta2 = functions.d_sigmoid_with_loss(d, y)
    #  b2の勾配
    grad['b2'] = np.sum(delta2, axis=0)
    #  W2の勾配
    grad['W2'] = np.dot(z1.T, delta2)
    #  中間層でのデルタ
    delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)
    # b1の勾配
    grad['b1'] = np.sum(delta1, axis=0)
    #  W1の勾配
    grad['W1'] = np.dot(x.T, delta1)
        
    print_vec("偏微分_dE/du2", delta2)
    print_vec("偏微分_dE/du2", delta1)

    print_vec("偏微分_重み1", grad["W1"])
    print_vec("偏微分_重み2", grad["W2"])
    print_vec("偏微分_バイアス1", grad["b1"])
    print_vec("偏微分_バイアス2", grad["b2"])

    return grad
    
# 訓練データ
x = np.array([[1.0, 5.0]])
# 目標出力
d = np.array([[0, 1]])
#  学習率
learning_rate = 0.01
network =  init_network()
y, z1 = forward(network, x)

# 誤差
loss = functions.cross_entropy_error(d, y)

grad = backward(x, d, z1, y)
for key in ('W1', 'W2', 'b1', 'b2'):
    network[key]  -= learning_rate * grad[key]

print("##### 結果表示 #####")    


print("##### 更新後パラメータ #####") 
print_vec("重み1", network['W1'])
print_vec("重み2", network['W2'])
print_vec("バイアス1", network['b1'])
print_vec("バイアス2", network['b2'])

# *** 重み1 ***
# [[0.1 0.3 0.5]
#  [0.2 0.4 0.6]]

# *** 重み2 ***
# [[0.1 0.4]
#  [0.2 0.5]
#  [0.3 0.6]]

# *** バイアス1 ***
# [0.1 0.2 0.3]

# *** バイアス2 ***
# [0.1 0.2]

# ##### 順伝播開始 #####
# *** 総入力1 ***
# [[1.2 2.5 3.8]]

# *** 中間層出力1 ***
# [[1.2 2.5 3.8]]

# *** 総入力2 ***
# [[1.86 4.21]]

# *** 出力1 ***
# [[0.08706577 0.91293423]]

# 出力合計: 1.0

# ##### 誤差逆伝播開始 #####
# *** 偏微分_dE/du2 ***
# [[ 0.08706577 -0.08706577]]

# *** 偏微分_dE/du2 ***
# [[-0.02611973 -0.02611973 -0.02611973]]

# *** 偏微分_重み1 ***
# [[-0.02611973 -0.02611973 -0.02611973]
#  [-0.13059866 -0.13059866 -0.13059866]]

# *** 偏微分_重み2 ***
# [[ 0.10447893 -0.10447893]
#  [ 0.21766443 -0.21766443]
#  [ 0.33084994 -0.33084994]]

# *** 偏微分_バイアス1 ***
# [-0.02611973 -0.02611973 -0.02611973]

# *** 偏微分_バイアス2 ***
# [ 0.08706577 -0.08706577]

# ##### 結果表示 #####
# ##### 更新後パラメータ #####
# *** 重み1 ***
# [[0.1002612  0.3002612  0.5002612 ]
#  [0.20130599 0.40130599 0.60130599]]

# *** 重み2 ***
# [[0.09895521 0.40104479]
#  [0.19782336 0.50217664]
#  [0.2966915  0.6033085 ]]

# *** バイアス1 ***
# [0.1002612 0.2002612 0.3002612]

# *** バイアス2 ***
# [0.09912934 0.20087066]

Section4 勾配降下法

勾配降下法の種類

• 勾配降下法
• 確率的勾配降下法
• ミニバッチ降下法

---

• 勾配降下法って何に使うのか？
• そもそも深層学習の目的は学習を通して誤差を最小にするネットワークを作成すること
  • それはつまり、誤差を最小化するパラメータを見つけること
  • どうやって誤差を最小化するパラメータを見るけるのか？
    • ここで使うのが勾配降下法！！

勾配降下法

• 学習率の値によって効率が大きく異なる
• 学習率で何が変わるのかというと、グレーの矢印の動き

• 学習率が大きいと最小値にたどりつかず発散してしまう
  

• 学習率が小さすぎるときは最小値にたどり着くことはできるが、たどり着くまでにとても時間がかかる

確率的勾配降下法

• 確率的勾配降下法のメリット
  • データが冗長の場合の計算コストの軽減
  • 望まない局所極小解に収束するリスクの軽減
  • オンライン学習ができる

• 学習データが入ってくるたびに都度パラメータを更新し、学習を進めていく方法
• 一方、バッチ学習では一度にすべての学習データを使ってパラメータ更新を行う

ミニバッチ勾配降下法

• ミニバッチ勾配降下法のメリット
  • 確率的勾配降下法のメリットを損なわず、計算機の計算資源を有効利用できる
    • CPUを利用したスレッド並列化やGPUを利用したSIMD並列化

実装演習

確率的勾配降下法

# サンプルとする関数
#yの値を予想するAI

def f(x):
    y = 3 * x[0] + 2 * x[1]
    return y

# 初期設定
def init_network():
    # print("##### ネットワークの初期化 #####")
    network = {}
    nodesNum = 10
    network['W1'] = np.random.randn(2, nodesNum)
    network['W2'] = np.random.randn(nodesNum)
    network['b1'] = np.random.randn(nodesNum)
    network['b2'] = np.random.randn()

    return network

# 順伝播
def forward(network, x):
    # print("##### 順伝播開始 #####")
    
    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']
    u1 = np.dot(x, W1) + b1
    z1 = functions.relu(u1)
    
    ## 試してみよう
    #z1 = functions.sigmoid(u1)
    
    u2 = np.dot(z1, W2) + b2
    y = u2
    
    return z1, y

# 誤差逆伝播
def backward(x, d, z1, y):
    # print("\n##### 誤差逆伝播開始 #####")    

    grad = {}
    
    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']

    # 出力層でのデルタ
    delta2 = functions.d_mean_squared_error(d, y)
    # b2の勾配
    grad['b2'] = np.sum(delta2, axis=0)
    # W2の勾配
    grad['W2'] = np.dot(z1.T, delta2)
    # 中間層でのデルタ
    #delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)

    ## 試してみよう
    delta1 = np.dot(delta2, W2.T) * functions.d_sigmoid(z1)

    delta1 = delta1[np.newaxis, :]
    # b1の勾配
    grad['b1'] = np.sum(delta1, axis=0)
    x = x[np.newaxis, :]
    # W1の勾配
    grad['W1'] = np.dot(x.T, delta1)

    return grad

# サンプルデータを作成
data_sets_size = 100000
data_sets = [0 for i in range(data_sets_size)]

for i in range(data_sets_size):
    data_sets[i] = {}
    # ランダムな値を設定
    data_sets[i]['x'] = np.random.rand(2)
    
    ## 試してみよう_入力値の設定
    # data_sets[i]['x'] = np.random.rand(2) * 10 -5 # -5〜5のランダム数値
    
    # 目標出力を設定
    data_sets[i]['d'] = f(data_sets[i]['x'])
    
losses = []
# 学習率
learning_rate = 0.07

# 抽出数
epoch = 1000

# パラメータの初期化
network = init_network()
# データのランダム抽出
random_datasets = np.random.choice(data_sets, epoch)

# 勾配降下の繰り返し
for dataset in random_datasets:
    x, d = dataset['x'], dataset['d']
    z1, y = forward(network, x)
    grad = backward(x, d, z1, y)
    # パラメータに勾配適用
    for key in ('W1', 'W2', 'b1', 'b2'):
        network[key]  -= learning_rate * grad[key]

    # 誤差
    loss = functions.mean_squared_error(d, y)
    losses.append(loss)

print("##### 結果表示 #####")    
lists = range(epoch)


plt.plot(lists, losses, '.')
# グラフの表示
plt.show()

Section5 誤差逆伝播法

• 算出された誤差を、出力層側から順に微分し、前の層前の層へと伝播
• 最小限の計算で各パラメータでの微分値を解析的に計算する手法

• 逆伝播により同じ式を繰り返し使うことが出来ること（微分の連鎖律を使っている）
• 計算結果（=誤差）から微分を逆算することで、不要な再帰的計算を避けて微分を算出できる

実装演習

# ウェイトとバイアスを設定
# ネートワークを作成
def init_network():
    print("##### ネットワークの初期化 #####")

    network = {}
    network['W1'] = np.array([
        [0.1, 0.3, 0.5],
        [0.2, 0.4, 0.6]
    ])

    network['W2'] = np.array([
        [0.1, 0.4],
        [0.2, 0.5],
        [0.3, 0.6]
    ])

    network['b1'] = np.array([0.1, 0.2, 0.3])
    network['b2'] = np.array([0.1, 0.2])
    
    print_vec("重み1", network['W1'])
    print_vec("重み2", network['W2'])
    print_vec("バイアス1", network['b1'])
    print_vec("バイアス2", network['b2'])

    return network

# 順伝播
def forward(network, x):
    print("##### 順伝播開始 #####")

    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']
    
    u1 = np.dot(x, W1) + b1
    z1 = functions.relu(u1)
    u2 = np.dot(z1, W2) + b2
    y = functions.softmax(u2)
    
    print_vec("総入力1", u1)
    print_vec("中間層出力1", z1)
    print_vec("総入力2", u2)
    print_vec("出力1", y)
    print("出力合計: " + str(np.sum(y)))

    return y, z1

# 誤差逆伝播
def backward(x, d, z1, y):
    print("\n##### 誤差逆伝播開始 #####")

    grad = {}

    W1, W2 = network['W1'], network['W2']
    b1, b2 = network['b1'], network['b2']
    #  出力層でのデルタ
    delta2 = functions.d_sigmoid_with_loss(d, y)
    #  b2の勾配
    grad['b2'] = np.sum(delta2, axis=0)
    #  W2の勾配
    grad['W2'] = np.dot(z1.T, delta2)
    #  中間層でのデルタ
    delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)
    # b1の勾配
    grad['b1'] = np.sum(delta1, axis=0)
    #  W1の勾配
    grad['W1'] = np.dot(x.T, delta1)
        
    print_vec("偏微分_dE/du2", delta2)
    print_vec("偏微分_dE/du2", delta1)

    print_vec("偏微分_重み1", grad["W1"])
    print_vec("偏微分_重み2", grad["W2"])
    print_vec("偏微分_バイアス1", grad["b1"])
    print_vec("偏微分_バイアス2", grad["b2"])

    return grad
    
# 訓練データ
x = np.array([[1.0, 5.0]])
# 目標出力
d = np.array([[0, 1]])
#  学習率
learning_rate = 0.01
network =  init_network()
y, z1 = forward(network, x)

# 誤差
loss = functions.cross_entropy_error(d, y)

grad = backward(x, d, z1, y)
for key in ('W1', 'W2', 'b1', 'b2'):
    network[key]  -= learning_rate * grad[key]

print("##### 結果表示 #####")    


print("##### 更新後パラメータ #####") 
print_vec("重み1", network['W1'])
print_vec("重み2", network['W2'])
print_vec("バイアス1", network['b1'])
print_vec("バイアス2", network['b2'])

# ##### ネットワークの初期化 #####
# *** 重み1 ***
# [[0.1 0.3 0.5]
#  [0.2 0.4 0.6]]

# *** 重み2 ***
# [[0.1 0.4]
#  [0.2 0.5]
#  [0.3 0.6]]

# *** バイアス1 ***
# [0.1 0.2 0.3]

# *** バイアス2 ***
# [0.1 0.2]

# ##### 順伝播開始 #####
# *** 総入力1 ***
# [[1.2 2.5 3.8]]

# *** 中間層出力1 ***
# [[1.2 2.5 3.8]]

# *** 総入力2 ***
# [[1.86 4.21]]

# *** 出力1 ***
# [[0.08706577 0.91293423]]

# 出力合計: 1.0

# ##### 誤差逆伝播開始 #####
# *** 偏微分_dE/du2 ***
# [[ 0.08706577 -0.08706577]]

# *** 偏微分_dE/du2 ***
# [[-0.02611973 -0.02611973 -0.02611973]]

# *** 偏微分_重み1 ***
# [[-0.02611973 -0.02611973 -0.02611973]
#  [-0.13059866 -0.13059866 -0.13059866]]

# *** 偏微分_重み2 ***
# [[ 0.10447893 -0.10447893]
#  [ 0.21766443 -0.21766443]
#  [ 0.33084994 -0.33084994]]

# *** 偏微分_バイアス1 ***
# [-0.02611973 -0.02611973 -0.02611973]

# *** 偏微分_バイアス2 ***
# [ 0.08706577 -0.08706577]

# ##### 結果表示 #####
# ##### 更新後パラメータ #####
# *** 重み1 ***
# [[0.1002612  0.3002612  0.5002612 ]
#  [0.20130599 0.40130599 0.60130599]]

# *** 重み2 ***
# [[0.09895521 0.40104479]
#  [0.19782336 0.50217664]
#  [0.2966915  0.6033085 ]]

# *** バイアス1 ***
# [0.1002612 0.2002612 0.3002612]

# *** バイアス2 ***
# [0.09912934 0.20087066]