PyTorchでCNNを徹底解説

2019/9/29 投稿
2019/11/8 やや見やすく編集(主観)
2020/2/1 SGDの解説Link追加
2020/8/17 図がないとよくわからないと思い図を追加
2020/9/21 コメントより補足説明追加と図の更新
2022/7/2 図の更新、新たな図の追加、文章修正
2022/11/6 畳み込みの映像更新

# 0. この記事の対象者
- Pythonを触ったことがあり,実行環境が整っている人
- PyTorchをある程度触ったことがある人
- PyTorchによるCNNの実装でより深くコード理解がしたい人
- この長くて大変恐縮な記事を読み切る根気がある人

# 1. はじめに
昨今では機械学習に対してPython言語による研究が主である.
なぜならPythonにはデータ分析や計算を高速で行うためのライブラリ(moduleと呼ばれる)がたくさん存在するからだ.
その中でも今回は**PyTorch**と呼ばれるmoduleを使用し,Convolutional Neural Networks(CNN)のexampleコードを徹底的に解説していく.

全体のコードは最後に貼っておくので,説明が煩わしい方はそちらから見てほしい.

ただしこの記事は自身のメモのようなもので,あくまで参考程度にしてほしいということと,簡潔に言うために正確には間違った表現や言い回しをしている場合があるが,そこはどうかご了承していただきたい.

# 2. 事前知識
Pythonには他プログラミング言語同様,「**型**」というものが定義した変数には割り当てられており,中でも「**list型**」,「**tuple型**」,「**dictionary型**」が初心者にとっての最初の壁としてよく出てくるように思う.
さらに,moduleとして「**numpy**」というものもあり,このnumpyが持つ特殊な型,「**ndarray型**」もよく出てくる.

ここではあえて説明はしないが,わからない人は是非検索をしてそれぞれをしっかり理解しておいてほしい.

# 3. PyTorchのインストール
PyTorchを初めて使用する場合,PythonにはPyTorchがまだインストールされていないためコマンドプロンプトなどでのインストールをしなければならない.
下記のLinkに飛び,ページの下の方にある「QUICK START LOCALLY」で自身の環境のものを選択し,現れたコマンドをcmd等で入力する(コマンドをコピペして実行で良いはず).

