PyTorch によるニューラルネットワーク

以下の公式リファレンスを参考にした．
Neural Networks -- PyTorch Tutorials 1.4.0 documentation

ニューラルネットワークの訓練の一般的な手順は以下の通り．
1. データ（訓練データ・テストデータ）を準備する．
2. 訓練可能なパラメータを持つニューラルネットワークを定義する．（Define the network）
3. ネットワークに訓練データを入力したときの損失関数を計算する．（Loss function）
4. ネットワークのパラメータに関する損失関数の勾配を計算する．（backward）
5. 損失関数の勾配に基づいてパラメータを更新する．（optimize）
6. 3 ~ 6 を何度も繰り返すことで訓練を行う．

手順通りにニューラルネットワークを構築していく．

1. データの準備

ニューラルネットワークの訓練に使うデータは，既にパッケージで用意されているものを使用するか，自分で準備したデータを使う．

既に用意されているものを使用する場合はtorchvisionパッケージを利用すると便利である．
機械学習でよく使用される MNIST や CIFAR10 などのデータセットtorchvision.datasetsが準備されているほか，汎用的な機械学習モデルtorchvision.modelsやデータ処理を行うモジュールtorchvision.transformsが用意されている．
詳しくは公式ドキュメントを参照 --> torchvision

訓練を実行するときにはtorch.utils.data.DataLoaderというデータの箱を用意する．DataLoaderは，入力データとそのラベルを合わせたデータセットを，バッチサイズだけひとまとめにしたものである．

準備の手順は以下の通り．
(1) データの前処理を行うtransformsを用意する．
(2) transformsを引数として Dataset クラスをインスタンス化してDatasetを用意する．
(3) Datasetを引数として DataLoader クラスをインスタンス化してDataLoaderを用意する．
(4) 訓練時にはDataLoaderを用いて，訓練データとラベルをバッチサイズのかたまりで取得する．

2. ニューラルネットワークの定義

ニューラルネットワークはtorch.nnパッケージを用いて構築できる．
nnは自動微分autogradを利用することでモデルの定義や微分を実行する．

nn.Moduleはニューラルネットワークの各種レイヤーやforward(input)メソッドを持っている．
そのため，新しいネットワークを構築する際にはnn.Moduleクラスを継承すればよい．

import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 3x3 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()
print(net)

# ---Output---
#Net(
#  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
#  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))
#  (fc1): Linear(in_features=576, out_features=120, bias=True)
#  (fc2): Linear(in_features=120, out_features=84, bias=True)
#  (fc3): Linear(in_features=84, out_features=10, bias=True)
#)

__init__()メソッドにて，ネットワークが保持するレイヤーを定義する．
LinearやConv2dなどのよく使用するほとんどのレイヤーがtorch.nnで定義されている．
詳しくは公式ドキュメントを参照 --> torch.nn

同様に，reluやmax_pool2dなどの処理はtorch.nn.functionalで定義されている．
処理が必要な場面で適宜呼び出して使用すればよい．
詳しくは公式ドキュメントを参照 --> torch.nn.functional

forward()メソッドにて，ネットワークの順伝播を定義する．
入力xが出力されるまでに通るレイヤーや実行される処理を順番に定義していく．

なお，ネットワークの逆伝播であるbackward()は定義する必要はない．
forward()を定義しautogradを使用することで．自動的に逆伝播が求まるようになっている．

訓練可能なパラメータはnet.parameters()で取得できる．
重みパラメータとバイアスパラメータで別々に取得されるため，定義したレイヤーの数 $\times$ 2 の長さのパラメータのリストが得られる．

params = list(net.parameters())
print(len(params))
print(params[0].size())   # conv1's weight
print(params[1].size())   # conv1's bias
print(params[0][0,:,:,:]) # conv1's weights on the first dimension

# ---Output---
#10
#torch.Size([6, 1, 3, 3])
#torch.Size([6])
#tensor([[[-0.0146, -0.0219,  0.0491],
#         [-0.3047, -0.0137,  0.0954],
#         [-0.2612, -0.2972, -0.2798]]], grad_fn=<SliceBackward>)

このネットワークに対して，$32 \times 32$ の適当なデータを入力してみる．

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

