ホーム » Fashion-MNIST

Fashion-MNIST」カテゴリーアーカイブ

TensorFlow 2.0 : Tutorials : Keras ML 基本 :- 衣料品画像を予測する : 基本分類

TensorFlow 2.0 : Tutorials : Keras ML 基本 :- 衣料品画像を予測する : 基本分類 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 10/01/2019

* 本ページは、TensorFlow org サイトの TF 2.0 – Beginner Tutorials – ML basics with Keras の以下のページを
翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com ; WebSite: https://www.classcat.com/
Facebook: https://www.facebook.com/ClassCatJP/

 

 

Tutorials : Keras ML 基本 :- 衣料品画像を予測する : 基本分類

このガイドはスニーカーやシャツのような、衣類の画像を分類するニューラルネットワーク・モデルを訓練します。詳細の総てを理解しなくてもかまいません、これは進むにつれて詳細が説明される完全な TensorFlow プログラムのペースの速いペースの概要です。

このガイドは、TensorFlow でモデルを構築して訓練する高位 API tf.keras を使用します。

from __future__ import absolute_import, division, print_function, unicode_literals

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
2.0.0-rc2

 

Fashion MNIST データセットをインポートする

このガイドは Fashion MNIST データセットを使用します、これは 10 カテゴリーの 70,000 グレースケール画像を含みます。この画像は、ここで見られるように衣料品の個々の品目を低解像度 (28 x 28 ピクセル) で示します :


Figure 1. Fashion-MNIST サンプル (by Zalando, MIT License).

Fashion MNIST は (コンピュータビジョンのための機械学習プログラムの “Hello, World” としてしばしば使用される) 古典的な MNIST データセットの差し込み式の (= drop-in) 置き換えとして意図されています。MNIST データセットはここで使用する衣料品の品目と同一の形式の手書き数字 (0, 1, 2, etc) の画像を含みます。

このガイドは Fashion MNIST を変化をつけるために利用します、そしてそれは通常の MNIST よりも僅かばかり挑戦的な問題だからです。両者のデータセットは比較的小さくそしてアルゴリズムが期待どおりに動作するかを検証するために使用されます。それらはコードをテストしてデバッグするための良い開始点です。

ここでは、ネットワークを訓練するために 60,000 画像が使用されて、ネットワークが画像を分類することをどの程度正確に学習したかを評価するために 10,000 画像が使用されます。TensorFlow から直接 Fashion MNIST にアクセスできます。TensorFlow から直接 Fashion MNIST データをインポートしてロードしてください :

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

 
データセットのロードは 4 つの NumPy 配列を返します :

  • train_images と train_labels 配列は訓練セット – モデルが学習するために使用するデータです。
  • モデルはテストセット – test_images と test_labels 配列に対してテストされます。

画像は 28×28 NumPy 配列で、 0 から 255 の範囲のピクセル値を持ちます。ラベルは整数の配列で、0 から 9 の範囲です。これらは画像が表わす衣料品のクラスに対応します :

ラベル クラス
0  T-シャツ/トップ (T-shirt/top)
1  ズボン (Trouser)
2  プルオーバー (Pullover)
3  ドレス (Dress)
4  コート (Coat)
5  サンダル (Sandal)
6  シャツ (Shirt)
7  スニーカー (Sneaker)
8  バッグ (Bag)
9  アンクルブーツ (Ankle boot)

各画像は単一のラベルにマップされます。クラス名はデータセットには含まれませんので、後で画像をプロットするときに使用するためにそれらをここでストアします :

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

 

データを調査する

モデルを訓練する前にデータセットのフォーマットを調べてみましょう。以下は訓練セットに 60,000 画像があることを示しており、各画像は 28 x 28 ピクセルとして表わされます :

train_images.shape
(60000, 28, 28)

同様に、訓練セットに 60,000 ラベルがあります :

len(train_labels)
60000

各ラベルは 0 と 9 の間の整数です :

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

テストセットには 10,000 画像があります。再び、各画像は 28 x 28 ピクセルとして表わされます :

test_images.shape
(10000, 28, 28)

そしてテストセットは 10,000 画像ラベルを含みます :

len(test_labels)
10000

 

データを前処理する

ネットワークを訓練する前にデータは前処理されなければなりません。訓練セットの最初の画像を調べれば、ピクセル値が 0 から 255 の範囲に収まることを見るでしょう:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

ニューラルネットワーク・モデルに供給する前にこれらの値を 0 と 1 の範囲にスケールします。このため、値を 255 で除算します。訓練セットとテストセットが同じ方法で前処理されることは重要です :

train_images = train_images / 255.0

test_images = test_images / 255.0

データが正しいフォーマットにあってネットワークを構築して訓練する準備ができていることを検証するために、訓練セットからの最初の 25 画像を表示して各画像の下にクラス名を表示しましょう。

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

 

モデルを構築する

ニューラルネットワークの構築はモデルの層を構成して、それからモデルをコンパイルすることが必要です。

 

層をセットアップする

ニューラルネットワークの基本的なビルディングブロックは層です。層はそれらに供給されるデータから表現を抽出します。望ましいのは、これらの表現が手元の問題のために意味があることです。

深層学習の殆どは単純な層を一緒に連鎖することで構成されます。tf.keras.layers.Dense のような、殆どの層は訓練の間に学習されるパラメータを持ちます。

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

ネットワークの最初の層、tf.keras.layers.Flatten は画像のフォーマットを (28 x 28 ピクセルの) 2 次元配列から (28 * 28 = 784 ピクセルの) 1 次元配列に変換します。この層を画像のピクセルの行をアンスタックしてそれらを並べるものとして考えてください。この層は学習するパラメータを持ちません; それはデータを再フォーマットするだけです。

ピクセルが平坦化された後は、ネットワークは 2 つの tf.keras.layers.Dense 層のシークエンスから成ります。これらは密結合、または完全結合な、ニューラル層です。最初の Dense 層は 128 ノード (またはニューロン) を持ちます。2 番目 (そして最後の) 層は 10-ノード softmax 層です、これは総計が 1 になる 10 個の確率スコアの配列を返します。各ノードは現在の画像が 10 クラスの一つに属する確率を示すスコアを含みます。

 

モデルをコンパイルする

モデルが訓練のために準備が整う前に、それは幾つかのより多くの設定を必要とします。これらはモデルの compile ステップの間に追加されます :

  • 損失関数 — これはモデルが訓練の間どのくらい正確かを測ります。モデルを正しい方向に「操縦する (= steer)」ためにこの関数を最小化することを望みます。
  • Optimizer — これはモデルがそれが見るデータとその損失関数に基づいてどのように更新されるかです。
  • メトリクス — 訓練とテストステップを監視するために使用されます。次のサンプルは accuracy (精度)、正しく分類された画像の比率を使用します。
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

 

モデルを訓練する

