PyTorch-はじめに

PyTorchは、Python用のオープンソースの機械学習ライブラリとして定義されています。自然言語処理などのアプリケーションに使用されます。最初はFacebookの人工知能研究グループと、その上に構築された確率的プログラミングのためのUberのPyroソフトウェアによって開発されました。

もともと、PyTorchは、トーチフレームワークに基づいたLusJITのPythonラッパーとしてヒューパーキンスによって開発されました。 2つのPyTorchバリアントがあります。

PyTorchは、PythonでTorchを再設計および実装すると同時に、バックエンドコードと同じコアCライブラリを共有します。 PyTorch開発者は、このバックエンドコードを調整して、Pythonを効率的に実行しました。また、GPUベースのハードウェアアクセラレーションと、Luaベースのトーチを作成した拡張機能も維持しました。

特徴

PyTorchの主な機能は以下に記載されています-

簡単なインターフェイス-PyTorchは使いやすいAPIを提供します。したがって、Pythonでの操作と実行は非常に簡単であると見なされます。このフレームワークでのコード実行は非常に簡単です。

Pythonの使用*-このライブラリは、Pythonデータサイエンススタックとスムーズに統合されるPythonicと見なされます。したがって、Python環境で提供されるすべてのサービスと機能を活用できます。

計算グラフ-PyTorchは、動的計算グラフを提供する優れたプラットフォームを提供します。したがって、ユーザーは実行時にそれらを変更できます。これは、開発者がニューラルネットワークモデルの作成に必要なメモリ量が分からない場合に非常に役立ちます。

PyTorchは、以下の3つの抽象化レベルを持っていることで知られています-

Tensor-GPUで実行される命令型n次元配列。
変数-計算グラフのノード。これはデータと勾配を保存します。
モジュール-状態または学習可能な重みを格納するニューラルネットワーク層。

PyTorchの利点

以下はPyTorchの利点です-

コードのデバッグと理解は簡単です。
トーチとして多くのレイヤーが含まれています。
多くの損失関数が含まれています。
GPUのNumPy拡張と見なすことができます。
構造が計算自体に依存するネットワークを構築できます。

TensorFlow vs. パイトーチ

TensorFlowとPyTorchの主な違いを以下で説明します-

PyTorch	TensorFlow
PyTorch is closely related to the lua-based Torch framework which is actively used in Facebook.	TensorFlow is developed by Google Brain and actively used at Google.
PyTorch is relatively new compared to other competitive technologies.	TensorFlow is not new and is considered as a to-go tool by many researchers and industry professionals.
PyTorch includes everything in imperative and dynamic manner.	TensorFlow includes static and dynamic graphs as a combination.
Computation graph in PyTorch is defined during runtime.	TensorFlow do not include any run time option.
PyTorch includes deployment featured for mobile and embedded frameworks.	TensorFlow works better for embedded frameworks.

PyTorch-インストール

PyTorchは人気のあるディープラーニングフレームワークです。このチュートリアルでは、オペレーティングシステムとして「Windows 10」を検討します。環境設定を成功させるための手順は次のとおりです-

ステップ1

次のリンクには、PyTorchに適したパッケージを含むパッケージのリストが含まれています。

https://drive.google.com/drive/folders/0B-X0-FlSGfCYdTNldW02UGl4MXM

あなたがする必要があるのは、それぞれのパッケージをダウンロードして、次のスクリーンショットに示すようにインストールすることです-

pytorch

パッケージ

ステップ2

Anaconda Frameworkを使用してPyTorchフレームワークのインストールを検証する必要があります。

次のコマンドを使用して、同じことを確認します-

conda list

PyTorchフレームワーク

「コンダリスト」には、インストールされているフレームワークのリストが表示されます。

コンダリスト

ハイライトされた部分は、PyTorchがシステムに正常にインストールされたことを示しています。

ニューラルネットワークの数学的構築ブロック

数学はあらゆる機械学習アルゴリズムに不可欠であり、特定の方法で適切なアルゴリズムを設計するための数学のさまざまなコアコンセプトが含まれています。

機械学習とデータ科学のための数学トピックの重要性は以下に記載されています-

機械学習

ここで、自然言語処理の観点から重要な機械学習の主要な数学的概念に焦点を当てましょう-

ベクトル

ベクトルは、連続または離散のいずれかの数値の配列と見なされ、ベクトルで構成される空間はベクトル空間と呼ばれます。ベクトルの空間次元は有限でも無限でもかまいませんが、機械学習とデータサイエンスの問題は固定長のベクトルを扱うことが観察されています。

ベクトル表現は以下のように表示されます-

temp = torch.FloatTensor([23,24,24.5,26,27.2,23.0])
temp.size()
Output - torch.Size([6])

機械学習では、多次元データを扱います。したがって、ベクトルは非常に重要になり、予測問題ステートメントの入力フィーチャと見なされます。

スカラー

スカラーは、1つの値のみを含むゼロ次元と呼ばれます。 PyTorchに関しては、ゼロ次元の特別なテンソルは含まれていません。したがって、宣言は次のように行われます-

x = torch.rand(10)
x.size()
Output - torch.Size([10])

行列

通常、構造化データのほとんどは、テーブルまたは特定のマトリックスの形式で表されます。 Python scikit-learn機械学習ライブラリですぐに利用できるBoston House Priceというデータセットを使用します。