[PyTorch 公式サイト](https://pytorch.org/)

さらに,今回は「torchvision」というmoduleも使用するためこちらもインストールしておいてほしい.
(大抵は公式サイトにあるコマンドをそのまま実行すればインストールされる)

# 4. CNNとは
**CNN(Convolutional Neural Networks)** は直訳すると**畳み込みニューラルネットワーク**というもので,入力されるdataに関して畳み込みという処理を複数回行うことでその入力data(例えば画像)から特徴を抽出していく.
特にこのCNNは画像の特徴を抽出するのに非常に優れており,昨今では様々な画像を用いた機械学習に用いられている.
畳み込みについて説明すると,以下の図のようなことが行われている.

![畳み込みの例](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/01c2f5a8-12bb-aa79-a594-a99efde2d5ad.png)

**kernel (parameter)** と書いてある青い枠が畳み込みをするためのパラメータである.
このkernelが入力画像の左上の領域と重なり,重なった部分の要素ごとに掛け算をしてそれらをすべて足したものが特徴画像の1ピクセルとなる.
その計算の詳細を吹き出し内に書いている.
そして次の1ピクセルを計算する際は入力画像の左上の領域が右に1ピクセルだけスライドして同じ計算をする(白の矢印).
これが入力画像の一番右まで行くと今度は一番左に戻って下に1ピクセルだけスライドし,同じことが繰り返される.
こうして特徴画像が出来上がるのだ.
畳み込みをしている様子をアニメーションで作ってみたので参考にしてほしい.

<iframe width="560" height="315" src="https://www.youtube.com/embed/xjqCTp4xAtA" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

左図が入力画像で,左図の赤い枠内の3x3ピクセルがカーネルである.
右図が出力の特徴量で,1ピクセルごと出力されているのがわかる.
(この動画はmanimというpythonライブラリを使っており、これを作るPythonプログラムは要望があればここに追記する.)
畳み込みの途中経過を切り出したのが下の図である
このように3x3の重なった部分との演算で右図の1ピクセルを出力し,右にスライドする(白い矢印).

![畳み込みアニメーション_途中](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/dc310130-cfa9-a97b-a998-12e3daeea64a.png)

:::note
ここで見るように**特徴画像のサイズがやや小さくなっている**ことに注意する(28x28から26x26へ).
どれだけサイズが小さくなるのはカーネルのサイズ(今回は3x3)により変わり,以下のlinkのページ下の方の「Shape」から手計算で求めることができる.
[畳み込み後の画像サイズ](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html)
:::

# 5. 今回の問題設定
今回は**MNIST**と呼ばれる手書き数字の白黒画像を用いて説明を行う.
以下がMNISTの画像である.

![MNIST.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/5e53fb5b-43ed-93ea-c499-3d10b2ece59a.png)

サイズは28x28ピクセルで,0~9の数字をもつ10クラスで用意されている.
これを使って**分類問題(Classification)** と呼ばれる問題を解くこととする.
この問題は1つの画像を入力してそれが何のクラスか(何の数字か)をあてる問題である.
ちなみに画像は以下のように各ピクセルごとに値をもつため,今回は28x28=784個の値を持った画像を入力する.

![スライド0.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/369b14ff-46a6-6dd3-627e-c700a320cab9.png)

値が0ほど黒く,値が大きいほど白くなる.


# 6. PyTorchによるCNN実装
## 6-1. PyTorchに用意されている特殊な型
numpyにはndarrayという型があるようにPyTorchには「**tensor型**」という型が存在する.
ndarray型のように行列計算などができ,互いにかなり似ているのだが,tensor型はGPUを使用できるという点で機械学習に優れている.
なぜなら機械学習はかなりの計算量が必要なため計算速度が早いGPUを使用するからだ.
ただし,機械学習においてグラフの出力や画像処理などでnumpyも重要な役割を持つ.
そのためndarrayとtensorを交互に行き来できるようにしておくことがとても大切である.

:::note
tensor型の操作や説明は下記Linkより参照していただきたい.
[PyTorchのtensor型とは](https://qiita.com/mslive/private/241bfb42d852bb801b96)
:::

## 6-2. PyTorchのimport
ここからはコマンドプロンプト等ではなくPythonファイルに書き込んでいく.
下記のコードを書くことでmoduleの使用をする.

```Python
import torch
import torchvision
```

ついでにnumpyもimportしておく.

```Python
import numpy
```

## 6-3. Datasetの取得
PyTorchのtorchvision moduleには主要なDatasetがすでに用意されており,たった数行のコードでDatasetのダウンロードから前処理までを可能とする.

結論から言うと3行のコードでDatasetの運用が可能となり,ステップごとに言えば,

1. transformsによる前処理の定義
2. Datasetsによる前処理&ダウンロード
3. DataloaderによるDatasetの使用

という流れになる.<br>

:::note
ここでは簡単に解説するがそれぞれのステップについて詳しく知りたい場合は以下のLinkを参照してほしい.
[PyTorchのtransforms,Datasets,Dataloaderの説明と自作Datasetの作成と使用](https://qiita.com/mslive/private/2a512831878b8018db02)
:::

### 6-3-1. transformsによる前処理の定義
以下に前処理の定義を示す.

```python
trans = torchvision.transforms.ToTensor()
```

この１行は,これから取得するDatasetの中身がndarray型のデータ集合であるため,前処理でtensor型にしたい.
そのためこの**trans**という変数をndarrayからtensorへと変換する関数のようなものにした(本当はtransはクラスインスタンスであるが気にしない).
もう少し詳しく言うと,以下のようにこの**trans**を使用でき,

```python
a = trans(ndarrayのdata)
```

ndarrayのdataを各画像のピクセル値（輝度）を **[0,1]の範囲**にしつつtensor型に変換し,変数**a**に渡している.

ここで例えばtensor変換だけでなくそのあとに正規化をしたい場合は以下のようにする.

```python
trans = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0.5,), (0.5,))])
```

torchvision.transforms.Composeは引数で渡されたlist型の[~~~~,~~~~,...]というのを**先頭から順に**実行していくものである.
そのためlist内の前処理の順番には十分注意する.
こうすることでtransという変数はTensor変換と正規化を一気にしてくれるハイブリッドな変数になった.

:::note
その他にもたくさんのtransformsがあり,それらは以下のLinkより参照してほしい.
[torchvision.transforms 公式サイト](https://pytorch.org/docs/stable/torchvision/transforms.html)
:::

### 6-3-2. Datasetsによる前処理&ダウンロード
以下にダウンロードを示す.

```python
trainset = torchvision.datasets.MNIST(root = 'path', train = True, download = True, transform = trans)
```

まずは引数の説明をしていく.

- **root**
Datasetを参照(または保存)するディレクトリを「**path**」の部分に指定する.
そのディレクトリに取得したいDatasetが存在すればダウンロードせずにそれを使用する.

- **train**
Training用のdataを取得するかどうかを選択する.
FalseにすればTest用のdataを取得するが,この2つの違いはdata数の違いと思ってくれて良い.

- **download**
rootで参照したディレクトリにDatasetがない場合ダウンロードするかどうかを決めることができる.

- **transform**
定義した前処理を渡す.
こうすることでDataset内のdataを**参照**する時にその前処理を自動で行ってくれる.

:::note
今回はMNISTを使用したが,他の使用できるDatasetは下記のLinkより参照して使用して欲しい.
その時のコードも大体同じである.
[torchvision.datasets 公式サイト](https://pytorch.org/docs/stable/torchvision/datasets.html)
:::

取得した**trainset**をそのまま出力してみると以下のようなDatasetの内容が表示されるはずだ.

```python
print(trainset)

------'''以下出力結果'''--------
Dataset MNIST
    Number of datapoints: 60000
    Root location: rootで指定したpathが出るはず
    Split: Train
    StandardTransform
Transform: Compose(
               ToTensor()
               Normalize(mean=(0.5,), std=(0.5,))
           )
```

これだけ見るとDatasetなのにどうやってdataを見ているの?となるが,dataの参照は以下のようにすれば良い.

```python
print(trainset[0])

------'''以下出力結果'''--------
(tensor([data内容]), そのdataに対応する正解label)
```

これでDatasetの0番目のdataを参照できる.
実は実際にDatasetのdataを使用するときも配列の参照のようにdataを参照している.

### 6-3-3. DataloaderによるDatasetの使用
DataloaderによるDatasetの使用は下記のコードで実行する.

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

まずは引数の説明をしていく.

- **第1引数**
先程取得したDatasetを入れる.

- **batch_size**
1回のtrainingまたはtest時に一気に何個のdataを使用するかを選択.
~~datasetの全data数を割り切れる値にしなければならない.~~ ← 割り切れなくてもよかった.ただし,最後のbatch数が少なくなる.

- **shuffle**
dataの参照の仕方をランダムにする.

- **num_workers**
並列処理をするかどうかで,2以上の場合その値だけ並行処理をする.

:::note warn
コメントで寄せられたので記述.Windows OSを使用している場合,num_worksが2以上だとエラーが起こることがあるらしい.
**エラーが起こる場合はnum_works=1や0とする**とよい.
:::

ちなみに,取得した**trainloader**を出力しても以下のようなオブジェクトタイプしか表示されない.

```python
print(trainloader)

------'''以下出力結果'''--------
<torch.utils.data.dataloader.DataLoader object at 0x7fdffa11ada0>
```

Datasetのように中身が見たい場合,配列の参照のようにするとエラーが起こる.
なぜならDataLoaderは配列ではなくiteratorというものを返しているためである.
無理やり中身を見ようとするならば以下のようにすれば良い.

```python
for data,label in trainloader:
    break
print(data)
print(label)

------'''以下出力結果'''--------
tensor([[data1], [data2],..., [data100]])
tensor([label1, label2,..., label100])
```

このように1回の取得でdataとlabelはバッチサイズ(今で言うと100)だけ取得され,もちろん各dataとlabelは対応しあっている.
図で見てみると
![trainloaderの概要](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/2a9a8306-c84d-c941-9d4e-52e60e2a1b0f.png)

このようにtrainloaderは全dataと対応するlabelをBatch毎に分けてセットで持ち,その1セットを変数detaとlabelに渡している.

ただし,**この確認は絶対に学習する前に同じプログラム内ではやらない方が良い**.
なぜならtrainloaderはiteratorであるため今回呼び出したdataは全データを見きるまで二度と見られることがなくなってしまう.
(iteratorは最初のセット100個を取り出すと次回の呼び出しからは次のセット100個を取り出す)
つまりこの参照をしてしまった100個のdataは2周目に入るまで見られなくなってしまう.
そこに十分注意してほしい.

### 6-3-4. test用datasetの取得
training用のdataset取得がわかればtest用もほとんど同じである.
以下にコードを示す.

```python
testset = torchvision.datasets.MNIST(root = '~/Documents/work/MNISTDataset/data', train = False, download = True, transform = trans)
testloader = torch.utils.data.DataLoader(testset, batch_size = 100, shuffle = False, num_workers = 2)
```

違う点とすればdatasetsの引数**train=False**であることと,dataloaderの引数**shuffle=False**となっているところだけである.
shuffleがFalseなのはTestの時にはdataをランダムに取得する必要がないからである.
transformは同様のtransを使用する.

## 6-4. Networkの定義
今回はCNNを作成するが,作成にはいくつかの手法がある.
- 「nn.XXXXX」を用意したclassベースで作る
- 「nn.XXXXX」をnn.Seaquentialを使って作る
- torchvisionに用意されている既存のモデル(VGGやResNet)を使う
その中でも今回私は **「nn.XXXXX」を用意したclassベースで作る**.
以下に簡単なCNNを作った.

```python
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, stride=2)

        self.conv1 = nn.Conv2d(1,16,3)
        self.conv2 = nn.Conv2d(16,32,3)

        self.fc1 = nn.Linear(32 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x
```

まず最初にtorch module内の「**torch.nn**」をimportする.
その際「**as nn**」と書くことで以降使用するときに「**nn.XXXX**」と書くだけで使用できるようになる.

続いて以下にnetworkの中身を上から順に説明していく.

### 6-4-1. classとしてNetworkを作成
Networkをclassとして作成する.
雛形で言えばこんな形になる.

```python
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
           ......

    def forward(self, x):
           ......

```
以下各行の説明.

- 1行目
classの定義をする.
classの後の「**Net**」はただのclass名だから好きなもので良い.
その名前の後の「**nn.Module**」はこのclassがnn.Moduleというclassを継承していることを意味する.
なぜ継承するかというとnn.ModuleがNetworkを使用する上でパラメータ操作などの重要な機能を持つためである.

- 2行目
「**def \_\_init\_\_(self)**」は初期化関数の定義で,コンストラクタなどと呼ばれる.
初めてclassを呼び出したときに,その実態をインスタンスと呼び,インスタンスが生成されたときにinitの中身が実行される.

- 3行目
「**super(Net, self).\_\_init\_\_()**」は継承したnn.Moduleの初期化関数(nn.Moduleの中の\_\_init\_\_())を起動している.
super()の引数の「**Net**」はもちろん自身が定義したclass名である.

- 最後の行
「**def forward(self, x)**」には実際のネットワークの処理を書いていく.

### 6-4-2. 初期化関数の定義
以下に初期化関数部分のみを再掲する.

```python
    def __init__(self):
        super(Net, self).__init__()
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, stride=2)

        self.conv1 = nn.Conv2d(1,16,3)
        self.conv2 = nn.Conv2d(16,32,3)

        self.fc1 = nn.Linear(32 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 10)
```

この中で定義した「**self.xxxxx**」という変数はclassを呼び出したインスタンスが保持する.
なので,convolutionやfully connectなどの学習に必要なパラメータを保持したいものなどをここに書いていく.
以下にコードの説明をする.

- **nn.ReLU()**
活性化関数というもので,各層の後に必ずと言っていいほど使用される処理である.
種類は他にもあるが,最もよく使われているのがReLUである.
ReLUは正の値はそのままで,負の値は0になるように変換する.

- **nn.MaxPool2d(2, stride=2)**
poolingと呼ばれる特徴量をサンプリングして減らす処理である.
このパラメータの場合,データサイズが半分になるような処理をする(サイズの小数点以下は切り下げられる).

- **nn.Conv2d(1,16,3)**
convolution(畳み込み)の定義で,第1引数はその入力のチャネル数,第2引数は畳み込み後のチャネル数,第3引数は畳み込みをするための正方形フィルタ(カーネル)の1辺のサイズである.
最初の畳み込みの例でも言ったが**畳み込み後の画像サイズは小さくなる**ため,畳み込みの例で紹介したlinkで計算しておく.

- **nn.Conv2d(16,32,3)**
2つ目のConvの定義で,基本は1つ目と同じように引数を設定する.
第1引数は入力のチャネル数になるが,1つ目のConvの出力が16channelなので,それに合わせる.

- **nn.Linear(32 * 5 * 5, 120)**
fully connectの定義で,第1引数は入力のサイズ(ただし入力は**行列ではなくベクトルでなければならない**),第2引数は出力後のベクトルサイズを示す.
この場合の第１引数の意味は入力ベクトルがベクトルになる前のdataでは**32Channel × 5Height× 5Width**(5×5の特徴画像が32枚)となっていたことがわかる.
**この特徴画像が5x5になることはConvとPoolingによるサイズ縮小を手計算で求める必要がある.**
どうやって特徴画像(行列の形)をベクトルにするかは6-4-3で説明する.

- **nn.Linear(120, 10)**
2つ目のfully connectの定義で,基本は1つ目と同じように引数を設定する.
また出力が10になっているのは,MNISTが10クラスのデータセットなため,10クラス分の出力をする

:::note
これらの他にも多数の機能をPyTorchは用意しており,それらは以下のLinkから参照してほしい.
[torch.nn 公式サイト](https://pytorch.org/docs/stable/nn.html)
:::

:::note
今回はMNISTを使用する上で作成しているので,他のDatasetにすると細かい引数が変わるので注意する.
(例えばMINSITは白黒画像なため1チャネルだが、カラー画像にすると最初の畳み込みの入力は3チャネルになる)
:::

### 6-4-3. 処理内容の定義
以下に処理部分のみ再掲する.

```python
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x
```

「**def forward(self, x)**」の引数**x**がこのネットワークに対しての入力dataである.
もちろんこのxはdataloaderから取得したバッチサイズ数のdata群である.
このように入力xを\_\_init\_\_()で定義した各層(self.XXXXX)に上から順に入力していく.
実際にどのように処理されていくかを詳しく説明していく.

- conv1(x), relu(x), pool(x)について
まず上から3つのconv1~poolまでの処理を図で説明する.
![最初の畳み込み処理](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/9f2c7c8f-1dbf-006d-dfb9-97a10ad125a7.png)
まずバッチサイズ分の1チャネルの入力画像が16個のkernel(parameter)を通じて16チャネルの特徴を得る.
このkernelはそれぞれが3x3のパラメータを持ち,16個全てのkernelが異なるパラメータを持っている.つまりここでのパラメータの総数は16x3x3=144である(ほんとはバイアス16個分もさらに追加されて144+16=160個である).
これがチャネル数が増えているカラクリとなっている.
それにReLUという活性化関数(グラフのような0以下は全て0になる関数)を適用させる.
そしてpoolingを行うことで特徴画像サイズが半分となる.

- conv2(x)について
同様にconv2に関しても見てみる.
![2回目の畳み込み処理](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/c65146d9-e297-c9fb-c966-115266f6e56c.png)
このように16チャネルの入力に対してconv2は16個のkernelを1セットにしたものを32セット持っており,1セットと16チャネルの入力を用いて出力の特徴画像1チャネルを求めている(これが32個あるから32チャネルとなる).
ちなみにここでも各kernelは3x3のパラメータを持ち,全てのkernelのパラメータは異なる.
ここでのパラメータの総数は32x16x3x3=4608である(ほんとはバイアス32x16=512個分もさらに追加されて4608+512=5120個である).

- view(~~~)について
「**x.view(x.size()[0], -1)**」はtensor型xの形を変換するもので,view(a,b)とみたときに引数aを縦,引数bを横とみた行列に変換することができる.
今回は行列形式を1本のベクトルにするため,Bach内の各1サンプルに対する特徴画像を横長に伸ばすイメージである.
例えばサンプルが一つの時はview(1, XXXX)とすれば1行XXXX列にすることで横長のベクトルに伸ばすことができる.
ここでXXXXに今回の特徴量である実際の値 5x5x32を入れてもいいのだが,view(1, -1)とするだけで同じことが実装できる.
(この-1の意味はもう片方の確定しているサイズになるように -1側を自動でサイズ調節するということである)
そして今回は1つのサンプルではなくミニバッチ数分のサンプルがあるためx.size()[0]で入力のミニバッチ数を指定している.
これが6-4-2で言った行列をベクトルの形に変換する操作である.
:::note
「**x.size()**」について詳しく説明すると,**x**のサイズを返すもので **(Batchsize,Channel,Height,Width)** というtuple型が返ってくる.
そのtupleの0番目を **x.size()[0]** で指定しているから,書き換えるとこの文は「**x.view(Batchsize, -1)**」ということになっている.
ということで行数がBatchsize(今の場合100個)になるように列数を自動調節し,100個の行ベクトルができたことになる(つまり100個の行列データを100個のベクトルデータにした).
以下は1サンプルに対してviewを行ったときの例である.
![viewの例](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/63555513-edfa-1a9d-26d9-6972a950603c.png)
:::

- fc1(x)について
viewによって特徴画像をベクトルにできたので,fully connect層(全結合層)に適応させることができる.
fc1は以下のようなことを行っている.
![fullyconnect層](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/f9a4163b-394b-6ae0-1889-c8b0c94e04b2.png)
ここでは見やすくするために先ほどの例で使った800次元のベクトルを縦に書いている.
このベクトルの各値を**ニューロン**といい拡大して簡単に真ん中のようなオレンジの丸で見てみる.
このすべてのニューロンから青色の線に沿って出力側の一つのニューロンzになっている.
詳しい計算は吹き出し内に書いている.
ここでwとは学習パラメータ(重みともいう)で,図で言うと青色の線上にあるものと考えてよい.
同様に他のニューロンzも異なる重みwで求まる.
全結合層の重みは800x120=96000個と,畳み込みに対して非常に学習パラメータが多いことが分かる(ほんとはバイアス800個分もさらに追加されて96000+800=96800個である).

:::note
このforward関数内では変数**x**は「**x = self.XXXXX(x)**」のように毎回更新されている.
変数が更新されても良いことを覚えておこう.
:::

## 6-5. Networkの準備とloss関数と最適化手法
以下にコードを示す.

```python
import torch.optim as optim

device = torch.device("cuda:0")
net = Net()
net = net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.0001, momentum=0.9, weight_decay=0.005)
```

- 1行目
まず最初に,最適化を定義するために「**torch.optim**」をimportした.
このmoduleは最適化の手法を多数持っている.

- 3行目
「**device = torch.device("cuda:0")**」はGPUを使用する際にどのGPUを使用するかを決めている.
この場合 **"cuda:0"** を使用するということを変数**device**にもたせている.
使っているPCの環境にGPUが複数あるなら「**"cuda:番号"**」とすればそのGPUを使用できる(または単に「 **"cuda"** 」とすれば番号など気にせずにGPUを使用できる).
またcpuを使用したい場合は「 **"cpu"** 」とすれば良い.

- 4行目
「 **net = Net()** 」は先程定義したNetworkを**作成**している(インスタンスの生成という).
**net**がNetwork内の変数や演算用のパラメータなどを保持することとなる.
また,この瞬間にNet()の初期化関数\_\_init\_\_()が起動している.
netを出力するとnetの詳細が見れる.
```python
print(net)

------'''以下出力結果'''--------
Net(
  (relu): ReLU()
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1))
  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))
  (fc1): Linear(in_features=800, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=10, bias=True)
)
```

- 5行目
「**net = net.to(device)**」は作成したNetworkである**net**が3行目で指定した「**device**」を使用するようにしている.
この「xxx.to(device)」はGPUとCPUを行き来するときにもよく使用する.

- 6行目
「**criterion = nn.CrossEntropyLoss()**」は**loss関数**を定義している(損失関数とも言い,学習をするための罰則の値を決める).
この**nn**は先程importした**torch.nn**のことで,実は**torch.nn**はNetwork内の演算以外にもlossを計算するための関数も多数用意しくれている.
今回はその中でも「**nn.CrossEntropyLoss()**」を使用し,**criterion**という変数にその機能をもたせる.
criterionを出力すると何を使用しているかがわかる.
```python
print(criterion)

------'''以下出力結果'''--------
CrossEntropyLoss()
```

- 7行目
「**optimizer = optim.SGD(net.parameters(), lr=0.0001, momentum=0.9, weight_decay=0.005)**」は最適化手法であり,この**optim** moduleが多数の手法を用意している.
最適化手法が一体何をするのかというと,**net**がもつパラメータが学習のたびに更新されていくのだが,その更新の仕方を決めているのである.
この更新方法は最適化手法により異なり,今回は確率的勾配降下法(SGD)を使うため「**optim.SGD()**」を使用する.
以下引数の説明.
   - 第1引数は**net**のパラメータを渡す.
   - 第2引数の「**lr=0.0001**」は学習率(learning rate)を意味し,簡単に言えば学習の速度を定義する.
     これはなるべく極小であることが望まれるが,学習がなかなか進まない場合はこの値を大きくしていく.
   - 第3引数の「**momentum=0.9**」は慣性項を意味し,前回の更新量に**momentum**の値倍をした項を更新時にさらに加算する.
     これもパラメータの更新に関わるもので,値が大きいほどパラメータは大きく更新される.
   - 第4引数の「**weight_decay=0.005**」は正則化項を意味し,更新を抑制することで過学習(over fitting)を抑制してくれる.
     これは値が大きいほど学習が遅くなる.

optimizerを出力するとそれぞれの引数の情報を見ることができる
```python
print(optimizer)

------'''以下出力結果'''--------
SGD (
Parameter Group 0
    dampening: 0
    lr: 0.0001
    momentum: 0.9
    nesterov: False
    weight_decay: 0.005
)
```

:::note
optimizerの引数で渡した「**net.parameters()**」はnetのパラメータを参照しているわけではなく,netのパラメータのiteratorを返している.
試しに出力をしてみてもパラメータの表示はされない.
```python
print(net.parameters())

------'''以下出力結果'''--------
<generator object Module.parameters at 0x7fb663b45c00>
```
詳しいNetworkのパラメータの閲覧や操作方法などが気になる方は以下のLinkより参照してほしい.
[PyTorchのNetworkのパラメータの閲覧と書き換え](https://qiita.com/mathlive/items/d9f31f8538e20a102e14)

また,詳しいSGDの操作やどう動いているかなどは以下のLinkより参照してほしい.
[PyTorch optim SGD徹底解説](https://qiita.com/mathlive/items/2c67efa2d451ea1da1b1)
:::

## 6-6. Training&Test
以下にコードを示す.

```python
for epoch in range(100):
    for (inputs, labels) in trainloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

    for (inputs, labels) in testloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
```

- for epoch in range(100)
1番外側のループで学習を何回するかの学習回数だけ繰り返される.
これをepochといい,今回はepochを100としている.
ここで注意してほしいのが**学習回数とパラメータの更新回数は別のもの**として考える.
epochは**学習回数**を意味し,次のfor文による処理が更新回数に相当する.

このコードはTrainingとTestをepochのループ内に各ループとして書いており,1ループ毎(1エポック毎)にそれぞれを実行している.
それぞれの説明を以下に示す.

### 6-6-1. Training
以下にTrainingのループを示す.

```python
    for (inputs, labels) in trainloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
```

- 1行目
trainloaderの説明の時のように,中身のdataとlabelをバッチサイズ分取得している.
この時,一回のループではバッチサイズ分の100個の値をとっているわけだから,このループは総data数60000を100で割った600回ぶん回ることがわかる.
この回数が先程言った**パラメータの更新回数**であり,**iteration**と呼ばれる.
もしバッチサイズが減ればiteration回数が増えることは当然のようにわかる.

- 2行目
取得したdataとlabelをGPUで使用するようにする.

- 3行目
勾配(gradient)情報を0に初期化をしている.
この勾配情報とは後のbackward()という関数により求められるもので,パラメータを更新する際に使用する.
iterationのたびに前の勾配情報が残らないようにするため0にする.

- 4行目
取得したdataをNetworkに入力している.
このようにNetworkの使用は「**net(data)**」とすればnetの**forward()** が実行される.
**outputs**はNetworkのforward()の返り値である.
今回の場合は1サンプルに対し10要素あり, **outputs=[0.1, 0.2, 0.35, 0.05, 0.05, 0.03, 0.07, 0.05, 0.04, 0.06]** のようなtensor型ベクトルとなって返ってくる.
この例だと3番目の値が最も大きいから,このdataは3番目のlabelを予想していることとなる(つまり数字の2だと予測している).
通常の分類問題の場合softmaxと呼ばれる関数により,出力の要素を確率値に変換する.
この10要素のベクトルがバッチ数分ある(つまり100x10の出力が返ってくる).

- 5行目
先ほど定義したloss関数を使用する.「**criterion(outputs, labels)**」とすれば**outputs**と**labels**とのlossを計算してくれる.
返り値はtensor型の値である.
この時outputsは10個の要素を持ったものだと説明したが,labelに関しては2や6といった画像の数字の答えになっている.
この10要素対1要素からlossを計算するためにcriterionの内部ではlabelをOne hot vectorに変換する.
One hotとはlabelの位置を1とし,他を0としてベクトルであり,2 = [0,0,1,0,0,0,0,0,0,0]となる.
実際には気にしなくても勝手に変換される.
ここでもしかしたら読者様の中に「**outputsに対してsoftmaxを最後に使用しなくてよいのか？**」と思う方がいるかもしれないが,実は**criterion**を定義した「**nn.CrossEntropyLoss()**」には内部でsoftmaxが実装されている.
もし他のloss関数を使用している場合はその関数がsoftmax等を使用しているかをしっかり確認してほしい.

- 6行目
計算したlossから勾配情報を計算している.
この計算をどうやっているかなどの詳しい情報はここでは割愛する.
この勾配情報を用いてcriterionのlossが小さくなるように更新をしていくのである.

- 7行目
実際に勾配情報を使用してパラメータの更新をする.
何故「**optimizer.step()**」によりパラメータが更新されるかというと**optimizer**の宣言時に**net.parameters()** を渡しているからである.
実は勾配情報はnetのパラメータが一緒に保持している.

### 6-6-2. Test
以下にTestのループを示す.

```python
    for (inputs, labels) in testloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
```

Trainingとほとんど同じなので説明は省く.
大きく違う点はTestではパラメータの更新がないため**backward()** と**step()** が必要ない.

# 7. まとめソースコード

以下に上の説明を踏まえ,実行中に見やすいよう出力等を追加したまとめのソースコードを示す.

```python
import torch
import torchvision
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt    #グラフ出力用module

BATCH_SIZE = 100
WEIGHT_DECAY = 0.005
LEARNING_RATE = 0.0001
EPOCH = 100
PATH = "Datasetのディレクトリpath"

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

trainset = torchvision.datasets.MNIST(root = PATH, train = True, download = True, transform = transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size = BATCH_SIZE,
                        shuffle = True, num_workers = 1) #Windows Osの方はnum_workers=1 または 0が良いかも

testset = torchvision.datasets.MNIST(root = PATH, train = False, download = True, transform = transform)
testloader = torch.utils.data.DataLoader(testset, batch_size = BATCH_SIZE,
                        shuffle = False, num_workers = 1) #Windows Osの方はnum_workers=1 または 0が良いかも

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(2, stride=2)

        self.conv1 = nn.Conv2d(1,16,3)
        self.conv2 = nn.Conv2d(16,32,3)

        self.fc1 = nn.Linear(32 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x


device = torch.device("cuda:0")
net = Net()
net = net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=LEARNING_RATE, momentum=0.9, weight_decay=WEIGHT_DECAY)

train_loss_value=[]      #trainingのlossを保持するlist
train_acc_value=[]       #trainingのaccuracyを保持するlist
test_loss_value=[]       #testのlossを保持するlist
test_acc_value=[]        #testのaccuracyを保持するlist 

for epoch in range(EPOCH):
    print('epoch', epoch+1)    #epoch数の出力
    for (inputs, labels) in trainloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
    sum_loss = 0.0          #lossの合計
    sum_correct = 0         #正解率の合計
    sum_total = 0           #dataの数の合計

    #train dataを使ってテストをする(パラメータ更新がないようになっている)
    for (inputs, labels) in trainloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        sum_loss += loss.item()                            #lossを足していく
        _, predicted = outputs.max(1)                      #出力の最大値の添字(予想位置)を取得
        sum_total += labels.size(0)                        #labelの数を足していくことでデータの総和を取る
        sum_correct += (predicted == labels).sum().item()  #予想位置と実際の正解を比べ,正解している数だけ足す
    print("train mean loss={}, accuracy={}"
            .format(sum_loss*BATCH_SIZE/len(trainloader.dataset), float(sum_correct/sum_total)))  #lossとaccuracy出力
    train_loss_value.append(sum_loss*BATCH_SIZE/len(trainloader.dataset))  #traindataのlossをグラフ描画のためにlistに保持
    train_acc_value.append(float(sum_correct/sum_total))   #traindataのaccuracyをグラフ描画のためにlistに保持

    sum_loss = 0.0
    sum_correct = 0
    sum_total = 0

    #test dataを使ってテストをする
    for (inputs, labels) in testloader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        sum_loss += loss.item()
        _, predicted = outputs.max(1)
        sum_total += labels.size(0)
        sum_correct += (predicted == labels).sum().item()
    print("test  mean loss={}, accuracy={}"
            .format(sum_loss*BATCH_SIZE/len(testloader.dataset), float(sum_correct/sum_total)))
    test_loss_value.append(sum_loss*BATCH_SIZE/len(testloader.dataset))
    test_acc_value.append(float(sum_correct/sum_total))

plt.figure(figsize=(6,6))      #グラフ描画用

#以下グラフ描画
plt.plot(range(EPOCH), train_loss_value)
plt.plot(range(EPOCH), test_loss_value, c='#00ff00')
plt.xlim(0, EPOCH)
plt.ylim(0, 2.5)
plt.xlabel('EPOCH')
plt.ylabel('LOSS')
plt.legend(['train loss', 'test loss'])
plt.title('loss')
plt.savefig("loss_image.png")
plt.clf()

plt.plot(range(EPOCH), train_acc_value)
plt.plot(range(EPOCH), test_acc_value, c='#00ff00')
plt.xlim(0, EPOCH)
plt.ylim(0, 1)
plt.xlabel('EPOCH')
plt.ylabel('ACCURACY')
plt.legend(['train acc', 'test acc'])
plt.title('accuracy')
plt.savefig("accuracy_image.png")
```

学習をするループ中とその前後に色々なものが追加されているが,それぞれグラフを出力したり実行中の結果を見たりするためのものである.

また,test時にtestloaderのみでなくtrainloaderも使用してtestを行っている(trainloaderが2回使われているが2つ目では更新がない).
どういうことかというと,学習時に使用した画像をもう一度ランダムに使用して精度がどれくらい出るかを見ているのである.
もちろんこのことからtestloaderの中の画像は学習では使用していない未知のデータという扱いである.

ところどころにある「**xxx.item()**」というのはtensor型のdataから通常のintやdoubleの数字として取り出している.
実際にグラフの結果を見ると以下のようなっている.
![accuracy_image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/32afb3a7-fa5c-3883-ccac-030301dcac1b.png)
![loss_image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/499474/84204b88-b1fa-3ae0-487e-964183fbe1d4.png)

lossが下がるにつれてaccuracy(分類精度)が向上しているのがわかる.
このネットワークで今回使ったパラメータだとMNISTでは分類精度97%くらいは出ることがわかった.


# 6. ひとこと
今回はPyTorchを使用してCNNを作成し,疑問に思ったことや少しずつ理解していく過程で分かったことなどを踏まえて徹底解説とさせて頂いた.
読みづらい点も多かったと思うが読んでいただきありがとうございます.