Tensorflow-quick-guide

提供：Dev Guides
移動先:案内、検索

TensorFlow-はじめに

TensorFlowは、機械学習とディープラーニングの概念を最も簡単な方法で実装するためにGoogleチームによって設計されたソフトウェアライブラリまたはフレームワークです。 最適化手法の計算代数を組み合わせて、多くの数式を簡単に計算できます。

TensorFlowの公式ウェブサイトは以下に記載されています-

https://www.tensorflow.org [www.tensorflow.org]

TensorFlowホームページ

TensorFlowの次の重要な機能について考えてみましょう-

  • テンソルと呼ばれる多次元配列の助けを借りて、数式を簡単に定義、最適化、計算する機能が含まれています。
  • ディープニューラルネットワークと機械学習技術のプログラミングサポートが含まれています。
  • これには、さまざまなデータセットを使用したスケーラブルな計算機能が含まれています。
  • TensorFlowは、GPUコンピューティングを使用して管理を自動化します。 また、同じメモリと使用データの最適化という独自の機能も含まれています。

TensorFlowが人気を博しているのはなぜですか？

TensorFlowは十分に文書化されており、多くの機械学習ライブラリが含まれています。 いくつかの重要な機能と同じ方法を提供します。

TensorFlowは「Google」製品とも呼ばれます。 さまざまな機械学習アルゴリズムと深層学習アルゴリズムが含まれています。 TensorFlowは、手書き数字の分類、画像認識、単語の埋め込み、さまざまなシーケンスモデルの作成のために、ディープニューラルネットワークをトレーニングおよび実行できます。

TensorFlow-インストール

TensorFlowをインストールするには、システムに「Python」をインストールすることが重要です。 Pythonバージョン3.4+は、TensorFlowのインストールを開始するのに最適と考えられています。

WindowsオペレーティングシステムにTensorFlowをインストールするには、次の手順を検討してください。

  • ステップ1 *-インストールされているPythonバージョンを確認します。

インストールされているPythonバージョン

  • ステップ2 *-ユーザーは、システムにTensorFlowをインストールするためのメカニズムを選択できます。 「pip」と「Anaconda」をお勧めします。 Pipは、Pythonでモジュールを実行およびインストールするために使用されるコマンドです。

TensorFlowをインストールする前に、システムにAnacondaフレームワークをインストールする必要があります。

Anacondaのインストール

インストールが成功したら、「conda」コマンドを使用してコマンドプロンプトをチェックインします。 コマンドの実行は以下に表示されます-

コンダコマンド実行

  • ステップ3 *-次のコマンドを実行して、TensorFlowのインストールを初期化します-
conda create --name tensorflow python = 3.5

TensorFlowのインストール

TensorFlowのセットアップに必要なパッケージをダウンロードします。

  • ステップ4 *-環境設定が成功した後、TensorFlowモジュールをアクティブにすることが重要です。
activate tensorflow

環境設定

  • ステップ5 *-pipを使用して、システムに「Tensorflow」をインストールします。 インストールに使用されるコマンドは以下のように言及されています-
pip install tensorflow

And, 

pip install tensorflow-gpu

インストールするピップ

TensorFlowをインストールするためのピップ

インストールが成功したら、TensorFlowのサンプルプログラムの実行を知ることが重要です。

次の例は、TensorFlowでの基本的なプログラム作成「Hello World」を理解するのに役立ちます。

Hello Worldの例

最初のプログラム実装のコードは以下に記載されています- 

>> activate tensorflow
>> python (activating python shell)
>> import tensorflow as tf
>> hello = tf.constant(‘Hello, Tensorflow!’)
>> sess = tf.Session()
>> print(sess.run(hello))

人工知能を理解する

人工知能には、機械および特殊なコンピューターシステムによる人間の知能のシミュレーションプロセスが含まれます。 人工知能の例には、学習、推論、自己修正が含まれます。 AIのアプリケーションには、音声認識、エキスパートシステム、画像認識、マシンビジョンが含まれます。

機械学習は、新しいデータとデータパターンを学習できるシステムとアルゴリズムを扱う人工知能の分野です。

機械学習とディープラーニングの概念を理解するために、下記のベン図に注目しましょう。

ベン図

機械学習には機械学習のセクションが含まれ、ディープラーニングは機械学習の一部です。 機械学習の概念に従うプログラムの機能は、観測データのパフォーマンスを向上させることです。 データ変換の主な動機は、将来、より良い結果を達成するために知識を改善し、その特定のシステムの望ましい出力により近い出力を提供することです。 機械学習には、データ内のパターンを認識する機能を含む「パターン認識」が含まれます。

パターンは、望ましい方法で出力を表示するようにトレーニングする必要があります。

機械学習は2つの異なる方法でトレーニングできます-

  • 教師付きトレーニング
  • 教師なしトレーニング

教師あり学習

教師あり学習または教師ありトレーニングには、トレーニングセットがシステムへの入力として与えられ、各例に望ましい出力値のラベルが付けられている手順が含まれます。 このタイプのトレーニングは、特定の損失関数の最小化を使用して実行されます。これは、目的の出力システムに関する出力エラーを表します。

トレーニングの完了後、各モデルの精度は、検証セットとも呼ばれるトレーニングセットからの互いに素な例に関して測定されます。

教師あり学習

「教師あり学習」を説明するための最良の例は、多くの写真に情報が含まれていることです。 ここで、ユーザーはモデルをトレーニングして新しい写真を認識できます。

教師なし学習

教師なし学習または教師なしトレーニングには、トレーニングの例が含まれます。トレーニングの例は、クラスが属するシステムによってラベル付けされていません。 システムは、共通の特性を共有するデータを探し、内部の知識機能に基づいてデータを変更します。このタイプの学習アルゴリズムは、クラスタリング問題で基本的に使用されます。

「教師なし学習」を説明する最良の例は、情報が含まれていない写真の束と、分類とクラスタリングを使用したユーザートレーニングモデルです。 このタイプのトレーニングアルゴリズムは、情報が提供されないため、仮定を使用して機能します。

教師なし学習

TensorFlow-数学的基礎

TensorFlowで基本的なアプリケーションを作成する前に、TensorFlowに必要な数学的概念を理解することが重要です。 数学は、機械学習アルゴリズムの中心と考えられています。 数学の中核概念の助けを借りて、特定の機械学習アルゴリズムのソリューションが定義されています。

ベクター

連続または離散の数値の配列は、ベクトルとして定義されます。 機械学習アルゴリズムは、出力生成を改善するために固定長のベクトルを処理します。

機械学習アルゴリズムは多次元データを処理するため、ベクトルが重要な役割を果たします。

ベクトル

ベクトルモデルの絵の表現は以下のとおりです-

ベクトルモデル

スカラー

スカラーは1次元ベクトルとして定義できます。 スカラーとは、大きさのみを含み、方向を含まないスカラーです。 スカラーでは、大きさのみが関係します。

スカラーの例には、子供の体重と身長のパラメーターが含まれます。

マトリックス

マトリックスは、行と列の形式で配置された多次元配列として定義できます。 行列のサイズは、行の長さと列の長さによって定義されます。 次の図は、指定されたマトリックスの表現を示しています。

多次元配列

前述の「m」行と「n」列のマトリックスを考えてみましょう。マトリックス表現は、マトリックスの長さも定義する「m *nマトリックス」として指定されます。

数学的計算

このセクションでは、TensorFlowのさまざまな数学計算について学習します。

行列の追加

マトリックスが同じ次元の場合、2つ以上のマトリックスの追加が可能です。 追加は、指定された位置ごとの各要素の追加を意味します。

行列の加算がどのように機能するかを理解するために、次の例を検討してください-

例：A = \ begin \ {bmatrix} 1＆2 \\ 3＆4 \ end \ {bmatrix} B = \ begin \ {bmatrix} 5＆6 \\ 7＆8 \ end \ {bmatrix} \： then \：A + B = \ begin \ {bmatrix} 1 + 5＆2 + 6 \\ 3 + 7＆4 + 8 \ end \ {bmatrix} = \ begin \ {bmatrix} 6＆8 \\ 10＆12 \ end \ {bmatrix}

行列の減算

行列の減算は、2つの行列の加算と同様の方法で動作します。 次元が等しい場合、ユーザーは2つの行列を減算できます。

例：A- \ begin \ {bmatrix} 1＆2 \\ 3＆4 \ end \ {bmatrix} B- \ begin \ {bmatrix} 5＆6 \\ 7＆8 \ end \ {bmatrix} \： then \：AB- \ begin \ {bmatrix} 1-5＆2-6 \\ 3-7＆4-8 \ end \ {bmatrix}-\ begin \ {bmatrix} -4＆-4 \\-4＆ -4 \ end \ {bmatrix}

行列の乗算

2つの行列A m* nおよびB p * qを乗算可能にするには、 n は p と等しくなければなりません。 結果の行列は-