ニューラルネットワーク・モデルの訓練は次のステップを必要とします :

  1. 訓練データをモデルに供給します。この例では、train_images と train_labels 配列にあります。
  2. モデルは画像とラベルを関連付けることを学習します。
  3. モデルにテストセットについて予測を行なうことを求めます — この例では test_images 配列です。予測が test_labels 配列からのラベルに適合するかを検証します。

訓練を開始するためには、model.fit メソッドを呼び出します — モデルは訓練データに “fit” しますのでそのように呼ばれます :

model.fit(train_images, train_labels, epochs=10)
Train on 60000 samples
Epoch 1/10
60000/60000 [==============================] - 5s 77us/sample - loss: 0.4944 - accuracy: 0.8262
Epoch 2/10
60000/60000 [==============================] - 4s 60us/sample - loss: 0.3750 - accuracy: 0.8658
Epoch 3/10
60000/60000 [==============================] - 3s 58us/sample - loss: 0.3373 - accuracy: 0.8759
Epoch 4/10
60000/60000 [==============================] - 4s 59us/sample - loss: 0.3130 - accuracy: 0.8854
Epoch 5/10
60000/60000 [==============================] - 4s 58us/sample - loss: 0.2951 - accuracy: 0.8911
Epoch 6/10
60000/60000 [==============================] - 3s 58us/sample - loss: 0.2793 - accuracy: 0.8972
Epoch 7/10
60000/60000 [==============================] - 4s 64us/sample - loss: 0.2682 - accuracy: 0.8997
Epoch 8/10
60000/60000 [==============================] - 4s 60us/sample - loss: 0.2595 - accuracy: 0.9040
Epoch 9/10
60000/60000 [==============================] - 3s 58us/sample - loss: 0.2479 - accuracy: 0.9062
Epoch 10/10
60000/60000 [==============================] - 3s 58us/sample - loss: 0.2390 - accuracy: 0.9105

<tensorflow.python.keras.callbacks.History at 0x7f9316b17390>

モデルが訓練されるとき、損失と精度メトリクスが表示されます。このモデルは訓練データ上でおよそ 0.88 (or 88%) の精度に到達します。

 

精度を評価する

次に、テストデータセット上でモデルがどのように遂行するか比較します :

test_loss, test_acc = model.evaluate(test_images, test_labels)

print('\nTest accuracy:', test_acc)
10000/1 [================================================================] - 1s 56us/sample - loss: 0.2327 - accuracy: 0.8860

Test accuracy: 0.886

テストデータセット上の精度は訓練データセット上の精度よりも少し悪いことが分かります。訓練精度とテスト精度の間のこの隔たりは overfitting を表します。overfitting は機械学習モデルが訓練データ上よりも新しい、未見の入力上でより悪く (パフォーマンスが) 遂行するときのことです。

 

予測を行なう

訓練されたモデルで、幾つかの画像について予測を行なうためにそれを使用することができます。

predictions = model.predict(test_images)

ここで、モデルはテストセットの各画像のためのラベルを予測しました。最初の予測を見てみましょう :

predictions[0]
array([5.2581032e-07, 1.4517748e-09, 2.5350946e-08, 9.0922248e-09,
       1.5219296e-08, 2.0876075e-03, 2.2626289e-06, 6.2742099e-02,
       8.7106038e-08, 9.3516731e-01], dtype=float32)

予測は 10 個の配列です。これらは画像が衣料品の 10 の異なる品目の各々に対応するモデルの「確信度 (= 信頼度, confidence)」を表しています。どのラベルが最高の確信度値を持つかを見ることができます :

np.argmax(predictions[0])
9

従ってモデルはこの画像がアンクルブーツ、あるいは class_names[9] であると最も確信しています。テストラベルがこの分類が正しいことを示しているか調べます :

test_labels[0]
9

10 クラス予測の完全なセットを見るためにこれをグラフ化できます。

def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array, true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array, true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

0 番目の画像、予測そして予測配列を見てみましょう。正しい予測ラベルは青色で不正な予測ラベルは赤色です。数字は予測ラベルのための (100 からの) パーセンテージを与えます。

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

幾つかの画像をそれらの予測とともにプロットしましょう。非常に確信されてる時でもモデルが間違う可能性があることに注意してください。

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

最後に、訓練されたモデルを使用して単一画像について予測を行ないます。

# Grab an image from the test dataset.
img = test_images[1]

print(img.shape)
(28, 28)

tf.keras モデルはサンプルのバッチ、あるいはコレクションについて一度に予測を行なうように最適化されています。そのため単一画像を使用していてさえも、それをリストに追加する必要があります :

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

さてこの画像のための正しいラベルを予測します :

predictions_single = model.predict(img)

print(predictions_single)
[[5.0687635e-05 3.4319962e-13 9.9877065e-01 3.5758646e-10 1.4342026e-04
  2.3974990e-15 1.0347982e-03 5.4287661e-18 3.5426123e-07 4.4112422e-14]]
plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

model.predict はリストのリストを返します — データのバッチの各画像に対して一つのリストです。バッチの (唯一の) 画像のための予測を掴みます :

np.argmax(predictions_single[0])
2

そしてモデルは予想どおりにラベルを予測します。

 

以上



TensorFlow 2.0 Beta : Tutorials : ML 基本 :- 最初のニューラルネットワークを訓練する: 基本分類

TensorFlow 2.0 Beta : Tutorials : ML 基本 :- 最初のニューラルネットワークを訓練する: 基本分類 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/21/2019

* 本ページは、TensorFlow の本家サイトの TF 2.0 Beta – Beginner Tutorials – ML basics の以下のページを翻訳した上で
適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

Tutorials : ML 基本 :- 最初のニューラルネットワークを訓練する: 基本分類

このガイドはスニーカーやシャツのような、衣類の画像を分類するニューラルネットワーク・モデルを訓練します。詳細の総てを理解しなくてもかまいません、これは進むにつれて詳細が説明される完全な TensorFlow プログラムのペースの速い概要です。

このガイドは、TensorFlow でモデルを構築して訓練する高位 API tf.keras を使用します。

!pip install -q tensorflow==2.0.0-beta1
from __future__ import absolute_import, division, print_function, unicode_literals

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
2.0.0-beta1

 

Fashion MNIST データセットをインポートする

このガイドは Fashion MNIST データセットを使用します、これは 10 カテゴリーの 70,000 グレースケール画像を含みます。この画像は、ここで見られるように衣料品の個々の品目を低解像度 (28 x 28 ピクセル) で示します :


Figure 1. Fashion-MNIST サンプル (by Zalando, MIT License).

Fashion MNIST は (コンピュータビジョンのための機械学習プログラムの “Hello, World” としてしばしば使用される) 古典的な MNIST データセットの差し込み式の (= drop-in) 置き換えとして意図されています。MNIST データセットはここで使用する衣料品の品目と同一の形式の手書き数字 (0, 1, 2, etc) の画像を含みます。

