TensorFlow・Keras のバックアップ(No.3)

「.NET 開発基盤部会 Wiki」は、「Open棟梁Project」,「OSSコンソーシアム .NET開発基盤部会」によって運営されています。

戻る
- 深層学習（deep learning）
- データマイニング（DM）- Python

目次 †

↑

概要 †

↑

TensorFlow? †

現在、最も人気のあるOSS（Apache License 2.0）の深層学習フレームワーク

Googleのサービスの研究と生産に使用されており、
DistBelief?（クローズドソース）の役割をほぼ置き換えている‍。

2015年11月9日にベータ版が公開され、
2017年2月15日には正式版がリリース。

ドキュメンテーションが充実している。

モバイルのプラットフォーム上でも動作（エッジ・コンピューティング

TensorBoard?と言う訓練過程を観察できる機能が付いている。

↑

言語 †

C言語、C++、Python、Java、Go

↑

特徴 †

人間が用いる学習や論理的思考と似たように、

パターンや相関を検出し解釈する
ニューラルネットワークを構築、訓練の要求を満たす。

↑

Keras †

迅速な実験を可能にすることに重点を置く。
OSS（MIT）。中心的な開発者・メンテナはGoogleのエンジニア
- 2015年に初版公開
- 2017年にTensorFlowコアライブラリをサポート
- 現在はTensorFlowに取り込まれ、tf.Kerasの形で使われるのが一般的。

↑

言語 †

Pythonで書かれている。

↑

特徴 †

∴ フレームワークによる記述を非常に高級にしてくれるラッパーとして機能する。

複数のバックエンドをサポート（TensorFlow、Theano、CNTK）

レイヤを積み上げていく要領でモデルを直感的に定義し・構築できる。

モデルの
- 実装が素早くできるのでプロトタイプの作成に便利。
- 構築が簡単で初心者にとっても解かり易いモノになる。

↑

環境：Notebook系 †

機械学習・深層学習の特性上、インタラクティブな環境の方が習得が捗る。

↑

チュートリアル †

↑

準備 †

↑

on Jupyter on Docker †

イメージを変えてコチラの例と同様にできる。
使用するイメージは、tensorflow/tensorflow:latest-jupyter

↑

インストール～初期化 †

インストール
```
!pip install --upgrade pip
```

tensorflow
```
!pip install -U tensorflow
```

keras
```
!pip install -U keras
```

その他
色々、足りてない。

!pip install numpy
!pip install pandas
!pip install seaborn
!pip install statsmodels
!pip install scikit-learn
!pip install opencv-python

警告の非表示

import warnings
warnings.filterwarnings('ignore')

インポート

基本的なライブラリ
NumPy, Pandas, Matplotlib

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

TensorFlow?

import tensorflow as tf
from tensorflow.keras.layers import BatchNormalization
print(tf.__version__)

Keras

import keras
print(keras.__version__)
# モデル定義
from keras.models import Model, Sequential, model_from_json
from keras.layers import Dense, Input, Activation, Flatten, Dropout, LSTM
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPool2D
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras import optimizers
from keras.optimizers import SGD, Adam
# その他
from keras.applications.vgg16 import VGG16
from keras.utils import np_utils

scikit-learn

from sklearn import metrics
from sklearn.metrics import confusion_matrix as cm
from sklearn.model_selection import train_test_split

opencv-python

import
```
import cv2 # OpenCV
```

以下のエラーになる場合、
「cannot open shared object file: No such file or directory」
以下のコマンドをTerminalから実行する。
```
apt-get update && apt-get upgrade -y
apt-get install -y libgl1-mesa-dev
apt-get install -y libopencv-dev
```

その他

from statsmodels.tsa.seasonal import seasonal_decompose

↑

CNN †

↑

手書き数字画像の認識 †

コチラのTensorFlow?・Keras版。

データセット

ロード

from keras.datasets import mnist
(x_train_org, y_train_org), (x_test_org, y_test_org) = mnist.load_data()
print(x_train_org.shape, x_test_org.shape)
print(y_train_org.shape, y_test_org.shape)