C m *q

A = \ begin \ {bmatrix} 1および2 \\ 3および4 \ end \ {bmatrix} B = \ begin \ {bmatrix} 5および6 \\ 7および8 \ end \ {bmatrix}

c _ \ {11} = \ begin \ {bmatrix} 1および2 \ end \ {bmatrix} \ begin \ {bmatrix} 5 \\ 7 \ end \ {bmatrix} = 1 \ times5 + 2 \ times7 = 19 \ ：c _ \ {12} = \ begin \ {bmatrix} 1および2 \ end \ {bmatrix} \ begin \ {bmatrix} 6 \\ 8 \ end \ {bmatrix} = 1 \ times6 + 2 \ times8 = 22

c _ \ {21} = \ begin \ {bmatrix} 3および4 \ end \ {bmatrix} \ begin \ {bmatrix} 5 \\ 7 \ end \ {bmatrix} = 3 \ times5 + 4 \ times7 = 43 \ ：c _ \ {22} = \ begin \ {bmatrix} 3および4 \ end \ {bmatrix} \ begin \ {bmatrix} 6 \\ 8 \ end \ {bmatrix} = 3 \ times6 + 4 \ times8 = 50

C = \ begin \ {bmatrix} c _ \ {11}＆c _ \ {12} \\ c _ \ {21}＆c _ \ {22} \ end \ {bmatrix} = \ begin \ {bmatrix} 19＆22 \\ 43および50 \ end \ {bmatrix}

行列の転置

行列Aの転置m* nは、一般にAT（転置）n *mで表され、列ベクトルを行ベクトルとして転置することによって取得されます。

例：A = \ begin \ {bmatrix} 1＆2 \\ 3＆4 \ end \ {bmatrix} \：then \：A ^ \ {T} \ begin \ {bmatrix} 1＆3 \\ 2＆ 4 \ end \ {bmatrix}

ベクトルのドット積

次元nの任意のベクトルは、行列v = R ^ n* 1として表すことができます。

v _ \ {1} = \ begin \ {bmatrix} v _ \ {11} \\ v _ \ {12} \\\ cdot \\\ cdot \\\ cdot \\ v _ \ {1n} \ end \ {bmatrix } v _ \ {2} = \ begin \ {bmatrix} v _ \ {21} \\ v _ \ {22} \\\ cdot \\\ cdot \\\ cdot \\ v _ \ {2n} \ end \ {bmatrix}

2つのベクトルのドット積は、対応するコンポーネントの積の合計です-同じ次元に沿ったコンポーネントであり、次のように表すことができます

v _ \ {1} \ cdot v _ \ {2} = v_1 ^ Tv _ \ {2} = v_2 ^ Tv _ \ {1} = v _ \ {11} v _ \ {21} + v _ \ {12} v _ \ { 22} + \ cdot \ cdot + v _ \ {1n} v _ \ {2n} = \ displaystyle \ sum \ limits _ \ {k = 1} ^ n v _ \ {1k} v _ \ {2k}

ベクトルの内積の例を以下に示します-

例：v _ \ {1} = \ begin \ {bmatrix} 1 \\ 2 \\ 3 \ end \ {bmatrix} v _ \ {2} = \ begin \ {bmatrix} 3 \\ 5 \\-1 \ end \ {bmatrix} v _ \ {1} \ cdot v _ \ {2} = v_1 ^ Tv _ \ {2} = 1 \ times3 + 2 \ times5-3 \ times1 = 10

機械学習と深層学習

人工知能は、最近の最も人気のあるトレンドの1つです。 機械学習と深層学習は人工知能を構成します。 以下に示すベン図は、機械学習と深層学習の関係を説明しています-

ベン図

機械学習

機械学習は、設計およびプログラミングされたアルゴリズムに従ってコンピューターを動作させる科学技術です。 多くの研究者は、機械学習が人間レベルのAIに向けて前進するための最良の方法であると考えています。 機械学習には次の種類のパターンが含まれます

  • 教師あり学習パターン
  • 教師なし学習パターン

深層学習

ディープラーニングは、関連するアルゴリズムが人工ニューラルネットワークと呼ばれる脳の構造と機能に触発された機械学習のサブフィールドです。

ディープラーニングの今日の価値はすべて、教師あり学習またはラベル付きデータとアルゴリズムからの学習です。

深層学習の各アルゴリズムは、同じプロセスを経ます。 出力として統計モデルを生成するために使用できる入力の非線形変換の階層が含まれています。

機械学習プロセスを定義する次の手順を検討してください

  • 関連するデータセットを識別し、分析のために準備します。
  • 使用するアルゴリズムのタイプを選択します
  • 使用されるアルゴリズムに基づいて分析モデルを構築します。
  • テストデータセットでモデルをトレーニングし、必要に応じて修正します。
  • モデルを実行してテストスコアを生成します。

機械学習と深層学習の違い

このセクションでは、機械学習とディープラーニングの違いについて学習します。

データ量

機械学習は大量のデータを処理します。 少量のデータにも役立ちます。 一方、データの量が急速に増加する場合、ディープラーニングは効率的に機能します。 次の図は、データの量で機械学習と深層学習の動作を示しています-

データ量

ハードウェアの依存関係

ディープラーニングアルゴリズムは、従来の機械学習アルゴリズムとは異なり、ハイエンドマシンに大きく依存するように設計されています。 深層学習アルゴリズムは、多数のハードウェアサポートを必要とする多数の行列乗算演算を実行します。

機能エンジニアリング

機能エンジニアリングとは、ドメインの知識を特定の機能に組み込んでデータの複雑さを軽減し、機能する学習アルゴリズムに見えるパターンを作成するプロセスです。

例-従来の機械学習パターンは、フィーチャエンジニアリングプロセスに必要なピクセルおよびその他の属性に焦点を当てています。 ディープラーニングアルゴリズムは、データからの高度な機能に焦点を当てています。 すべての新しい問題の新しい機能抽出機能を開発するタスクを削減します。

問題解決アプローチ

従来の機械学習アルゴリズムは、標準的な手順に従って問題を解決します。 問題を部分に分割し、それぞれを解決し、それらを組み合わせて必要な結果を得ます。 ディープラーニングは、問題を分割するのではなく、端から端まで問題を解決することに焦点を当てています。

実行時間

実行時間は、アルゴリズムのトレーニングに必要な時間です。 ディープラーニングには多くのパラメーターが含まれており、通常よりも時間がかかるため、トレーニングには多くの時間が必要です。 機械学習アルゴリズムは、比較的短い実行時間で済みます。

解釈可能性

解釈可能性は、機械学習アルゴリズムとディープラーニングアルゴリズムを比較する主な要因です。 その主な理由は、業界での使用に先立って、ディープラーニングが依然として再考されていることです。

機械学習と深層学習の応用

このセクションでは、機械学習と深層学習のさまざまなアプリケーションについて学習します。

  • 指紋による顔認識および出席マークまたはナンバープレートによる車両識別に使用されるコンピュータービジョン。
  • 画像検索のためのテキスト検索などの検索エンジンからの情報検索。
  • 指定されたターゲットIDを使用した自動メールマーケティング。
  • がん腫瘍の医学的診断または慢性疾患の異常同定。
  • 写真のタグ付けなどのアプリケーションの自然言語処理。 このシナリオを説明する最良の例は、Facebookで使用されています。
  • オンライン広告。

今後の動向

  • 業界でデータサイエンスと機械学習を使用する傾向が高まるにつれて、各組織がビジネスで機械学習を教え込むことが重要になります。
  • ディープラーニングは、機械学習よりも重要性を増しています。 ディープラーニングは、最先端のパフォーマンスにおける最高のテクニックの1つであることが証明されています。
  • 機械学習とディープラーニングは、研究および学術分野で有益であることが証明されます。

結論

この記事では、マシンラーニングとディープラーニングの概要を、将来のトレンドにも焦点を当てたイラストと相違点で説明しました。 AIアプリケーションの多くは、主にセルフサービスを促進し、エージェントの生産性とワークフローの信頼性を高めるために、機械学習アルゴリズムを利用しています。 機械学習とディープラーニングアルゴリズムには、多くの企業や業界のリーダーにとって魅力的な見通しが含まれています。

TensorFlow-基本

この章では、TensorFlowの基本について学習します。 テンソルのデータ構造を理解することから始めます。

テンソルデータ構造

テンソルは、TensorFlow言語の基本的なデータ構造として使用されます。 テンソルは、データフローグラフと呼ばれるフロー図の接続エッジを表します。 テンソルは、多次元配列またはリストとして定義されます。

テンソルは、次の3つのパラメータによって識別されます-

Rank

テンソル内で記述される次元の単位はランクと呼ばれます。 テンソルの次元数を識別します。 テンソルのランクは、定義されたテンソルの次数またはn次元として説明できます。

