PyTorch 2.0 チュートリアル : 入門 : ニューラルネットワークの構築 (翻訳/解説)

翻訳 : (株)クラスキャットセールスインフォメーション
作成日時 : 03/18/2023 (2.0.0)

* 本ページは、PyTorch 2.0 Tutorials の以下のページを翻訳した上で適宜、補足説明したものです：

Introduction to PyTorch : Learn the Basics : Build the Neural Network

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

クラスキャット人工知能研究開発支援サービス

◆ クラスキャットは人工知能・テレワークに関する各種サービスを提供しています。お気軽にご相談ください :

人工知能研究開発支援
1. 人工知能研修サービス(経営者層向けオンサイト研修)
2. テクニカルコンサルティングサービス
3. 実証実験(プロトタイプ構築)
4. アプリケーションへの実装
人工知能研修サービス
PoC(概念実証)を失敗させないための支援

◆ 人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。スケジュール。

お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。

◆ お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部セールス・インフォメーション
sales-info@classcat.com ; Website: www.classcat.com ; ClassCatJP

PyTorch 2.0 チュートリアル : 入門 : ニューラルネットワークの構築

ニューラルネットワークはデータ上で演算を実行する層/モジュールから構成されます。torch.nn 名前空間は貴方自身のニューラルネットワークを構築するために必要な総てのビルディング・ブロックを提供します。PyTorch の総てのモジュールは nn.Module をサブクラス化します。ニューラルネットワークは他のモジュール (層) から成りそれ自身がモジュールです。このネスト構造は複雑なアーキテクチャを容易に構築して管理することを可能にします。

以下のセクションでは、FashionMNIST データセットで画像を分類するためのニューラルネットワークを構築します。

import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

訓練のためのデバイスを取得する

私たちは、利用可能な場合に GPU のようなハードウェア・アクセラレータ上でモデルを訓練できることを望みます。torch.cuda が利用可能であるかを見るために確認しましょう、そうでないなら CPU を利用し続けます。

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")

Using cuda device

クラスを定義する

nn.Module をサブクラス化することによりニューラルネットワークを定義して、__init__ でニューラルネットワーク層を初期化します。総ての nn.Module サブクラスは forward メソッドで入力データ上の演算を実装します。

class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

NeuralNetwork のインスタンスを作成し、そしてそれをデバイスに移し、そしてその構造をプリントします。

model = NeuralNetwork().to(device)
print(model)

NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)

モデルを利用するために、それに入力データを渡します。これはモデルの forward を幾つかのバックグラウンド演算と共に実行します。model.forward を直接呼ばないでください！

入力上のモデルの呼び出しは、各クラスに対する 10 の raw 予測値の各出力に対応する dim=0, そして各出力の個々の値に対応する dim=1 を含む 2-次元テンソルを返します。それを nn.Softmax モジュールのインスタンスに渡すことにより予測確率を得ます。

X = torch.rand(1, 28, 28, device=device)
logits = model(X)
pred_probab = nn.Softmax(dim=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")

Predicted class: tensor([2], device='cuda:0')

モデル層

FashionMNIST モデルの層を分解しましょう。それを例示するため、サイズ 28×28 の 3 画像のサンプル・ミニバッチを取りそしてそれをネットワークに渡すときそれに何が起きるかを見ます。

input_image = torch.rand(3,28,28)
print(input_image.size())

torch.Size([3, 28, 28])

nn.Flatten

各 2D 28×28 画像を 784 ピクセル値の連続的な配列に変換するために nn.Flatten 層を初期化します ((dim=0 の) ミニバッチ次元は保持されます)。

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.size())

torch.Size([3, 784])

nn.Linear

線形層はそのストアされた重みとバイアスを使用して入力に線形変換を適用するモジュールです。

layer1 = nn.Linear(in_features=28*28, out_features=20)
hidden1 = layer1(flat_image)
print(hidden1.size())

torch.Size([3, 20])

nn.ReLU

非線形活性はモデルの入力と出力の間の複雑なマッピングを作成するものです。それらは非線形性を導入するために線形変更の後に適用され、ニューラルネットワークが広範囲の現象を学習するのに役立ちます。

このモデルでは、線形層の間に nn.ReLU を使用しますが、貴方のモデルに非線形性を導入するための他の活性もあります。

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")