確認
関数の定義はコチラ。

show_image_info(x_train_org, y_train_org, [0,1,2,3,4,5,6,7,8,9], 10)

変換

XのKeras入力用型変換

x_train_std = x_train_org.astype('f')
x_test_std = x_test_org.astype('f')

Xの画素を0.0-1.0の範囲に正規化
```
x_train_std /= 255
x_test_std /= 255
```

正解ラベルのOne-Hotエンコーディング
Kerasでは正解ラベルはOne-Hotベクトル化が必要。
・エンコーディング

y_train = np_utils.to_categorical(y_train_org, num_classes=10).astype('i') 
y_test = np_utils.to_categorical(y_test_org, num_classes=10).astype('i')

・デコーディング

print((y_train.argmax(axis=1) == y_train_org).all())
print((y_test.argmax(axis=1) == y_test_org).all())

モデルの定義
以下のように層を重ねて多層パーセプトロン（MLP）モデルを定義

Flatten
Flattenで画像行列をベクトル化

Dense
全結合層（Dense）に入力

Activation（活性化関数）
活性化関数（線形、ReLU、tanh、シグモイド関数）のモジュール

線型の活性化関数：
決定境界はパーセプトロンと変わらない。
非線型の活性化関数：
・決定境界が曲線となりよく分類できる。
・ニューラルネットで大量のパラメータを用意することで複雑な決定境界を作れる。

Optimizers
勾配降下法のアルゴリズムを決める。
- SGD (MomentumSGD, NAG)
- Rmsprop
- Adam
- AdaDelta?
- AdaGrad?

batchsize
ミニバッチ学習のサンプル数を決める。

epoch数
学習の繰り返し回数を決める。
- 計算リソースと相談
- 基本は多い方が精度が高い
- 過学習が起きることもある

Activation（softmax関数）
- 予測を行うための計算処理（順伝播計算）
- softmax関数：出力層への入力を確率に変換する活性化関数

誤差逆伝播法で学習を行うための計算処理（逆伝播計算）

cross_entropy誤差関数（損失関数）：
・cross_entropy誤差関数とはニューラルネットに特有の誤差関数
・softmax関数と対になるのはsoftmax_cross_entropy誤差関数
・誤差逆伝播法を行ったときに手前の層まで更新が行き渡る。

ニューラルネットは数式上では大規模な合成関数で、
連鎖律（合成関数の微分の計算規則）で手前の層のパラメタを調整できる｡

確率的勾配降下法：
バッチ学習の最急降下法を改良しサンプリングを使って高速に行う勾配降下法。

# モデルのインスタンスを作成
model = Sequential()

# addメソッドで層を追加していく。

# Flatten：入力の変換層、入力サイズを指定
model.add(Flatten(input_shape=(28, 28)))

# 入力層
# Dense：全結合（線形結合）層、出力サイズを指定
model.add(Dense(900))
# Activation: 活性化関数を定義（ReLU
model.add(Activation('relu'))

# 多層化：繰り返し
model.add(Dense(1000))
model.add(Activation('relu'))
model.add(Dense(500))
model.add(Activation('relu'))

# 出力層：
# Dense：全結合（線形結合）層、出力サイズを指定
model.add(Dense(10))
# Activation: 活性化関数を定義（softmax
model.add(Activation('softmax'))

# 誤差関数、最適化手法、評価基準を指定してコンパイル
# ・損失関数　：categorical_crossentropy（分類の定番、回帰ならRMSE）
# ・最適化手法：SGD（基本的な確率的勾配降下法）
# ・評価方法　：Accuracy（精度）に指定
model.compile(loss='categorical_crossentropy',
              optimizer=SGD(),
              metrics=['accuracy'])

モデルの学習
以下のようなパラメタを設定して学習を実行する。

訓練用入力データ、教師データ
テスト用入力データ、教師データ
batch_size：バッチサイズ
epochs：エポック数

varbose：学習時の表示
・0:表示なし
・1:通常表示
・2:エポックと出力のみ表示