形状

行と列の数が一緒になって、Tensorの形状を定義します。

Type

タイプは、Tensorの要素に割り当てられたデータタイプを示します。

ユーザーは、テンソルを構築するために次のアクティビティを考慮する必要があります-

  • n次元配列を作成する
  • n次元配列を変換します。

Tensorデータ構造

TensorFlowのさまざまな次元

TensorFlowにはさまざまなディメンションが含まれています。 寸法は以下に簡単に説明されています-

一次元テンソル

1次元テンソルは、同じデータ型の1セットの値を含む通常の配列構造です。

宣言 

>>> import numpy as np
>>> tensor_1d = np.array([1.3, 1, 4.0, 23.99])
>>> print tensor_1d

出力の実装は、以下のスクリーンショットに示されています-

一次元テンソル

要素のインデックス付けは、Pythonリストと同じです。 最初の要素はインデックス0で始まります。インデックスを介して値を出力するには、インデックス番号を指定するだけです。 

>>> print tensor_1d[0]
1.3
>>> print tensor_1d[2]
4.0

宣言

二次元テンソル

配列のシーケンスは、「2次元テンソル」の作成に使用されます。

二次元テンソルの作成は以下に説明されています-

二次元テンソル

以下は、二次元配列を作成するための完全な構文です- 

>>> import numpy as np
>>> tensor_2d = np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)])
>>> print(tensor_2d)
[[The specific elements of two dimensional tensors can be tracked with the help of row number and column number specified as index numbers.

[source,result,notranslate]

>>> tensor_2d [3] [2] 14 

image:/tensorflow/two_dimensional_tensors_tracked.jpg[Two Dimensional Tensors Tracked]

=== Tensor Handling and Manipulations

In this section, we will learn about Tensor Handling and Manipulations.

To begin with, let us consider the following code −

[source,prettyprint,notranslate]

テンソルフローをtfとしてインポートします。

matrix1 = np.array（[（2,2,2）、（2,2,2）、（2,2,2）]、dtype = 'int32'）matrix2 = np.array（[（1,1、 1）、（1,1,1）、（1,1,1）]、dtype = 'int32'）

印刷（matrix1）印刷（matrix2）

matrix1 = tf.constant（matrix1）matrix2 = tf.constant（matrix2）matrix_product = tf.matmul（matrix1、matrix2）matrix_sum = tf.add（matrix1、matrix2）matrix_3 = np.array（[（2,7,2） 、（1,4,2）、（9,0,2）]、dtype = 'float32'）print（matrix_3）

matrix_det = tf.Session（）をセッションとしてtf.matrix_determinant（matrix_3）：result1 = sess.run（matrix_product）result2 = sess.run（matrix_sum）result3 = sess.run（matrix_det）

印刷（結果1）印刷（結果2）印刷（結果3） 

*Output*

The above code will generate the following output −

image:/tensorflow/tensor_handling_and_manipulations.jpg[Tensor Handling and Manipulations]

==== Explanation

We have created multidimensional arrays in the above source code. Now, it is important to understand that we created graph and sessions, which manage the Tensors and generate the appropriate output. With the help of graph, we have the output specifying the mathematical calculations between Tensors.

TensorFlow-畳み込みニューラルネットワーク

機械学習の概念を理解した後、焦点を深層学習の概念に移すことができます。 ディープラーニングは機械学習の一部であり、ここ数十年で研究者がとった重要なステップと考えられています。 ディープラーニングの実装例には、画像認識や音声認識などのアプリケーションが含まれます。

以下は、ディープニューラルネットワークの2つの重要なタイプです-

  • 畳み込みニューラルネットワーク
  • リカレントニューラルネットワーク

この章では、CNN、畳み込みニューラルネットワークに焦点を当てます。

畳み込みニューラルネットワーク

畳み込みニューラルネットワークは、アレイの複数のレイヤーを介してデータを処理するように設計されています。 このタイプのニューラルネットワークは、画像認識や顔認識などのアプリケーションで使用されます。 CNNと他の通常のニューラルネットワークの主な違いは、CNNが入力を2次元配列として受け取り、他のニューラルネットワークが焦点を当てる特徴抽出に焦点を当てるのではなく、画像に直接作用することです。

CNNの主要なアプローチには、認識の問題の解決策が含まれます。 GoogleやFacebookなどのトップ企業は、認識プロジェクトに向けた研究開発に投資して、活動をより迅速に完了させています。

畳み込みニューラルネットワークは3つの基本的なアイデアを使用します-

  • 現地の各分野
  • 畳み込み
  • プーリング

これらのアイデアを詳細に理解しましょう。

CNNは、入力データ内に存在する空間相関を利用します。 ニューラルネットワークの各同時層は、いくつかの入力ニューロンを接続します。 この特定の領域は、局所受容野と呼ばれます。 局所受容野は隠れたニューロンに焦点を合わせています。 隠されたニューロンは、特定の境界外の変更を実現せずに、言及されたフィールド内の入力データを処理します。

以下は、ローカルの各フィールドを生成する図表です-

畳み込みニューラルネットワーク

上記の表現を観察すると、各接続は、1つの層から別の層への移動に関連する接続を持つ隠れニューロンの重みを学習します。 ここでは、個々のニューロンが時々シフトを実行します。 このプロセスは「畳み込み」と呼ばれます。

入力レイヤーから非表示のフィーチャマップへの接続のマッピングは「共有ウェイト」として定義され、含まれるバイアスは「共有バイアス」と呼ばれます。

CNNまたは畳み込みニューラルネットワークは、CNN宣言の直後に配置されたプールレイヤーを使用します。 これは、畳み込みネットワークから得られる機能マップとしてユーザーからの入力を受け取り、圧縮された機能マップを準備します。 層のプーリングは、前の層のニューロンを持つ層の作成に役立ちます。

CNNのTensorFlow実装

このセクションでは、CNNのTensorFlow実装について学習します。 ネットワーク全体の実行と適切な次元を必要とする手順は、以下に示すとおりです-

  • ステップ1 *-TensorFlowに必要なモジュールと、CNNモデルの計算に必要なデータセットモジュールを含めます。
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

ステップ2 *- run_cnn（）*という関数を宣言します。これには、データプレースホルダーの宣言を含むさまざまなパラメーターと最適化変数が含まれます。 これらの最適化変数は、トレーニングパターンを宣言します。 

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

ステップ3 *-このステップでは、28 x 28ピクセル= 784の入力パラメーターでトレーニングデータプレースホルダーを宣言します。 これは、 mnist.train.nextbatch（）*から描画される平坦化された画像データです。

要件に応じてテンソルを変更できます。 最初の値（-1）は、渡されたデータの量に基づいてそのディメンションを動的にシェーピングするように関数に指示します。 中間の2つの寸法は画像サイズに設定されます（つまり、 28 x 28）。 

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])
  • ステップ4 *-畳み込み層を作成することが重要です-
layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')
  • ステップ5 *-出力を完全に接続された出力ステージの準備を整えます-28 x 28の寸法の2層のストライド2プーリングの後、14 x 14または最小7 x 7 x、y座標の寸法に、ただし出力チャンネルは64です。 「密」レイヤーと完全に接続されたレイヤーを作成するには、新しい形状が[-1、7 x 7 x 64]である必要があります。 このレイヤーにいくつかの重みとバイアス値を設定し、ReLUでアクティブ化できます。
flattened = tf.reshape(layer2, [-1, 7 *7* 64])

wd1 = tf.Variable(tf.truncated_normal([7 *7* 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)
  • ステップ6 *-必要なオプティマイザーを使用した特定のsoftmaxアクティベーションを持つ別のレイヤーが精度評価を定義し、初期化演算子のセットアップを行います。
wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()
  • ステップ7 *-記録変数を設定する必要があります。 これにより、データの正確性を保存するための要約が追加されます。
tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')

   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels)/batch_size)

      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c/total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

以下は、上記のコードによって生成された出力です- 

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

TensorFlow-リカレントニューラルネットワーク

リカレントニューラルネットワークは、深層学習指向のアルゴリズムの一種で、シーケンシャルアプローチに従います。 ニューラルネットワークでは、各入力と出力が他のすべてのレイヤーから独立していることを常に想定しています。 これらのタイプのニューラルネットワークは、数学的計算を逐次的に実行するため、リカレントと呼ばれます。

リカレントニューラルネットワークを訓練するために次の手順を検討してください-

  • ステップ1 *-データセットから特定の例を入力します。
  • ステップ2 *-ネットワークは例をとり、ランダムに初期化された変数を使用していくつかの計算を計算します。
  • ステップ3 *-予測結果が計算されます。
  • ステップ4 *-生成された実際の結果と期待値を比較すると、エラーが発生します。
  • ステップ5 *-エラーをトレースするために、変数も調整された同じパスを介して伝播されます。
  • ステップ6 *-出力を取得するために宣言された変数が適切に定義されていると確信できるまで、1から5までのステップが繰り返されます。
  • ステップ7 *-これらの変数を適用して、新しい見えない入力を取得することにより、体系的な予測が行われます。

