画像分類は赤ちゃんでも数秒でできる作業ですが、機械にとっては最近の進歩まで大変な作業でした。 そして ディープラーニング 。自動運転車は、物体を検出して必要なアクションをリアルタイムで実行できます。これは、次の理由により可能です。 画像分類。この記事では、次のトピックについて説明します。
TensorFlowとは何ですか？
TensorFlow は、さまざまなタスクにわたるデータフロープログラミングのためのGoogleのオープンソース機械学習フレームワークです。グラフ内のノードは数学演算を表し、グラフのエッジはノード間で通信される多次元データ配列を表します。
テンソルは単なる多次元配列であり、2次元テーブルをより高次元のデータに拡張したものです。 Tensorflowには、ディープラーニングに適した多くの機能があり、そのコアオープンソースライブラリは、MLモデルの開発とトレーニングに役立ちます。
javaとc ++の違いは何ですか
画像分類とは何ですか？
画像分類の目的は、デジタル画像のすべてのピクセルをいくつかのピクセルの1つに分類することです。 土地被覆 クラス または テーマ 。次に、この分類されたデータを使用して、 主題図 画像に存在する土地被覆の。
現在、分類中のアナリストとコンピューター間の相互作用に応じて、分類には2つのタイプがあります。
- 監視あり＆
- 監督されない
それでは、時間を無駄にすることなく、TensorFlow画像分類に飛び込みましょう。簡単と難しいの2つの例があります。簡単なものから始めましょう。
TensorFlow画像分類：ファッションMNIST
ファッションMNISTデータセット
ここでは、10のカテゴリに70,000のグレースケール画像を含むFashionMNISTデータセットを使用します。トレーニングには60000を使用し、残りはテスト目的に10000を使用します。データをインポートしてロードするだけで、TensorFlowから直接FashionMNISTにアクセスできます。
- 最初にライブラリをインポートしましょう
from __future__ import Absolute_import、division、print_function＃TensorFlowおよびtf.keras import tensorflow as tf from tensorflow import keras＃ヘルパーライブラリimport numpy as np import matplotlib.pyplot as plt
- データをロードしましょう
fashion_mnist = keras.datasets.fashion_mnist（train_images、train_labels）、（test_images、test_labels）= fashion_mnist.load_data（）
- 次に、画像をクラスにマッピングします
class_names = ['Tシャツ/トップ'、 'ズボン'、 'プルオーバー'、 'ドレス'、 'コート'、 'サンダル'、 'シャツ'、 'スニーカー'、 'バッグ'、 'アンクルブーツ']
- データの探索
train_images。形状
＃各ラベルは0〜9です
train_labels
test_images。形状
- 次に、データを前処理します。
plt。図（） plt。imshow（（train_images[0]） plt。カラーバー（） plt。グリッド（（誤り） plt。公演（）
＃トレーニングセットの最初の画像を調べると、ピクセル値が0〜255の範囲にあることがわかります。
- ニューラルネットワークにフィードするには、画像を0-1からスケーリングする必要があります
train_images = train_images / 255.0 test_images = test_images / 255.0
- いくつかの画像を表示してみましょう。
plt。図（（figsize=（（10、10）） ために 私 に 範囲（（25）： plt。サブプロット（（5、5、私+1） plt。xticks（[]） plt。yticks（[]） plt。グリッド（（誤り） plt。imshow（（train_images[私]、 cmap=plt。CM。バイナリ） plt。xlabel（（class_names[train_labels[私]]） plt。公演（）
- レイヤーを設定する
モデル = ハード。一連の（[ ハード。レイヤー。平らにする（（input_shape=（（28、 28））、 ハード。レイヤー。密集（（128、 アクティベーション=tf。いいえ。relu）、 ハード。レイヤー。密集（（10、 アクティベーション=tf。いいえ。ソフトマックス） ]）
- モデルをコンパイルする
モデル。コンパイル（（オプティマイザ='アダム'、 損失='sparse_categorical_crossentropy'、 メトリック=['正確さ']）
- モデルトレーニング
モデル。フィット（（train_images、 train_labels、 エポック=10）
- 精度の評価
test_loss、 test_acc = モデル。評価する（（test_images、 test_labels） 印刷（（「テスト精度：」、 test_acc）
- 予測をする
予測 = モデル。予測する（（test_images）
予測[0]
予測は10個の数値の配列です。これらは、画像が10種類の衣料品のそれぞれに対応しているというモデルの「自信」を表しています。どのラベルが最も高い信頼値を持っているかを確認できます。
Javaで2進数を10進数に変換する方法
例えば。argmax（（予測[0]）#Modelはそれがアンクルブーツであると最も確信しています。それが正しいかどうか見てみましょう出力：9
test_labels[0]
出力：9
- それでは、10チャンネルのフルセットを見てみましょう。
def plot_image（（私、 予測配列、 true_label、 img）： 予測配列、 true_label、 img = 予測配列[私]、 true_label[私]、 img[私] plt。グリッド（（誤り） plt。xticks（[]） plt。yticks（[]） plt。imshow（（img、 cmap=plt。CM。バイナリ） 予測ラベル = 例えば。argmax（（予測配列） もし 予測ラベル == true_label： 色 = '緑' そうしないと： 色 = 'ネット' plt。xlabel（（'{} {：2.0f}％（{}） '。フォーマット（（class_names[予測ラベル]、 100*例えば。最大（（予測配列）、 class_names[true_label]）、 色=色） def plot_value_array（（私、 予測配列、 true_label）： 予測配列、 true_label = 予測配列[私]、 true_label[私] plt。グリッド（（誤り） plt。xticks（[]） plt。yticks（[]） thisplot = plt。バー（（範囲（（10）、 予測配列、 色='＃777777'） plt。ylim（[0、 1]） 予測ラベル = 例えば。argmax（（予測配列） thisplot[予測ラベル]。set_color（（'ネット'） thisplot[true_label]。set_color（（'緑'）
- 最初に0番目と10番目の画像を見てみましょう
私 = 0 plt。図（（figsize=（（6、3）） plt。サブプロット（（1、2、1） plot_image（（私、 予測、 test_labels、 test_images） plt。サブプロット（（1、2、2） plot_value_array（（私、 予測、 test_labels） plt。公演（）
私 = 10 plt。図（（figsize=（（6、3）） plt。サブプロット（（1、2、1） plot_image（（私、 予測、 test_labels、 test_images） plt。サブプロット（（1、2、2） plot_value_array（（私、 予測、 test_labels） plt。公演（）
- それでは、いくつかの画像とその予測をプロットしてみましょう。正しいものは緑で、間違ったものは赤です。
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt。図（（figsize=（（2*2*num_cols、 2*num_rows）） ために 私 に 範囲（（num_images）： plt。サブプロット（（num_rows、 2*num_cols、 2*私+1） plot_image（（私、 予測、 test_labels、 test_images） plt。サブプロット（（num_rows、 2*num_cols、 2*私+2） plot_value_array（（私、 予測、 test_labels） plt。公演（）
- 最後に、トレーニング済みモデルを使用して、単一の画像に関する予測を行います。
＃テストデータセットから画像を取得します img = test_images[0] 印刷（（img。形状）
＃画像を唯一のメンバーであるバッチに追加します。 img = （（例えば。expand_dims（（img、0）） 印刷（（img。形状）
予測シングル = モデル。予測する（（img） 印刷（（予測シングル）plot_value_array（（0、 予測シングル、 test_labels） plt。xticks（（範囲（（10）、 class_names、 回転=フォーファイブ） plt。公演（）
予測結果 = 例えば。argmax（（予測シングル[0]）
出力：9
CIFAR-10：CNN
CIFAR-10データセットは、飛行機、犬、猫、その他のオブジェクトで構成されています。画像を前処理してから、すべてのサンプルで畳み込みニューラルネットワークをトレーニングします。画像は正規化する必要があり、ラベルはワンホットエンコードする必要があります。このユースケースは、TensorFlow画像分類に関する疑問を確実に解消します。
- データのダウンロード
から urllib.request インポート urlretrieve から os.path インポート isfile、 すすです から tqdm インポート tqdm インポート tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' クラス DownloadProgress（（tqdm）： last_block = 0 def 針（（自己、 block_num=1、 block_size=1、 全体の大きさ=無し）： 自己。合計 = 全体の大きさ 自己。更新（（（block_num - 自己。last_block） * block_size） 自己。last_block = block_num '' ' データ（zip）ファイルがすでにダウンロードされているかどうかを確認します そうでない場合は、「https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz」からダウンロードして、cifar-10-python.tar.gzとして保存します。 '' ' もし ない isfile（（'cifar-10-python.tar.gz'）： と DownloadProgress（（単位=「B」、 unit_scale=本当、 大臣=1、 説明=「CIFAR-10データセット」） なので pbar： urlretrieve（（ 「https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz」、 'cifar-10-python.tar.gz'、 pbar。針） もし ない すすです（（cifar10_dataset_folder_path）： と tarfile。開いた（（'cifar-10-python.tar.gz'） なので タール： タール。extractall（） タール。閉じる（）
- 必要なライブラリのインポート
インポート 漬物 インポート numpy なので 例えば インポート matplotlib.pyplot なので plt
- データを理解する
データの元のバッチは、numpy配列で表された10000×3072テンソルです。ここで、10000はサンプルデータの数です。画像はカラーで、サイズは32×32です。フィードは、（幅x高さx num_channel）または（num_channelx幅x高さ）のいずれかの形式で実行できます。ラベルを定義しましょう。
def load_label_names（）： 戻る ['飛行機'、 '自動車'、 '鳥'、 'ネコ'、 '鹿'、 '犬'、 'カエル'、 'うま'、 '輸送する'、 'トラック']
- データの再形成
2段階でデータを再形成します
まず、行ベクトル（3072）を3つに分割します。各ピースは各チャネルに対応します。これにより、テンソルの次元は（3 x 1024）になります。次に、前のステップで得られたテンソルを32で除算します。ここで32は、画像の幅を意味します。これにより、（3x32x32）になります。
次に、データを（num_channel、width、height）から（width、height、num_channel）に転置する必要があります。そのために、転置関数を使用します。
def load_cfar10_batch（（cifar10_dataset_folder_path、 batch_id）： と 開いた（（cifar10_dataset_folder_path + '/ data_batch_' + p（（batch_id）、 モード='rb'） なので ファイル： ＃エンコーディングタイプが「latin1」であることに注意してください バッチ = 漬物。負荷（（ファイル、 エンコーディング='latin1'） 特徴 = バッチ['データ']。形を変える（（（len（（バッチ['データ']）、 3、 32、 32））。転置（（0、 2、 3、 1） ラベル = バッチ[「ラベル」] 戻る 特徴、 ラベル
- データの調査
def display_stats（（cifar10_dataset_folder_path、 batch_id、 sample_id）： 特徴、 ラベル = load_cfar10_batch（（cifar10_dataset_folder_path、 batch_id） もし ない （（0 <= sample_id < len（（特徴））：： 印刷（（'{}バッチのサンプル{}。{}範囲外です。」。フォーマット（（len（（特徴）、 batch_id、 sample_id）） 戻る 無し 印刷（（' バッチの統計＃{}： '。フォーマット（（batch_id）） 印刷（（'サンプル数：{} '。フォーマット（（len（（特徴）））） label_names = load_label_names（） label_counts = 辞書（（zip（（*例えば。ユニーク（（ラベル、 return_counts=本当）））） ために キー、 値 に label_counts。アイテム（）： 印刷（（'のラベル数[{}]（{}）：{}'。フォーマット（（キー、 label_names[キー]。アッパー（）、 値）） sample_image = 特徴[sample_id] sample_label = ラベル[sample_id] 印刷（（' 画像の例{}： '。フォーマット（（sample_id）） 印刷（（'画像-最小値：{}最大値：{}'。フォーマット（（sample_image。分（）、 sample_image。最大（））） 印刷（（'画像-形状：{}'。フォーマット（（sample_image。形状）） 印刷（（'ラベル-ラベルID：{}名前：{}'。フォーマット（（sample_label、 label_names[sample_label]）） plt。imshow（（sample_image）
％matplotlib 列をなして ％設定 InlineBackend。figure_format = '網膜' インポート numpy なので 例えば ＃データセットを探索する batch_id = 3 sample_id = 7000 display_stats（（cifar10_dataset_folder_path、 batch_id、 sample_id）
- 前処理関数の実装
最小-最大正規化を使用してデータを正規化します。これにより、すべてのx値が0から1の範囲になります。
y =（x-min）/（max-min）
def ノーマライズ（（バツ）： '' ' 引数 --x：numpy配列に画像データを入力します[32、32、3] 戻る -正規化されたx '' ' min_val = 例えば。分（（バツ） max_val = 例えば。最大（（バツ） バツ = （（バツ-min_val） / （（max_val-min_val） 戻る バツ
- ワンホットエンコード
def one_hot_encode（（バツ）： '' ' 引数 --x：ラベルのリスト 戻る -1つのホットエンコーディングマトリックス（ラベルの数、クラスの数） '' ' エンコードされた = 例えば。ゼロ（（（len（（バツ）、 10）） ために idx、 時間 に 列挙する（（バツ）： エンコードされた[idx] [時間] = 1 戻る エンコードされた
- データの前処理と保存
def _preprocess_and_save（（ノーマライズ、 one_hot_encode、 特徴、 ラベル、 ファイル名）： 特徴 = ノーマライズ（（特徴） ラベル = one_hot_encode（（ラベル） 漬物。投げ捨てる（（（特徴、 ラベル）、 開いた（（ファイル名、 'wb'）） def preprocess_and_save_data（（cifar10_dataset_folder_path、 ノーマライズ、 one_hot_encode）： n_batches = 5 valid_features = [] valid_labels = [] ために batch_i に 範囲（（1、 n_batches + 1）： 特徴、 ラベル = load_cfar10_batch（（cifar10_dataset_folder_path、 batch_i） ＃バッチのデータセット全体で検証データとしてのポイントとなるインデックスを見つける（10％） index_of_validation = int（（len（（特徴） * 0.1） ＃バッチのデータセット全体の90％を前処理します ＃-機能を正規化する ＃-ラベルをone_hot_encodeする ＃-'preprocess_batch_' + batch_numberという名前の新しいファイルに保存します ＃-各バッチの各ファイル _preprocess_and_save（（ノーマライズ、 one_hot_encode、 特徴[：-index_of_validation]、 ラベル[：-index_of_validation]、 'preprocess_batch_' + p（（batch_i） + '.p'） ＃トレーニングデータセットとは異なり、検証データセットはすべてのバッチデータセットを通じて追加されます ＃-バッチのwholdデータセットの10％を取得します ＃-それらをのリストに追加します ＃-valid_features ＃-valid_labels valid_features。拡張する（（特徴[-index_of_validation：]） valid_labels。拡張する（（ラベル[-index_of_validation：]） ＃スタックされたすべての検証データセットを前処理する _preprocess_and_save（（ノーマライズ、 one_hot_encode、 例えば。アレイ（（valid_features）、 例えば。アレイ（（valid_labels）、 'preprocess_validation.p'） ＃テストデータセットをロードする と 開いた（（cifar10_dataset_folder_path + '/ test_batch'、 モード='rb'） なので ファイル： バッチ = 漬物。負荷（（ファイル、 エンコーディング='latin1'） ＃テストデータを前処理する test_features = バッチ['データ']。形を変える（（（len（（バッチ['データ']）、 3、 32、 32））。転置（（0、 2、 3、 1） test_labels = バッチ[「ラベル」] ＃すべてのテストデータを前処理して保存する _preprocess_and_save（（ノーマライズ、 one_hot_encode、 例えば。アレイ（（test_features）、 例えば。アレイ（（test_labels）、 'preprocess_training.p'）
preprocess_and_save_data（（cifar10_dataset_folder_path、 ノーマライズ、 one_hot_encode）
- チェックポイント
インポート 漬物 valid_features、 valid_labels = 漬物。負荷（（開いた（（'preprocess_validation.p'、 モード='rb'））
- ネットワークの構築
モデル全体は合計14層で構成されています。
インポート tensorflow なので tf def conv_net（（バツ、 keep_prob）： conv1_filter = tf。変数（（tf。切断正規（（形状=[3、 3、 3、 64]、 平均=0、 stddev=0.08）） conv2_filter = tf。変数（（tf。切断正規（（形状=[3、 3、 64、 128]、 平均=0、 stddev=0.08）） conv3_filter = tf。変数（（tf。切断正規（（形状=[5、 5、 128、 256]、 平均=0、 stddev=0.08）） conv4_filter = tf。変数（（tf。切断正規（（形状=[5、 5、 256、 512]、 平均=0、 stddev=0.08）） ＃1、2 conv1 = tf。いいえ。conv2d（（バツ、 conv1_filter、 歩幅=[1、1、1、1]、 パディング='同じ'） conv1 = tf。いいえ。relu（（conv1） conv1_pool = tf。いいえ。max_pool（（conv1、 ksize=[1、2、2、1]、 歩幅=[1、2、2、1]、 パディング='同じ'） conv1_bn = tf。レイヤー。batch_normalization（（conv1_pool） ＃3。4 conv2 = tf。いいえ。conv2d（（conv1_bn、 conv2_filter、 歩幅=[1、1、1、1]、 パディング='同じ'） conv2 = tf。いいえ。relu（（conv2） conv2_pool = tf。いいえ。max_pool（（conv2、 ksize=[1、2、2、1]、 歩幅=[1、2、2、1]、 パディング='同じ'） conv2_bn = tf。レイヤー。batch_normalization（（conv2_pool） ＃5、6 conv3 = tf。いいえ。conv2d（（conv2_bn、 conv3_filter、 歩幅=[1、1、1、1]、 パディング='同じ'） conv3 = tf。いいえ。relu（（conv3） conv3_pool = tf。いいえ。max_pool（（conv3、 ksize=[1、2、2、1]、 歩幅=[1、2、2、1]、 パディング='同じ'） conv3_bn = tf。レイヤー。batch_normalization（（conv3_pool） ＃7、8 conv4 = tf。いいえ。conv2d（（conv3_bn、 conv4_filter、 歩幅=[1、1、1、1]、 パディング='同じ'） conv4 = tf。いいえ。relu（（conv4） conv4_pool = tf。いいえ。max_pool（（conv4、 ksize=[1、2、2、1]、 歩幅=[1、2、2、1]、 パディング='同じ'） conv4_bn = tf。レイヤー。batch_normalization（（conv4_pool） ＃9 平らな = tf。寄稿。レイヤー。平らにする（（conv4_bn） ＃10 full1 = tf。寄稿。レイヤー。full_connected（（入力=平らな、 num_outputs=128、 Activation_fn=tf。いいえ。relu） full1 = tf。いいえ。脱落（（full1、 keep_prob） full1 = tf。レイヤー。batch_normalization（（full1） ＃ 十一 full2 = tf。寄稿。レイヤー。full_connected（（入力=full1、 num_outputs=256、 Activation_fn=tf。いいえ。relu） full2 = tf。いいえ。脱落（（full2、 keep_prob） full2 = tf。レイヤー。batch_normalization（（full2） ＃12 full3 = tf。寄稿。レイヤー。full_connected（（入力=full2、 num_outputs=512、 Activation_fn=tf。いいえ。relu） full3 = tf。いいえ。脱落（（full3、 keep_prob） full3 = tf。レイヤー。batch_normalization（（full3） ＃13 full4 = tf。寄稿。レイヤー。full_connected（（入力=full3、 num_outputs=1024、 Activation_fn=tf。いいえ。relu） full4 = tf。いいえ。脱落（（full4、 keep_prob） full4 = tf。レイヤー。batch_normalization（（full4） ＃14 でる = tf。寄稿。レイヤー。full_connected（（入力=full3、 num_outputs=10、 Activation_fn=無し） 戻る でる
- ハイパーパラメータ
エポック = 10 バッチサイズ = 128 keep_probability = 0.7 Learning_rate = 0.001
ロジット = conv_net（（バツ、 keep_prob） モデル = tf。身元（（ロジット、 名前=「ロジット」） ＃ロジットTensorに名前を付けて、トレーニング後にディスクからロードできるようにします ＃損失とオプティマイザー 費用 = tf。reduce_mean（（tf。いいえ。softmax_cross_entropy_with_logits（（ロジット=ロジット、 ラベル=Y）） オプティマイザ = tf。列車。AdamOptimizer（（Learning_rate=Learning_rate）。最小化（（費用） ＃ 正確さ correct_pred = tf。等しい（（tf。argmax（（ロジット、 1）、 tf。argmax（（Y、 1）） 正確さ = tf。reduce_mean（（tf。キャスト（（correct_pred、 tf。float32）、 名前='正確さ'）
- ニューラルネットワークをトレーニングする
＃単一の最適化
def train_neural_network（（セッション、 オプティマイザ、 keep_probability、 feature_batch、 label_batch）： セッション。実行（（オプティマイザ、 feed_dict={{ バツ： feature_batch、 Y： label_batch、 keep_prob： keep_probability }）
#Showing Stats def print_stats（（セッション、 feature_batch、 label_batch、 費用、 正確さ）： 損失 = sess。実行（（費用、 feed_dict={{ バツ： feature_batch、 Y： label_batch、 keep_prob： 1。 }） valid_acc = sess。実行（（正確さ、 feed_dict={{ バツ： valid_features、 Y： valid_labels、 keep_prob： 1。 }） 印刷（（'損失：{：> 10.4f}検証精度：{：.6f}'。フォーマット（（損失、 valid_acc））
- モデルの完全なトレーニングと保存
def batch_features_labels（（特徴、 ラベル、 バッチサイズ）： '' ' フィーチャとラベルをバッチに分割する '' ' ために 開始 に 範囲（（0、 len（（特徴）、 バッチサイズ）： 終わり = 分（（開始 + バッチサイズ、 len（（特徴）） 産出 特徴[開始：終わり]、 ラベル[開始：終わり] def load_preprocess_training_batch（（batch_id、 バッチサイズ）： '' ' 前処理されたトレーニングデータをロードし、それらをバッチ以下で返します '' ' ファイル名 = 'preprocess_batch_' + p（（batch_id） + '.p' 特徴、 ラベル = 漬物。負荷（（開いた（（ファイル名、 モード='rb'）） ＃サイズ以下のバッチでトレーニングデータを返す 戻る batch_features_labels（（特徴、 ラベル、 バッチサイズ）
＃モデルとパスの保存
save_model_path = './image_classification' 印刷（（'トレーニング...'） と tf。セッション（） なので sess： ＃変数の初期化 sess。実行（（tf。global_variables_initializer（）） ＃トレーニングサイクル ために 時代 に 範囲（（エポック）： ＃すべてのバッチをループする n_batches = 5 ために batch_i に 範囲（（1、 n_batches + 1）： ために batch_features、 batch_labels に load_preprocess_training_batch（（batch_i、 バッチサイズ）： train_neural_network（（sess、 オプティマイザ、 keep_probability、 batch_features、 batch_labels） 印刷（（'時代{：> 2}、CIFAR-10バッチ{}： '。フォーマット（（時代 + 1、 batch_i）、 終わり=''） print_stats（（sess、 batch_features、 batch_labels、 費用、 正確さ） ＃モデルを保存 セーバー = tf。列車。セーバー（） save_path = セーバー。セーブ（（sess、 save_model_path）
これで、Tensorflow画像分類の重要な部分が完了しました。それでは、モデルをテストします。
- モデルのテスト
インポート 漬物 インポート numpy なので 例えば インポート matplotlib.pyplot なので plt から sklearn.preprocessing インポート LabelBinarizer def batch_features_labels（（特徴、 ラベル、 バッチサイズ）： '' ' フィーチャとラベルをバッチに分割する '' ' ために 開始 に 範囲（（0、 len（（特徴）、 バッチサイズ）： 終わり = 分（（開始 + バッチサイズ、 len（（特徴）） 産出 特徴[開始：終わり]、 ラベル[開始：終わり] def display_image_predictions（（特徴、 ラベル、 予測、 top_n_predictions）： n_classes = 10 label_names = load_label_names（） label_binarizer = LabelBinarizer（） label_binarizer。フィット（（範囲（（n_classes）） label_ids = label_binarizer。reverse_transform（（例えば。アレイ（（ラベル）） 図、 斧 = plt。サブプロット（（nrows=top_n_predictions、 ncols=2、 figsize=（（20、 10）） 図。tight_layout（） 図。suptitle（（「ソフトマックス予測」、 フォントサイズ=20、 Y=1.1） n_predictions = 3 マージン = 0.05 ind = 例えば。アレンジ（（n_predictions） 幅 = （（1。 - 2.2。 * マージン） / n_predictions ために image_i、 （（特徴、 label_id、 pred_indicies、 pred_values） に 列挙する（（zip（（特徴、 label_ids、 予測。インデックス、 予測。値））：： もし （（image_i < top_n_predictions）： pred_names = [label_names[pred_i] ために pred_i に pred_indicies] 正しい名前 = label_names[label_id] 斧[image_i] [0]。imshow（（（特徴*255）。astype（（例えば。int32、 コピー=誤り）） 斧[image_i] [0]。set_title（（正しい名前） 斧[image_i] [0]。set_axis_off（） 斧[image_i] [1]。バル（（ind + マージン、 pred_values[：3]、 幅） 斧[image_i] [1]。set_yticks（（ind + マージン） 斧[image_i] [1]。set_yticklabels（（pred_names[：：-1]） 斧[image_i] [1]。set_xticks（[0、 0.5、 1.0]）
％matplotlib 列をなして ％設定 InlineBackend。figure_format = '網膜' インポート tensorflow なので tf インポート 漬物 インポート ランダム save_model_path = './image_classification' バッチサイズ = 64 n_samples = 10 top_n_predictions = 5 def test_model（）： test_features、 test_labels = 漬物。負荷（（開いた（（'preprocess_training.p'、 モード='rb'）） ロードされたグラフ = tf。グラフ（） と tf。セッション（（グラフ=ロードされたグラフ） なので sess： ＃モデルをロード ローダ = tf。列車。import_meta_graph（（save_model_path + '.meta'） ローダ。戻す（（sess、 save_model_path） ＃ロードされたモデルからテンソルを取得 ロードされた_x = ロードされたグラフ。get_tensor_by_name（（'input_x：0'） ロードされた_y = ロードされたグラフ。get_tensor_by_name（（'output_y：0'） ロードされたキーププロブ = ロードされたグラフ。get_tensor_by_name（（'keep_prob：0'） ロードされたロジット = ロードされたグラフ。get_tensor_by_name（（'logits：0'） ロードされた_acc = ロードされたグラフ。get_tensor_by_name（（'精度：0'） ＃メモリ制限の精度をバッチで取得 test_batch_acc_total = 0 test_batch_count = 0 ために train_feature_batch、 train_label_batch に batch_features_labels（（test_features、 test_labels、 バッチサイズ）： test_batch_acc_total + = sess。実行（（ ロードされた_acc、 feed_dict={{ロードされた_x： train_feature_batch、 ロードされた_y： train_label_batch、 ロードされたキーププロブ： 1.0}） test_batch_count + = 1 印刷（（'テストの精度：{} '。フォーマット（（test_batch_acc_total/test_batch_count）） ＃ランダムサンプルを印刷する random_test_features、 random_test_labels = タプル（（zip（（*ランダム。サンプル（（リスト（（zip（（test_features、 test_labels））、 n_samples）））） random_test_predictions = sess。実行（（ tf。いいえ。top_k（（tf。いいえ。ソフトマックス（（ロードされたロジット）、 top_n_predictions）、 feed_dict={{ロードされた_x： random_test_features、 ロードされた_y： random_test_labels、 ロードされたキーププロブ： 1.0}） display_image_predictions（（random_test_features、 random_test_labels、 random_test_predictions、 top_n_predictions） test_model（）
出力： テスト精度：0.5882762738853503
c ++は番号を昇順でソートします
さて、より多くのエポックのためにニューラルネットワークをトレーニングしたり、活性化関数を変更したりすると、より正確な結果が得られる可能性があります。
これで、このTensorFlow画像分類の記事は終わりです。これで、同じものを使用してあらゆる種類の画像を分類できるようになり、画像分類の初心者ではないと確信しています。
エドゥレカの Python認定トレーニングでは、業界の要件と要求に応じて業界の専門家によってキュレーションされます。 SoftMax関数、オートエンコーダニューラルネットワーク、制限付きボルツマンマシン（RBM）、Keras、TFLearnなどの概念を習得します。このコースは、リアルタイムのケーススタディを使用して業界の専門家によって特別にキュレーションされています。