batch_size = 100
n_epoch = 20
# Keras Model の fit() は History オブジェクトを返す
hist = model.fit(x_train_std, y_train,
                 validation_data=(x_test_std, y_test),
                 batch_size=batch_size,
                 epochs=n_epoch,
                 verbose=1
                 )

※ batch_size、epochsについてはコチラ

モデルの推論
関数の定義はコチラ。

index = 10
show_image_info(x_train_org, y_train_org, [0,1,2,3,4,5,6,7,8,9], index)

predict = model.predict(x_test_std[index].reshape(1, 28, 28)).argmax()
answer  = y_test_org[index]

print('predict: ', predict)
print('answer : ', answer)

if predict == answer:
    print('正解')
else:
    print('不正解')

モデルの評価

テストデータで評価

model.evaluate(x_test_std, y_test) #（損失値、精度）を返す

訓練データで評価
エポック毎の精度（acc）と損失値（loss）

val_～はテストデータ、
それ以外は訓練データに対応する。
```
hist.history
```

グラフへの表示
・関数定義

# 損失値(Loss)の遷移のプロット
def plot_history_loss(hist):
    plt.plot(hist.history['loss'],label="loss for training")
    plt.plot(hist.history['val_loss'],label="loss for validation")
    plt.title('model loss')
    plt.xlabel('epoch')
    plt.ylabel('loss')
    plt.legend(loc='best')
    plt.show()
    
# 精度(Accuracy)の遷移のプロット
def plot_history_acc(hist):
    plt.plot(hist.history['accuracy'],label="accuracy for training")
    plt.plot(hist.history['val_accuracy'],label="accuracy for validation")
    plt.title('model accuracy')
    plt.xlabel('epoch')
    plt.ylabel('accuracy')
    plt.legend(loc='best')
    plt.ylim([0, 1])
    plt.show()

・グラフ表示

plot_history_loss(hist)
plot_history_acc(hist)

混同行列を出力

混同行列を取得

result = model.predict(x_test_std).argmax(axis=1)
confmat = cm(y_test_org, result)  # y_testはOne-Hot表現前
confmat

関数定義

def plot_cm(confmat, size):
    fig, ax = plt.subplots(figsize=(size, size))
    ax.matshow(confmat, cmap=plt.cm.Blues, alpha=0.3)
    for i in range(confmat.shape[0]):
        for j in range(confmat.shape[1]):
            ax.text(x=j, y=i, s=confmat[i, j], va='center', ha='center')
    plt.xticks(np.arange(0, size, 1))
    plt.yticks(np.arange(0, size, 1))
    plt.xlabel('predicted label')
    plt.ylabel('true label')
    plt.show()

グラフ表示
　間違い易い、組合せが解る（1・7、2・7、3・8、3・9、4・9、7・9）。
```
 plot_cm(confmat, 10)
```

メトリック表示

関数定義
ロジスティクス回帰の所の関数をカスタマイズ

def print_metrics(data, label, result):
    print('accuracy: %.3f' % metrics.accuracy_score(label, result)) # 正答率
    print('recall: %.3f' % metrics.recall_score(label, result, average='macro')) # 再現率（マクロ平均）
    print('precision: %.3f' % metrics.precision_score(label, result, average='macro')) # 適合率（マクロ平均）
    print('f1_score: %.3f' % metrics.f1_score(label, result, average='macro')) # f値（マクロ平均）

指標確認

print_metrics(x_test_std, y_test_org, result)  # y_testはOne-Hot表現前

間違った画像の出力
関数の定義はコチラ。

index = (y_test_org != result)
for i, val in enumerate(index):
    if val == True:
        print('predict: ', result[i])
        print('answer : ', y_test_org[i])
        show_image_info(x_test_org, y_test_org, [0,1,2,3,4,5,6,7,8,9], i)

↑

商品の自動タグ付け †

データセット

ロード

サイトから取ってくる場合だが、

import os
from urllib import request
os.mkdir('./datasets') 
url = 'https://.../train.pickle'
request.urlretrieve(url, './datasets/train.pickle')
url = 'https://.../test.pickle'
request.urlretrieve(url, './datasets/test.pickle')
url = 'https://.../label.pickle'
request.urlretrieve(url, './datasets/label.pickle')

