TensorFlow : Get Started : tf.contrib.learn クイックスタート （翻訳/解説）
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 03/18/2017

* 本ページは、TensorFlow の本家サイトの Get Started – tf.contrib.learn Quickstart を翻訳した上で
適宜、補足説明したものです：
    https://www.tensorflow.org/get_started/tflearn
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

TensorFlow の高位な機械学習 API (tf.contrib.learn) は様々な機械学習モデルを構成し、トレーニングし、そして評価することを容易にします。このチュートリアルでは、花弁 (petal) とガク片 (sepal) の形状をもとに花の種を予測するために、tf.contrib.learn を使用してニューラルネットワーク分類器を構築しそれをアイリス・データセットで訓練します。コードを書いて次の５つのステップを実行します :

1. アイリス訓練/テストデータを含む CSV を TensorFlow データセットにロードする
2. ニューラルネットワーク分類器を構築する
3. 訓練データを使用してモデルを fit する
4. モデルの精度を評価する
5. 新しいサンプルを分類する

 

完全なニューラルネットワーク・ソースコード

これがニューラルネットワーク分類器のための full コードです :

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import urllib

import numpy as np
import tensorflow as tf

# Data sets
IRIS_TRAINING = "iris_training.csv"
IRIS_TRAINING_URL = "http://download.tensorflow.org/data/iris_training.csv"

IRIS_TEST = "iris_test.csv"
IRIS_TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"

def main():
  # If the training and test sets aren't stored locally, download them.
  if not os.path.exists(IRIS_TRAINING):
    raw = urllib.urlopen(IRIS_TRAINING_URL).read()
    with open(IRIS_TRAINING, "w") as f:
      f.write(raw)

  if not os.path.exists(IRIS_TEST):
    raw = urllib.urlopen(IRIS_TEST_URL).read()
    with open(IRIS_TEST, "w") as f:
      f.write(raw)

  # Load datasets.
  training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
      filename=IRIS_TRAINING,
      target_dtype=np.int,
      features_dtype=np.float32)
  test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
      filename=IRIS_TEST,
      target_dtype=np.int,
      features_dtype=np.float32)

  # Specify that all features have real-value data
  feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]

  # Build 3 layer DNN with 10, 20, 10 units respectively.
  classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
                                              hidden_units=[10, 20, 10],
                                              n_classes=3,
                                              model_dir="/tmp/iris_model")
  # Define the training inputs
  def get_train_inputs():
    x = tf.constant(training_set.data)
    y = tf.constant(training_set.target)

    return x, y

  # Fit model.
  classifier.fit(input_fn=get_train_inputs, steps=2000)

  # Define the test inputs
  def get_test_inputs():
    x = tf.constant(test_set.data)
    y = tf.constant(test_set.target)

    return x, y

  # Evaluate accuracy.
  accuracy_score = classifier.evaluate(input_fn=get_test_inputs,
                                       steps=1)["accuracy"]

  print("\nTest Accuracy: {0:f}\n".format(accuracy_score))

  # Classify two new flower samples.
  def new_samples():
    return np.array(
      [[6.4, 3.2, 4.5, 1.5],
       [5.8, 3.1, 5.0, 1.7]], dtype=np.float32)

  predictions = list(classifier.predict(input_fn=new_samples))

  print(
      "New Samples, Class Predictions:    {}\n"
      .format(predictions))

if __name__ == "__main__":
    main()

次のセクションでコードを詳細に通り抜けます。

 

アイリス CSV データを TensorFlow にロードする

アイリス・データセットは 150 行のデータを含み、３つの関連アイリス種 : アイリス・セトサ (setosa)、アイリス・バージニカ (virginica)、アイリス・バージカラー (versicolor) のそれぞれから 50 サンプルから成ります。

