PytorchのNNモジュールと最初のニューラルネットワークモデルを実装する

PyTorch でモデルを構築します (主に NN モジュール)。

nn.リニア

nn.Linear は線形レイヤーを作成します。ここでは、入力ディメンションと出力ディメンションをパラメータとして渡す必要があります。

線形 = nn.Linear(10, 2)
 example_input = torch.randn(3, 10)
 example_output = 線形(example_input)
出力例

上記のコードは linear で nx10 入力を受け取り、nx2 出力を返します。

印刷(例の入力)
 print(例の出力) 
 
テンソル([[ 1.1122, -0.1381, 0.5547, -0.3326, -0.5676, 0.2810, -0.5521, -0.8729,
         -0.6627, 0.8729],
        [ 1.9134, 0.2397, -0.8340, 1.1532, -1.6725, 0.6171, -0.0357, -1.6848,
         -0.8454, 0.3876],
        [-0.0786、-0.1541、-0.8385、-0.1587、-0.0121、1.4457、-0.0132、1.5653、
         -1.6954, -0.9350]])
 # 出力は次のようになります
テンソル([[-0.1249, -0.8002],
        [-1.0945, -0.2297],
        [-0.3558, 0.8439]], grad_fn=<AddmmBackward>)

nn.レル

nn.Relu は、指定された線形出力に対して relu 活性化関数演算を実行します。

 relu = nn.ReLU()
 relu_output = relu(example_output)
 relu_出力
 
 # 出力は次のようになります
テンソル([[0.0000, 0.0000],
        [0.0000, 0.0000],
        [0.0000, 0.8439]], grad_fn=<ReluBackward0>)

nn.バッチノルム1d

nn.BatchNorm1d は、異なる入力バッチ間で一貫した平均と標準偏差を維持するために使用される正規化手法です。

バッチノルム = nn.BatchNorm1d(2)
バッチノルム出力 = バッチノルム(relu_output)
バッチノルム出力
 
 # 出力は次のようになります
テンソル([[ 0.0000, -0.7071],
        [ 0.0000, -0.7071],
        [ 0.0000, 1.4142]], grad_fn=<NativeBatchNormBackward>)

nn.シーケンシャル

nn.Sequential は、一連の操作を一度に作成します。 Tensorflow の Sequential とまったく同じです。

 mlp_layer = nn.シーケンシャル(
    nn.線形(5, 2)、
    nn.バッチノルム1d(2)、
    nn.ReLU()
 ）
テスト例 = torch.randn(5,5) + 1
 print( "入力: " )
印刷(テスト例)
 print( "出力: " )
 mlp_layer(test_example) を印刷します
 
 # 出力は次のようになります
入力：
テンソル([[ 1.4617, 1.2446, 1.4919, 1.5978, -0.3410],
        [-0.2819, 0.5567, 1.0113, 1.8053, -0.0833],
        [ 0.2830, 1.0857, 1.2258, 2.6602, 0.1339],
        [ 0.8682, 0.9344, 1.3715, 0.0279, 1.8011],
        [ 0.6172, 1.1414, 0.6030, 0.3876, 1.3653]])
出力:
テンソル([[0.0000, 0.0000],
        [0.0000, 1.3722],
        [0.0000, 0.8861],
        [1.0895, 0.0000],
        [1.3047, 0.0000]], grad_fn=<ReluBackward0>)

上記のモデルでは、オプティマイザーがなければ、対応する損失を取得できません。

 torch.optim をoptimとしてインポートします
adam_opt = optim.Adam(mlp_layer.parameters(), lr=1e-1)
 # ここでlrは学習率、1e-1は0.1を表します
訓練例 = torch.randn(100,5) + 1
 adam_opt.ゼロ_grad()
 # 1から平均値を引いたものを単純な損失関数として使用します
cur_loss = torch.abs (1 - mlp_layer(train_example)).mean()
 cur_loss.後方()
 # パラメータの更新
adam_opt.ステップ()
 cur_loss.data を印刷します
# 出力は次のようになります
テンソル(0.7467)

上記では 1 エポックしか使用していませんが、線形モデルトレーニングの損失は 0.7467 でした。上記は、NN モデルを構築するプロセス全体です。

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

1 つの隠し層を使用して 1 つの出力ユニットを開発する最初の分類ニューラルネットワークを実装しましょう。

まず、次のコマンドを使用してPyTorchライブラリをインポートします。

輸入トーチ
torch.nnをnnとしてインポートする

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

 n_in、n_h、n_out、バッチサイズ = 10、5、1、10

ニューラルネットワークは入力データを組み合わせて対応する出力データを取得するため、次のように同じ手順に従います。

 x = torch.randn(バッチサイズ、n_in)
 y = トーチ.テンソル([[1.0], [0.0], [0.0],
 [1.0]、[1.0]、[1.0]、[0.0]、[0.0]、[1.0]、[1.0]])

シーケンシャルモデルを作成します。シーケンシャルモデルを作成するには、次のコードを使用します。

モデル = nn.Sequential(nn.Linear(n_in, n_h),
   nn.ReLU()、
   nn.Linear(n_h, n_out)、
   nn.シグモイド())

損失関数は、以下に示すように、勾配降下法オプティマイザの助けを借りて構築されます。

 # 損失関数を構築する
基準 = torch.nn.MSELoss()
 # 最適化ツールの構築
オプティマイザー = torch.optim.SGD(model.parameters(), lr = 0.01)

指定されたコード行で反復ループを使用して勾配降下モデルを実装します。

 # 勾配降下法
範囲(50)内のエポックの場合:
   # フォワードパス: x をモデルに渡して予測された y を計算する
   y_pred = モデル(x) 
 
   # 損失を計算する
   損失 = 基準(y_pred, y) 
 
   # グラデーションを0にクリア
   オプティマイザ.zero_grad() 
 
   # バックプロパゲーション、勾配の解決
   損失.後方() 
 
   # モデルパラメータを更新する
   オプティマイザ.ステップ()
   エポック% 10 == 0の場合:
      print( 'エポック: ' , エポック, '損失: ' , loss.item())

出力は次のようになります

エポック: 0 損失: 0.2508794665336609
エポック: 10 損失: 0.24847669899463654
エポック: 20 損失: 0.24615907669067383
エポック: 30 損失: 0.24392127990722656
エポック: 40 損失: 0.24175791442394257

【編集者のおすすめ】