リカレントニューラルネットワークを表すための模式的なアプローチは以下に説明されています-

リカレントニューラルネットワーク

TensorFlowを使用したリカレントニューラルネットワークの実装

このセクションでは、TensorFlowでリカレントニューラルネットワークを実装する方法を学習します。

  • ステップ1 *-TensorFlowには、リカレントニューラルネットワークモジュールの特定の実装のためのさまざまなライブラリが含まれています。
#Import necessary modules
from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

前述のように、ライブラリは入力データの定義に役立ちます。入力データは、リカレントニューラルネットワーク実装の主要部分を形成します。

  • ステップ2 *-主な動機は、リカレントニューラルネットワークを使用して画像を分類することです。ここでは、すべての画像行をピクセルのシーケンスと見なします。 MNIST画像の形状は、特に28 * 28ピクセルとして定義されています。 ここで、記載されている各サンプルに対して28ステップの28シーケンスを処理します。 入力パラメーターを定義して、シーケンシャルパターンを完成させます。
n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
   'out': tf.Variable(tf.random_normal([n_classes]))
}
  • ステップ3 *-RNNで定義された関数を使用して結果を計算し、最良の結果を取得します。 ここでは、各データ形状が現在の入力形状と比較され、結果が計算されて精度が維持されます。
def RNN(x, weights, biases):
   x = tf.unstack(x, n_steps, 1)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']

pred = RNN(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.global_variables_initializer()
  • ステップ4 *-このステップでは、グラフを起動して計算結果を取得します。 これは、テスト結果の精度の計算にも役立ちます。
with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations

   while step * batch_size < training_iters:
      batch_x, batch_y = mnist.train.next_batch(batch_size)
      batch_x = batch_x.reshape((batch_size, n_steps, n_input))
      sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})

      if step % display_step == 0:
         # Calculate batch accuracy
         acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})

         # Calculate batch loss
         loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})

         print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
            "{:.6f}".format(loss) + ", Training Accuracy= " + \
            "{:.5f}".format(acc))
      step += 1
   print("Optimization Finished!")
      test_len = 128
   test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))

   test_label = mnist.test.labels[:test_len]
   print("Testing Accuracy:", \
      sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

以下のスクリーンショットは、生成された出力を示しています-

リカレントニューラルネットワーク実装出力

リカレントニューラルネットワーク実装出力TransFlow

TensorFlow-TensorBoardの視覚化

TensorFlowには、TensorBoardと呼ばれる視覚化ツールが含まれています。 データフローグラフの分析に使用されるほか、機械学習モデルの理解にも使用されます。 TensorBoardの重要な機能には、パラメーターに関するさまざまなタイプの統計情報と、垂直方向のグラフの詳細が含まれます。

ディープニューラルネットワークには、最大36,000のノードが含まれます。 TensorBoardは、これらのノードを高レベルブロックで折りたたんで、同一の構造を強調表示するのに役立ちます。 これにより、計算グラフの主要セクションに焦点を当てたグラフの分析が改善されます。 TensorBoardの視覚化は、ユーザーがノードをパン、ズーム、および展開して詳細を表示できる非常にインタラクティブなものと言われています。

次の概略図表現は、TensorBoard視覚化の完全な動作を示しています-

TensorBoardビジュアライゼーション

アルゴリズムは、ノードを上位レベルのブロックにまとめて、高度なノードを分離する同一の構造を持つ特定のグループを強調表示します。 このようにして作成されたTensorBoardは有用であり、機械学習モデルの調整にも同様に重要です。 この視覚化ツールは、表示する必要のある要約情報と詳細を含む構成ログファイル用に設計されています。

次のコードを使用して、TensorBoardの視覚化のデモ例に焦点を当てましょう- 

import tensorflow as tf

# Constants creation for TensorBoard visualization
a = tf.constant(10,name = "a")
b = tf.constant(90,name = "b")
y = tf.Variable(a+b*2,name = 'y')
model = tf.initialize_all_variables() #Creation of model

with tf.Session() as session:
   merged = tf.merge_all_summaries()
   writer = tf.train.SummaryWriter("/tmp/tensorflowlogs",session.graph)
   session.run(model)
   print(session.run(y))

次の表は、ノード表現に使用されるTensorBoard視覚化のさまざまなシンボルを示しています-

ノード表現

TensorFlow-ワード埋め込み

単語の埋め込みは、単語などの離散オブジェクトからベクトルや実数へのマッピングの概念です。 機械学習の入力にとって重要です。 この概念には、離散入力オブジェクトを有用なベクトルに効果的に変換する標準関数が含まれています。

単語埋め込みの入力のサンプル図は以下のとおりです- 

blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259)
blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158)
orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213)
oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976)

Word2vec

Word2vecは、教師なしの単語埋め込み手法に使用される最も一般的なアプローチです。 スキップグラムを使用して、指定された入力単語が単語のコンテキストを予測するようにモデルをトレーニングします。

TensorFlowは、洗練と最適化のレベルを高め、マルチスレッドの概念と高レベルの抽象化を使用して、この種のモデルを実装する多くの方法を可能にします。 

import os
import math
import numpy as np
import tensorflow as tf

from tensorflow.contrib.tensorboard.plugins import projector
batch_size = 64
embedding_dimension = 5
negative_samples = 8
LOG_DIR = "logs/word2vec_intro"

digit_to_word_map = {
   1: "One",
   2: "Two",
   3: "Three",
   4: "Four",
   5: "Five",
   6: "Six",
   7: "Seven",
   8: "Eight",
   9: "Nine"}
sentences = []

# Create two kinds of sentences - sequences of odd and even digits.
   for i in range(10000):
   rand_odd_ints = np.random.choice(range(1, 10, 2), 3)
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_odd_ints]))
   rand_even_ints = np.random.choice(range(2, 10, 2), 3)
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_even_ints]))

# Map words to indices
word2index_map = {}
index = 0

for sent in sentences:
   for word in sent.lower().split():

   if word not in word2index_map:
      word2index_map[word] = index
      index += 1
index2word_map = {index: word for word, index in word2index_map.items()}

vocabulary_size = len(index2word_map)

# Generate skip-gram pairs
skip_gram_pairs = []

for sent in sentences:
   tokenized_sent = sent.lower().split()

   for i in range(1, len(tokenized_sent)-1):
      word_context_pair = [[word2index_map[tokenized_sent[i-1]],
         word2index_map[tokenized_sent[i+1]]], word2index_map[tokenized_sent[i]]]

      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][0]])
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][1]])

def get_skipgram_batch(batch_size):
   instance_indices = list(range(len(skip_gram_pairs)))
      np.random.shuffle(instance_indices)
   batch = instance_indices[:batch_size]
   x = [skip_gram_pairs[i][0] for i in batch]
   y = [[skip_gram_pairs[i][1]] for i in batch]
   return x, y

# batch example
x_batch, y_batch = get_skipgram_batch(8)
x_batch
y_batch
[index2word_map[word] for word in x_batch] [index2word_map[word[0]] for word in y_batch]

# Input data, labels train_inputs = tf.placeholder(tf.int32, shape = [batch_size])
   train_labels = tf.placeholder(tf.int32, shape = [batch_size, 1])

# Embedding lookup table currently only implemented in CPU with
   tf.name_scope("embeddings"):
   embeddings = tf.Variable(
      tf.random_uniform([vocabulary_size, embedding_dimension], -1.0, 1.0),
         name = 'embedding')
   # This is essentialy a lookup table
   embed = tf.nn.embedding_lookup(embeddings, train_inputs)

# Create variables for the NCE loss
nce_weights = tf.Variable(
   tf.truncated_normal([vocabulary_size, embedding_dimension], stddev = 1.0/
      math.sqrt(embedding_dimension)))

nce_biases = tf.Variable(tf.zeros([vocabulary_size]))

loss = tf.reduce_mean(
   tf.nn.nce_loss(weights = nce_weights, biases = nce_biases, inputs = embed,
   labels = train_labels,num_sampled = negative_samples,
   num_classes = vocabulary_size)) tf.summary.scalar("NCE_loss", loss)

# Learning rate decay
global_step = tf.Variable(0, trainable = False)
   learningRate = tf.train.exponential_decay(learning_rate = 0.1,
   global_step = global_step, decay_steps = 1000, decay_rate = 0.95, staircase = True)

train_step = tf.train.GradientDescentOptimizer(learningRate).minimize(loss)
   merged = tf.summary.merge_all()