このガイドは Fashion MNIST を変化をつけるために利用します、そしてそれは通常の MNIST よりも僅かばかり挑戦的な問題だからです。両者のデータセットは比較的小さくそしてアルゴリズムが期待どおりに動作するかを検証するために使用されます。それらはコードをテストしてデバッグするための良い開始点です。

ネットワークを訓練するために 60,000 画像を使用してネットワークが画像を分類することをどの程度正確に学習したかを評価するために 10,000 画像を使用します。TensorFlow から直接 Fashion MNIST にアクセスできます。TensorFlow から直接 Fashion MNIST データをインポートしてロードすることができます :

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

 
データセットのロードは 4 つの NumPy 配列を返します :

  • train_images と train_labels 配列は訓練セット – モデルが学習するために使用するデータです。
  • モデルはテストセット – test_images と test_labels 配列に対してテストされます。

画像は 28×28 NumPy 配列で、 0 から 255 の範囲のピクセル値を持ちます。ラベルは整数の配列で、0 から 9 の範囲です。これらは画像が表わす衣料品のクラスに対応します :

ラベル クラス
0 T-シャツ/トップ (T-shirt/top)
1 ズボン (Trouser)
2 プルオーバー (Pullover)
3 ドレス (Dress)
4 コート (Coat)
5 サンダル (Sandal)
6 シャツ (Shirt)
7 スニーカー (Sneaker)
8 バッグ (Bag)
9 アンクルブーツ (Ankle boot)

各画像は単一のラベルにマップされます。
クラス名はデータセットには含まれませんので、後で画像をプロットするときに使用するためにそれらをここでストアします :

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

 

データを調査する

モデルを訓練する前にデータセットのフォーマットを調べてみましょう。以下は訓練セットに 60,000 画像があることを示しており、各画像は 28 x 28 ピクセルとして表わされます :

train_images.shape
(60000, 28, 28)

同様に、訓練セットに 60,000 ラベルがあります :

len(train_labels)
60000

各ラベルは 0 と 9 の間の整数です :

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

テストセットには 10,000 画像があります。再び、各画像は 28 x 28 ピクセルとして表わされます :

test_images.shape
(10000, 28, 28)

そしてテストセットは 10,000 画像ラベルを含みます :

len(test_labels)
10000

 

データを前処理する

ネットワークを訓練する前にデータは前処理されなければなりません。訓練セットの最初の画像を調べれば、ピクセル値が 0 から 255 の範囲に収まることを見るでしょう:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

ニューラルネットワーク・モデルに供給する前にこれらの値を 0 と 1 の範囲にスケールします。このため、値を 255 で除算します。訓練セットとテストセットが同じ方法で前処理されることは重要です :

train_images = train_images / 255.0

test_images = test_images / 255.0

データが正しいフォーマットにあってネットワークを構築して訓練する準備ができていることを検証するために、訓練セットからの最初の 25 画像を表示して各画像の下にクラス名を示します。

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

 

モデルを構築する

ニューラルネットワークの構築はモデルの層を構成して、それからモデルをコンパイルすることが必要です。

層をセットアップする

ニューラルネットワークの基本的なビルディングブロックは層です。層はそれらに供給されるデータから表現を抽出します。望ましいのは、これらの表現が手元の問題のために意味があることです。

深層学習の殆どは単純な層を一緒に連鎖することで構成されます。tf.keras.layers.Dense のような、殆どの層は訓練の間に学習されるパラメータを持ちます。

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

ネットワークの最初の層、tf.keras.layers.Flatten は画像のフォーマットを (28 x 28 ピクセルの) 2 次元配列から (28 * 28 = 784 ピクセルの) 1 次元配列に変換します。この層を画像のピクセルの行をアンスタックしてそれらを並べるものとして考えてください。この層は学習するパラメータを持ちません; それはデータを再フォーマットするだけです。

ピクセルが平坦化された後は、ネットワークは 2 つの tf.keras.layers.Dense 層のシークエンスから成ります。これらは密結合、または完全結合、ニューラル層です。最初の Dense 層は 128 ノード (またはニューロン) を持ちます。2 番目 (そして最後の) 層は 10-ノード softmax 層です、これは総計が 1 になる 10 個の確率スコアの配列を返します。各ノードは現在の画像が 10 クラスの一つに属する確率を示すスコアを含みます。

 

モデルをコンパイルする

モデルが訓練のために準備が整う前に、それは幾つかの更なる設定を必要とします。これらはモデルの compile ステップの間に追加されます :

  • 損失関数 — これはモデルが訓練の間どのくらい正確かを測ります。モデルを正しい方向に「操縦する (= steer)」ためにこの関数を最小化することを望みます。
  • Optimizer — これはモデルがそれが見るデータとその損失関数に基づいてどのように更新されるかです。
  • メトリクス — 訓練とテストステップを監視するために使用されます。次のサンプルは accuracy (精度)、正しく分類された画像の比率を使用します。
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

 

モデルを訓練する

ニューラルネットワーク・モデルの訓練は次のステップを必要とします :

  1. 訓練データをモデルに供給します。この例では、train_images と train_labels 配列にあります。
  2. モデルは画像とラベルを関連付けることを学習します。
  3. モデルにテストセットについて予測を行なうことを求めます — この例では test_images 配列です。予測が test_labels 配列からのラベルに適合するかを検証します。

訓練を開始するためには、model.fit メソッドを呼び出します — モデルは訓練データに “fit” しますのでそのように呼ばれます :

model.fit(train_images, train_labels, epochs=10)
WARNING: Logging before flag parsing goes to stderr.
W0614 17:29:10.846302 140495257376512 deprecation.py:323] From /tmpfs/src/tf_docs_env/lib/python3.5/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.where in 2.0, which has the same broadcast rule as np.where

Train on 60000 samples
Epoch 1/10
60000/60000 [==============================] - 4s 69us/sample - loss: 0.5003 - accuracy: 0.8231
Epoch 2/10
60000/60000 [==============================] - 4s 67us/sample - loss: 0.3734 - accuracy: 0.8649
Epoch 3/10
60000/60000 [==============================] - 4s 63us/sample - loss: 0.3391 - accuracy: 0.8755
Epoch 4/10
60000/60000 [==============================] - 4s 62us/sample - loss: 0.3141 - accuracy: 0.8842
Epoch 5/10
60000/60000 [==============================] - 4s 64us/sample - loss: 0.2960 - accuracy: 0.8901
Epoch 6/10
60000/60000 [==============================] - 4s 61us/sample - loss: 0.2814 - accuracy: 0.8961
Epoch 7/10
60000/60000 [==============================] - 4s 62us/sample - loss: 0.2691 - accuracy: 0.8996
Epoch 8/10
60000/60000 [==============================] - 4s 63us/sample - loss: 0.2581 - accuracy: 0.9046
Epoch 9/10
60000/60000 [==============================] - 4s 62us/sample - loss: 0.2504 - accuracy: 0.9068
Epoch 10/10
60000/60000 [==============================] - 4s 66us/sample - loss: 0.2419 - accuracy: 0.9095