左から右へ、アイリス・セトサ (by Radomil, CC BY-SA 3.0)、アイリス・バージカラー (by Dlanglois, CC BY-SA 3.0)、そしてアイリス・バージニカ (by Frank Mayfield, CC BY-SA 2.0) です。

各行は各花のサンプルのための次のデータを含みます : がく片長さ、がく片幅、花弁長さ、花弁幅、そして花の種。花の種は整数で表され、0 はアイリス・セトサを示し、1 はアイリス・バージカラーを示し、そして 2 はアイリス・バージニカを示します。

がく片長さ	がく片幅	花弁長さ	花弁幅	種
5.1	3.5	1.4	0.2	0
4.9	3.0	1.4	0.2	0
4.7	3.2	1.3	0.2	0
…	…	…	…	…
7.0	3.2	4.7	1.4	1
6.4	3.2	4.5	1.5	1
6.9	3.1	4.9	1.5	1
…	…	…	…	…
6.5	3.0	5.2	2.0	2
6.2	3.4	5.4	2.3	2
5.9	3.0	5.1	1.8	2

このチュートリアルのために、アイリス・データは無作為に２つの別の CSV に分割されます :

• 120 サンプルの訓練セット ( iris_training.csv )
• 30 サンプルのテストセット ( iris_test.csv ).

始めるには、最初に全ての必要なモジュールをインポートして、データセットをどこにダウンロードしてストアするかを定義します :

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import urllib

import tensorflow as tf
import numpy as np

IRIS_TRAINING = "iris_training.csv"
IRIS_TRAINING_URL = "http://download.tensorflow.org/data/iris_training.csv"

IRIS_TEST = "iris_test.csv"
IRIS_TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"

そして、訓練とテストセットがまだローカルに保持されていないならば、ダウンロードします。

if not os.path.exists(IRIS_TRAINING):
  raw = urllib.urlopen(IRIS_TRAINING_URL).read()
  with open(IRIS_TRAINING,'w') as f:
    f.write(raw)

if not os.path.exists(IRIS_TEST):
  raw = urllib.urlopen(IRIS_TEST_URL).read()
  with open(IRIS_TEST,'w') as f:
    f.write(raw)

次に、訓練とテストセットを learn.datasets.base の load_csv_with_header() メソッドを使用してデータセットにロードします。load_csv_with_header() は３つの必要な引数を取ります :

• filename, これは CSV ファイルへのファイルパスを取ります。
• target_dtype, これはデータセットの目標値 (target value) の numpy データ型を取ります。
• features_dtype, これはデータセットの特徴値 (feature values) の numpy データ型を取ります。

ここで、目標 (target, モデルを訓練して予測するための値) は花の種で、これは 0-2 の整数ですから、妥当な numpy データ型は np.int です :

# Load datasets.
training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TRAINING,
    target_dtype=np.int,
    features_dtype=np.float32)
test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
    filename=IRIS_TEST,
    target_dtype=np.int,
    features_dtype=np.float32)

tf.contrib.learn のデータセットは named tuples (名前付きタプル) です; データと目標 (target) フィールドを通して特徴データと目標値にアクセスできます。ここで、training_set.data と training_set.target はトレーニングセットのための特徴データと目標値をそれぞれ含み、そして test_set.data と test_set.target はテストセットのための特徴データと目標値を含みます。

後で、”DNNClassifier をアイリス訓練データに fit させる” でモデルを訓練するために training_set.data と training_set.target を使用して、そして “モデル精度を評価する” では test_set.data と test_set.target を使用します。しかしまずは、次のセクションでモデルを構築します。

 

深層ニューラルネットワーク分類器を構築する

tf.contrib.learn は Estimator と呼ばれる、事前定義されたモデルを各種提供しています、これは貴方のデータ上で訓練と評価演算を実行するために “枠にとらわれない (out of the box)” モデルとして使用できます。 ここで、アイリス・データに fit させるために深層ニューラルネットワーク分類器モデルを構成します。tf.contrib.learn を使用して、２、３行のコードで tf.contrib.learn.DNNClassifier をインスタンス化できます :

