「.NET 開発基盤部会 Wiki」は、「Open棟梁Project」,「OSSコンソーシアム .NET開発基盤部会」によって運営されています。
目次 †
学習の概要 †
ニューラルネットワークにおいては、特徴量を機械が選択し重みを学習（自動獲得）する。
- 構造化データ
- 特徴量を表から選択する。
- 場合によっては次元圧縮したりする。
- 非構造化データ
- 画像
入力画像データから、本質的なデータを抽出できるように設計された変換器を指す。
- 画像データの特徴量は通常、ベクトルを使用して表される。
- SIFT, SURF, HOGなど、人が設計した変換器によって画像データをベクトル化する。
重みの自動獲得 †
学習フェーズでは、信号は逆方向に伝播する。
- 実際のニューラルネットワークの重みパラメタは、
- 数千、数万になるため、手動での設定は不可能。
- 更に層を深めた深層学習（deep learning）では数億にも登る。
- 重みパラメタの自動獲得のため、
- 損失関数という指標を導入する。
損失関数を使用して値が最小（最大）になるような重みパラメタを探す。
- このようなパラメタを探し出すためには、勾配法という手法を用いる。
勾配は、各場所で（損失）関数の値を最も減らす方向を示す。
学習はデータ駆動 †
- MNISTデータセットの様な画像の分類処理を行うアルゴリズムを考え出すのは困難。
しかし、機械にデータを学習させる機械学習を用いれば分類処理が実現可能。
人間が（暗黙的な学習によって、）これらを判別することはできる。
従って、人間の脳も、一部は、このようなデータ駆動で動いているのかもしれない。
- このように、アルゴリズムを捻り出すのではなく、データを有効活用して解決する方法に、
画像から特徴量を抽出し、特徴量のパターンを機械学習の技術で学習するという方法がある。
損失関数（誤差関数） †
- 損失関数は、誤差関数とほぼ同じか、より包括的な概念。
- 予想データと正解データの出力の間に、
どのくらい誤差があるのかを評価する関数。
- 作成した予測モデルの精度を評価する際に使われ、
- 値（誤差）が小さければ小さいほど正確なモデルと言える。
- モデル関数とデータ群の誤差という文脈では誤差関数と呼ばれる。
- 学習の文脈では損失関数と呼ばれ、誤差関数以外にも例えばKL情報量などを含む。
- 深層学習では一つの指標を手がかりに最適なパラメタを探索する。
- この指標を損失関数を呼び、パラメタに対して連続的に変化する関数を用いる。
- これは学習時に、微分によって傾きが0になってパラメタの更新できなくなることを防ぐため。
損失関数上の地形 †
- ほとんどの最適化アルゴリズムは、正確な勾配やヘッセ行列を前提としている。
- 鞍点
・ある方向から見ると極小値であるが、別の方向から見ると極大値になる点。
・鞍点の数はパラメタの数に対して指数関数的に増加するのでディープラーニングの場合は非常に多く存在する｡
- 平地：ほぼ水平な領域
・勾配が0となるような平地領域ではSGDで学習が進まなくなる｡
・MomentumSGDなどの慣性を用いた最適化アルゴリズムで解決を図る｡
- 崖：ほぼ垂直な領域
・勾配が急すぎて（勾配爆発を起こし）、パラメタが遠くに吹っ飛ぶ。
・同じ値の掛け算が繰り返し行われる場合に発生
・RNNなどで多く現れ、長期依存性が現れるのもこの地形が原因｡
・勾配の大きさに上限を設ける勾配クリッピングが有効｡
- ノイズやバイアス
・ノイズやバイアスが加わった場合、勾配が滑らかにならずギザギザした形になる｡
・これを回避するためには､損失関数をより平坦な代理損失関数で代用する｡
- ヘッセ行列
関数の二階偏導関数全体が作る正方行列で対称行列
・固有値の符号をみることにより極小点や凸性の判定を行える。
・固有値が全て正であれば、凸関数になるので大域解が求まることを保証できる。
- 悪条件
ヘッセ行列の特異値が非常に大きいまたは非常に小さい場合、その逆行列を求めることが困難になる。
・極端な比率の変数：ある変数が他の変数に比べて数桁大きいまたは小さい値を取る場合
・局所的な不連続性：関数が局所的な不連続性や非線形性を持つ場合
2乗和誤差 †
回帰の場合（ニューラルネットワークの出力と正解となる教師データの各要素の差の二乗の総和の２分の一。
- 説明
- k:データの次元数
- yk:ニューラルネットワークの出力
- tk:教師データ
- 例(k=10)
- yk:ニューラルネットワークの出力
=[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]
Softmax関数の出力（全て足して1.0になる。）
- tk:教師データ
=[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
※ 正解ラベルを1、ソレ以外を0とする、one-hot表現
- Python
- 実装
"""This is a test program."""
import numpy as np
def mean_squared_error(yk, tk):
"""損失関数(2乗和誤差)"""
return 0.5 * np.sum((yk - tk)**2)
# 教師データ
tk = np.array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0])
# 推定データ1の誤差
yk = np.array([0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0])
print(mean_squared_error(yk, tk))
# 推定データ2の誤差
yk = np.array([0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0])
print(mean_squared_error(yk, tk))
- 高ければ高いほど、０に近いデータになる。
tkで２が正解の場合、ykで２の確率が一番高いとしたデータの場合のE。
0.0975
- 低ければ低いほど、１に近いデータになる。
tkで２が正解の場合、ykで７の確率が一番高いとしたデータの場合のE。
0.5975
- 前者の損失関数(2乗和誤差)の出力が小さい前者のykがより適合していることを示している。
多クラス交差エントロピー誤差 †
多値分類（正解ラベルのykデータの底がeの自然対数 log eを計算する。
- 説明
- log:logは底がeの自然対数 log e
- k:データの次元数
- yk:ニューラルネットワークの出力
- tk:教師データ
- Python
- 実装
"""This is a test program."""
import numpy as np
def cross_entropy_error(yk, tk):
"""損失関数(交差エントロピー誤差)"""
delta = 1e-7 # log(0)はマイナス∞になるのを微小な値を足して防止。
return - np.sum(tk * np.log(yk + delta))
tk = np.array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0])
yk = np.array([0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0])
print(cross_entropy_error(yk, tk))
yk = np.array([0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0])
print(cross_entropy_error(yk, tk))
- 高ければ高いほど、０に近いデータになる。
tkで２が正解の場合、ykで２の確率が一番高いとしたデータの場合のE。
0.510825457099
- 低ければ低いほど、大きいデータになる。
tkで２が正解の場合、ykで７の確率が一番高いとしたデータの場合のE。
2.30258409299
- 前者の損失関数(交差エントロピー誤差)の出力が小さい前者のykがより適合していることを示している。
二値交差エントロピー誤差 †
ミニバッチ対応版
return np.mean(- y * np.log(p) - (1-y) * np.log(1-p))
勾配の計算 †
微分（偏微分）で求めた勾配の示す方向は、
各場所で関数の値を最も減らす方向（である可能性が高い）。
勾配降下法 †
- 勾配法では、広大なパラメタ空間から、複雑な損失関数が、
最小（最大）値を出力する鞍点（saddle point）を、勾配を使用して探す。
- 勾配降下法 : （誤差などが）最小になるパラメタ値を探す。
- 勾配上昇法 : （確率などが）最大になるパラメタ値を探す。
- ランダムにデータを選択する場合
- １つのデータを選択する場合、確率的勾配降下法（SGD）と呼ぶ。
- ｎ個のデータを選択し、損失の平均値を使用する場合、ミニバッチ勾配降下法と呼ぶ。
- 全てのデータを選択し、損失の平均値を使用する場合、バッチ勾配降下法(最急降下法)
- 注意点
- 勾配の指す方向に最小（最大）値があることは保証されない。
- 複雑な関数の場合は、勾配の指す方向に最小（最大）値が無い可能性が高い。
曲線の勾配計算 †
- 説明
- すべての変数の偏微分をベクトルとしてまとめたものを勾配と呼ぶ。
- 上記の例なら、x0=3, x1=4の場合、勾配は、(6, 8)となる。
- Python
- 実装
"""This is a test program."""
import numpy as np
def numerical_gradient(f, x01):
"""偏微分"""
h = 1e-4 # 微小な値hとして1の-4乗を用いる
grad = np.zeros_like(x01) # x01と同じ形状で要素が0。
for idx in range(x01.size):
tmp_val = x01[idx]
# 前方差分から中心差分にして誤差減
# f(x + h)
fxh1 = f(tmp_val + h)
# f(x - h)
fxh2 = f(tmp_val - h)
# (f(x + h) - f(x - h)) / 2 * h
grad[idx] = (fxh1 - fxh2) / (2 * h)
return grad
def function_2(x):
return np.sum(x**2)
print(numerical_gradient(function_2, np.array([3.0, 4.0])))
print(numerical_gradient(function_2, np.array([0.0, 2.0])))
print(numerical_gradient(function_2, np.array([3.0, 0.0])))
曲面の勾配計算 †
- Python
以下の式の最小値を勾配法で求める。
2 2
f(x0, x1) = x0 + x1
- 実装
import numpy as np
def numerical_gradient(f, x01):
"""偏微分"""
h = 1e-4 # 微小な値hとして1の-4乗を用いる
grad = np.zeros_like(x01) # x01と同じ形状で要素が0。
# print("x01:" + str(x01));
for idx in range(x01.size):
tmp_val = x01[idx]
# 前方差分から中心差分にして誤差減
# f(x + h)
fxh1 = f(tmp_val + h)
# f(x - h)
fxh2 = f(tmp_val - h)
# (f(x + h) - f(x - h)) / 2 * h
grad[idx] = (fxh1 - fxh2) / (2 * h)
return grad
def gradient_descent(f, init_x01, lr, step_num):
print("ln : step_num = " + str(lr) + " : " + str(step_num))
x01 = init_x01
for i in range(step_num):
grad = numerical_gradient(f, x01)
x01 -= lr * grad
return x01
def function_2(x):
return np.sum(x**2)
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function_2, init_x, 0.1, 100))
# 学習率が大きすぎる。
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function_2, init_x, 10.0, 100))
# 学習率が小さすぎる。
init_x = np.array([-3.0, 4.0])
print(gradient_descent(function_2, init_x, 1e-10, 100))
NNに対する勾配 †
ニューラルネットワークの学習における勾配は、
重みパラメタに関する損失関数の勾配となる。
- simpleNetを使って推論/学習
- 実装
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient
from gradient_simplenet import simpleNet
print("==================================================")
print("==================================================")
net = simpleNet()
print("W:" + str(net.W))
x = np.array([0.6, 0.9])
p = net.predict(x)
print("p:" + str(p))
t = np.array([0, 0, 1])
l = net.loss(x, t)
print("loss:" + str(l))
- simpleNetを使って勾配を求める
- 実装
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient
from gradient_simplenet import simpleNet
print("==================================================")
print("==================================================")
net = simpleNet()
print("W:" + str(net.W))
x = np.array([0.6, 0.9])
t = np.array([0, 0, 1])
f = lambda w: net.loss(x, t)
dW = numerical_gradient(f, net.W)
print("dW:" + str(dW))
- 出力
==================================================
==================================================
W:[[ 1.83160192 0.4900981 -0.94188042]
[-0.24946104 2.91410946 -0.00695892]]
dW:[[ 0.06708443 0.51711391 -0.58419835]
[ 0.10062665 0.77567087 -0.87629752]]
- w11を h 増やすと、0.06708443 h 増加する。
- w12を h 増やすと、0.10062665 h 増加する。
- w21を h 増やすと、0.51711391 h 増加する。
- w22を h 増やすと、0.77567087 h 増加する。
- w31を h 増やすと、-0.58419835 h 増加する( = 減少する)。
- w32を h 増やすと、-0.87629752 h 増加する( = 減少する)。
- 勾配がプラスならhをマイナス方向に、マイナスならプラス方向に動かす。
見せかけの最適化を防ぐ †
- 停留点は、極大点、極小点、鞍点のいずれかになりうる。
- 鞍点は、ある次元では最小だが、別の次元では最大（最小ではない）など。
- 最小化問題において、極小点は局所最小点または大域的最小点のいずれか。
- （最大化問題において、極大点は局所最大点または大域的最大点のいずれか。）
ミニバッチ学習 †
- 平均を取って誤差逆伝播する。
- ミニバッチがランダムにサンプリングされている限り、
ミニバッチから平均として算出された損失の勾配が真の勾配に従う。
バッチ、ミニバッチ、オンライン学習 †
- バッチ学習（一括学習）
- 全てのサンプルを一度に用いて勾配を求める手法
- 機械学習のアルゴリズムでは基本的にバッチ学習が採用される。
- ただし、深層学習では、データが多過ぎるため、現実的でない。
- オンライン学習（逐次学習）
- ひとつのサンプルのみを用いて勾配を求める手法
- ノイズや外れ値の影響を受け易く、解が適切な値に収束し難い。
- ミニバッチ学習
データを幾つかの塊に小分けにして、その塊毎に勾配を求める手法。
- 勾配計算に損失関数の平均値を使用しても問題はない。
- バッチ学習とオンライン学習の折衷案で、多くの場合において現実的な方法。
- バッチ学習ほど学習時間がかからず、
- オンライン学習ほど解の収束が不安定にならない｡
| バッチ学習（一括学習） | ミニバッチ学習 | オンライン学習（逐次学習） | | 効率 | ✕ | ○ | ◎ | | 安定性 | ◎ | ○ | ✕ |
ミニバッチ学習を訓練用データセットに適用 †
- ミニバッチ学習では、上記の損失関数を訓練用データセットに対して適用する。
- ここでは、訓練用データセットに対する損失関数の総和を指標とする。
- 説明
- 交差エントロピー誤差の式をN個のデータを含む訓練用データセット用に拡張する。
- 最後に、Nで割って正規化する（データ１個あたりの平均の損失関数を求める）。
- one-hot表現の場合
"""This is a test program."""
import numpy as np
def mean_squared_error(ynk, tnk):
"""損失関数(交差エントロピー誤差)"""
print("tnk:" + str(tnk))
print("ynk:" + str(ynk))
batch_size = ynk.shape[0]
print("batch_size:" + str(batch_size))
delta = 1e-7 # log(0)はマイナス∞になるのを微小な値を足して防止。
return - 1 / batch_size * (np.sum(tnk * np.log(ynk + delta)))
TNK = np.array([[0, 0, 1, 0, 0, 0, 0, 0, 0, 0], \
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]])
YNK = np.array([[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0], \
[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))
YNK = np.array([[0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0], \
[0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))
- one-hot表現でない場合
"""This is a test program."""
import numpy as np
def mean_squared_error(ynk, tnk):
"""損失関数(交差エントロピー誤差)"""
print("tnk:" + str(tnk))
print("ynk:" + str(ynk))
batch_size = ynk.shape[0]
print("batch_size:" + str(batch_size))
delta = 1e-7 # log(0)はマイナス∞になるのを微小な値を足して防止。
ynk = ynk + delta
print("arange:" + str(ynk[np.arange(batch_size), tnk]))
return - 1 / batch_size * (np.sum(np.log(ynk[np.arange(batch_size), tnk])))
TNK = np.array([2, 2])
YNK = np.array([[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0], \
[0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))
YNK = np.array([[0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0], \
[0.1, 0.05, 0.1, 0.0, 0.05, 0.1, 0.0, 0.6, 0.0, 0.0]])
print("mean_squared_error:" + str(mean_squared_error(YNK, TNK)))
バッチサイズ、イテレーション数、エポック数 †
- 1,000件の訓練データでバッチサイズを200にすると、
サブセットのサイズは200件でバッチの回数は５回になる。
- 訓練データサイズとバッチサイズが決まれば自動的に決まる。
- エポック数
- 一つの訓練データを何回繰り返して学習させるか？
- 深層学習ではパラメタが収束するまで同じ訓練データで繰り返し学習。
- 学習回数（エポック数）を一定以上増加させると、過学習が発生
適切なバッチサイズの選択 †
- 適切なバッチサイズを選ぶ事が、学習を上手く行うために必要になる。
- 大きくした場合
- 大まかな特徴を捉えるため精度は下がる。
- パラメタの更新が少ないため計算コストは下がる。
- 小さくした場合
- 精度は上がる。小さすぎると学習が終了しない可能性がある。
- １件毎に誤差逆伝播処理するため計算回数＝コストは上がる。
- その他注意点
- GPU を用いて計算する際は、2 のべき乗にバッチサイズを設定する。
- バイアスがかからないようにミニバッチはランダムに選ぶ。
- バッチサイズ5
- そもそも学習が上手くできていない。
- 1つ1つのデータに敏感に反応し過ぎて学習が難しい。
- バッチサイズ50
- 初めは順調に学習が進む。
- 途中から過学習を起こす。
- バッチサイズ500
- 過学習を起こすことなく順調に学習が進むが、
- パラメタ更新回数が少ないため、学習は途中
※loss（損失）とacc（正解率）の進捗を確認する。
その他 †
実装 †
手順 †
前提 †
- ニューラルネットワークには適応可能な重みとバイアスがある。
- 学習により、この重みとバイアスを訓練データに適応するように調整する。
- ニューラルネットワークの学習は、以下の4つのステップで行われる。
ステップ 1 †
- 訓練データから、ランダムにデータを選択する。
- ここでは、損失関数の値を減らすことを目的とする。
ステップ 2 †
- ミニバッチの損失関数を減らすために、各重みパラメタの勾配を求める。
- 勾配は、損失関数の値を最も減らす方向を示す。
ステップ 3 †
重みパラメタを勾配の方向に微小量だけ更新する。
ステップ 4 †
ステップ 1, ステップ 2, ステップ 3を繰り返す。
2層NNのクラス †
TwoLayerNet?クラス
https://github.com/oreilly-japan/deep-learning-from-scratch/blob/master/ch04/two_layer_net.py
変数 †
| # | 変数 | 説明 | | 1 | params | ニューラルネットワークの重みパラメタのディクショナリ変数 | | 1-1 | | params['W1'] | 第1層の重み | | 1-2 | | params['b1'] | 第1層のバイアス | | 1-3 | | params['W2'] | 第2層の重み | | 1-4 | | params['b2'] | 第2層のバイアス | | 2 | grads | numerical_gradientで計算された勾配を保持するディクショナリ変数 | | 1-1 | | params['W1'] | 第1層の重みの勾配 | | 1-2 | | params['b1'] | 第1層のバイアスの勾配 | | 1-3 | | params['W2'] | 第2層の重みの勾配 | | 1-4 | | params['b2'] | 第2層のバイアスの勾配 |
メソッド †
| # | メソッド シグネチャ | 引数 | 説明 | | 1 | __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01): | コンストラクタ | | 1-1 | | self | インスタンス | | 1-2 | | input_size | 入力層のニューロンの数 | | 1-3 | | hidden_size | 隠れニューロンの数 | | 1-4 | | output_size | 出力層のニューロンの数 | | 1-5 | | weight_init_std | ・・・ | | 2 | predict(self, x): | 推論を行う | | 2-1 | | self | インスタンス | | 2-2 | | x | 画像データ | | 3 | loss(self, x, t): | 損失関数の値を求める | | 3-1 | | self | インスタンス | | 3-2 | | x | 画像データ | | 3-3 | | t | 正解ラベル | | 4 | accuracy(self, x, t): | 推論の精度を求める | | 4-1 | | self | インスタンス | | 4-2 | | x | 画像データ | | 4-3 | | t | 正解ラベル | | 5 | numerical_gradient(self, x, t): | lossを使用し各重みパラメタの勾配を求める | | 5-1 | | self | インスタンス | | 5-2 | | x | 画像データ | | 5-3 | | t | 正解ラベル | | 6 | gradient(self, x, t): | numerical_gradientの高速版 | | 6-1 | | self | インスタンス | | 6-2 | | x | 画像データ | | 6-3 | | t | 正解ラベル |
学習過程の実装 †
勾配法により（損失）関数を少なくしていく。
- 重みパラメタ
- W(1) =
(784, x = 100)
- b(1) =
(1, x = 100)
- 隠れ層 (x = 100)
- A(1) =
(100, x = 100)
- = x(2) =
(100, x = 100)
- 重みパラメタ
- W(2) =
(x = 100, 10)
- b(2) =
(1, 10)
- 第2層
- A(2) =
(100, 10) # 0-9の数字
- 実装
C:\deep-learning-from-scratch-master\ch04\train_neuralnetを以下のように編集
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet
# データの読み込み
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
iters_num = 10000 # 繰り返しの回数を適宜設定する
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1
train_loss_list = []
for i in range(iters_num):
print(str(i) + " / " + str(iters_num))
batch_mask = np.random.choice(train_size, batch_size)
x_batch = x_train[batch_mask]
t_batch = t_train[batch_mask]
# 勾配の計算
#grad = network.numerical_gradient(x_batch, t_batch)
grad = network.gradient(x_batch, t_batch)
# パラメータの更新
for key in ('W1', 'b1', 'W2', 'b2'):
network.params[key] -= learning_rate * grad[key]
loss = network.loss(x_batch, t_batch)
train_loss_list.append(loss)
plt.xlabel("Iteration")
plt.ylabel("loss")
plt.plot(range(iters_num), train_loss_list)
plt.show()
学習結果を確認する実装 †
学習結果を使用して、学習データとテストデータを推論する。
- 出力
1バッチ・サイクル毎に学習した重みパラメタを使用した推論結果が表示される。
- CMD
train acc, test acc | 0.102183333333, 0.101
train acc, test acc | 0.783416666667, 0.7894
train acc, test acc | 0.874916666667, 0.8791
train acc, test acc | 0.8964, 0.8991
train acc, test acc | 0.907433333333, 0.9092
train acc, test acc | 0.913616666667, 0.9147
train acc, test acc | 0.9184, 0.9185
train acc, test acc | 0.923366666667, 0.9238
train acc, test acc | 0.926316666667, 0.9275
train acc, test acc | 0.9294, 0.9298
train acc, test acc | 0.932666666667, 0.9318
train acc, test acc | 0.9341, 0.9341
train acc, test acc | 0.936816666667, 0.9367
train acc, test acc | 0.940133333333, 0.9382
train acc, test acc | 0.94175, 0.9397
train acc, test acc | 0.943566666667, 0.9417
train acc, test acc | 0.945233333333, 0.9435
ハイパーパラメタ †
- 1回のミニバッチのサイズ
batch_size = 100
|
![[PukiWiki]](image/pukiwiki.png "[PukiWiki]")
accuracy.png
learning.png