<tensorflow.python.keras.callbacks.History at 0x7fc73ff97e48>

モデルが訓練されるとき、損失と精度メトリクスが表示されます。このモデルは訓練データ上でおよそ 0.88 (or 88%) の精度に到達します。

 

精度を評価する

次に、テストデータセット上でモデルがどのように遂行するか比較します :

test_loss, test_acc = model.evaluate(test_images, test_labels)

print('\nTest accuracy:', test_acc)
10000/10000 [==============================] - 0s 38us/sample - loss: 0.3343 - accuracy: 0.8822

Test accuracy: 0.8822

テストデータセット上の精度は訓練データセット上の精度よりも少し悪いことが分かります。訓練精度とテスト精度の間のこの隔たりは overfitting を表します。overfitting は機械学習モデルが訓練データ上よりも新しい、未見の入力上でより悪く遂行するときのことです。

 

予測を行なう

訓練されたモデルで、幾つかの画像について予測を行なうためにそれを使用することができます。

predictions = model.predict(test_images)

ここで、モデルはテストセットの各画像のためにラベルを予測しました。最初の予測を見てみましょう :

predictions[0]
array([1.6820312e-08, 1.2007975e-10, 1.7058468e-07, 1.1677981e-09,
       8.4652679e-10, 4.4132438e-03, 4.1356127e-08, 1.2666054e-02,
       1.5807228e-07, 9.8292035e-01], dtype=float32)

予測は 10 の数の配列です。これらは画像が衣料品の 10 の異なる品目の各々に対応する、モデルの「確信度 (= 信頼度, confidence)」を表しています。どのラベルが最高の確信度値を持つかを見ることができます :

np.argmax(predictions[0])
9

従ってモデルはこの画像がアンクルブーツ、あるいは class_names[9] であると最も確信しています。テストラベルがこの分類が正しいことを示しているか調べます :

test_labels[0]
9

10 クラス予測の完全なセットを見るためにこれをグラフ化できます。

def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array[i], true_label[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

0 番目の画像、予測そして予測配列を見てみましょう。

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

幾つかの画像をそれらの予測とともにプロットしましょう。正しい予測ラベルは青色で正しくない予測ラベルは赤色です。数字は予測ラベルに対する (100 からの) パーセントです。非常に確信されてる時でもモデルが間違う可能性があることに注意してください。

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions, test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions, test_labels)
plt.show()

最後に、訓練されたモデルを使用して単一画像について予測を行ないます。

# Grab an image from the test dataset.
img = test_images[0]

print(img.shape)
(28, 28)

tf.keras モデルはバッチ、サンプルのコレクションについて一度に予測を行なうように最適化されています。そのため単一画像を使用していてさえも、それをリストに追加する必要があります :

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

さてこの画像のための正しいラベルを予測します :

predictions_single = model.predict(img)

print(predictions_single)
[[1.6820247e-08 1.2007975e-10 1.7058436e-07 1.1677960e-09 8.4652357e-10
  4.4132336e-03 4.1355889e-08 1.2666019e-02 1.5807197e-07 9.8292035e-01]]