# Specify that all features have real-value data
feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]

# Build 3 layer DNN with 10, 20, 10 units respectively.
classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
                                            hidden_units=[10, 20, 10],
                                            n_classes=3,
                                            model_dir="/tmp/iris_model")

上のコードは最初にモデルの特徴カラムを定義します、これはデータセットの特徴のためのデータ型を指定します。全ての特徴データは連続的ですので、特徴カラムを構成するために使用するのに tf.contrib.layers.real_valued_column が適当な関数になります。データセット (ガク片幅、ガク片長さ、花弁幅、花弁高さ (height)) には４つの特徴があり、従って全てのデータを保持するためには次元は 4 でなければなりません。

それから、コードは次の引数を使用して DNNClassifier モデルを作成します :

• feature_columns=feature_columns. 上で定義された特徴カラムのセット。
• hidden_units=[10, 20, 10]. ３つの 隠れ層 で、10, 20, そして 10 ニューロンをそれぞれ含みます。
• n_classes=3. ３つの目標クラスで、３つのアイリス種を表します。
• model_dir=/tmp/iris_model. モデル訓練の間に TensorFlow が checkpoint データをセーブするディレクトリ。TensorFlow で更にロギングとモニタリングのためには、Logging and Monitoring Basics with tf.contrib.learn を参照してください。

 

訓練入力パイプラインを記述する

tf.contrib.learn API は入力関数を使用し、これはモデルのためのデータを生成する TensorFlow 演算を作成します。この場合は、データは tf.constant TensorFlow 定数にストアできるほどに小さいです。次のコードは最も単純な可能な入力パイプラインを生成します :

# Define the test inputs
def get_train_inputs():
  x = tf.constant(training_set.data)
  y = tf.constant(training_set.target)

  return x, y

 

DNNClassifier をアイリス訓練データに fit させる

DNN classifier モデルを構成した今、fit メソッドを使用してそれをアイリス訓練データに fit させることができます。input_fn として get_train_inputs と、訓練のためのステップ数 (ここでは、2000) を渡します :

# Fit model.
classifier.fit(input_fn=get_train_inputs, steps=2000)

モデルの状態は classifier に保持されます、これは望むならば繰り返し訓練できることを意味します。例えば、上は次と同値です :

classifier.fit(x=training_set.data, y=training_set.target, steps=1000)
classifier.fit(x=training_set.data, y=training_set.target, steps=1000)

けれども、訓練の間モデルを追跡することに目を向けるならば、代わりにロギング演算を実行するために TensorFlow モニタを使用することを望むでしょう。このトピックについての詳細はチュートリアル “Logging and Monitoring Basics with tf.contrib.learn” を参照してください。

 

モデル精度を評価する

アイリス訓練データで DNNClassifier モデルを fit させました ; 今、evaluate メソッドを使用してアイリス・テストデータでその精度を確認できます。fit のように、evaluate は入力パイプラインを構築する入力関数を取ります。evaluate は評価結果とともに dict を返します。次のコードはアイリス・テストデータ —test_set.data とtest_set.target— を結果からの精度を評価して表示するために渡します :

# Define the test inputs
def get_test_inputs():
  x = tf.constant(test_set.data)
  y = tf.constant(test_set.target)

  return x, y

# Evaluate accuracy.
accuracy_score = classifier.evaluate(input_fn=get_test_inputs,
                                     steps=1)["accuracy"]

print("\nTest Accuracy: {0:f}\n".format(accuracy_score))

[注意] 評価するための steps 引数はここでは重要です。evaluate は通常は入力の終わりに到達するまで実行されます。ファイルのセットに渡り評価するためにはこれは完璧ですが、ここで使用される constants は期待する OutOfRangeError あるいは StopIteration を決して throw しません。