Kerasデータセットにあるもよう。
```
from keras.datasets import cifar10
(x_train,y_train),(x_test,y_test)=cifar10.load_data()
```
https://qiita.com/God_KonaBanana/items/10fa8bb58cdd1dbd2e59

確認

関数を定義

def unpickle(file):
    import pickle
    with open(file, 'rb') as f:
        return pickle.load(f, encoding='bytes')

関数で読込

train = unpickle('./datasets/train.pickle')
test = unpickle('./datasets/test.pickle')
label = unpickle('./datasets/label.pickle')

変数に代入

x_train_org = train['data']
y_train_org = train['label']
x_test_org = test['data']
y_test_org = test['label']
print(x_train_org.shape)
print(y_train_org.shape)
print(x_test_org.shape)
print(y_test_org.shape)

変換

要素の並び順を入れ替える
（Opencv, Kerasの仕様の関係上

# サンプル数, height, width, channelへ変更
x_train = x_train_org.transpose([0, 2, 3, 1])
x_test = x_test_org.transpose([0, 2, 3, 1])

XのKeras入力用型変換

x_train_std = x_train.astype('f')
x_test_std = x_test.astype('f')

Xの画素を0.0-1.0の範囲に正規化
```
x_train_std /= 255
x_test_std /= 255
```

正解ラベルのOne-Hotエンコーディング
Kerasでは正解ラベルはOne-Hotベクトル化が必要。
・エンコーディング

y_train = np_utils.to_categorical(y_train_org, num_classes=5).astype('i') 
y_test = np_utils.to_categorical(y_test_org, num_classes=5).astype('i')

・デコーディング

print((y_train.argmax(axis=1) == y_train_org).all())
print((y_test.argmax(axis=1) == y_test_org).all())

画像とラベルを確認
関数の定義はコチラ。
```
show_image_info(x_train, y_train_org, label, 1300)
```

モデルの定義
畳み込み層とプーリング層が3層、全結合層が2層のCNNモデル

input_shape：入力のテンソルの形
filters：カーネル数＝フィルター数＝特徴マップ数
kernel_size：カーネルのサイズ（辺のピクセル数
strides：カーネルをスライドさせる際のピクセル数

padding：画像の縁取り処理における縁取り幅（kernel_size=3,3ならpadding=1,1(=same)で縮小しない。）

model = Sequential()

# 畳み込み層とプーリング層１ 
model.add(Conv2D(input_shape=(32, 32, 3), filters=64, kernel_size=(4, 4), strides=(1, 1), padding='same')) # 畳み込み層
# バッチ正規化の追加位置
model.add(MaxPool2D(pool_size=(2, 2))) # プーリング増
model.add(Activation('relu'))

# 畳み込み層とプーリング層２
model.add(Conv2D(filters=128, kernel_size=(4, 4), strides=(1, 1), padding='same')) # 畳み込み層
# バッチ正規化の追加位置
model.add(MaxPool2D(pool_size=(2, 2))) # プーリング増
model.add(Activation('relu'))

# 畳み込み層とプーリング層３
model.add(Conv2D(filters=128, kernel_size=(4, 4), strides=(1, 1), padding='same')) # 畳み込み層
# バッチ正規化の追加位置
model.add(MaxPool2D(pool_size=(2, 2))) # プーリング増
model.add(Activation('relu'))

model.add(Flatten())

# 全結合層１
model.add(Dense(512))
model.add(Activation('relu'))

# Dropoutの追加位置

# 全結合層２
model.add(Dense(5))
model.add(Activation('softmax'))

# コンパイル 
model.compile(loss='categorical_crossentropy',
              optimizer=SGD(0.01), # 学習率：0.01
              metrics=['accuracy'])

モデルの学習

batch_size = 500
n_epoch = 30
hist = model.fit(x_train_std , y_train,
                 validation_data=(x_test_std, y_test),
                 batch_size=batch_size,
                 epochs=n_epoch,
                 verbose=1)

モデルの推論
関数の定義はコチラ。