with tf.Session() as sess:
   train_writer = tf.summary.FileWriter(LOG_DIR,
      graph = tf.get_default_graph())
   saver = tf.train.Saver()

   with open(os.path.join(LOG_DIR, 'metadata.tsv'), "w") as metadata:
      metadata.write('Name\tClass\n') for k, v in index2word_map.items():
      metadata.write('%s\t%d\n' % (v, k))

   config = projector.ProjectorConfig()
   embedding = config.embeddings.add() embedding.tensor_name = embeddings.name

   # Link this tensor to its metadata file (e.g. labels).
   embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv')
      projector.visualize_embeddings(train_writer, config)

   tf.global_variables_initializer().run()

   for step in range(1000):
      x_batch, y_batch = get_skipgram_batch(batch_size) summary, _ = sess.run(
         [merged, train_step], feed_dict = {train_inputs: x_batch, train_labels: y_batch})
      train_writer.add_summary(summary, step)

      if step % 100 == 0:
         saver.save(sess, os.path.join(LOG_DIR, "w2v_model.ckpt"), step)
         loss_value = sess.run(loss, feed_dict = {
            train_inputs: x_batch, train_labels: y_batch})
         print("Loss at %d: %.5f" % (step, loss_value))

   # Normalize embeddings before using
   norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims = True))
   normalized_embeddings = embeddings/
      norm normalized_embeddings_matrix = sess.run(normalized_embeddings)

ref_word = normalized_embeddings_matrix[word2index_map["one"]]

cosine_dists = np.dot(normalized_embeddings_matrix, ref_word)
ff = np.argsort(cosine_dists)[::-1][1:10] for f in ff: print(index2word_map[f])
print(cosine_dists[f])

出力

上記のコードは、次の出力を生成します-

Word2vec

TensorFlow-単層パーセプトロン

単層パーセプトロンを理解するには、人工ニューラルネットワーク（ANN）を理解することが重要です。 人工神経回路網は、生体神経回路の機能に触発されたメカニズムを備えた情報処理システムです。 人工ニューラルネットワークには、相互に接続された多くの処理ユニットがあります。 以下は、人工ニューラルネットワークの概略図です-

概略図

この図は、隠れユニットが外部層と通信することを示しています。 一方、入力ユニットと出力ユニットは、ネットワークの非表示層を介してのみ通信します。

ノードとの接続のパターン、レイヤーの総数、入力と出力の間のノードのレベル、レイヤーごとのニューロンの数は、ニューラルネットワークのアーキテクチャを定義します。

アーキテクチャには2つのタイプがあります。 これらのタイプは、次のように機能性人工ニューラルネットワークに焦点を当てています-

  • 単層パーセプトロン
  • 多層パーセプトロン

単層パーセプトロン

単層パーセプトロンは、最初に作成されたニューラルモデルです。 ニューロンのローカルメモリの内容は、重みのベクトルで構成されます。 単層パーセプトロンの計算は、それぞれが重みのベクトルの対応する要素で乗算された値を持つ入力ベクトルの合計の計算に対して実行されます。 出力に表示される値は、アクティベーション関数の入力になります。

単一層パーセプトロン

TensorFlowを使用した画像分類問題の単一層パーセプトロンの実装に焦点を当てましょう。 単層パーセプトロンを説明する最良の例は、「ロジスティック回帰」の表現です。

ロジスティック回帰

今、私たちはロジスティック回帰を訓練する次の基本的なステップを考えてみましょう-

  • 重みは、トレーニングの開始時にランダムな値で初期化されます。
  • トレーニングセットの各要素について、目的の出力と実際の出力の差で誤差が計算されます。 計算された誤差は、重みの調整に使用されます。
  • このプロセスは、トレーニングセット全体で発生したエラーが指定されたしきい値以上になるまで、最大反復回数に達するまで繰り返されます。

ロジスティック回帰の評価のための完全なコードは以下に記載されています- 

# Import MINST data
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

import tensorflow as tf
import matplotlib.pyplot as plt

# Parameters
learning_rate = 0.01
training_epochs = 25
batch_size = 100
display_step = 1

# tf Graph Input
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes

# Create model
# Set model weights
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

# Construct model
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax

# Minimize error using cross entropy
cross_entropy = y*tf.log(activation)
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1))

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost)

#Plot settings
avg_set = []
epoch_set = []

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph
with tf.Session() as sess:
   sess.run(init)

   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)

      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys})
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")

   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase')
   plt.ylabel('cost')
   plt.xlabel('epoch')
   plt.legend()
   plt.show()

   # Test model
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1))

   # Calculate accuracy
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

出力

上記のコードは、次の出力を生成します-

ロジスティック回帰の評価

ロジスティック回帰は、予測分析と見なされます。 ロジスティック回帰は、データを記述し、1つの従属バイナリ変数と1つ以上の名義変数または独立変数との関係を説明するために使用されます。

独立変数

TensorFlow-線形回帰

この章では、TensorFlowを使用した線形回帰の実装の基本的な例に焦点を当てます。 ロジスティック回帰または線形回帰は、順序離散カテゴリの分類のための教師あり機械学習アプローチです。 この章の目標は、ユーザーが予測変数と1つ以上の独立変数との関係を予測できるモデルを構築することです。

これらの2つの変数間の関係は、線形と見なされます。 yが従属変数であり、xが独立変数と見なされる場合、2つの変数の線形回帰関係は次の式のようになります- 

Y = Ax+b

線形回帰のアルゴリズムを設計します。 これにより、次の2つの重要な概念を理解できます。

  • コスト関数
  • 勾配降下アルゴリズム

線形回帰の概略図は以下に記載されています-

回路図の線形回帰

線形回帰の方程式のグラフィカルなビューは以下に記載されています-

グラフィカルな回路図表現

線形回帰のアルゴリズムを設計する手順

ここで、線形回帰のアルゴリズムの設計に役立つ手順について学習します。

ステップ1

線形回帰モジュールをプロットするために必要なモジュールをインポートすることが重要です。 PythonライブラリNumPyとMatplotlibのインポートを開始します。 

import numpy as np
import matplotlib.pyplot as plt

ステップ2

ロジスティック回帰に必要な係数の数を定義します。 

number_of_points = 500
x_point = []
y_point = []
a = 0.22
b = 0.78

ステップ3

回帰方程式の周りに300個のランダムなポイントを生成するための変数を繰り返します-

Y = 0.22x + 0.78 

for i in range(number_of_points):
   x = np.random.normal(0.0,0.5)
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x])
   y_point.append([y])

ステップ4

Matplotlibを使用して、生成されたポイントを表示します。 

fplt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() plt.show()

ロジスティック回帰の完全なコードは次のとおりです- 

import numpy as np
import matplotlib.pyplot as plt

number_of_points = 500
x_point = []
y_point = []
a = 0.22
b = 0.78

for i in range(number_of_points):
   x = np.random.normal(0.0,0.5)
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x])
   y_point.append([y])

plt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend()
plt.show()

入力として取得されるポイントの数は、入力データと見なされます。

ロジスティック回帰のコード

TensorFlow-TFLearnとそのインストール

TFLearnは、TensorFlowフレームワークで使用されるモジュール式で透過的なディープラーニングの側面として定義できます。 TFLearnの主な動機は、新しい実験を促進および表示するために、TensorFlowに高レベルのAPIを提供することです。

TFLearnの次の重要な機能を考慮してください-

  • TFLearnは使いやすく、理解しやすいです。
  • 高度にモジュール化されたネットワークレイヤー、オプティマイザー、およびそれらに埋め込まれたさまざまなメトリックを構築するための簡単なコンセプトが含まれています。
  • TensorFlow作業システムとの完全な透過性が含まれています。
  • 複数の入力、出力、オプティマイザーを受け入れる組み込みテンソルをトレーニングする強力なヘルパー関数が含まれています。
  • 簡単で美しいグラフの視覚化が含まれています。
  • グラフの視覚化には、重み、勾配、およびアクティベーションのさまざまな詳細が含まれます。

次のコマンドを実行してTFLearnをインストールします- 

pip install tflearn

上記のコードを実行すると、次の出力が生成されます-

TFLearnのインストール

次の図は、ランダムフォレスト分類子を使用したTFLearnの実装を示しています- 

from __future__ import division, print_function, absolute_import

#TFLearn module implementation
import tflearn
from tflearn.estimators import RandomForestClassifier

# Data loading and pre-processing with respect to dataset
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot = False)

m = RandomForestClassifier(n_estimators = 100, max_nodes = 1000)
m.fit(X, Y, batch_size = 10000, display_step = 10)

print("Compute the accuracy on train data:")
print(m.evaluate(X, Y, tflearn.accuracy_op))

print("Compute the accuracy on test set:")
print(m.evaluate(testX, testY, tflearn.accuracy_op))

print("Digits for test images id 0 to 5:")
print(m.predict(testX[:5]))

print("True digits:")
print(testY[:5])

TensorFlow-CNNとRNNの違い

この章では、CNNとRNNの違いに焦点を当てます-