フル・スクリプトを実行した時、次に近いようなものを出力するでしょう :

Test Accuracy: 0.966667

精度結果は様々かもしれませんが、90% より高くなるべきです。比較的小さいデータセットに対しては悪くありません！

 

新しいサンプルを分類する

新しいサンプルを分類するためには estimator の predict メソッドを使用します。例えば、これら２つの新しい花のサンプルがあるとします :

がく片長さ	がく片幅	花弁長	花弁幅
6.4	3.2	4.5	1.5
5.8	3.1	5.0	1.7

predict() メソッドを使用してこれらの種を予測できます。predict は generator を返し、これは簡単にリストに変換されます。次のコードはクラス予測を取得して出力します :

# Classify two new flower samples.
def new_samples():
  return np.array(
    [[6.4, 3.2, 4.5, 1.5],
     [5.8, 3.1, 5.0, 1.7]], dtype=np.float32)

predictions = list(classifier.predict(input_fn=new_samples))

print(
    "New Samples, Class Predictions:    {}\n"
    .format(predictions))

結果は次のように見れるはずです :

New Samples, Class Predictions:    [1 2]

モデルはこうして最初のサンプルはアイリス・バージカラーであることを、そして２つ目のサンプルはアイリス・バージニカであることを予測します。

以上

TensorFlow : Get Started : TensorFlow で始めましょう （翻訳/解説）
翻訳 : (株)クラスキャット セールスインフォメーション
再検証日時 : 04/13/2017
作成日時 : 03/18/2017

* TensorFlow の Get Started 文書が追加補充され、より分かりやすくなっています。tf.contrib.learn への言及もあります。
* 本ページは、TensorFlow の本家サイトの Get Started – Getting Started With TensorFlow を翻訳した上で適宜、補足説明したものです：
    https://www.tensorflow.org/get_started/get_started
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

このガイドは貴方に TensorFlow によるプログラミングを開始して頂くためのものです。このガイドを使用する前に、TensorFlow をインストールしましょう。このガイドから多くを得るためには、次について知っておくべきです :

• Python でどのようにプログラムするか。
• 少なくとも配列について少々。
• 理想的には機械学習について何某か。けれども、機械学習について殆どあるいは全く知らないとしても、これは依然として読むべき最初のガイドとなるでしょう。

TensorFlow は複数の API を提供します。最も低いレベルの API — TensorFlow Core — は完全なプログラミング制御を貴方に提供します。 機械学習研究者とモデル上の優れた制御レベルを必要とする他の人たちのためには TensorFlow Core を推奨します。より高位の API は TensorFlow Core の上に構築されています。これらの高位 API は典型的には TensorFlow Core よりも学習して使用するのがより簡単です。更に、より高位の API は反復的なタスクをより簡単にして異なるユーザ間で一貫性を保持できます。tf.contrib.learn のような高位 API はデータセット、推定器 (estimator)、トレーニングそして推論を管理する手助けをします。高位 TensorFlow API の２、３ — これらのメソッド名は contrib を含むものです — は依然として開発中であることに注意してください。幾つかの contrib メソッドは後の TensorFlow リリースでは変更されるか廃止される可能性もあります。

このガイドは TensorFlow Core 上のチュートリアルから始めます。後で、同じモデルを tf.contrib.learn でどのように実装するかを示します。TensorFlow Core の原理を知ることは、よりコンパクトな高位 API を使用するときに、どのように物事が内部的に動作するかの偉大なメンタルモデルを与えてくれます。

 

テンソル (Tensors)

TensorFlow におけるデータの中心的なユニットはテンソルです。テンソルは、任意の次元数の配列に形状化されたプリミティブな値のセットから成ります。テンソルのランク (rank) はその次元の数です。テンソルの幾つかの例をここに示します :