index = 10
show_image_info(x_train, y_train_org, label, index)

predict = model.predict(x_test_std[index].reshape(1, 32, 32, 3)).argmax()
answer  = y_test_org[index]

print('predict: ', predict)
print('answer : ', answer)

if predict == answer:
    print('正解')
else:
    print('不正解')

モデルの評価

テストデータで評価
コチラと同じ。

訓練データで評価
- コチラと同じ。
- 訓練不足であることが解る。

混同行列を出力
コチラと同じ。

メトリック表示
コチラと同じ。

間違った画像の出力
コチラとホボ同じ。

index = (y_test_org != result)
for i, val in enumerate(index):
    if val == True:
        print('predict: ', result[i])
        print('answer : ', y_test_org[i])
        show_image_info(x_test, y_test_org, label, i)

性能向上

訓練不足を補う
batch_size, epochs=n_epoch

チューニングを行う

その他のCNNモデル
ググると色々出てくる。
計算量からGPUが必須。

AlexNet?
ILSVRC2012で優勝し、Deep Learningブームの火付け役となった

GoogLeNet?
インセプションモジュールという構造を採用し深いネットワークの学習を可能にした

VGG16
畳み込み13層と全結合3層の計16層から成る畳み込みニューラルネットワーク

ResNet?
残差学習という手法を取り入れ152層の深いネットワークの学習を可能にした

↑

画像とラベルの確認 †

def show_image_info(x, y, label, index):
    print(label[y[index]])
    plt.imshow(x[index].astype(np.uint8))
    plt.show()

↑

画像の前処理 †

OpenCVを使用する。

lenna.pngの

ダウンロード

url = 'https://upload.wikimedia.org/wikipedia/en/7/7d/Lenna_%28test_image%29.png'
request.urlretrieve(url, 'lenna.png')

読込・確認

img = cv2.imread('lenna.png')
print(type(img))
print(img.shape)
plt.imshow(img) # OpenCVはBGR解釈なので青みがかる。

変換して保存

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # RGB解釈に変更。
plt.imshow(img) # 元のRGB解釈の色合いで表示される。
cv2.imwrite('new_lenna.jpg', img) # RGB解釈で保存

様々な変換処理

比較関数を定義

def diff_image_info(img1, img2):
    print(img1.shape)
    print(img2.shape)
    plt.subplot(1, 2, 1)
    plt.imshow(img1)
    plt.subplot(1, 2, 2)
    plt.imshow(img2)

リサイズ
学習に画像データを入力するときは画像のサイズを揃える。
```
img2 = cv2.resize(img, (224, 224))
diff_image_info(img, img2)
```

クロップ
画像の一部を切り抜く処理はarrayのスライシングで実装。

ピクセル

img2 = img[100:400,100:400,:]
diff_image_info(img, img2)

比率

h, w, c = img.shape
img2 = img[:, int(w * (1/5)): int(w *(4/5)), :]
diff_image_info(img, img2)

明るさ調整

グレースケール化
色の意味合いが低い場合、モノクロ画像に変換し計算量を減らす。
```
grayed = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
diff_image_info(img, grayed)
```

2値化

th, binary = cv2.threshold(grayed, 125, 255, cv2.THRESH_BINARY)
diff_image_info(grayed, binary)

平滑化
画像をぼやかしノイズ（ガサつきなど）を取り除く。
```
blurred = cv2.GaussianBlur(binary, (11, 11), 0)
diff_image_info(binary, blurred)
```

ヒストグラム平坦化
画像の明るさの範囲を引き伸ばすと明暗部分でも輪郭線が認識し易くなる。
```
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
clahed = clahe.apply(grayed)
diff_image_info(grayed, clahed)
```

Mean Subtraction
0～1正規化と合わせた標準化のようなスケーリング処理
BatchNormalization?のように共変量シフトを抑制できる｡
```
img2 = img.astype('f')
img2 /= 255 # 0～1正規化
img2 -= np.mean(img2) # スケーリング
diff_image_info(img, img2)
```

データ拡張（data augmentation）

左右反転

flipped = cv2.flip(img, 1)
diff_image_info(img, flipped)