CNN RNN
It is suitable for spatial data such as images. RNN is suitable for temporal data, also called sequential data.
CNN is considered to be more powerful than RNN. RNN includes less feature compatibility when compared to CNN.
This network takes fixed size inputs and generates fixed size outputs. RNN can handle arbitrary input/output lengths.
CNN is a type of feed-forward artificial neural network with variations of multilayer perceptrons designed to use minimal amounts of preprocessing. RNN unlike feed forward neural networks - can use their internal memory to process arbitrary sequences of inputs.
CNNs use connectivity pattern between the neurons. This is inspired by the organization of the animal visual cortex, whose individual neurons are arranged in such a way that they respond to overlapping regions tiling the visual field. Recurrent neural networks use time-series information - what a user spoke last will impact what he/she will speak next.
CNNs are ideal for images and video processing. RNNs are ideal for text and speech analysis.

次の図は、CNNとRNNの概略図を示しています-

CNNとRNNの概略図

TensorFlow-ケラス

Kerasは、TensorFlowフレームワーク上で実行されるコンパクトで習得しやすい高レベルPythonライブラリです。 これは、形状や数学的詳細の概念を維持するニューラルネットワークのレイヤーの作成など、ディープラーニング技術の理解に重点を置いて作成されています。 フレームワークの作成は、次の2つのタイプにすることができます-

  • シーケンシャルAPI
  • 機能的なAPI

Kerasでディープラーニングモデルを作成するには、次の8つのステップを検討してください-

  • データの読み込み
  • ロードされたデータを前処理する
  • モデルの定義
  • モデルのコンパイル
  • 指定されたモデルに適合
  • 評価する
  • 必要な予測を行う
  • モデルを保存する

以下に示すように、出力の実行と表示にJupyter Notebookを使用します-

  • ステップ1 *-データをロードし、ロードしたデータの前処理を最初に実装して、ディープラーニングモデルを実行します。
import warnings
warnings.filterwarnings('ignore')

import numpy as np
np.random.seed(123) # for reproducibility

from keras.models import Sequential
from keras.layers import Flatten, MaxPool2D, Conv2D, Dense, Reshape, Dropout
from keras.utils import np_utils
Using TensorFlow backend.
from keras.datasets import mnist

# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train/= 255
X_test/= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

このステップは「ライブラリとモジュールのインポート」として定義できます。つまり、すべてのライブラリとモジュールが初期ステップとしてインポートされます。

  • ステップ2 *-このステップでは、モデルアーキテクチャを定義します-
model = Sequential()
model.add(Conv2D(32, 3, 3, activation = 'relu', input_shape = (28,28,1)))
model.add(Conv2D(32, 3, 3, activation = 'relu'))
model.add(MaxPool2D(pool_size = (2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))
  • ステップ3 *-指定したモデルをコンパイルしましょう-
model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
  • ステップ4 *-トレーニングデータを使用してモデルを近似します-
model.fit(X_train, Y_train, batch_size = 32, epochs = 10, verbose = 1)

作成された反復の出力は次のとおりです- 

Epoch 1/10 60000/60000 [==============================] - 65s -
loss: 0.2124 -
acc: 0.9345
Epoch 2/10 60000/60000 [==============================] - 62s -
loss: 0.0893 -
acc: 0.9740
Epoch 3/10 60000/60000 [==============================] - 58s -
loss: 0.0665 -
acc: 0.9802
Epoch 4/10 60000/60000 [==============================] - 62s -
loss: 0.0571 -
acc: 0.9830
Epoch 5/10 60000/60000 [==============================] - 62s -
loss: 0.0474 -
acc: 0.9855
Epoch 6/10 60000/60000 [==============================] - 59s -
loss: 0.0416 -
acc: 0.9871
Epoch 7/10 60000/60000 [==============================] - 61s -
loss: 0.0380 -
acc: 0.9877
Epoch 8/10 60000/60000 [==============================] - 63s -
loss: 0.0333 -
acc: 0.9895
Epoch 9/10 60000/60000 [==============================] - 64s -
loss: 0.0325 -
acc: 0.9898
Epoch 10/10 60000/60000 [==============================] - 60s -
loss: 0.0284 -
acc: 0.9910

TensorFlow-分散コンピューティング

この章では、分散TensorFlowを開始する方法に焦点を当てます。 目的は、TFサーバーなど、繰り返し発生する基本的な分散TFの概念を開発者が理解できるようにすることです。 Jupyter Notebookを使用して、分散TensorFlowを評価します。 TensorFlowを使用した分散コンピューティングの実装については、以下で説明します-

  • ステップ1 *-分散コンピューティングに必須の必要なモジュールをインポートします-
import tensorflow as tf
  • ステップ2 *-1つのノードでTensorFlowクラスターを作成します。 このノードは、「worker」という名前のジョブを処理し、localhost：2222で1つのテイクを実行します。
cluster_spec = tf.train.ClusterSpec({'worker' : ['localhost:2222']})
server = tf.train.Server(cluster_spec)
server.target

上記のスクリプトは、次の出力を生成します- 

'grpc://localhost:2222'
The server is currently running.
  • ステップ3 *-各セッションのサーバー構成は、次のコマンドを実行して計算できます-
server.server_def

上記のコマンドは、次の出力を生成します- 

cluster {
   job {
      name: "worker"
      tasks {
         value: "localhost:2222"
      }
   }
}
job_name: "worker"
protocol: "grpc"

ステップ4 *-サーバーである実行エンジンでTensorFlowセッションを起動します。 TensorFlowを使用してローカルサーバーを作成し、 *lsof を使用してサーバーの場所を見つけます。 

sess = tf.Session(target = server.target)
server = tf.train.Server.create_local_server()
  • ステップ5 *-このセッションで利用可能なデバイスを表示し、それぞれのセッションを閉じます。
devices = sess.list_devices()
for d in devices:
   print(d.name)
sess.close()

上記のコマンドは、次の出力を生成します- 

/job:worker/replica:0/task:0/device:CPU:0

TensorFlow-エクスポート

ここでは、TensorFlowでのMetaGraphの形成に焦点を当てます。 これは、TensorFlowのエクスポートモジュールを理解するのに役立ちます。 MetaGraphには、以前にトレーニングされたグラフのトレーニング、評価の実行、または推論の実行に必要な基本情報が含まれています。

以下は、同じためのコードスニペットです- 

def export_meta_graph(filename = None, collection_list = None, as_text = False):
   """this code writes `MetaGraphDef` to save_path/filename.

   Arguments:
   filename: Optional meta_graph filename including the path. collection_list:
      List of string keys to collect. as_text: If `True`,
      writes the meta_graph as an ASCII proto.

   Returns:
   A `MetaGraphDef` proto. """

同じための典型的な使用モデルの一つは以下に記載されています- 

# Build the model ...
with tf.Session() as sess:
   # Use the model ...
# Export the model to/tmp/my-model.meta.
meta_graph_def = tf.train.export_meta_graph(filename = '/tmp/my-model.meta')

TensorFlow-多層パーセプトロン学習

多層パーセプトロンは、人工ニューラルネットワークの最も複雑なアーキテクチャを定義します。 実質的にパーセプトロンの複数の層から形成されます。

多層パーセプトロン学習の図式表現は以下のとおりです-

多層パーセプトロン

MLPネットワークは通常、教師あり学習形式に使用されます。 MLPネットワークの典型的な学習アルゴリズムは、逆伝播アルゴリズムとも呼ばれます。

次に、画像分類問題のMLPを使用した実装に焦点を当てます。 

# Import MINST data
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

import tensorflow as tf
import matplotlib.pyplot as plt

# Parameters
learning_rate = 0.001
training_epochs = 20
batch_size = 100
display_step = 1

# Network Parameters
n_hidden_1 = 256

# 1st layer num features
n_hidden_2 = 256 # 2nd layer num features
n_input = 784 # MNIST data input (img shape: 28*28) n_classes = 10
# MNIST total classes (0-9 digits)

# tf Graph input
x = tf.placeholder("float", [None, n_input])
y = tf.placeholder("float", [None, n_classes])

# weights layer 1
h = tf.Variable(tf.random_normal([n_input, n_hidden_1])) # bias layer 1
bias_layer_1 = tf.Variable(tf.random_normal([n_hidden_1]))
# layer 1 layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, h), bias_layer_1))

# weights layer 2
w = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2]))

# bias layer 2
bias_layer_2 = tf.Variable(tf.random_normal([n_hidden_2]))

# layer 2
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w), bias_layer_2))

# weights output layer
output = tf.Variable(tf.random_normal([n_hidden_2, n_classes]))

# biar output layer
bias_output = tf.Variable(tf.random_normal([n_classes])) # output layer
output_layer = tf.matmul(layer_2, output) + bias_output

# cost function
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
   logits = output_layer, labels = y))

#cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output_layer, y))
# optimizer
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# optimizer = tf.train.GradientDescentOptimizer(
   learning_rate = learning_rate).minimize(cost)

# Plot settings
avg_set = []
epoch_set = []

# Initializing the variables
init = tf.global_variables_initializer()

# Launch the graph
with tf.Session() as sess:
   sess.run(init)

   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)

      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, feed_dict = {
            x: batch_xs, y: batch_ys})
         # Compute average loss
         avg_cost += sess.run(cost, feed_dict = {x: batch_xs, y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print
         Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)
      avg_set.append(avg_cost)
      epoch_set.append(epoch + 1)
   print
   "Training phase finished"

   plt.plot(epoch_set, avg_set, 'o', label = 'MLP Training phase')
   plt.ylabel('cost')
   plt.xlabel('epoch')
   plt.legend()
   plt.show()

   # Test model
   correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1))

   # Calculate accuracy
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
   print
   "Model Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

上記のコード行は、次の出力を生成します-

MLPによる実装

TensorFlow-パーセプトロンの隠されたレイヤー

この章では、xおよびf（x）と呼ばれる既知の点のセットから学習する必要があるネットワークに焦点を当てます。 単一の非表示層がこの単純なネットワークを構築します。

パーセプトロンの隠れ層の説明のためのコードは以下に示すとおりです- 

#Importing the necessary modules
import tensorflow as tf
import numpy as np
import math, random
import matplotlib.pyplot as plt

np.random.seed(1000)
function_to_learn = lambda x: np.cos(x) + 0.1*np.random.randn(*x.shape)
layer_1_neurons = 10
NUM_points = 1000

#Training the parameters
batch_size = 100
NUM_EPOCHS = 1500

all_x = np.float32(np.random.uniform(-2*math.pi, 2*math.pi, (1, NUM_points))).T
   np.random.shuffle(all_x)

train_size = int(900)
#Training the first 700 points in the given set x_training = all_x[:train_size]
y_training = function_to_learn(x_training)

#Training the last 300 points in the given set x_validation = all_x[train_size:]
y_validation = function_to_learn(x_validation)

plt.figure(1)
plt.scatter(x_training, y_training, c = 'blue', label = 'train')
plt.scatter(x_validation, y_validation, c = 'pink', label = 'validation')
plt.legend()
plt.show()

X = tf.placeholder(tf.float32, [None, 1], name = "X")
Y = tf.placeholder(tf.float32, [None, 1], name = "Y")

#first layer
#Number of neurons = 10
w_h = tf.Variable(
   tf.random_uniform([1, layer_1_neurons],\ minval = -1, maxval = 1, dtype = tf.float32))
b_h = tf.Variable(tf.zeros([1, layer_1_neurons], dtype = tf.float32))
h = tf.nn.sigmoid(tf.matmul(X, w_h) + b_h)

#output layer
#Number of neurons = 10
w_o = tf.Variable(
   tf.random_uniform([layer_1_neurons, 1],\ minval = -1, maxval = 1, dtype = tf.float32))
b_o = tf.Variable(tf.zeros([1, 1], dtype = tf.float32))

#build the model
model = tf.matmul(h, w_o) + b_o

#minimize the cost function (model - Y)
train_op = tf.train.AdamOptimizer().minimize(tf.nn.l2_loss(model - Y))

#Start the Learning phase
sess = tf.Session() sess.run(tf.initialize_all_variables())

errors = []
for i in range(NUM_EPOCHS):
   for start, end in zip(range(0, len(x_training), batch_size),\
      range(batch_size, len(x_training), batch_size)):
      sess.run(train_op, feed_dict = {X: x_training[start:end],\ Y: y_training[start:end]})
   cost = sess.run(tf.nn.l2_loss(model - y_validation),\ feed_dict = {X:x_validation})
   errors.append(cost)

   if i%100 == 0:
      print("epoch %d, cost = %g" % (i, cost))

plt.plot(errors,label='MLP Function Approximation') plt.xlabel('epochs')
plt.ylabel('cost')
plt.legend()
plt.show()

出力

以下は、機能層の近似の表現です-

関数層の近似

ここでは、2つのデータがWの形で表されています。 2つのデータは次のとおりです。凡例セクションに表示される異なる色で表される訓練と検証。

異なる色

MLP関数の近似

TensorFlow-オプティマイザー

オプティマイザーは、特定のモデルをトレーニングするための追加情報を含む拡張クラスです。 オプティマイザークラスは指定されたパラメーターで初期化されますが、Tensorは必要ないことに注意することが重要です。 オプティマイザーは、特定のモデルのトレーニングの速度とパフォーマンスを改善するために使用されます。

TensorFlowの基本的なオプティマイザーは- 

tf.train.Optimizer

このクラスは、tensorflow/python/training/optimizer.pyの指定されたパスで定義されます。

以下はTensorflowのいくつかのオプティマイザーです-

  • 確率的勾配降下
  • 勾配クリッピングを使用した確率的勾配降下
  • 勢い
  • ネステロフの勢い
  • アダグラード
  • アダデルタ
  • RMSProp
  • Adam
  • アダマックス
  • SMORMS3

確率的勾配降下法に焦点を当てます。 同じためのオプティマイザーを作成するための図は以下に記載されています- 

def sgd(cost, params, lr = np.float32(0.01)):
   g_params = tf.gradients(cost, params)
   updates = []

   for param, g_param in zip(params, g_params):
      updates.append(param.assign(param - lr*g_param))
   return updates

基本パラメーターは、特定の機能内で定義されます。 後続の章では、オプティマイザーの実装による勾配降下最適化に焦点を当てます。

TensorFlow-XOR実装

この章では、TensorFlowを使用したXOR実装について学習します。 TensorFlowでのXOR実装を開始する前に、XORテーブルの値を見てみましょう。 これは、暗号化および復号化プロセスを理解するのに役立ちます。

A B A XOR B
0 0 0
0 1 1
1 0 1
1 1 0

XOR Cipher暗号化方式は、基本的にブルートフォース方式では解読が困難なデータを暗号化するために使用されます。つまり、適切なキーに一致するランダムな暗号化キーを生成します。

XOR暗号を使用した実装の概念は、XOR暗号化キーを定義し、ユーザーが暗号化しようとするこのキーを使用して、指定された文字列の文字のXOR操作を実行することです。 次に、以下で説明するTensorFlowを使用したXOR実装に焦点を当てます- 

#Declaring necessary modules
import tensorflow as tf
import numpy as np
"""
A simple numpy implementation of a XOR gate to understand the backpropagation
algorithm
"""

x = tf.placeholder(tf.float64,shape = [4,2],name = "x")
#declaring a place holder for input x
y = tf.placeholder(tf.float64,shape = [4,1],name = "y")
#declaring a place holder for desired output y

m = np.shape(x)[0]#number of training examples
n = np.shape(x)[1]#number of features
hidden_s = 2 #number of nodes in the hidden layer
l_r = 1#learning rate initialization

theta1 = tf.cast(tf.Variable(tf.random_normal([3,hidden_s]),name = "theta1"),tf.float64)
theta2 = tf.cast(tf.Variable(tf.random_normal([hidden_s+1,1]),name = "theta2"),tf.float64)

#conducting forward propagation
a1 = tf.concat([np.c_[np.ones(x.shape[0])],x],1)
#the weights of the first layer are multiplied by the input of the first layer

z1 = tf.matmul(a1,theta1)
#the input of the second layer is the output of the first layer, passed through the
   activation function and column of biases is added

a2 = tf.concat([np.c_[np.ones(x.shape[0])],tf.sigmoid(z1)],1)
#the input of the second layer is multiplied by the weights

z3 = tf.matmul(a2,theta2)
#the output is passed through the activation function to obtain the final probability

h3 = tf.sigmoid(z3)
cost_func = -tf.reduce_sum(y*tf.log(h3)+(1-y)*tf.log(1-h3),axis = 1)

#built in tensorflow optimizer that conducts gradient descent using specified
   learning rate to obtain theta values

optimiser = tf.train.GradientDescentOptimizer(learning_rate = l_r).minimize(cost_func)