plot_value_array(0, predictions_single, test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

model.predict はリストのリストを返します — データのバッチの各画像に対して一つのリストです。バッチの (唯一の) 画像のための予測を掴みます :

np.argmax(predictions_single[0])
9

そして、前のように、モデルは 9 のラベルを予測します。

 

以上



TensorFlow 2.0 Alpha : Tutorials : ML 基本 :- 最初のニューラルネットワークを訓練する: 基本分類

TensorFlow 2.0 Alpha : Beginner Tutorials : ML 基本 :- 最初のニューラルネットワークを訓練する: 基本分類 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 03/26/2019

* 本ページは、TensorFlow の本家サイトの TF 2.0 Alpha – Beginner Tutorials – ML basics の以下のページを翻訳した上で
適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

最初のニューラルネットワークを訓練する: 基本分類

このガイドはスニーカーやシャツのような、衣類の画像を分類するニューラルネットワーク・モデルを訓練します。詳細の総てを理解しなくてもかまいません、これは進むにつれて詳細が説明される完全な TensorFlow プログラムのペースの速い概要です。

このガイドは、TensorFlow でモデルを構築して訓練する高位 API tf.keras を使用します。

!pip install -q tensorflow==2.0.0-alpha0
from __future__ import absolute_import, division, print_function

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
2.0.0-alpha0

 

Fashion MNIST データセットをインポートする

このガイドは Fashion MNIST データセットを使用します、これは 10 カテゴリーの 70,000 グレースケール画像を含みます。この画像は、ここで見られるように衣料品の個々の品目を低解像度 (28 x 28 ピクセル) で示します :


Figure 1. Fashion-MNIST サンプル (by Zalando, MIT License).

Fashion MNIST は (コンピュータビジョンのための機械学習プログラムの “Hello, World” としてしばしば使用される) 古典的な MNIST データセットの差し込み式の (= drop-in) 置き換えとして意図されています。MNIST データセットはここで使用する衣料品の品目と同一の手書き数字 (0, 1, 2, etc) の画像を含みます。

このガイドは Fashion MNIST を多様性のために利用します、そしてそれは通常の MNIST よりも僅かばかり挑戦的な問題だからです。両者のデータセットは比較的小さくそしてアルゴリズムが期待どおりに動作するかを検証するために使用されます。それらはコードをテストしてデバッグするための良い開始点です。

ネットワークを訓練するために 60,000 画像を使用してネットワークが画像を分類することをどの程度正確に学習したかを評価するために 10,000 画像を使用します。TensorFlow から直接 Fashion MNIST にアクセスし、データを単にインポートしてロードすることができます :

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

 
データセットのロードは 4 つの NumPy 配列を返します :

  • train_images と train_labels 配列は訓練セット – モデルが学習するために使用するデータです。
  • モデルはテストセット – test_images と test_labels 配列に対してテストされます。

画像は 28×28 NumPy 配列で、 0 と 255 の範囲のピクセル値を持ちます。ラベルは整数の配列で、0 から 9 の範囲です。これらは画像が表わす衣料品のクラスに対応します :

ラベル クラス
0 T-シャツ/トップ (T-shirt/top)
1 ズボン (Trouser)
2 プルオーバー (Pullover)
3 ドレス (Dress)
4 コート (Coat)
5 サンダル (Sandal)
6 シャツ (Shirt)
7 スニーカー (Sneaker)
8 バッグ (Bag)
9 アンクルブーツ (Ankle boot)

各画像は単一のラベルにマップされます。
クラス名はデータセットには含まれませんので、後で画像をプロットするときに使用するためにそれらをここでストアします :

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

 

データを調査する

モデルを訓練する前にデータセットのフォーマットを調べてみましょう。以下は訓練セットに 60,000 画像があることを示し、各画像は 28 x 28 ピクセルとして表わされます :

train_images.shape
(60000, 28, 28)

同様に、訓練セットに 60,000 ラベルがあります :

len(train_labels)
60000

各ラベルは 0 と 9 の間の整数です :

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

テストセットには 10,000 画像があります。再度、各画像は 28 x 28 ピクセルとして表わされます :

test_images.shape
(10000, 28, 28)

そしてテストセットは 10,000 画像ラベルを含みます :

len(test_labels)
10000

 

データを前処理する

ネットワークを訓練する前にデータは前処理されなければなりません。訓練セットの最初の画像を調べれば、ピクセル値が 0 から 255 の範囲に収まることを見るでしょう:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

ニューラルネットワーク・モデルに供給する前に これらの値を 0 と 1 の範囲にスケールします。このため、値を 255 で除算します。訓練セットとテストセットが同じ方法で前処理されることは重要です :

train_images = train_images / 255.0

test_images = test_images / 255.0

訓練セットからの最初の 25 画像を表示して各画像の下にクラス名を示します。データが正しいフォーマットにあることを検証すればネットワークを構築して訓練する準備ができます。

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

 

モデルを構築する

ニューラルネットワークの構築はモデルの層を configure することを必要とし、それからモデルをコンパイルします。

層をセットアップする

ニューラルネットワークの基本的なビルディングブロックは層です。層はそれらに供給されるデータから表現を抽出します。そして、望ましいのは、これらの表現が手元の問題のためにより意味があることです。

深層学習の殆どは単純な層を一緒に連鎖することで構成されます。tf.keras.layers.Dense のような、殆どの層は訓練の間に学習されるパラメータを持ちます。

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

ネットワークの最初の層、tf.keras.layers.Flatten は画像のフォーマットを (28 x 28 ピクセルの) 2d 配列から 28 * 28 = 784 ピクセルの 1d 配列に変換します。この層を画像のピクセルの行をアンスタックしてそれらを並べるものとして考えてください。この層は学習するパラメータを持ちません; それはデータを再フォーマットするだけです。

ピクセルが平坦化された後は、ネットワークは 2 つの tf.keras.layers.Dense 層のシークエンスから成ります。これらは密結合、または完全結合、ニューラル層です。最初の Dense 層は 128 ノード (またはニューロン) を持ちます。2 番目 (そして最後の) 層は 10-ノード softmax 層です — これは総計が 1 になる 10 個の確率スコアの配列を返します。各ノードは現在の画像が 10 クラスの一つに属する確率を示すスコアを含みます。

 

モデルをコンパイルする

モデルが訓練のために準備が整う前に、それは幾つかの更なる設定を必要とします。これらはモデルのコンパイル段階の間に追加されます :

  • 損失関数 — これはモデルが訓練の間どのくらい正確かを測ります。モデルを正しい方向に「操縦する (= steer)」ためにこの関数を最小化することを望みます。
  • Optimizer — これはモデルがそれが見るデータとその損失関数に基づいてどのように更新されるかです。
  • メトリクス — 訓練とテストステップを監視するために使用されます。次のサンプルは accuracy (精度) – 正しく分類された画像の比率 – を使用します。
model.compile(optimizer='adam', 
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

 

モデルを訓練する

ニューラルネットワーク・モデルの訓練は次のステップを必要とします :

  1. 訓練データをモデルに供給します — この例では、train_images と train_labels 配列です。
  2. モデルは画像とラベルを結びつけることを学習します。
  3. モデルにテストセットについて予測を行なうことを求めます — この例では test_images 配列です。予測が test_labels 配列からのラベルに適合するかを検証します。

訓練を開始するためには、model.fit メソッドを呼び出します — モデルは訓練データに “fit” します :

model.fit(train_images, train_labels, epochs=5)
Epoch 1/5
60000/60000 [==============================] - 5s 84us/sample - loss: 0.5039 - accuracy: 0.8214
Epoch 2/5
60000/60000 [==============================] - 4s 74us/sample - loss: 0.3768 - accuracy: 0.8633
Epoch 3/5
60000/60000 [==============================] - 5s 78us/sample - loss: 0.3385 - accuracy: 0.8758
Epoch 4/5
60000/60000 [==============================] - 5s 76us/sample - loss: 0.3131 - accuracy: 0.8838
Epoch 5/5
60000/60000 [==============================] - 5s 79us/sample - loss: 0.2930 - accuracy: 0.8914

<tensorflow.python.keras.callbacks.History at 0x7f9fc269b278>

モデルが訓練されるとき、損失と精度メトリクスが表示されます。このモデルは訓練データ上でおよそ 0.88 (or 88%) の精度に達します。

 

精度を評価する

次に、テストデータセット上でモデルがどのように遂行するか比較します :

test_loss, test_acc = model.evaluate(test_images, test_labels)

print('\nTest accuracy:', test_acc)
10000/10000 [==============================] - 0s 46us/sample - loss: 0.3595 - accuracy: 0.8740

Test accuracy: 0.874

テストデータセット上の精度は訓練データセット上の精度よりも少し悪いことが分かります。訓練精度とテスト精度の間のこの隔たりは overfitting の例です。overfitting は機械学習モデルが新しいデータ上で訓練データ上よりもより悪く遂行するときです。

 

予測を行なう

訓練されたモデルで、幾つかの画像について予測を行なうためにそれを使用することができます。

predictions = model.predict(test_images)

ここで、モデルはテストセットの各画像のためにラベルを予測しました。最初の予測を見てみましょう :

predictions[0]
array([1.1913482e-05, 2.5270497e-08, 9.4376639e-07, 5.6023836e-10,
       3.0359536e-07, 4.5878277e-03, 1.3910754e-06, 1.4167473e-01,
       1.1293515e-05, 8.5371155e-01], dtype=float32)

予測は 10 の数の配列です。これらは画像が衣料品の 10 の異なる品目の各々に対応する、モデルの「確信度 (= 信頼度, confidence)」を記述しています。どのラベルが最高の確信度値を持つかを見ることができます :

np.argmax(predictions[0])
9

従ってモデルはこの画像がアンクルブーツ、あるいは class_names[9] であると最も確信しています。そしてこれが正しいことを見るためにテスト・ラベルを確認できます :

test_labels[0]
9

10 チャネルの完全なセットを見るためにこれをグラフ化できます。

def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])
  
  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'
  
  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array[i], true_label[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1]) 
  predicted_label = np.argmax(predictions_array)
 
  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

0 番目の画像、予測そして予測配列を見てみましょう。

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

幾つかの画像をそれらの予測とともにプロットしましょう。正しい予測ラベルは青色で正しくない予測ラベルは赤色です。数字は予測ラベルに対する (100 からの) パーセントです。非常に確信されてる時でもそれが間違う可能性があることに注意してください。