3 # a rank 0 tensor; this is a scalar with shape []
[1. ,2., 3.] # a rank 1 tensor; this is a vector with shape [3]
[[1., 2., 3.], [4., 5., 6.]] # a rank 2 tensor; a matrix with shape [2, 3]
[[[1., 2., 3.]], [[7., 8., 9.]]] # a rank 3 tensor with shape [2, 1, 3]

TensorFlow Core チュートリアル

TensorFlow をインポートする

TensorFlow プログラムのための標準的な import ステートメントは次のようなものです :

import tensorflow as tf

これは Python に全ての TensorFlow のクラス、メソッド、そしてシンボルへのアクセスを与えます。殆どのドキュメントは貴方がこれを既に実行していることを仮定しています。

計算グラフ

TensorFlow Core プログラムを２つの個別のセクションから成るものと考えて良いです :

1. 計算グラフを構築する。
2. 計算グラフを実行する。

計算グラフはノードのグラフに配列されたTensorFlow 演算の系列です。単純な計算グラフを構築してみましょう。各ノードはゼロまたはそれ以上のテンソルを入力として取り、出力としてテンソルを生成します。ノードの一つの型は constant です。全ての TensorFlow constant のように、それは入力を取らずに、内部的に保持した値を出力します。浮動小数点テンソル node1 と node2 を次のように作成できます :

node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)

最後の print ステートメントは以下を生成します :

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

ノードのプリンティングは貴方が期待したような、値 3.0 と 4.0 を出力しないことに注目しましょう。その代わり、それらは評価されたときに 3.0 と 4.0 をそれぞれ生成するノードです。実際にノードを評価するためには、session の中で計算グラフを実行しなければなりません。session は TensorFlow ランタイムの制御と状態をカプセル化します。

次のコードは Session オブジェクトを作成してそして node1 と node2 を評価するために十分な計算グラフを実行するためにその run メソッドを呼び出します。次のように session で計算グラフを実行することにより :

sess = tf.Session()
print(sess.run([node1, node2]))

3.0 と 4.0 の期待した値を見ます :

[3.0, 4.0]

テンソル・ノードを演算 (演算もまたノードです) と結合することでより複雑な計算を構築できます。例えば、２つの constant ノードを加算して新しいグラフを次のように生成できます :

node3 = tf.add(node1, node2)
print("node3: ", node3)
print("sess.run(node3): ",sess.run(node3))

最後の２つの print ステートメントは以下を生成します :

node3:  Tensor("Add_2:0", shape=(), dtype=float32)
sess.run(node3):  7.0

TensorFlow は TensorBoard と呼ばれるユティリティを提供しています、これは計算グラフの図を表示できます。以下は TensorBoard がグラフをどのように可視化するかを示すスクリーンショットです :

そのままでは、このグラフは特に面白くありません、何故ならばこれはいつも定数の結果を生成するからです。

グラフは外部入力を受け取るようにパラメータ化され、これはプレースホルダーとして知られます。プレースホルダーは後で値を提供するという約束 (= promise) です。

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)

すぐ前の３行は幾分、関数か lambda のようでそこでは２つの入力パラメータ (a と b) とそしてそれらの上の演算を定義します。これらのプレースホルダーに具体的な値を提供するテンソルを指定するために feed_dict パラメータを使用して、複数の入力でこのグラフを評価できます :

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

出力は次の結果になります :

7.5
[ 3.  7.]

TensorBoard では、グラフはこのように見えます :

他の演算を追加することで計算グラフをより複雑にできます。例えば :

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

は以下の出力を生成します :

22.5

前の計算グラフは TensorBoard では次のように見えるでしょう :

機械学習では典型的には上のように、任意の入力が取れるモデルが望まれます。モデルをトレーニング可能にするためには、同じ入力で新しい出力を得るためにグラフを変更できる必要があります。variable はグラフにトレーニング可能なパラメータを追加することを可能にします。それらは型と初期値で構築されます :

W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