#setting required X and Y values to perform XOR operation
X = [[Y = [[0],[1],[1],[0]]

#initializing all variables, creating a session and running a tensorflow session
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#running gradient descent for each iteration and printing the hypothesis
   obtained using the updated theta values
for i in range(100000):
   sess.run(optimiser, feed_dict = {x:X,y:Y})#setting place holder values using feed_dict
   if i%100==0:
      print("Epoch:",i)
      print("Hyp:",sess.run(h3,feed_dict = {x:X,y:Y}))

上記のコード行は、以下のスクリーンショットに示すように出力を生成します-

TensorFlowを使用したXOR実装

TensorFlow-勾配降下最適化

勾配降下法の最適化は、データサイエンスの重要な概念と考えられています。

勾配降下最適化の実装を理解するために、以下に示す手順を検討してください-

ステップ1

勾配降下最適化を定義するために必要なモジュールとxおよびy変数の宣言を含めます。 

import tensorflow as tf

x = tf.Variable(2, name = 'x', dtype = tf.float32)
log_x = tf.log(x)
log_x_squared = tf.square(log_x)

optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(log_x_squared)

ステップ2

必要な変数を初期化し、それぞれの関数で定義および呼び出すためのオプティマイザーを呼び出します。 

init = tf.initialize_all_variables()

def optimize():
   with tf.Session() as session:
      session.run(init)
      print("starting at", "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))

      for step in range(10):
         session.run(train)
         print("step", step, "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
optimize()

上記のコード行は、以下のスクリーンショットに示すように出力を生成します-

変数の初期化

出力に示されているように、必要なエポックと反復が計算されていることがわかります。

TensorFlow-グラフの形成

偏微分方程式（PDE）は微分方程式であり、いくつかの独立変数の未知の関数を持つ偏微分を含みます。 偏微分方程式を参照して、新しいグラフの作成に焦点を当てます。

寸法500 * 500平方の池があると仮定します- 

*N = 500*

次に、偏微分方程式を計算し、それを使用してそれぞれのグラフを作成します。 グラフを計算するための以下の手順を検討してください。

  • ステップ1 *-シミュレーション用のライブラリをインポートします。
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
  • ステップ2 *-2D配列を畳み込みカーネルに変換し、2D畳み込み演算を簡素化するための関数を含めます。
def make_kernel(a):
   a = np.asarray(a)
   a = a.reshape(list(a.shape) + [1,1])
   return tf.constant(a, dtype=1)

def simple_conv(x, k):
   """A simplified 2D convolution operation"""
   x = tf.expand_dims(tf.expand_dims(x, 0), -1)
   y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1], padding = 'SAME')
   return y[0, :, :, 0]

def laplace(x):
   """Compute the 2D laplacian of an array"""
   laplace_k = make_kernel([[return simple_conv(x, laplace_k)

sess = tf.InteractiveSession()
  • ステップ3 *-反復回数を含めてグラフを計算し、それに応じてレコードを表示します。
N = 500

# Initial Conditions -- some rain drops hit a pond

# Set everything to zero
u_init = np.zeros([N, N], dtype = np.float32)
ut_init = np.zeros([N, N], dtype = np.float32)

# Some rain drops hit a pond at random points
for n in range(100):
   a,b = np.random.randint(0, N, 2)
   u_init[a,b] = np.random.uniform()

plt.imshow(u_init)
plt.show()

# Parameters:
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# Create variables for simulation state
U = tf.Variable(u_init)
Ut = tf.Variable(ut_init)

# Discretized PDE update rules
U_ = U + eps *Ut
Ut_ = Ut + eps* (laplace(U) - damping * Ut)

# Operation to update the state
step = tf.group(U.assign(U_), Ut.assign(Ut_))

# Initialize state to initial conditions
tf.initialize_all_variables().run()

# Run 1000 steps of PDE
for i in range(1000):
   # Step simulation
   step.run({eps: 0.03, damping: 0.04})

   # Visualize every 50 steps
   if i % 500 == 0:
      plt.imshow(U.eval())
      plt.show()

グラフは以下のようにプロットされます-

グラフの形成

プロットされたグラフ

TensorFlowを使用した画像認識

TensorFlowには画像認識の特別な機能が含まれており、これらの画像は特定のフォルダーに保存されます。 比較的同じイメージを使用すると、セキュリティ目的でこのロジックを簡単に実装できます。

画像認識コードの実装のフォルダ構造は以下のとおりです-

画像認識

dataset_imageには、ロードする必要がある関連画像が含まれています。 ロゴを定義した画像認識に焦点を当てます。 画像は「load_data.py」スクリプトでロードされます。これは、画像内のさまざまな画像認識モジュールに関するメモを保持するのに役立ちます。 

import pickle
from sklearn.model_selection import train_test_split
from scipy import misc

import numpy as np
import os

label = os.listdir("dataset_image")
label = label[1:]
dataset = []

for image_label in label:
   images = os.listdir("dataset_image/"+image_label)

   for image in images:
      img = misc.imread("dataset_image/"+image_label+"/"+image)
      img = misc.imresize(img, (64, 64))
      dataset.append((img,image_label))
X = []
Y = []

for input,image_label in dataset:
   X.append(input)
   Y.append(label.index(image_label))

X = np.array(X)
Y = np.array(Y)

X_train,y_train, = X,Y

data_set = (X_train,y_train)

save_label = open("int_to_word_out.pickle","wb")
pickle.dump(label, save_label)
save_label.close()

画像のトレーニングは、指定されたフォルダー内に認識可能なパターンを保存するのに役立ちます。 

import numpy
import matplotlib.pyplot as plt

from keras.layers import Dropout
from keras.layers import Flatten
from keras.constraints import maxnorm
from keras.optimizers import SGD
from keras.layers import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K

import load_data
from keras.models import Sequential
from keras.layers import Dense

import keras
K.set_image_dim_ordering('tf')

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train,y_train) = load_data.data_set

# normalize inputs from 0-255 to 0.0-1.0
X_train = X_train.astype('float32')

#X_test = X_test.astype('float32')
X_train = X_train/255.0

#X_test = X_test/255.0
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)

#y_test = np_utils.to_categorical(y_test)
num_classes = y_train.shape[1]

# Create the model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), padding = 'same',
   activation = 'relu', kernel_constraint = maxnorm(3)))

model.add(Dropout(0.2))
model.add(Conv2D(32, (3, 3), activation = 'relu', padding = 'same',
   kernel_constraint = maxnorm(3)))

model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Flatten())
model.add(Dense(512, activation = 'relu', kernel_constraint = maxnorm(3)))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation = 'softmax'))

# Compile model
epochs = 10
lrate = 0.01
decay = lrate/epochs
sgd = SGD(lr = lrate, momentum = 0.9, decay = decay, nesterov = False)
model.compile(loss = 'categorical_crossentropy', optimizer = sgd, metrics = ['accuracy'])
print(model.summary())

#callbacks = [keras.callbacks.EarlyStopping(
   monitor = 'val_loss', min_delta = 0, patience = 0, verbose = 0, mode = 'auto')]
callbacks = [keras.callbacks.TensorBoard(log_dir='./logs',
   histogram_freq = 0, batch_size = 32, write_graph = True, write_grads = False,
   write_images = True, embeddings_freq = 0, embeddings_layer_names = None,
   embeddings_metadata = None)]

# Fit the model

model.fit(X_train, y_train, epochs = epochs,
   batch_size = 32,shuffle = True,callbacks = callbacks)

# Final evaluation of the model
scores = model.evaluate(X_train, y_train, verbose = 0)
print("Accuracy: %.2f%%" % (scores[1]*100))

# serialize model to JSONx
model_json = model.to_json()
with open("model_face.json", "w") as json_file:
   json_file.write(model_json)

# serialize weights to HDF5
model.save_weights("model_face.h5")
print("Saved model to disk")

上記のコード行は、次のように出力を生成します-

認識可能なパターン

認識可能なパターン出力

ニューラルネットワークトレーニングの推奨事項

この章では、TensorFlowフレームワークを使用して実装できるニューラルネットワークトレーニングのさまざまな側面を理解します。

以下は、評価することができる10の推奨事項です-

バックプロパゲーション

バックプロパゲーションは偏微分を計算する簡単な方法で、ニューラルネットに最適な合成の基本形式が含まれます。

バックプロパゲーション

確率的勾配降下

確率的勾配降下では、*バッチ*はサンプルの合計数であり、ユーザーはこれを使用して1回の反復で勾配を計算します。 これまでのところ、バッチはデータセット全体であると想定されています。 最良の例は、Google規模での作業です。多くの場合、データセットには数十億または数千億の例が含まれています。

確率的勾配降下法

学習率の減衰

学習率の減衰

学習率の適応は、勾配降下最適化の最も重要な機能の1つです。 これは、TensorFlowの実装に不可欠です。

脱落

多数のパラメーターを持つディープニューラルネットは、強力な機械学習システムを形成します。 ただし、このようなネットワークでは過剰なフィッティングが深刻な問題です。

ドロップアウト

最大プーリング

最大プーリングは、サンプルベースの離散化プロセスです。 その目的は、入力表現をダウンサンプリングすることです。これにより、必要な仮定を使用して次元が低下します。

最大プーリング

Long Short Term Memory（LSTM）

LSTMは、指定されたニューロン内でどの入力を使用するかに関する決定を制御します。 これには、何を計算し、どの出力を生成するかを決定するコントロールが含まれています。

長期メモリ

「https://www.finddevguides.com/index.php?title=Tensorflow-quick-guide&oldid=79420」から取得
Powered by MediaWiki