# Plot the first X test images, their predicted label, and the true label
# Color correct predictions in blue, incorrect predictions in red
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions, test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions, test_labels)
plt.show()

最後に、訓練されたモデルを使用して単一画像について予測を行ないます。

# Grab an image from the test dataset
img = test_images[0]

print(img.shape)
(28, 28)

tf.keras モデルはバッチ、サンプルのコレクションについて一度に予測を行なうように最適化されています。そのため単一画像を使用していてさえも、それをリストに追加する必要があります :

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

さて画像を予測します :

predictions_single = model.predict(img)

print(predictions_single)
[[1.1913485e-05 2.5270452e-08 9.4376657e-07 5.6023952e-10 3.0359516e-07
  4.5878240e-03 1.3910718e-06 1.4167461e-01 1.1293518e-05 8.5371172e-01]]
plot_value_array(0, predictions_single, test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

model.predict はリストのリストを返します、データのバッチの各画像に対して一つです。バッチの (唯一の) 画像のための予測を掴みます :

np.argmax(predictions_single[0])
9

そして、前のように、モデルは 9 のラベルを予測します。

 

以上



TensorFlow : Tutorials : Keras : 最初のニューラルネットワークを訓練する: 基本分類

TensorFlow : Keras : 最初のニューラルネットワークを訓練する: 基本分類 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 08/05/2018

* TensorFlow 1.9 でドキュメント構成が変更され、数篇が新規に追加されましたので再翻訳しました。
* 本ページは、TensorFlow の本家サイトの Tutorials – Learn and use ML – Train your first neural network: basic classification を翻訳した上で適宜、補足説明したものです:

* Fashion Mnist については fashion-mnist/README.ja.md を参照してください (弊社スタッフが翻訳しています)。
* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com ; WebSite: https://www.classcat.com/
Facebook: https://www.facebook.com/ClassCatJP/

 

このガイドはスニーカーやシャツのような、衣類の画像を分類するニューラルネットワーク・モデルを訓練します。詳細の総てを理解しなくてもかまいません、これは進むにつれて詳細が説明される完全な TensorFlow プログラムのペースの速い概要です。

このガイドは、TensorFlow でモデルを構築して訓練する高位 API tf.keras を使用します。

# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
1.9.0

 

Fashion MNIST データセットをインポートする

このガイドは Fashion MNIST データセットを使用します、これは 10 カテゴリーの 70,000 グレースケール画像を含みます。この画像は、ここで見られるように、衣料品の個々の品目を低解像度 (28 x 28 ピクセル) で示します :

 

Figure 1. Fashion-MNIST サンプル (by Zalando, MIT License).

 
Fashion MNIST は (コンピュータビジョンのための機械学習プログラムの “Hello, World” としてしばしば使用される) 古典的な MNIST データセットの差し込み式の (= drop-in) 置き換えとして意図されています。MNIST データセットはここで使用する衣料品の品目と同一の手書き数字 (0, 1, 2, etc) の画像を含みます。

このガイドは Fashion MNIST を多様性のために利用します、そしてそれは通常の MNIST よりも僅かばかり挑戦的な問題だからです。両者のデータセットは比較的小さくそしてアルゴリズムが期待どおりに動作するかを検証するために使用されます。それらはコードをテストしてデバッグするための良い開始点です。

ネットワークを訓練するために 60,000 画像を使用してネットワークが画像を分類することをどの程度正確に学習したかを評価するために 10,000 画像を使用します。TensorFlow から直接 Fashion MNIST にアクセスし、データを単にインポートしてロードすることができます :

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 5us/step
Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 7s 0us/step
Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 4s 1us/step

 
データセットのロードは 4 つの NumPy 配列を返します :

  • train_images と train_labels 配列は訓練セット – モデルが学習するために使用するデータです。
  • モデルはテストセット – test_images と test_labels 配列に対してテストされます。

画像は 28×28 NumPy 配列で、 0 と 255 の範囲のピクセル値を持ちます。ラベルは整数の配列で、0 から 9 の範囲です。これらは画像が表わす衣料品のクラスに対応します :

ラベル クラス
0 T-シャツ/トップ (T-shirt/top)
1 ズボン (Trouser)
2 プルオーバー (Pullover)
3 ドレス (Dress)
4 コート (Coat)
5 サンダル (Sandal)
6 シャツ (Shirt)
7 スニーカー (Sneaker)
8 バッグ (Bag)
9 アンクルブーツ (Ankle boot)

各画像は単一のラベルにマップされます。クラス名はデータセットには含まれませんので、後で画像をプロットするときに使用するためにそれらをここでストアします :

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

 

データを調査する

モデルを訓練する前にデータセットのフォーマットを調べてみましょう。以下は訓練セットに 60,000 画像があることを示し、各画像は 28 x 28 ピクセルとして表わされます :

train_images.shape
(60000, 28, 28)

同様に、訓練セットに 60,000 ラベルがあります :

len(train_labels)
60000

各ラベルは 0 と 9 の間の整数です :

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

テストセットには 10,000 画像があります。再度、各画像は 28 x 28 ピクセルとして表わされます :

test_images.shape
(10000, 28, 28)

そしてテストセットは 10,000 画像ラベルを含みます :

len(test_labels)
10000

 

データを前処理する

ネットワークを訓練する前にデータは前処理されなければなりません。訓練セットの最初の画像を調べれば、ピクセル値が 0 から 255 の範囲に収まることを見るでしょう:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.gca().grid(False)

ニューラルネットワーク・モデルに供給する前に これらの値を 0 と 1 の範囲にスケールします。このため、画像成分のデータ型を integer から float にキャストし、 255 で除算します。画像を前処理する関数がここにあります。

訓練セットとテストセットが同じ方法で前処理されることは重要です :

train_images = train_images / 255.0

test_images = test_images / 255.0

訓練セットからの最初の 25 画像を表示して各画像の下にクラス名を示します。データが正しいフォーマットにあることを検証すればネットワークを構築して訓練する準備ができます。

import matplotlib.pyplot as plt
%matplotlib inline

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid('off')
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
/usr/local/lib/python3.5/dist-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Passing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.
  warnings.warn(message, mplDeprecation, stacklevel=1)

 

 

モデルを構築する

ニューラルネットワークの構築はモデルの層を configure することを必要とし、それからモデルをコンパイルします。

層をセットアップする

ニューラルネットワークの基本的なビルディングブロックは層です。層はそれらに供給されるデータから表現を抽出します。そして、望ましいのは、これらの表現が手元の問題のためにより意味があることです。

深層学習の殆どは単純な層を一緒に連鎖することで構成されます。tf.keras.layers.Dense のような、殆どの層は訓練の間に学習されるパラメータを持ちます。

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation=tf.nn.relu),
    keras.layers.Dense(10, activation=tf.nn.softmax)
])