Before ReLU: tensor([[-0.0268, -0.3243,  0.3880, -0.9153, -0.3297, -0.1589, -0.1333, -0.0382,
          0.2381,  0.2798, -0.5312, -0.9450, -0.3658,  0.4742,  0.1515, -0.2414,
         -0.0575, -0.6051,  0.0514, -0.0270],
        [-0.1248, -0.3438,  0.2025, -0.9244,  0.0296, -0.2264,  0.1275, -0.5591,
          0.4021,  0.1917, -0.3066, -1.0259, -0.5957,  0.0976, -0.1842, -0.0264,
         -0.2379, -0.5513,  0.2192,  0.1878],
        [-0.0379, -0.0942,  0.4165, -0.5674, -0.1190,  0.1490,  0.1794, -0.5908,
          0.1531,  0.2556, -0.1236, -0.9351, -0.5639,  0.2472, -0.2982, -0.4175,
         -0.1257, -0.5059,  0.0707,  0.0913]], grad_fn=<AddmmBackward0>)


After ReLU: tensor([[0.0000, 0.0000, 0.3880, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.2381,
         0.2798, 0.0000, 0.0000, 0.0000, 0.4742, 0.1515, 0.0000, 0.0000, 0.0000,
         0.0514, 0.0000],
        [0.0000, 0.0000, 0.2025, 0.0000, 0.0296, 0.0000, 0.1275, 0.0000, 0.4021,
         0.1917, 0.0000, 0.0000, 0.0000, 0.0976, 0.0000, 0.0000, 0.0000, 0.0000,
         0.2192, 0.1878],
        [0.0000, 0.0000, 0.4165, 0.0000, 0.0000, 0.1490, 0.1794, 0.0000, 0.1531,
         0.2556, 0.0000, 0.0000, 0.0000, 0.2472, 0.0000, 0.0000, 0.0000, 0.0000,
         0.0707, 0.0913]], grad_fn=<ReluBackward0>)

nn.Sequential

nn.Sequential はモジュールの順序付けられたコンテナです。データは定義されたのと同じ順序で総てのモジュールに渡されます。seq_modules のような簡単なネットワークをまとめるためにシーケンシャル・コンテナを利用できます。

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)
input_image = torch.rand(3,28,28)
logits = seq_modules(input_image)

nn.Softmax

ニューラルネットワークの最後の線形層はロジットを返します – [-infty, infty] 内の raw 値です – これは nn.Softmax モジュールに渡されます。ロジットは各クラスのためのモデルの予測確率を表す値 [0, 1] にスケールされます。dim パラメータはそれに沿って値が合計 1 にならなければならない次元を示します。

softmax = nn.Softmax(dim=1)
pred_probab = softmax(logits)

モデル・パラメータ

ニューラルネットワーク内の多くの層はパラメータ化されます、つまり訓練の間に最適化される関連する重みとバイアスを持ちます。nn.Module のサブクラス化はモデル・オブジェクトの内部で定義された総てのフィールドを追跡し、そしてモデルの parameters() または named_parameters() メソッドを使用して総てのパラメータをアクセス可能にします。

この例では、各パラメータに対して反復し、そしてそのサイズと値のプレビューをプリントします。

print(f"Model structure: {model}\n\n")

for name, param in model.named_parameters():
    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

Model structure: NeuralNetwork(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear_relu_stack): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)


Layer: linear_relu_stack.0.weight | Size: torch.Size([512, 784]) | Values : tensor([[ 0.0182,  0.0149, -0.0287,  ...,  0.0255, -0.0269, -0.0310],
        [ 0.0134, -0.0235,  0.0252,  ...,  0.0060,  0.0224,  0.0193]],
       device='cuda:0', grad_fn=<SliceBackward0>)

Layer: linear_relu_stack.0.bias | Size: torch.Size([512]) | Values : tensor([-0.0281,  0.0062], device='cuda:0', grad_fn=<SliceBackward0>)

Layer: linear_relu_stack.2.weight | Size: torch.Size([512, 512]) | Values : tensor([[-0.0238,  0.0284, -0.0362,  ...,  0.0069,  0.0253,  0.0276],
        [-0.0403, -0.0079, -0.0289,  ..., -0.0333, -0.0307,  0.0224]],
       device='cuda:0', grad_fn=<SliceBackward0>)

Layer: linear_relu_stack.2.bias | Size: torch.Size([512]) | Values : tensor([-0.0072, -0.0251], device='cuda:0', grad_fn=<SliceBackward0>)

Layer: linear_relu_stack.4.weight | Size: torch.Size([10, 512]) | Values : tensor([[-0.0017,  0.0317, -0.0203,  ...,  0.0224,  0.0380,  0.0129],
        [ 0.0209, -0.0309, -0.0163,  ...,  0.0222, -0.0413, -0.0158]],
       device='cuda:0', grad_fn=<SliceBackward0>)

Layer: linear_relu_stack.4.bias | Size: torch.Size([10]) | Values : tensor([-0.0394,  0.0200], device='cuda:0', grad_fn=<SliceBackward0>)

以上

2023年3月
月	火	水	木	金	土	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31