constant は tf.constant を呼び出したときに初期化されそれらの値は決して変わりません。variable は tf.Variable を呼び出したときに初期化されません。

TensorFlow プログラムで全ての variable を初期化するためには、次のように特殊な演算を明示的に呼び出さなければなりません :

init = tf.global_variables_initializer()
sess.run(init)

init が、全てのグローバル variables を初期化する TensorFlow サブグラフへのハンドルであることを理解することは重要です。sess.run を呼び出すまでは、variables は初期化されないままです。

x はプレースホルダーなので、次のように幾つかの x の値に対して linear_model を同時に評価することができます :

print(sess.run(linear_model, {x:[1,2,3,4]}))

出力は次のように生成されます :

[ 0.          0.30000001  0.60000002  0.90000004]

モデルを作成しましたが、それがどの程度良いかはまだ分かっていません。トレーニング・データ上でモデルを評価するためには、望ましい値を提供する y プレースホルダーが必要で、損失関数を書く必要があります。

損失関数は現在のモデルが提供されたデータからどの程度遠く離れているのかを計測します。線形回帰のための標準的な損失モデルを使用します、これは現在のモデルと提供されたデータの間の delta (差分) の二乗の合計します。linear_model – y はベクトルを作成しこれは各要素が相当するサンプルのエラー delta です。それらのエラーを二乗するために tf.square を呼び出します。それから、tf.reduce_sum を使用して全ての二乗されたエラーを合計して単一のスカラを作成します、これは全てのサンプルのエラーを抽象化します :

y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

損失値を生成します :

23.66

W と b の値を -1 と 1 という完全な値に再割り当てすることによりこれを手動で改善できるでしょう。variable は tf.Variable に提供された値に初期化されますが tf.assign のような演算子を使用して変更できます。例えば、W=-1 と b=1 はモデルに対しての最適なパラメータです。W と b をそれぞれ変更できます :

fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

最後の print は今や損失がゼロであることを示します。

0.0

W と b の “完全な” 値を推測しましたが、機械学習の核心は正しいモデルパラメータを自動的に見つけることです。次のセクションでどのようにこれを成し遂げるかを示します。

tf.train API

機械学習の完全な議論はこのチュートリアルの範囲外です。けれども、TensorFlow は損失関数を最小化するために各変数をゆっくりと変更する optimizer を提供します。もっとも単純な optimizer は勾配降下です。それは変数に関する損失の導関数の大きさにしたがって各変数を変更します。一般的に、シンボル型の導関数を手動で計算することは退屈で誤りがちです。結果として、モデルの記述のみが与えられたときに TensorFlow は tf.gradients を使用して自動的に導関数を生成します。単純化のために、optimizer は典型的にはこれを貴方のために行ないます。例えば、

optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
  sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})

print(sess.run([W, b]))

最終的なモデル・パラメータは :

[array([-0.9999969], dtype=float32), array([ 0.99999082],
 dtype=float32)]

今や実際の機械学習を行ないました！ この単純な線形回帰は TensorFlow core コードの多くを必要としませんが、モデルへデータを供給する、より複雑なモデルとメソッドは更なるコードを必要とします。このように TensorFlow は共通のパターン、構造、そして機能のためにより高位の抽象を提供します。次のセクションではこれらの抽象の幾つかをどのように使用するかを学びます。

完全なプログラム

完全なトレーニング可能な線形回帰モデルはこのように示されます :

import numpy as np
import tensorflow as tf

# Model parameters
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x:x_train, y:y_train})

# evaluate training accuracy
curr_W, curr_b, curr_loss  = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))

実行すると、以下を生成します :

W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

このより複雑なプログラムは依然として TensorBoard で可視化できます :

tf.contrib.learn

tf.contrib.learn は高位な TensorFlow ライブラリで機械学習の技巧を単純化し、次を含みます :

• トレーニング・ループを実行する
• 評価ループを実行する
• データセットを管理する
• 供給を管理する