回転
・関数定義

def opencv_rotate(img, angle=30):
    size = (img.shape[0], img.shape[1])
    center = (int(size[0]/2), int(size[1]/2))
    rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
    return cv2.warpAffine(img, rotation_matrix, size)

・回転実行

rotated = opencv_rotate(img, 30)
diff_image_info(img, rotated)

並進
・関数定義

def opencv_move(img, h=100, v=50):
    rows, cols, channnels = img.shape
    M = np.float32([[1,0,h],[0,1,v]])
    return cv2.warpAffine(img, M, (cols, rows))

・並進実行

moved = opencv_move(img, 200, 100)
diff_image_info(img, moved)

拡大
・関数定義

def opencv_zoomin(img, h=2.0, v=2.0):
    zoomed = cv2.resize(img, None, fx=h, fy=v)
    height_1, width_1, channel_1 = img.shape
    height_2, width_2, channel_2 = zoomed.shape
    x =  int((width_2 - width_1) / 2)
    y =  int((height_2 - height_1) / 2)
    return zoomed[y:y+height_1, x:x+width_1]

・拡大実行

zoomed = opencv_zoomin(img, 2, 3)
diff_image_info(img, zoomed)

ガンマ変換
画像の明るさを全体的に明るく or 暗くする処理
・関数定義

def opencv_gamma(img, gamma=0.5):
    look_up_table = np.zeros((256, 1), dtype='uint8')
    for i in range(256):
        look_up_table[i][0] = 255 * pow(float(i) / 255, 1.0 / gamma)
    return cv2.LUT(img, look_up_table)

・ガンマ変換

img_gamma = opencv_gamma(img, 0.3)
diff_image_info(img, img_gamma)

ガウシアンノイズ
画像の加工過程で発生する粒が散らばったようなノイズを加える。・関数定義

def opencv_gaussian(img, loc=0.0, scale=5.0):
    row, col, ch = img.shape
    noise = np.random.normal(loc,scale,(row,col,ch))
    noise = noise.reshape(row,col,ch)
    noised = img + noise
    noised /= 255
    return noised

・ガンマ変換

img_gaussian = opencv_gaussian(img, 50, 100)
diff_image_info(img, img_gaussian)

関数例

バッチ変換

def get_changed(img):
    ...
    return img

バッチ拡張

def get_augmented(img):
    # 左右反転
    if np.random.rand() > 0.5:
        img = cv2.flip(img, 1)
    # 左右度回転
    if np.random.rand() > 0.5:
        size = (img.shape[0], img.shape[1])
        center = (int(size[0]/2), int(size[1]/2))
        angle = np.random.randint(-45, 45) # -45 ～ +45 の範囲で
        rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
        img = cv2.warpAffine(img, rotation_matrix, size)
    return img
plt.imshow(get_augmented(x_train[1300]).astype(np.uint8))

↑

転移学習、ファイン・チューニング †

全結合層部分を含まない学習済みモデルの読込
- weights ：重みの初期値（'random': ランダム, 'imagenet': 学習済みの重み）
- include_top ：全結合層のダウンロード（True: する, False: しない）
- input_tensor：入力テンソルの型（縦, 横, チャンネル）
```
inputs = VGG16(weights='imagenet', include_top=False, input_tensor=Input(shape=(32, 32, 3)))
# inputs.output_shape => (None, 1, 1, 512)
```

追加する全結合層部分を定義

n_class = 5
output = Sequential()
output.add(Flatten(input_shape=inputs.output_shape[1:]))
output.add(Dense(256))
output.add(Activation('relu'))
output.add(Dropout(0.5))
output.add(Dense(n_class))
output.add(Activation('softmax'))

全結合層部分を含まない学習済みモデルに全結合層部分を追加
```
model = Model(inputs=base_model.input, outputs=output(base_model.output))
```

畳み込み層のパラメタを固定してコンパイル

for layer in model.layers[:15]:
    layer.trainable = False
model.compile(loss='categorical_crossentropy',
              optimizer=SGD(lr=0.0001),
              metrics=['accuracy'])

