PyTorch 1.8 チュートリアル : PyTorch の学習 : 基本 – ニューラルネットワークを構築する (翻訳/解説)
翻訳 : (株)クラスキャットセールスインフォメーション
作成日時 : 03/13/2021 (1.8.0)

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

Learning PyTorch : Learn the Basics : Build the Neural Network

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

★ 無料セミナー実施中 ★ クラスキャット主催人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社公式 Web サイトでご確認頂けます。

お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援	人工知能研修サービス	テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

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

株式会社クラスキャット セールス・マーケティング本部セールス・インフォメーション

E-Mail：sales-info@classcat.com ; WebSite: https://www.classcat.com/ ; Facebook

PyTorch の学習 : 基本 – ニューラルネットワークを構築する

ニューラルネットワークはデータ上で演算を遂行する層/モジュールから成ります。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('Using {} device'.format(device))

Using cuda device

クラスを定義する

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

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__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),
            nn.ReLU()
        )

    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)
    (5): ReLU()
  )
)

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

入力上のモデルの呼び出しは各クラスのための raw 予測値を持つ 10-次元 tensor を返します。それを 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}")

PrPredicted class: tensor([8], 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.0715, -0.0163,  0.1325, -0.0666, -0.1519, -0.3665,  0.4882,  0.4187,
         -0.0264,  0.3075, -0.0382,  0.2257,  0.2364, -0.0494, -0.2785,  0.6214,
         -0.0841, -0.3982, -0.1663, -0.7309],
        [ 0.3159, -0.4386,  0.1752, -0.0150, -0.6118, -0.6524,  0.5537,  0.4267,
         -0.1928,  0.2673, -0.0153,  0.2980,  0.5688,  0.0612,  0.2030,  0.2418,
          0.0530, -0.1632, -0.2824, -0.5628],
        [ 0.1016, -0.3829,  0.1288,  0.0120, -0.2156, -0.5707,  0.8527,  0.1903,
          0.2310,  0.0388, -0.2461, -0.0158,  0.5415,  0.0810,  0.0500,  0.4378,
         -0.0994, -0.0030, -0.2011, -0.7926]], grad_fn=)


After ReLU: tensor([[0.0715, 0.0000, 0.1325, 0.0000, 0.0000, 0.0000, 0.4882, 0.4187, 0.0000,
         0.3075, 0.0000, 0.2257, 0.2364, 0.0000, 0.0000, 0.6214, 0.0000, 0.0000,
         0.0000, 0.0000],
        [0.3159, 0.0000, 0.1752, 0.0000, 0.0000, 0.0000, 0.5537, 0.4267, 0.0000,
         0.2673, 0.0000, 0.2980, 0.5688, 0.0612, 0.2030, 0.2418, 0.0530, 0.0000,
         0.0000, 0.0000],
        [0.1016, 0.0000, 0.1288, 0.0120, 0.0000, 0.0000, 0.8527, 0.1903, 0.2310,
         0.0388, 0.0000, 0.0000, 0.5415, 0.0810, 0.0500, 0.4378, 0.0000, 0.0000,
         0.0000, 0.0000]], grad_fn=)

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)

モデル・パラメータ

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

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

print("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)
    (5): ReLU()
  )
) 


Layer: linear_relu_stack.0.weight | Size: torch.Size([512, 784]) | Values : tensor([[-0.0106,  0.0014,  0.0097,  ..., -0.0026, -0.0077,  0.0342],
        [ 0.0062,  0.0124,  0.0343,  ...,  0.0080, -0.0333,  0.0252]],
       device='cuda:0', grad_fn=<SliceBackward>) 

Layer: linear_relu_stack.0.bias | Size: torch.Size([512]) | Values : tensor([0.0350, 0.0038], device='cuda:0', grad_fn=<SliceBackward>) 

Layer: linear_relu_stack.2.weight | Size: torch.Size([512, 512]) | Values : tensor([[-0.0115, -0.0172,  0.0140,  ...,  0.0178,  0.0111,  0.0351],
        [ 0.0207,  0.0279,  0.0257,  ..., -0.0332,  0.0235,  0.0394]],
       device='cuda:0', grad_fn=<SliceBackward>) 

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

Layer: linear_relu_stack.4.weight | Size: torch.Size([10, 512]) | Values : tensor([[-1.8048e-04,  2.6085e-02,  8.4344e-04,  ..., -3.6906e-02,
          1.7753e-02, -3.4632e-02],
        [-1.6887e-02,  4.0806e-02,  1.1717e-02,  ..., -8.0980e-05,
         -2.7076e-02,  4.2600e-02]], device='cuda:0', grad_fn=<SliceBackward>) 

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

以上

2021年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