tf.contrib.learn は多くの一般的なモデルを定義します。

基本的な使い方

線形回帰プログラムが tf.contrib.learn でどのくらい単純になるかに注目しましょう :

import tensorflow as tf
# NumPy is often used to load, manipulate and preprocess data.
import numpy as np

# Declare list of features. We only have one real-valued feature. There are many
# other types of columns that are more complicated and useful.
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]

# An estimator is the front end to invoke training (fitting) and evaluation
# (inference). There are many predefined types like linear regression,
# logistic regression, linear classification, logistic classification, and
# many neural network classifiers and regressors. The following code
# provides an estimator that does linear regression.
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)

# TensorFlow provides many helper methods to read and set up data sets.
# Here we use `numpy_input_fn`. We have to tell the function how many batches
# of data (num_epochs) we want and how big each batch should be.
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
                                              num_epochs=1000)

# We can invoke 1000 training steps by invoking the `fit` method and passing the
# training data set.
estimator.fit(input_fn=input_fn, steps=1000)

# Here we evaluate how well our model did. In a real example, we would want
# to use a separate validation and testing data set to avoid overfitting.
estimator.evaluate(input_fn=input_fn)

実行時、以下を生成します :

    {'global_step': 1000, 'loss': 1.9650059e-11}

カスタム・モデル

tf.contrib.learn はその事前定義されたモデルに貴方をロックするわけではありません。TensorFlow に組み込まれていないカスタムモデルを作成したいとしましょう。tf.contrib.learn のデータセット、供給、トレーニング等の高位抽象を依然として保持可能です。例示のために、LinearRegressor と同値な私たち自身のモデルをより低位な TensorFlow API の知識を使用してどのように実装するかを示します。

tf.contrib.learn で動作するカスタムモデルを定義するためには、tf.contrib.learn.Estimator を使用する必要があります。tf.contrib.learn.LinearRegressor は実際には tf.contrib.learn.Estimator のサブクラスです。Estimator をサブクラス化する代わりに、tf.contrib.learn にどのように予測、トレーニングステップ、そして損失を評価可能であるかを知らせる関数 model_fn を単純に Estimator に提供します。コードは次のようなものです :

import numpy as np
import tensorflow as tf
# Declare list of features, we only have one real-valued feature
def model(features, labels, mode):
  # Build a linear model and predict values
  W = tf.get_variable("W", [1], dtype=tf.float64)
  b = tf.get_variable("b", [1], dtype=tf.float64)
  y = W*features['x'] + b
  # Loss sub-graph
  loss = tf.reduce_sum(tf.square(y - labels))
  # Training sub-graph
  global_step = tf.train.get_global_step()
  optimizer = tf.train.GradientDescentOptimizer(0.01)
  train = tf.group(optimizer.minimize(loss),
                   tf.assign_add(global_step, 1))
  # ModelFnOps connects subgraphs we built to the
  # appropriate functionality.
  return tf.contrib.learn.ModelFnOps(
      mode=mode, predictions=y,
      loss=loss,
      train_op=train)

estimator = tf.contrib.learn.Estimator(model_fn=model)
# define our data set
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x}, y, 4, num_epochs=1000)

# train
estimator.fit(input_fn=input_fn, steps=1000)
# evaluate our model
print(estimator.evaluate(input_fn=input_fn, steps=10))

実行時、以下を生成します :

{'loss': 5.9819476e-11, 'global_step': 1000}

カスタム model() 関数の内容が、どのようにより低位な API からの手動モデルのトレーニング・ループに非常に類似しているかに注意してください。

 

次のステップ

さて今貴方は TensorFlow の基本の実際上の知識を持ちました。更に学ぶために見ることができる幾つかのチュートリアルがあります。もし貴方が機械学習の初心者であるならば ML 初心者向けの MNIST を見てください、そうでなければ 専門家のための深層 MNIST を見てください。

以上