boston_tensor = torch.from_numpy(boston.data)
boston_tensor.size()
Output: torch.Size([506, 13])
boston_tensor[:2]
Output:
Columns 0 to 7
0.0063 18.0000 2.3100 0.0000 0.5380 6.5750 65.2000 4.0900
0.0273 0.0000 7.0700 0.0000 0.4690 6.4210 78.9000 4.9671
Columns 8 to 12
1.0000 296.0000 15.3000 396.9000 4.9800
2.0000 242.0000 17.8000 396.9000 9.1400

PyTorch-ニューラルネットワークの基本

ニューラルネットワークの主な原理には、基本的な要素のコレクション、つまり、人工ニューロンまたはパーセプトロンが含まれます。これには、x1、x2…などのいくつかの基本的な入力が含まれます。 xnは、合計が活性化ポテンシャルより大きい場合にバイナリ出力を生成します。

サンプルニューロンの模式図は以下のとおりです-

サンプルニューロン

生成される出力は、活性化ポテンシャルまたはバイアスを伴う加重和と見なすことができます。

Output = \ sum_jw_jx_j + Bias

典型的なニューラルネットワークアーキテクチャは次のとおりです-

ニューラルネットワークアーキテクチャ

入力と出力の間のレイヤーは非表示レイヤーと呼ばれ、レイヤー間の接続の密度とタイプが構成です。たとえば、完全に接続された構成では、レイヤーLのすべてのニューロンがL + 1のニューロンに接続されています。より明確なローカライズのために、次の層にローカルネイバーフッド、たとえば9つのニューロンのみを接続できます。図1-9は、密な接続を持つ2つの隠れ層を示しています。

ニューラルネットワークのさまざまな種類は次のとおりです-

フィードフォワードニューラルネットワーク

フィードフォワードニューラルネットワークには、ニューラルネットワークファミリの基本単位が含まれます。このタイプのニューラルネットワークにおけるデータの移動は、現在の隠れ層を介して、入力層から出力層へと行われます。 1つの層の出力は、ネットワークアーキテクチャのあらゆる種類のループに制限がある入力層として機能します。

フィードフォワードニューラルネットワーク

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

リカレントニューラルネットワークは、データパターンが一定期間にわたって結果的に変化する場合です。 RNNでは、指定されたニューラルネットワークで入力パラメーターを受け入れ、出力パラメーターを表示するために同じレイヤーが適用されます。

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

torch.nnパッケージを使用して、ニューラルネットワークを構築できます。

ニューラルネットワークの構築

これは、単純なフィードフォワードネットワークです。入力を受け取り、いくつかのレイヤーを次々に通過させ、最終的に出力を提供します。

PyTorchの助けを借りて、ニューラルネットワークの典型的なトレーニング手順のために次の手順を使用できます-

学習可能なパラメーター（または重み）を持つニューラルネットワークを定義します。
入力のデータセットを反復処理します。
ネットワークを介した入力の処理。
損失を計算します（出力が正しいことからどれくらい離れているか）。
勾配をネットワークのパラメーターに伝播します。 *通常、以下の単純な更新を使用して、ネットワークの重みを更新します

rule: weight = weight -learning_rate* gradient

機械学習の普遍的なワークフロー

人工知能は、最近大幅に増加しています。機械学習と深層学習は人工知能を構成します。下記のベン図は、機械学習と深層学習の関係を説明しています。

関係機械学習

機械学習

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

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

深層学習

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

ディープラーニングは、教師あり学習またはラベル付きデータとアルゴリズムからの学習を通じて非常に重要になりました。深層学習の各アルゴリズムは同じプロセスを経ます。入力の非線形変換の階層が含まれ、出力として統計モデルを作成するために使用します。

機械学習プロセスは、次の手順を使用して定義されます-

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

PyTorch-機械学習vs. 深層学習

この章では、機械学習とディープラーニングの概念の主な違いについて説明します。

データ量

機械学習はさまざまな量のデータで機能し、主に少量のデータに使用されます。一方、データの量が急速に増加する場合、ディープラーニングは効率的に機能します。次の図は、データ量に関する機械学習と深層学習の動作を示しています-

データ量

ハードウェアの依存関係

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

機能エンジニアリング

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

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

PyTorch-最初のニューラルネットワークの実装

PyTorchには、ニューラルネットワークを作成および実装する特別な機能が含まれています。この章では、1つの隠れ層が単一の出力ユニットを開発する単純なニューラルネットワークを作成します。

私たちは次の手順を使用して、PyTorchを使用して最初のニューラルネットワークを実装します-

ステップ1

まず、以下のコマンドを使用してPyTorchライブラリをインポートする必要があります-

import torch
import torch.nn as nn

ステップ2

以下に示すように、すべてのレイヤーとバッチサイズを定義して、ニューラルネットワークの実行を開始します-

# Defining input size, hidden layer size, output size and batch size respectively
n_in, n_h, n_out, batch_size = 10, 5, 1, 10

ステップ3

ニューラルネットワークには、それぞれの出力データを取得するための入力データの組み合わせが含まれているため、以下に示すのと同じ手順に従います-