ネットワークの最初の層、tf.keras.layers.Flatten は画像のフォーマットを (28 x 28 ピクセルの) 2d 配列を 28 * 28 = 784 ピクセルの 1d 配列に変換します。この層を画像のピクセルの行をアンスタックしてそれらを並べるものとして考えてください。この層は学習するパラメータを持ちません; それはデータを再フォーマットするだけです。

ピクセルが平坦化された後は、ネットワークは 2 つの tf.keras.layers.Dense 層のシークエンスから成ります。これらは密結合、または完全結合、ニューラル層です。最初の Dense 層は 128 ノード (またはニューロン) を持ちます。2 番目 (そして最後の) 層は 10-ノード softmax 層です — これは総計が 1 になる 10 個の確率スコアの配列を返します。各ノードは現在の画像が 10 数字クラスの一つに属する確率を示すスコアを含みます。

 

モデルをコンパイルする

モデルが訓練のために準備が整う前に、それは幾つかの更なる設定を必要とします。これらはモデルのコンパイル段階の間に追加されます :

  • 損失関数 —これはモデルが訓練の間どのくらい正確かを測ります。モデルを正しい方向に「操縦する (= steer)」ためにこの関数を最小化することを望みます。
  • Optimizer — これはモデルがそれが見るデータとその損失関数に基づいてどのように更新されるかです。
  • メトリクス — 訓練とテストステップを監視するために使用されます。次のサンプルは accuracy (精度) – 正しく分類された画像の比率 – を使用します。