# ---Output---
#tensor([[-0.0703,  0.0575, -0.0679, -0.1168, -0.1093,  0.0815, -0.0085,  0.0408,
#          0.1275,  0.0472]], grad_fn=<AddmmBackward>)

入力した乱数が初期パラメータを持つレイヤーを通って出力されている．

zero_grad()メソッドで全てのパラメータの勾配をゼロにできる．予期せぬパラメータ更新を避けるためにbackward()を実行する前にzero_grad()を実行することが推奨される．

torch.nnはミニバッチが入力されることを前提としている．例えば，nn.Conv2dは入力として4次元の Tensor ($\rm{nSamples} \times nChannels \times Height \times Width$) を用意する必要がある．

3. 損失関数

MSELoss()やCrossEntropyLoss()などのよく使用する損失関数はnnパッケージに用意されている．
以下では，乱数を入力した際の出力値と，同じサイズの乱数列を用いてMSELossを計算している．

input = torch.randn(1, 1, 32, 32)
output = net(input)
target = torch.randn(10)    # a dummy target, for example
target = target.view(1,-1)  # make it the same shape as output
criterion = nn.MSELoss()
loss = criterion(output, target)
print(loss)

# ---Output---
#tensor(0.5322, grad_fn=<MseLossBackward>)

ここまでの順伝播を追ってみると，

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d 
      -> view -> linear -> relu -> linear -> relu -> linear 
      -> MSELoss 
      -> loss

となっており，grad_fn属性を見ることで確認できる．

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

# ---Output---
#<MseLossBackward object at 0x7f5008a1c4e0>
#<AddmmBackward object at 0x7f5008a1c5c0>
#<AccumulateGrad object at 0x7f5008a1c4e0>

4. 勾配計算

パラメータ更新のために誤差逆伝播を行うには，損失関数の勾配が必要である．PyTorch では，損失関数lossに対してloss.backward()を実行すれば勾配を自動的に計算してくれる．
勾配が蓄積されてしまうのを避けるために，訓練時には iteration ごとにnet.zero_grad()を実行し，勾配を消去することが推奨される．

net.zero_grad()     # zeroes the gradient buffers of all parameters
print("conv1.bias.grad before backward")
print(net.conv1.bias.grad)

loss.backward()
print("conv1.bias.grad after backward")
print(net.conv1.bias.grad)

# ---Output---
#conv1.bias.grad before backward
#tensor([0., 0., 0., 0., 0., 0.])
#conv1.bias.grad after backward
#tensor([ 0.0072, -0.0051, -0.0008, -0.0017,  0.0043, -0.0030])

5. パラメータの更新

パラメータ更新（最適化）はtorch.optimから引用すればよい．
ここでは，以下の式で定義される確率的勾配降下法（SGD）を使用してみる．
詳しくは公式ドキュメントを参照 --> torch.optim

weight -> weight - learning_rate * gradient

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output,target)
loss.backward()
optimizer.step()        # do the update

6. 訓練

上記の 3 ~ 6 の手順を繰り返すことでネットワークの訓練を実行する．

CIFAR10を用いた実装

例として，CIFAR10 を用いた画像分類を行うニューラルネットワークを訓練する．
以下の公式リファレンスを参照した．
Training a Classifier -- PyTorch Tutorials 1.4.0 documentation

データの準備

torchvision.datasetsに用意されている CIFAR10 のデータを取得し標準化する．
torchvision dataset のデータは [0,1] の範囲の値を持つ PILImage であるため，ここでは [-1,1] の範囲の値を持つ Tensor に標準化している．

import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

準備したデータを表示してみる．

import matplotlib.pyplot as plt
import numpy as np

def imshow(img):
    img = img/2 + 0.5 # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1,2,0)))
    plt.show()
    
# get some random training imges
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))

# print labels
print(''.join('%5s' % classes[labels[j]] for j in range(4)))

[Output]

ネットワークの構築

続いて，画像の分類を行うネットワークを構築する．

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

損失関数と最適化手法の定義

ネットワークが構築できたら，損失関数と最適化手法を定義する．

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

訓練

ネットワーク・損失関数・最適化手法が定義できたら，訓練データを使って訓練を開始する．