# Create dummy input and target tensors (data)
x = torch.randn(batch_size, n_in)
y = torch.tensor([[Step 4

Create a sequential model with the help of in-built functions. Using the below lines of code, create a sequential model −

[source,prettyprint,notranslate]

＃モデルの作成model = nn.Sequential（nn.Linear（n_in、n_h）、nn.ReLU（）、nn.Linear（n_h、n_out）、nn.Sigmoid（））

=== Step 5

Construct the loss function with the help of Gradient Descent optimizer as shown below −

[source,prettyprint,notranslate]

損失関数の条件を構築する= torch.nn.MSELoss（）＃オプティマイザーを構築する（この場合は確率的勾配降下）オプティマイザー= torch.optim.SGD（model.parameters（）、lr = 0.01）

=== Step 6

Implement the gradient descent model with the iterating loop with the given lines of code −

[source,prettyprint,notranslate]

＃range（50）のエポックの勾配降下：＃フォワードパス：モデルにxを渡すことで予測yを計算y_pred = model（x）

＃損失損失を計算して印刷する= criteria（y_pred、y）print（ 'epoch：'、epoch、 'loss：'、loss.item（））

＃勾配をゼロにし、後方パスを実行し、重みを更新します。 optimizer.zero_grad（）

＃後方パス（backpropagation）loss.backward（）を実行します

＃パラメーターoptimizer.step（）を更新します

=== Step 7

The output generated is as follows −

[source,prettyprint,notranslate]

エポック：0損失：0.2545787990093231エポック：1損失：0.2545052170753479エポック：2損失：0.254431813955307エポック：3損失：0.25435858964920044エポック：4損失：0.2542854845523834エポック：5損失：0.25421255826950073エポック：6損失：0.25413978099823エポック：損失8損失：0.2539947032928467エポック：9損失：0.25392240285873413エポック：10損失：0.25385022163391113エポック：11損失：0.25377824902534485エポック：12損失：0.2537063956260681エポック：13損失：0.2536346912384033エポック：14損失：0.25356316566467285 epoch：917損失：エポック：0.25342053174972534エポック：17損失：0.2533493936061859エポック：18損失：0.2532784342765808エポック：19損失：0.25320762395858765エポック：20損失：0.2531369626522064エポック：21損失：0.25306645035743713エポック：22損失：0.252996027469635 epエポック：25損失：0.25278574228286743エポック：26損失：0.25271597504615784エポック：27損失：0.25264623761177063エポック：28損失：0.2 5257670879364014エポック：29損失：0.2525072991847992エポック：30損失：0.2524380087852478エポック：31損失：0.2523689270019531エポック：32損失：0.25229987502098083エポック：33損失：0.25223103165626526エポック：34損失：0.25216227769851685エポック：0.25202 ：37損失：0.2519568204879761エポック：38損失：0.251888632774353エポック：39損失：0.25182053446769714エポック：40損失：0.2517525553703308エポック：41損失：0.2516847252845764エポック：42損失：0.2516169846057892エポック：43損失：0.2515493929386283エポック：45損失損失：0.25141456723213196エポック：46損失：0.2513473629951477エポック：47損失：0.2512802183628082エポック：48損失：0.2512132525444031エポック：49損失：0.2511464059352875

PyTorch-機能ブロックへのニューラルネットワーク

深層学習アルゴリズムのトレーニングには、次の手順が含まれます-

データパイプラインの構築
ネットワークアーキテクチャの構築
損失関数を使用したアーキテクチャの評価
最適化アルゴリズムを使用してネットワークアーキテクチャの重みを最適化する

特定の深層学習アルゴリズムのトレーニングは、以下に示すように、ニューラルネットワークを機能ブロックに変換するための正確な要件です-

機能ブロック

上記の図に関して、ディープラーニングアルゴリズムは、入力データを取得し、それらに埋め込まれた多数のレイヤーを含むそれぞれのアーキテクチャを構築することを伴います。

上記の図を観察すると、ニューラルネットワークの重みの最適化に関して損失関数を使用して精度が評価されます。

PyTorch-用語

この章では、PyTorchで最も一般的に使用される用語のいくつかについて説明します。

PyTorch NumPy

PyTorchテンソルはNumPy配列と同一です。テンソルはn次元の配列であり、PyTorchに関して、これらのテンソルを操作するための多くの機能を提供します。

PyTorchテンソルは通常、GPUを使用して数値計算を高速化します。 PyTorchで作成されたこれらのテンソルを使用して、2層ネットワークをランダムデータに適合させることができます。ユーザーは、ネットワークを介して前方および後方パスを手動で実装できます。

変数とオートグラード

autogradを使用する場合、ネットワークのフォワードパスは*計算グラフ*を定義します。グラフのノードはテンソルになり、エッジは入力テンソルから出力テンソルを生成する関数になります。

PyTorch Tensorは、変数が計算グラフのノードを表す変数オブジェクトとして作成できます。

動的グラフ

静的グラフは、ユーザーがグラフを事前に最適化できるため便利です。プログラマが同じグラフを何度も再利用している場合、同じグラフが何度も再実行されるため、この潜在的にコストのかかる事前の最適化を維持できます。

それらの主な違いは、Tensor Flowの計算グラフが静的であり、PyTorchが動的計算グラフを使用することです。

Optimパッケージ

PyTorchのoptimパッケージは、多くの方法で実装される最適化アルゴリズムの概念を抽象化し、一般的に使用される最適化アルゴリズムの図を提供します。これはimportステートメント内で呼び出すことができます。

マルチプロセッシング

マルチプロセッシングは同じ操作をサポートしているため、すべてのテンソルは複数のプロセッサで動作します。キューのデータは共有メモリに移動され、ハンドルは別のプロセスにのみ送信されます。

PyTorch-データの読み込み

PyTorchには、データセットのロードと準備に使用されるtorchvisionというパッケージが含まれています。これには、データセットとデータセットの変換と読み込みに役立つDataLoaderとDataLoaderという2つの基本機能が含まれています。

データセット

データセットは、指定されたデータセットからデータポイントを読み取り、変換するために使用されます。実装する基本的な構文は以下のとおりです-

trainset = torchvision.datasets.CIFAR10(root = './data', train = True,
   download = True, transform = transform)

DataLoaderは、データのシャッフルおよびバッチ処理に使用されます。マルチプロセッシングワーカーと並行してデータをロードするために使用できます。

trainloader = torch.utils.data.DataLoader(trainset, batch_size = 4,
   shuffle = True, num_workers = 2)

例：CSVファイルの読み込み

PythonパッケージPandaを使用して、csvファイルをロードします。元のファイルの形式は次のとおりです（イメージ名、68ランドマーク-各ランドマークにはx、y座標があります）。

landmarks_frame = pd.read_csv('faces/face_landmarks.csv')

n = 65
img_name = landmarks_frame.iloc[n, 0]
landmarks = landmarks_frame.iloc[n, 1:].as_matrix()
landmarks = landmarks.astype('float').reshape(-1, 2)

PyTorch-線形回帰

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

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

Y = Ax+b

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

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

線形回帰の概略図を以下に示します

結果の解釈

Y = ax + b

a の値は勾配です。
b の値は* y-インターセプト*です。
r は*相関係数*です。
_r ^ 2 ^ _ は*相関係数*です。

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

結果の解釈

次の手順は、PyTorchを使用して線形回帰を実装するために使用されます-

ステップ1

以下のコードを使用してPyTorchで線形回帰を作成するために必要なパッケージをインポートします-

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import seaborn as sns
import pandas as pd
%matplotlib inline

sns.set_style(style = 'whitegrid')
plt.rcParams["patch.force_edgecolor"] = True

ステップ2

以下に示すように、利用可能なデータセットで単一のトレーニングセットを作成します-

m = 2 # slope
c = 3 # interceptm = 2 # slope
c = 3 # intercept
x = np.random.rand(256)

noise = np.random.randn(256)/4

y = x *m + c + noise

df = pd.DataFrame()
df['x'] = x
df['y'] = y

sns.lmplot(x ='x', y ='y', data = df)

シングルトレーニング

ステップ3

以下で説明するように、PyTorchライブラリを使用して線形回帰を実装します-

import torch
import torch.nn as nn
from torch.autograd import Variable
x_train = x.reshape(-1, 1).astype('float32')
y_train = y.reshape(-1, 1).astype('float32')

class LinearRegressionModel(nn.Module):
   def __init__(self, input_dim, output_dim):
      super(LinearRegressionModel, self).__init__()
      self.linear = nn.Linear(input_dim, output_dim)

   def forward(self, x):
      out = self.linear(x)
      return out
input_dim = x_train.shape[1]
output_dim = y_train.shape[1]
input_dim, output_dim(1, 1)
model = LinearRegressionModel(input_dim, output_dim)
criterion = nn.MSELoss()
[w, b] = model.parameters()

def get_param_values():
   return w.data[0][0], b.data[0]

def plot_current_fit(title = ""):
plt.figure(figsize = (12,4))
plt.title(title)
plt.scatter(x, y, s = 8)
w1 = w.data[0][0]
b1 = b.data[0]
x1 = np.array([0., 1.])
y1 = x1* w1 + b1
plt.plot(x1, y1, 'r', label = 'Current Fit ({:.3f}, {:.3f})'.format(w1, b1))
plt.xlabel('x (input)')
plt.ylabel('y (target)')
plt.legend()
plt.show()
plot_current_fit('Before training')

生成されたプロットは次のとおりです-

プロット生成

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

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

ディープニューラルネットワークの2つの重要なタイプを以下に示します-

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

この章では、最初のタイプ、つまり畳み込みニューラルネットワーク（CNN）に焦点を当てます。

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

畳み込みニューラルネットワークは、アレイの複数のレイヤーを介してデータを処理するように設計されています。このタイプのニューラルネットワークは、画像認識や顔認識などのアプリケーションで使用されます。

CNNと他の通常のニューラルネットワークの主な違いは、CNNは入力を2次元配列として受け取り、他のニューラルネットワークが焦点を当てる特徴抽出に焦点を当てるのではなく、画像に直接作用することです。

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

すべての畳み込みニューラルネットワークには3つの基本的なアイデアが含まれています-

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

これらの各用語を詳細に理解しましょう。

ローカルの各フィールド

CNNは、入力データ内に存在する空間相関を利用します。ニューラルネットワークの並行層のそれぞれは、いくつかの入力ニューロンを接続します。この特定の領域は、ローカル受容フィールドと呼ばれます。隠れたニューロンにのみ焦点を合わせます。隠されたニューロンは、指定されたフィールド内の入力データを処理し、特定の境界外の変更を認識しません。

ローカルのそれぞれのフィールドを生成するダイアグラムの表現は以下のとおりです-

ローカルそれぞれのフィールド

畳み込み

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

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

プーリング

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

PyTorchの実装

PyTorchを使用して畳み込みニューラルネットワークを作成するには、次の手順を使用します。

ステップ1

単純なニューラルネットワークを作成するために必要なパッケージをインポートします。

from torch.autograd import Variable
import torch.nn.functional as F

ステップ2

畳み込みニューラルネットワークのバッチ表現でクラスを作成します。入力xのバッチ形状の寸法は（3、32、32）です。

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18* 16 *16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

ステップ3

（3、32、32）から（18、32、32）への最初の畳み込みサイズの変化の活性化を計算します。

次元のサイズが（18、32、32）から（18、16、16）に変わります。サイズが（18、16、16）から（1、4608）に変化するため、ニューラルネットの入力層のデータディメンションを変更します。

-1は、この次元を他の与えられた次元から推測することを思い出してください。

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18* 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)

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

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

以下の図は、リカレントニューラルネットワークの完全なアプローチと動作を指定しています-

Recurrent Neural Networks Ex

上記の図では、c1、c2、c3、およびx1は、o1のそれぞれの出力を提供するいくつかの隠された入力値、つまりh1、h2、およびh3を含む入力と見なされます。 PyTorchの実装に焦点を当てて、リカレントニューラルネットワークを使用して正弦波を作成します。

トレーニング中、一度に1つのデータポイントを使用して、モデルへのトレーニングアプローチに従います。入力シーケンスxは20個のデータポイントで構成され、ターゲットシーケンスは入力シーケンスと同じと見なされます。

ステップ1

以下のコードを使用して、リカレントニューラルネットワークを実装するために必要なパッケージをインポートします-

import torch
from torch.autograd import Variable
import numpy as np
import pylab as pl
import torch.nn.init as init

ステップ2

入力レイヤーのサイズを7に設定して、モデルのハイパーパラメーターを設定します。ターゲットシーケンスを作成するために、6つのコンテキストニューロンと1つの入力ニューロンがあります。

dtype = torch.FloatTensor
input_size, hidden_size, output_size = 7, 6, 1
epochs = 300
seq_length = 20
lr = 0.1
data_time_steps = np.linspace(2, 10, seq_length + 1)
data = np.sin(data_time_steps)
data.resize((seq_length + 1, 1))

x = Variable(torch.Tensor(data[:-1]).type(dtype), requires_grad=False)
y = Variable(torch.Tensor(data[1:]).type(dtype), requires_grad=False)

トレーニングデータを生成します。xは入力データシーケンス、yは必須のターゲットシーケンスです。

ステップ3

重みは、平均がゼロの正規分布を使用して、リカレントニューラルネットワークで初期化されます。 W1は入力変数の受け入れを表し、w2は以下に示すように生成される出力を表します-

w1 = torch.FloatTensor(input_size,
hidden_size).type(dtype)
init.normal(w1, 0.0, 0.4)
w1 = Variable(w1, requires_grad = True)
w2 = torch.FloatTensor(hidden_size, output_size).type(dtype)
init.normal(w2, 0.0, 0.3)
w2 = Variable(w2, requires_grad = True)

ステップ4

ここで、ニューラルネットワークを一意に定義するフィードフォワード用の関数を作成することが重要です。

def forward(input, context_state, w1, w2):
   xh = torch.cat((input, context_state), 1)
   context_state = torch.tanh(xh.mm(w1))
   out = context_state.mm(w2)
   return (out, context_state)

ステップ5

次のステップは、リカレントニューラルネットワークの正弦波実装のトレーニング手順を開始することです。外側のループは各ループを反復し、内側のループはsequenceの要素を反復します。ここでは、連続変数の予測に役立つ平均二乗誤差（MSE）も計算します。

for i in range(epochs):
   total_loss = 0
   context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = True)
   for j in range(x.size(0)):
      input = x[j:(j+1)]
      target = y[j:(j+1)]
      (pred, context_state) = forward(input, context_state, w1, w2)
      loss = (pred - target).pow(2).sum()/2
      total_loss += loss
      loss.backward()
      w1.data -= lr *w1.grad.data
      w2.data -= lr* w2.grad.data
      w1.grad.data.zero_()
      w2.grad.data.zero_()
      context_state = Variable(context_state.data)
   if i % 10 == 0:
      print("Epoch: {} loss {}".format(i, total_loss.data[0]))

context_state = Variable(torch.zeros((1, hidden_size)).type(dtype), requires_grad = False)
predictions = []

for i in range(x.size(0)):
   input = x[i:i+1]
   (pred, context_state) = forward(input, context_state, w1, w2)
   context_state = context_state
   predictions.append(pred.data.numpy().ravel()[0])

ステップ6

さて、サイン波を必要に応じてプロットします。

pl.scatter(data_time_steps[:-1], x.data.numpy(), s = 90, label = "Actual")
pl.scatter(data_time_steps[1:], predictions, label = "Predicted")
pl.legend()
pl.show()

出力

上記のプロセスの出力は次のとおりです-

サイン波

PyTorch-データセット

この章では、 torchvision.datasets およびそのさまざまなタイプに焦点を当てます。 PyTorchには次のデータセットローダーが含まれています-

MNIST
COCO（キャプションと検出）

データセットには、以下に示す2種類の関数の大部分が含まれます-

Transform -画像を取り込んで、標準的なものの修正版を返す関数。これらは、変換と一緒に構成できます。
Target_transform -ターゲットを取得して変換する関数。たとえば、キャプション文字列を受け取り、ワールドインデックスのテンソルを返します。

MNIST

以下は、MNISTデータセットのサンプルコードです-

dset.MNIST(root, train = TRUE, transform = NONE,
target_transform = None, download = FALSE)

パラメータは次のとおりです-

root -処理されたデータが存在するデータセットのルートディレクトリ。
train -True =トレーニングセット、False =テストセット
download -True =インターネットからデータセットをダウンロードし、ルートに配置します。

COCO

これには、COCO APIがインストールされている必要があります。次の例は、PyTorchを使用したデータセットのCOCO実装を実証するために使用されます-

import torchvision.dataset as dset
import torchvision.transforms as transforms
cap = dset.CocoCaptions(root = ‘ dir where images are’,
annFile = ’json annotation file’,
transform = transforms.ToTensor())
print(‘Number of samples: ‘, len(cap))
print(target)

達成される出力は次のとおりです-

Number of samples: 82783
Image Size: (3L, 427L, 640L)

PyTorch-修道院の紹介

Conventsの目的は、CNNモデルをゼロから構築することです。ネットワークアーキテクチャには、次の手順の組み合わせが含まれます-

Conv2d
MaxPool2d
整流線形ユニット
View *線形レイヤー

モデルのトレーニング

モデルのトレーニングは、画像分類の問題と同じプロセスです。次のコードスニペットは、提供されたデータセットのトレーニングモデルの手順を完了します-

def fit(epoch,model,data_loader,phase
= 'training',volatile = False):
   if phase == 'training':
      model.train()
   if phase == 'training':
      model.train()
   if phase == 'validation':
      model.eval()
   volatile=True
   running_loss = 0.0
   running_correct = 0
   for batch_idx , (data,target) in enumerate(data_loader):
      if is_cuda:
         data,target = data.cuda(),target.cuda()
         data , target = Variable(data,volatile),Variable(target)
      if phase == 'training':
         optimizer.zero_grad()
         output = model(data)
         loss = F.nll_loss(output,target)
         running_loss + =
         F.nll_loss(output,target,size_average =
         False).data[0]
         preds = output.data.max(dim = 1,keepdim = True)[1]
         running_correct + =
         preds.eq(target.data.view_as(preds)).cpu().sum()
         if phase == 'training':
            loss.backward()
            optimizer.step()
   loss = running_loss/len(data_loader.dataset)
   accuracy = 100.* running_correct/len(data_loader.dataset)
   print(f'{phase} loss is {loss:{5}.{2}} and {phase} accuracy is {running_correct}/{len(data_loader.dataset)}{accuracy:{return loss,accuracy}})

このメソッドには、トレーニングと検証のためのさまざまなロジックが含まれています。異なるモードを使用する主な理由は2つあります-

トレインモードでは、ドロップアウトにより値のパーセンテージが削除されますが、これは検証またはテストフェーズでは発生しません。
トレーニングモードでは、勾配を計算し、モデルのパラメーター値を変更しますが、テストまたは検証段階では逆伝播は必要ありません。

PyTorch-修道院を最初から訓練する

この章では、修道院をゼロから作成することに焦点を当てます。これは、トーチを使用してそれぞれの修道院またはサンプルのニューラルネットワークを作成することを推測します。

ステップ1

それぞれのパラメーターで必要なクラスを作成します。パラメーターには、ランダムな値の重みが含まれます。

class Neural_Network(nn.Module):
   def __init__(self, ):
      super(Neural_Network, self).__init__()
      self.inputSize = 2
      self.outputSize = 1
      self.hiddenSize = 3
      # weights
      self.W1 = torch.randn(self.inputSize,
      self.hiddenSize) # 3 X 2 tensor
      self.W2 = torch.randn(self.hiddenSize, self.outputSize) # 3 X 1 tensor

ステップ2

シグモイド関数を使用して、関数のフィードフォワードパターンを作成します。

def forward(self, X):
   self.z = torch.matmul(X, self.W1) # 3 X 3 ".dot"
   does not broadcast in PyTorch
   self.z2 = self.sigmoid(self.z) # activation function
   self.z3 = torch.matmul(self.z2, self.W2)
   o = self.sigmoid(self.z3) # final activation
   function
   return o
   def sigmoid(self, s):
      return 1/(1 + torch.exp(-s))
   def sigmoidPrime(self, s):
      # derivative of sigmoid
      return s *(1 - s)
   def backward(self, X, y, o):
      self.o_error = y - o # error in output
      self.o_delta = self.o_error* self.sigmoidPrime(o) # derivative of sig to error
      self.z2_error = torch.matmul(self.o_delta, torch.t(self.W2))
      self.z2_delta = self.z2_error * self.sigmoidPrime(self.z2)
      self.W1 + = torch.matmul(torch.t(X), self.z2_delta)
      self.W2 + = torch.matmul(torch.t(self.z2), self.o_delta)

ステップ3

下記のようにトレーニングと予測モデルを作成します-

def train(self, X, y):
   # forward + backward pass for training
   o = self.forward(X)
   self.backward(X, y, o)
def saveWeights(self, model):
   # Implement PyTorch internal storage functions
   torch.save(model, "NN")
   # you can reload model with all the weights and so forth with:
   # torch.load("NN")
def predict(self):
   print ("Predicted data based on trained weights: ")
   print ("Input (scaled): \n" + str(xPredicted))
   print ("Output: \n" + str(self.forward(xPredicted)))

PyTorch-修道院での特徴抽出

畳み込みニューラルネットワークには、*抽出*という主要な機能が含まれています。畳み込みニューラルネットワークの特徴抽出を実装するには、次の手順を使用します。

ステップ1

それぞれのモデルをインポートして、「PyTorch」で特徴抽出モデルを作成します。

import torch
import torch.nn as nn
from torchvision import models

ステップ2

必要なときに呼び出すことができる機能抽出のクラスを作成します。

class Feature_extractor(nn.module):
   def forward(self, input):
      self.feature = input.clone()
      return input
new_net = nn.Sequential().cuda() # the new network
target_layers = [conv_1, conv_2, conv_4] # layers you want to extract`
i = 1
for layer in list(cnn):
   if isinstance(layer,nn.Conv2d):
      name = "conv_"+str(i)
      art_net.add_module(name,layer)
      if name in target_layers:
         new_net.add_module("extractor_"+str(i),Feature_extractor())
      i+=1
   if isinstance(layer,nn.ReLU):
      name = "relu_"+str(i)
      new_net.add_module(name,layer)
   if isinstance(layer,nn.MaxPool2d):
      name = "pool_"+str(i)
      new_net.add_module(name,layer)
new_net.forward(your_image)
print (new_net.extractor_3.feature)

PyTorch-修道院の可視化

この章では、修道院の助けを借りてデータ視覚化モデルに焦点を当てます。従来のニューラルネットワークで視覚化の完全な図を取得するには、次の手順が必要です。

ステップ1

従来のニューラルネットワークの視覚化に重要な必要なモジュールをインポートします。

import os
import numpy as np
import pandas as pd
from scipy.misc import imread
from sklearn.metrics import accuracy_score

import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Flatten, Activation, Input
from keras.layers import Conv2D, MaxPooling2D
import torch

ステップ2

トレーニングおよびテストデータで潜在的なランダム性を停止するには、以下のコードで示されるように、それぞれのデータセットを呼び出します-

seed = 128
rng = np.random.RandomState(seed)
data_dir = "../../datasets/MNIST"
train = pd.read_csv('../../datasets/MNIST/train.csv')
test = pd.read_csv('../../datasets/MNIST/Test_fCbTej3.csv')
img_name = rng.choice(train.filename)
filepath = os.path.join(data_dir, 'train', img_name)
img = imread(filepath, flatten=True)

ステップ3

以下のコードを使用して完璧な方法で定義されたトレーニングおよびテストデータを取得するために必要な画像をプロットします-

pylab.imshow(img, cmap ='gray')
pylab.axis('off')
pylab.show()

出力は以下のように表示されます-

トレーニング

PyTorch-修道院でのシーケンス処理

この章では、代わりに両方のシーケンスにわたる単一の2D畳み込みニューラルネットワークに依存する代替アプローチを提案します。ネットワークの各レイヤーは、これまでに生成された出力シーケンスに基づいてソーストークンを再コーディングします。したがって、注意のようなプロパティはネットワーク全体に広がっています。

ここでは、*データセットに含まれる値から特定のプーリングを持つシーケンシャルネットワークを作成する*ことに焦点を当てます。このプロセスは、「画像認識モジュール」にも最適です。

シーケンシャルネットワーク

次の手順は、PyTorchを使用して修道院でシーケンス処理モデルを作成するために使用されます-

ステップ1

修道院を使用してシーケンス処理のパフォーマンスに必要なモジュールをインポートします。

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
import numpy as np

ステップ2

以下のコードを使用して、それぞれのシーケンスでパターンを作成するために必要な操作を実行します-

batch_size = 128
num_classes = 10
epochs = 12
# input image dimensions
img_rows, img_cols = 28, 28
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000,28,28,1)
x_test = x_test.reshape(10000,28,28,1)
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

ステップ3

モデルをコンパイルし、以下に示すように、前述の従来のニューラルネットワークモデルのパターンに適合します-

model.compile(loss =
keras.losses.categorical_crossentropy,
optimizer = keras.optimizers.Adadelta(), metrics =
['accuracy'])
model.fit(x_train, y_train,
batch_size = batch_size, epochs = epochs,
verbose = 1, validation_data = (x_test, y_test))
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

生成される出力は次のとおりです-

ニューラルネットワークモデル

PyTorch-ワード埋め込み

この章では、有名な単語埋め込みモデルword2vecを理解します。 Word2vecモデルは、関連モデルのグループの助けを借りて、単語の埋め込みを作成するために使用されます。 Word2vecモデルは純粋なCコードで実装され、勾配は手動で計算されます。

PyTorchのword2vecモデルの実装は、以下の手順で説明されています-

ステップ1

以下に説明するように、ワード埋め込みでライブラリを実装します-

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

ステップ2

word2vecと呼ばれるクラスを使用して、ワード埋め込みのスキップグラムモデルを実装します。 emb_size、emb_dimension、u_embedding、v_embedding タイプの属性が含まれます。

class SkipGramModel(nn.Module):
   def __init__(self, emb_size, emb_dimension):
      super(SkipGramModel, self).__init__()
      self.emb_size = emb_size
      self.emb_dimension = emb_dimension
      self.u_embeddings = nn.Embedding(emb_size, emb_dimension, sparse=True)
      self.v_embeddings = nn.Embedding(emb_size, emb_dimension, sparse = True)
      self.init_emb()
   def init_emb(self):
      initrange = 0.5/self.emb_dimension
      self.u_embeddings.weight.data.uniform_(-initrange, initrange)
      self.v_embeddings.weight.data.uniform_(-0, 0)
   def forward(self, pos_u, pos_v, neg_v):
      emb_u = self.u_embeddings(pos_u)
      emb_v = self.v_embeddings(pos_v)
      score = torch.mul(emb_u, emb_v).squeeze()
      score = torch.sum(score, dim = 1)
      score = F.logsigmoid(score)
      neg_emb_v = self.v_embeddings(neg_v)
      neg_score = torch.bmm(neg_emb_v, emb_u.unsqueeze(2)).squeeze()
      neg_score = F.logsigmoid(-1 *neg_score)
      return -1* (torch.sum(score)+torch.sum(neg_score))
   def save_embedding(self, id2word, file_name, use_cuda):
      if use_cuda:
         embedding = self.u_embeddings.weight.cpu().data.numpy()
      else:
         embedding = self.u_embeddings.weight.data.numpy()
      fout = open(file_name, 'w')
      fout.write('%d %d\n' % (len(id2word), self.emb_dimension))
      for wid, w in id2word.items():
         e = embedding[wid]
         e = ' '.join(map(lambda x: str(x), e))
         fout.write('%s %s\n' % (w, e))
def test():
   model = SkipGramModel(100, 100)
   id2word = dict()
   for i in range(100):
      id2word[i] = str(i)
   model.save_embedding(id2word)

ステップ3

mainメソッドを実装して、単語埋め込みモデルを適切な方法で表示します。

if __name__  ==  '__main__':
   test()

PyTorch-再帰的ニューラルネットワーク

ディープニューラルネットワークには、自然言語のプロセスを理解する機械学習のブレークスルーを可能にする独自の機能があります。これらのモデルのほとんどは、言語を単語または文字のフラットシーケンスとして扱い、リカレントニューラルネットワークまたはRNNと呼ばれる種類のモデルを使用することが観察されています。

多くの研究者は、言語はフレーズの階層ツリーに関して最もよく理解されているという結論に達します。このタイプは、特定の構造を考慮した再帰的ニューラルネットワークに含まれています。

PyTorchには、これらの複雑な自然言語処理モデルを非常に簡単にする特定の機能があります。これは、コンピュータービジョンを強力にサポートする、あらゆる種類の深層学習向けのフル機能のフレームワークです。

再帰的ニューラルネットワークの機能

再帰的なニューラルネットワークは、構造のような異なるグラフで同じ重みのセットを適用するような方法で作成されます。
ノードはトポロジ順にトラバースされます。
このタイプのネットワークは、自動微分のリバースモードによってトレーニングされます。
自然言語処理には、再帰的ニューラルネットワークの特殊なケースが含まれます。
この再帰的ニューラルテンソルネットワークには、ツリー内のさまざまな構成機能ノードが含まれます。

再帰的ニューラルネットワークの例は以下に示されています-

再帰的ニューラルテンソルネットワーク

Pytorch-quick-guide

PyTorch-はじめに

特徴

PyTorchの利点

TensorFlow vs. パイトーチ

PyTorch-インストール

ステップ1

ステップ2

ニューラルネットワークの数学的構築ブロック

ベクトル

スカラー

行列

PyTorch-ニューラルネットワークの基本

フィードフォワードニューラルネットワーク

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

機械学習の普遍的なワークフロー

機械学習

深層学習

PyTorch-機械学習vs. 深層学習

データ量

ハードウェアの依存関係

機能エンジニアリング

PyTorch-最初のニューラルネットワークの実装

ステップ1

ステップ2

ステップ3

PyTorch-機能ブロックへのニューラルネットワーク

PyTorch-用語

PyTorch NumPy

変数とオートグラード

動的グラフ

Optimパッケージ

マルチプロセッシング

PyTorch-データの読み込み

データセット

例：CSVファイルの読み込み

PyTorch-線形回帰

結果の解釈

ステップ1

ステップ2

ステップ3

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

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

ローカルの各フィールド

畳み込み

プーリング

PyTorchの実装

ステップ1

ステップ2

ステップ3

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

ステップ1

ステップ2

ステップ3

ステップ4

ステップ5

ステップ6

出力

PyTorch-データセット

MNIST

COCO

PyTorch-修道院の紹介

モデルのトレーニング

PyTorch-修道院を最初から訓練する

ステップ1

ステップ2

ステップ3

PyTorch-修道院での特徴抽出

ステップ1

ステップ2

PyTorch-修道院の可視化

ステップ1

ステップ2

ステップ3

PyTorch-修道院でのシーケンス処理

ステップ1

ステップ2

ステップ3

PyTorch-ワード埋め込み

ステップ1