モデルの確認と試用

確認
```
model.summary()
```

前処理

関数定義

def preprocess_vgg16(img):
    # リサイズ
    img= cv2.resize(img, (32, 32))
    # RGBからそれぞれvgg指定の値を引く
    # (mean-subtractionに相当)
    img[:, :, 0] -= 103.939
    img[:, :, 1] -= 116.779
    img[:, :, 2] -= 123.68
    return img

前処理実行
leakageの防止（データ分割後にデータ変換・拡張等）
なお、get_augmented、get_changedについては画像の前処理を参照。

x_train_list = []
for img in x_train:
    x_train_list.append(preprocess_vgg16(get_augmented(get_changed(img))))
x_train_aug = np.array(x_train_list)
x_test_list = []
for img in x_test:
    x_test_list.append(preprocess_vgg16(get_augmented(get_changed(img))))
x_test_aug = np.array(x_test_list)

試用
調整てfitを行う（前述の手順）。

batch_size = 100
n_epoch = 1 # 試用なので回数を減らす

↑

RNN †

↑

時系列予測 †

https://github.com/AileenNielsen/TimeSeriesAnalysisWithPython/blob/master/data/AirPassengers.csv

↑

共通 †

↑

オブジェクトの保存と復元 †

pickleのシリアライズとデシリアライズで保存と復元

保存されるオブジェクト

import pickle
obj = '保存されるオブジェクト'

シリアライズ相当

with open('sample.pickle','wb') as f:
   pickle.dump(obj, f)

デシリアライズ相当

with open('sample.pickle','rb') as f:
   loaded_obj = pickle.load(f)

復元されたオブジェクト
```
print(loaded_obj)
```

↑

勾配降下法アルゴリズムの選択 †

SGD
（Stochastic Gradient Descent）

概要
- 勾配が最も急な向きに勾配を下る手法
- 勾配が急であればあるほど大きくパラメタを変化させる｡
- 変化を学習率というハイパーパラメタによって調整する。

欠点

最短距離でない、無駄に谷間を往復する。
学習率が大きい場合は無駄な往復が目立つ。

学習率の調整に手間がかかる。
調整が難しいため自動調整のアルゴリズムが必要。

コード
- lr ：学習率（0以上のfloat
```
optimizer = optimizers.SGD(lr=0.01)
```

MomentumSGD

概要
- SGDに慣性（加速・減速）の概念を加えた最適化手法｡
- 加速で、谷間での無駄な往復を減らし、早く収束する。

欠点
加速しているため、極小値付近で止まり難い。

コード
SGDのコードに「momentum」（慣性項の係数（0以上のF）を追加。
```
optimizer = optimizers.SGD(lr=0.01, momentum=0.9)
```

NesterovAG
（Nesterov Accelerated Gradient）

概要
極小値付近でブレーキをかける機能を加えたアルゴリズム

コード
MomentumSGDのコードに「nesterov=True」を追加。
```
optimizer = optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True)
```

AdaGrad?

概要
- 極小値に差し掛かったところで更新を緩やかにする。
- NesterovAGのブレーキ機能を学習率の減衰によって実現

コード
デフォルト・パラメタが推奨
- lr ：学習率（0以上のfloat
- epsilon：分母の最小値（0以上のfloat
- decay ：学習率減衰（0以上のfloat
```
optimizer = optimizers.Adagrad(lr=0.01, epsilon=None, decay=0.0)
```

RMSprop
（Root Mean Square Propagation）

概要
- Adagradの改良版
- 学習率の減衰が穏やかになる機能を指数移動平均の導入によって追加

コード
- AdaGrad?のコードに「rho」（指数移動平均）を追加。
- 学習率以外はデフォルト・パラメタが推奨
```
optimizer = optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0)
```

AdaDelta?

概要
- Adagradの改良版
- RMSpropに､もうひと工夫加えたようなアルゴリズム

コード
- AdaGrad?のコードに「rho」（指数移動平均）を追加。
- デフォルト・パラメタが推奨
```
optimizer = optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=None, decay=0.0)
```