for epoch in range(2): # loop over the dataset multiple times
    
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data
        
        # zero the parameter gradients
        optimizer.zero_grad()
        
        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs,labels)
        loss.backward()
        optimizer.step()
        
        # print statistics
        running_loss += loss.item()
        if i%2000==1999: # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' % (epoch+1, i+1, running_loss/2000))
            running_loss = 0.0
            
print('Finished Training')

# ---Output---
#[1,  2000] loss: 2.149
#[1,  4000] loss: 1.832
#[1,  6000] loss: 1.651
#[1,  8000] loss: 1.573
#[1, 10000] loss: 1.514
#[1, 12000] loss: 1.458
#[2,  2000] loss: 1.420
#[2,  4000] loss: 1.371
#[2,  6000] loss: 1.348
#[2,  8000] loss: 1.333
#[2, 10000] loss: 1.326
#[2, 12000] loss: 1.293
#Finished Training

ここでは，12000個の訓練データすべてを使った訓練を2回行っている．訓練に使用するデータが増えるほど，損失関数 loss が小さくなっているため，学習が進行している様子が観察できる．（学習はまだ完了していないと思われるが，今回はここで中断し先に進む．）

モデルパラメータの保存

訓練済みのモデルのパラメータはtorch.save()で保存できる．

PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)

テストデータに適用

テストデータに対して，訓練済みのネットワークを適用してみる．
まずは，テストデータの中身を確認する．

dataiter = iter(testloader)
images, labels = dataiter.next()

imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

[Output]

続いて，保存したネットワークのパラメータを読み込む．
その後，読み込んだモデルにテストデータを入力し，分類結果を表示してみる．

net = Net()
net.load_state_dict(torch.load(PATH))
# ---Output---
# <All keys matched successfully>

outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
# ---Output---
# Predicted:    cat  ship plane plane

3枚目の画像を ship ではなく plane と誤判定しているが，それ以外の3つは正しく分類できていることがわかる．

10000枚のテストデータすべてに対する正解率を計算してみる．

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        
print('Accuracy of the network on the 10000 test images: %d %%' % (100*correct/total))
# ---Output---
# Accuracy of the network on the 10000 test images: 52 %

正解率は 52% となり，画像分類器としてはあまり精度の良いものではないといえる．

続いて，分類の種類ごとに正解率を取得してみる．

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))

with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs,1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1
            
for i in range(10):
    print('Accuracy of %5s : %2d %%' % ( classes[i], 100*class_correct[i]/class_total[i]))

# ---Output---
# Accuracy of plane : 61 %
# Accuracy of   car : 61 %
# Accuracy of  bird : 52 %
# Accuracy of   cat : 26 %
# Accuracy of  deer : 34 %
# Accuracy of   dog : 51 %
# Accuracy of  frog : 67 %
# Accuracy of horse : 43 %
# Accuracy of  ship : 76 %
# Accuracy of truck : 50 %

ここから，cat の分類は苦手だが ship の分類は得意であることがわかる．

GPUを用いる場合

GPU上で訓練を行う場合には，deviceで CUDA device を指定する必要がある．
まず，GPU が利用可能かどうか調べる．以下のコードでcuda:0と表示されれば GPU が利用可能である．

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Assuming that we are on a CUDA machine, this should print a CUDA device:
print(device)

# ---Output---
# cuda:0

.to(device)でネットワークやデータを GPU 上に移動できる．
訓練の際には，イテレーションごとにデータを GPU に移動することを忘れないように．

net.to(device)
inputs, labels = data[0].to(device), data[1].to(device)

まとめ

最後に，以上の手順を一つのコードでまとめておく．

# import packages -------------------------------
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# prepare data ----------------------------------
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# define a network ------------------------------
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

# define loss function and optimizer -------------
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# start training ---------------------------------
for epoch in range(2): # loop over the dataset multiple times
    
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data
        
        # zero the parameter gradients
        optimizer.zero_grad()
        
        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs,labels)
        loss.backward()
        optimizer.step()
        
        # print statistics
        running_loss += loss.item()
        if i%2000==1999: # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' % (epoch+1, i+1, running_loss/2000))
            running_loss = 0.0
            
print('Finished Training')

# check on test data ----------------------------
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        
print('Accuracy of the network on the 10000 test images: %d %%' % (100*correct/total))