model.compile(optimizer=tf.train.AdamOptimizer(), 
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

 

モデルを訓練する

ニューラルネットワーク・モデルの訓練は次のステップを必要とします :

  1. 訓練データをモデルに供給します — この例では、train_images と train_labels 配列です。
  2. モデルは画像とラベルを結びつけることを学習します。
  3. モデルにテストセットについて予測を行なうことを求めます — この例では test_images 配列です。予測がラベルに適合するかを test_labels 配列から検証します。

訓練を開始するためには、model.fit メソッドを呼び出します — モデルは訓練データに “fit” します :

model.fit(train_images, train_labels, epochs=5)
Epoch 1/5
60000/60000 [==============================] - 2s 36us/step - loss: 0.4975 - acc: 0.8247
Epoch 2/5
60000/60000 [==============================] - 2s 35us/step - loss: 0.3732 - acc: 0.8662
Epoch 3/5
60000/60000 [==============================] - 2s 34us/step - loss: 0.3376 - acc: 0.8764
Epoch 4/5
60000/60000 [==============================] - 2s 34us/step - loss: 0.3127 - acc: 0.8851
Epoch 5/5
60000/60000 [==============================] - 2s 34us/step - loss: 0.2960 - acc: 0.8920

モデルが訓練されるとき、損失と精度メトリクスが表示されます。このモデルは訓練データ上でおよそ 0.88 (or 88%) の精度に達します。

 

精度を評価する

次に、テストデータセット上でモデルはどのように遂行するか比べます :

test_loss, test_acc = model.evaluate(test_images, test_labels)

print('Test accuracy:', test_acc)
10000/10000 [==============================] - 0s 22us/step
Test accuracy: 0.8684

テストデータセット上の精度は訓練データセット上の精度よりも少し悪いことが分かります。訓練精度とテスト精度の間のこのギャップは overfitting の例です。overfitting は機械学習モデルが新しいデータ上で訓練データ上よりもより悪く遂行するときを指します。

 

予測を行なう

訓練されたモデルで、幾つかの画像について予測を行なうためにそれを使用することができます。

predictions = model.predict(test_images)

ここで、モデルはテストセットの各画像に対するラベルを予測しました。最初の予測を見てみましょう :

predictions[0]
array([3.7345725e-07, 2.1462286e-06, 4.2489796e-07, 8.0572853e-08,
       1.7010115e-07, 8.7923609e-02, 8.6243728e-07, 2.2786972e-01,
       4.5513571e-05, 6.8415713e-01], dtype=float32)

予測は 10 個の数字の配列です。これらは画像が衣料品の 10 個の異なる品目の各々に対応する、モデルの “confidence” を表します。どのラベルが最高の confidence 値を持つかを見ることができます :

np.argmax(predictions[0])
9

従ってモデルはこの画像はアンクルブーツ、または class_names[9] であることを最も信頼しています。そしてこれが正しいことを見るためにテストラベルを確認することができます :

test_labels[0]
9

それらの予測とともに幾つかの画像をプロットしましょう。正しい予測ラベルは緑色で正しくない予測ラベルは赤色です。

# Plot the first 25 test images, their predicted label, and the true label
# Color correct predictions in green, incorrect predictions in red
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid('off')
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    predicted_label = np.argmax(predictions[i])
    true_label = test_labels[i]
    if predicted_label == true_label:
      color = 'green'
    else:
      color = 'red'
    plt.xlabel("{} ({})".format(class_names[predicted_label], 
                                  class_names[true_label]),
                                  color=color)
      
/usr/local/lib/python3.5/dist-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Passing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.
  warnings.warn(message, mplDeprecation, stacklevel=1)

 

最後に、単一の画像について予測を行なうために訓練されたモデルを使用します。

# Grab an image from the test dataset
img = test_images[0]

print(img.shape)
(28, 28)

tf.keras モデルはサンプルのバッチ、あるいはコレクション上で一度に予測するために最適化されています。そのため単一の画像を使用している場合でもそれをリストに追加する必要があります :

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

今、画像を予測します :

predictions = model.predict(img)

print(predictions)
[[3.7345919e-07 2.1462295e-06 4.2490018e-07 8.0573272e-08 1.7010170e-07
  8.7923639e-02 8.6243847e-07 2.2787002e-01 4.5513811e-05 6.8415678e-01]]

model.predict はリストのリストを返します、データのバッチの各画像のために一つです。バッチの画像 (だけ) のための予測を把握するためには :

prediction = predictions[0]

np.argmax(prediction)
9

そして、前のように、モデルは 9 のラベルを予測します。

 

以上



TensorFlow: TensorFlow で Fashion-MNIST

TensorFlow : TensorFlow で Fashion-MNIST

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 08/28/2017

* 本ページは、github 上の Fashion-MNIST の README.md を翻訳した上で、
簡単な MLP モデルの TensorFlow 実装で動作確認したものです :

Fashion-MNIST Github README-ja

  • 本 Fashion-MNIST の README の翻訳ドキュメントを author の Dr. Han Xiao 氏の要望で README-ja として公式 repository に push する運びとなりました。
  • Fashion-MNIST は既存の MNIST 用のモデルがそのまま流用できる便利なデータセットですので、MNIST に食傷気味の皆様、是非ご活用ください! ファイル名もフォーマットも MNIST と完全互換でありながら、学習難易度が少しだけ高めの優れものです。

 

(1) Fashion-MNIST README 翻訳

60,000 サンプルの訓練セットと 10,000 サンプルのテストセットから成る、Zalando の記事の画像のデータセットです。各サンプルは 28×28 グレースケール画像で、10 クラスからのラベルと関連付けられています。Fashion-MNIST は、機械学習アルゴリズムのベンチマークのためのオリジナルの MNIST データセット直接的な差し込み式の (= drop-in) 置き換え としてサーブすることを意図しています。

ここにどのようにデータが見えるかのサンプルがあります (各クラスは3行取ります) :

 

何故でしょう?

オリジナルの MNIST データセットは沢山の手書き数字を含みます。AI/ML/データサイエンス・コミュニティの人々はこのデータセットを好みそして彼らのアルゴリズムを検証するためのベンチマークとしてそれを使用します。実際に、MNIST はしばしば試してみる最初のデータセットです。「もしそれが MNIST で動作しなければ、まったく動作しないだろう」と彼らは言いました。「そうですね~、もし MNIST で動作するとしても、他の上では依然として失敗するかもしれませんが。」

Fashion-MNIST は、機械学習アルゴリズムのベンチマークのためのオリジナルの MNIST データセットの直接的な差し込み式の (= drop-in) 置き換えとしてサーブすることを意図しています、というのはそれは同じ画像サイズでそして訓練及びテスト分割の構造を共有しているからです。

真面目な機械学習研究者へ

真面目な話し、MNIST を置き換えることについて話しをしています。幾つかの良い理由がここにあります :

データを取得する

データセットをダウンロードするためには直接リンクを使用することができます。データはオリジナルの MNIST データと同じフォーマットでストアされています。

名前 内容 サンプル サイズ リンク
train-images-idx3-ubyte.gz 訓練セット画像 60,000 26 MBytes ダウンロード
train-labels-idx1-ubyte.gz 訓練セット・ラベル 60,000 29 KBytes ダウンロード
t10k-images-idx3-ubyte.gz テストセット画像 10,000 4.2 MBytes ダウンロード
t10k-labels-idx1-ubyte.gz テストセット・ラベル 10,000 5.0 KBytes ダウンロード

あるいはこのレポジトリを clone することもできます、データセットは data/fashion の下です。この repo はベンチーマークと可視化のための幾つかのスクリプトを含みます。

git clone git@github.com:zalandoresearch/fashion-mnist.git

ラベル

各訓練とテスト・サンプルは以下のラベル群の一つに割り当てられています :

ラベル 記述
0 T-shirt/top
1 Trouser
2 Pullover
3 Dress
4 Coat
5 Sandal
6 Shirt
7 Sneaker
8 Bag
9 Ankle boot

使い方

Python (numpy が必要) でデータをロードする

  • この repo の utils/mnist_reader を使用する :
import mnist_reader
X_train, y_train = mnist_reader.load_mnist('data/fashion', kind='train')
X_test, y_test = mnist_reader.load_mnist('data/fashion', kind='t10k')

TensorFlow でデータをロードする

from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets('data/fashion')

data.train.next_batch(100)

他の言語でデータをロードする

機械学習コミュニティでもっとも人気のあるデータセットの一つですので、人々は多くの言語で MNIST loader を実装してきています。それらは Fashion-MNIST データセットをロードするためにも使用できるでしょう (最初に decompress する必要があるかもしれません)。それらは私たちによってテストはされていないことには注意してください。

ベンチマーク

scikit-learn ベースの自動ベンチマーキング・システムを構築しました、これは異なるパラメータの 125 の (深層学習ではない) 分類器をカバーします。結果はここで見つかります。

 
結果は benchmark/runner.py を実行することで再現できます。推奨方法はこの docker コンテナをビルドして deploy することです (訳注 : リンク欠落)。

貴方のベンチマークを submit することを歓迎します。新しい issue を作成してください、貴方の結果はここでリストされます。詳細は Contributing セクションを確認してください。ベンチマークを submit する前に、このリストにリストされていなことを必ず確認してください。

分類器 前処理 テスト精度 Submitter コード
2 Conv Layers with max pooling (Keras) None 0.876 Kashif Rasul zalando_mnist_cnn
2 Conv Layers with max pooling (Tensorflow) >300 epochs None 0.916 Tensorflow’s doc convnet
Simple 2 layer convnet <100K parameter None 0.925 @hardmaru pytorch_tiny_custom_mnist_adam
GRU+SVM None 0.888 @AFAgarap gru_svm_zalando
GRU+SVM with dropout None 0.855 @AFAgarap gru_svm_zalando_dropout
WRN40-4 8.9M params standard preprocessing (mean/std subtraction/division) and augmentation (random crops/horizontal flips) 0.967 @ajbrock WideResNet & Freezout
DenseNet-BC 768K params standard preprocessing (mean/std subtraction/division) and augmentation (random crops/horizontal flips) 0.954 @ajbrock DenseNets & Freezout
MobileNet augmentation (horizontal flips) 0.950 @苏剑林 Chinese blog post

他の探求

Generative adversarial networks (GANs)

可視化

t-SNE on Fashion-MNIST (左) とオリジナルの MNIST (右)

PCA on Fashion-MNIST (左) とオリジナルの MNIST (右)

Contributing, Contact, Citing Fashion-MNIST & License

(訳注 : 原文 をご確認ください。)

(訳注 : README の翻訳は以上です。)

 

(2) TensorFlow で Fashion-MNIST

さて、せっかくですので、TensorFlow 実装で簡単に Fashion-MNIST を試しておきます。取り敢えずのお試しということで、モデルには 512, 512 ノードを持つ2層の簡単な MLP を使いました。但し、Dropout は付けています。

データセットのロードは上記の方法でロードしても良いですし、MNIST データセットと同じ構造をしていますので自前の MNIST loader コードであれば単純にデータセットを置き換えても良いです。

要は、MNIST 用のモデルの実装を少しだけ修正すれば流用できます。

訓練結果

比較のために、最初にこのモデルをオリジナルの MNIST で動作確認しておきます。
わずか 20 epochs ほどで訓練損失は 0.02 を割り、テスト精度は 98 % を超えます :

次に、Fashion-MNIST データセットで試してみますと、20 epochs だと損失は 0.3 前後で精度は 88 % を超える程度です :

念のためにもう少し訓練を続けると、50 epochs で損失 0.2 前後、精度は 90 % を超え始めます。そして 100 epochs で損失 0.15 前後、精度 90.5 % 程度でした。下の画像は 100 epochs までの訓練損失の TensorBoard グラフと、テスト精度のグラフです :

上述のベンチマークと比較してみると、テスト精度 90% は MLP としては悪い数字ではないようです。

 
以上

AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時:2021年10月13日(水)
会場:WEBセミナー
共催:クラスキャット、日本FLOW(株)
後援:働き方改革推進コンソーシアム
参加費: 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com