Adam
（ADAptive Moment estimation）

概要
MomentumSGD系の慣性項とAdaGrad?系の学習率の
両方の自動調整の機能を持ち合わせたアルゴリズム

コード
- beta_1 ：MomentumSGDのmomentum
- beta_2 ：AdaGrad?のrho
- amsgrad：AMSGradを適用するかどうか。
```
optimizer = optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
```

↑

過学習の抑止 †

商品の自動タグ付けのモデル定義に以下を追加。

早期終了（early stopping）

EarlyStopping?クラス

monitor ：監視する値
patience：指定エポック数の間、改善がない場合、学習を停止
mode ：収束判定（auto: 自動, min: 最小時, max: 最大時）

verbose ：標準出力で通知をするか否か

es = EarlyStopping(monitor='val_loss', patience=5, mode='min', verbose=0)
hist = model.fit(x_train_std , y_train,
                 validation_data=(x_test_std, y_test),
                 batch_size=batch_size,
                 epochs=n_epoch,
                 verbose=1,
                 callbacks=[es]) # EarlyStoppingを適用

ModelCheckpoint?クラス
検証誤差が最も低い状態のモデルを保存
- monitor ：監視する値（デフォルト: val_loss）
- mode ：収束判定（auto: 自動, min: 最小時, max: 最大時）
- verbose ：標準出力で通知をするか否か
- filepath ：モデルを保存するファイルパス
- save_best_only：最良の状態のモデルのみを保存するかどうか（bool）
```
mc = ModelCheckpoint(monitor='val_loss', mode='min', verbose=1, filepath='./dl4', save_best_only=True)
hist = model.fit(x_train_std , y_train,
                 validation_data=(x_test_std, y_test),
                 batch_size=batch_size,
                 epochs=n_epoch,
                 verbose=1,
                 callbacks=[mc]) # ModelCheckpointを適用
```

ドロップアウト（Dropout）
最終層の一つ前に以下を追加。
```
# 無効化比率0.5のDropout
model.add(Dropout(rate=0.5))
```

バッチ正規化（Batch Normalization）
畳み込み層とプーリング層の間に以下を追加。
```
model.add(BatchNormalization())
```

↑

モデルの保存と復元 †

モデルの保存

# モデルはjson形式
json_string = model.to_json()
with open('mnist.model', 'w') as f:
    f.write(json_string)
# パラメータはhdf5形式
model.save_weights('param.hdf5')

モデルの復元
復元後、再度コンパイルが必要になる。

# モデルはjson形式
with open('mnist.model', 'r') as f:
    json_string = f.read()
model = model_from_json(json_string)
# パラメータはhdf5形式
model.load_weights('param.hdf5')

↑

on Azure Machine Learning †

↑

参考 †

TensorFlow? - Wikipedia
https://ja.wikipedia.org/wiki/TensorFlow
Keras - Wikipedia
https://ja.wikipedia.org/wiki/Keras

TensorFlow?をDockerで動かす（Jupyter notebook編） | ぺんぎんや
https://e-penguiner.com/tensorflow-jupyter-notebook-with-docker/

Visualizing Optimization Algos - GIFs - Imgur
https://imgur.com/a/Hqolp

MNISTでハイパーパラメータをいじってloss/accuracyグラフを見てみる - Qiita
https://qiita.com/hiroyuki827/items/213146d551a6e2227810

目次 †

概要 †

TensorFlow? †

言語 †

特徴 †

Keras †

言語 †

特徴 †

環境：Notebook系 †

Jupyter Notebook †

JupyterLab †

Azure Machine Learning †

チュートリアル †

準備 †

on Jupyter on Docker †

インストール ～ 初期化 †

CNN †

手書き数字画像の認識 †

商品の自動タグ付け †

画像とラベルの確認 †

画像の前処理 †

転移学習、ファイン・チューニング †

RNN †

時系列予測 †

共通 †

オブジェクトの保存と復元 †

勾配降下法アルゴリズムの選択 †

過学習の抑止 †

モデルの保存と復元 †

on Azure Machine Learning †

参考 †

インストール～初期化 †