【LINEbot】Pythonで女優識別botを作ろう Part4【モデル構築編】

こんにちは！

「女優識別botを作ろう」の第４回目となる今回は、いよいよモデル構築に関して解説していきます。

確認ですが、今回は、画像収集・モデル入力用データに加工済みという前提で進めていきます。

今回の内容

モデル構築
転移学習

第3回目の記事はこちら。

>>【LINEbot】Pythonで女優識別botを作ろう Part3【入力用データ作成編】

では、さっそく見ていきましょう。

今回使うモデル紹介

今回、自作したデータセットを学習させるために、転移学習を行います。

転移学習を知らない人のために簡単に説明すると、転移学習は、ある分野ですでに学習済みのモデルを別の分野で活用することによって、学習時間を大幅に減らしつつ高い精度のモデルを作れる、というものです。

詳しくは、転移学習とは【数式無し】をご覧ください。

自分で層を何層も重ねてモデルを作ってもいいのですが、これだと精度がうまく上がらない可能性が高いので、今回は転移学習を行います。

調べるといろんなモデルが出てくるのですが、特に有名なものを挙げると、VGGやResNetなどがあります。

今回は、VGG16というモデルで転移学習を行います。

では、次の章でコードを紹介します。

モデル学習用コード

モデル学習用のコードはこちらになります。

# ライブラリのインポート
import pickle
import numpy as np

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.models as models
import pytorch_lightning as pl
from pytorch_lightning import Trainer


# データセットの読み込み
PATH = "./datasets/datasets.pl"   # 作成したデータセットのオブジェクトを格納しているフォルダのパス

# データセットの非pickle化
with open(PATH, "rb") as f:
    datasets = pickle.load(f)

datasets = torch.utils.data.TensorDataset(datasets[0], datasets[1])
N_train = int(len(datasets) * 0.8)   # 8割を学習用に使用
N_val = int(len(datasets)) - N_train   # 2割を検証用に使用

# データの分割
train, val = torch.utils.data.random_split(datasets, [N_train, N_val])


# 学習用クラス
class TrainNet(pl.LightningModule):
    @pl.data_loader
    def train_dataloader(self):
        return torch.utils.data.DataLoader(train, self.batch_size, shuffle=True)

    def training_step(self, batch, batch_nb):
        x, t = batch
        y = self.forward(x)
        y_label = torch.argmax(y, dim=1)
        acc = torch.sum(y_label == t, dtype=torch.float32) / len(t)
        loss = F.cross_entropy(y, t)
        results = {"loss": loss, "acc": acc}
        return results


# 検証用クラス
class ValidationNet(pl.LightningModule):
    @pl.data_loader
    def val_dataloader(self):
        return torch.utils.data.DataLoader(val, self.batch_size)

    def validation_step(self, batch, batch_nb):
        x, t = batch
        y = self.forward(x)
        loss = F.cross_entropy(y, t)
        y_label = torch.argmax(y, dim=1)
        acc = torch.sum(y_label == t, dtype=torch.float32) / len(t)
        results = {"val_loss": loss, "val_acc": acc}
        return results

    def validation_end(self, outputs):
        avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean()
        avg_acc = torch.stack([x["val_acc"] for x in outputs]).mean()
        results = {"val_loss": avg_loss, "val_acc": avg_acc}
        print(f"val_loss: {avg_loss:.3f}, val_acc: {avg_acc:.3f}")
        return results

# メインクラス
class Net(TrainNet, ValidationNet):
    def __init__(self, batch_size=256):
        super(Net, self).__init__()
        self.batch_size = batch_size

        # 転移学習に使用する vgg16 の読み込み
        self.model = models.vgg16(pretrained=True)

        # 追加する層の宣言
        self.classifier = nn.Linear(1000, 5)

        for i, param in enumerate(self.model.parameters()):
            # 学習済みパラメータの一部を固定
            if i < 18:
                param.requires_grad = False
            else:
                param.requires_grad = True

    def configure_optimizers(self):
        optimizer = torch.optim.Adam(self.parameters(), lr=7.5e-4, weight_decay=1e-5)
        return optimizer

    def forward(self, x):
        x = self.model(x)
        x = self.classifier(x)
        return x


def main():
    # 再現性の確保
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False
    torch.manual_seed(0)
    np.random.seed(0)
    torch.cuda.manual_seed(0)

    # モデルの定義
    net = Net(batch_size=128)  # バッチサイズは128
    trainer = Trainer(gpus=1, max_nb_epochs=50, early_stop_callback=True)

    # 学習
    trainer.fit(net)

    # 精度の確認
    print(trainer.callback_metrics)

    # 学習済みモデルのパラメータの保存
    torch.save(net.state_dict(), "./model.pt")


if __name__ == "__main__":
    main()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

# ライブラリのインポート

import pickle

import numpy as np

import torch

import torch.nn as nn

import torch.nn.functional as F

import torchvision.models as models

import pytorch_lightning as pl

from pytorch_lightning import Trainer

# データセットの読み込み

PATH = "./datasets/datasets.pl" # 作成したデータセットのオブジェクトを格納しているフォルダのパス

# データセットの非pickle化

with open(PATH, "rb") as f:

datasets = pickle.load(f)

datasets = torch.utils.data.TensorDataset(datasets[0], datasets[1])

N_train = int(len(datasets) * 0.8) # 8割を学習用に使用

N_val = int(len(datasets)) - N_train # 2割を検証用に使用

# データの分割

train, val = torch.utils.data.random_split(datasets, [N_train, N_val])

# 学習用クラス

class TrainNet(pl.LightningModule):

@pl.data_loader

def train_dataloader(self):

return torch.utils.data.DataLoader(train, self.batch_size, shuffle=True)

def training_step(self, batch, batch_nb):

x, t = batch

y = self.forward(x)

y_label = torch.argmax(y, dim=1)

acc = torch.sum(y_label == t, dtype=torch.float32) / len(t)

loss = F.cross_entropy(y, t)

results = {"loss": loss, "acc": acc}

return results

# 検証用クラス

class ValidationNet(pl.LightningModule):

@pl.data_loader

def val_dataloader(self):

return torch.utils.data.DataLoader(val, self.batch_size)

def validation_step(self, batch, batch_nb):

x, t = batch

y = self.forward(x)

loss = F.cross_entropy(y, t)

y_label = torch.argmax(y, dim=1)

acc = torch.sum(y_label == t, dtype=torch.float32) / len(t)

results = {"val_loss": loss, "val_acc": acc}

return results

def validation_end(self, outputs):

avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean()

avg_acc = torch.stack([x["val_acc"] for x in outputs]).mean()

results = {"val_loss": avg_loss, "val_acc": avg_acc}

print(f"val_loss: {avg_loss:.3f}, val_acc: {avg_acc:.3f}")

return results

# メインクラス

class Net(TrainNet, ValidationNet):

def __init__(self, batch_size=256):

super(Net, self).__init__()

self.batch_size = batch_size

# 転移学習に使用する vgg16 の読み込み

self.model = models.vgg16(pretrained=True)

# 追加する層の宣言

self.classifier = nn.Linear(1000, 5)

for i, param in enumerate(self.model.parameters()):

# 学習済みパラメータの一部を固定

if i < 18:

param.requires_grad = False

else:

param.requires_grad = True

def configure_optimizers(self):

optimizer = torch.optim.Adam(self.parameters(), lr=7.5e-4, weight_decay=1e-5)

return optimizer

def forward(self, x):

x = self.model(x)

x = self.classifier(x)

return x

def main():

# 再現性の確保

torch.backends.cudnn.deterministic = True

torch.backends.cudnn.benchmark = False

torch.manual_seed(0)

np.random.seed(0)

torch.cuda.manual_seed(0)

# モデルの定義

net = Net(batch_size=128) # バッチサイズは128

trainer = Trainer(gpus=1, max_nb_epochs=50, early_stop_callback=True)

# 学習

trainer.fit(net)

# 精度の確認

print(trainer.callback_metrics)

# 学習済みモデルのパラメータの保存

torch.save(net.state_dict(), "./model.pt")

if __name__ == "__main__":

main()

かなり長々とした印象を受ける方もいるかもしれませんが、大部分が PyTorch Lightning の基本的なコードですので、少しずつ理解してみてください。

記事の最後の方に、PyTorchの使い方を一通りマスターできるサイトを紹介しているので、そちらで先に勉強してみることもおすすめです。

主な流れは PyTorch Lightning で共通しているため、ここではモデル学習部分のみに焦点を当てて解説します。

まず、最初の13~25行目までの部分で、前回の記事で作成したデータセットを入力用データとして読み込んでいます。

# データセットの読み込み
PATH = "./datasets/datasets.pl"   # 作成したデータセットのオブジェクトを格納しているフォルダのパス
 
# データセットの非pickle化
with open(PATH, "rb") as f:
    datasets = pickle.load(f)
 
datasets = torch.utils.data.TensorDataset(datasets[0], datasets[1])
N_train = int(len(datasets) * 0.8)   # 8割を学習用に使用
N_val = int(len(datasets)) - N_train   # 2割を検証用に使用
 
# データの分割
train, val = torch.utils.data.random_split(datasets, [N_train, N_val])

# データセットの読み込み

PATH = "./datasets/datasets.pl" # 作成したデータセットのオブジェクトを格納しているフォルダのパス

# データセットの非pickle化

with open(PATH, "rb") as f:

datasets = pickle.load(f)

datasets = torch.utils.data.TensorDataset(datasets[0], datasets[1])

N_train = int(len(datasets) * 0.8) # 8割を学習用に使用

N_val = int(len(datasets)) - N_train # 2割を検証用に使用

# データの分割

train, val = torch.utils.data.random_split(datasets, [N_train, N_val])

PATH には前回作成した、 model.pt のパスを指定します。

そのすぐ下の部分でデータを読み込み、21~25行目のところでデータを学習用と検証用に分割しています。

では、次に実際にモデルを定義している部分を見てみます。

モデル定義は Net クラスの中の72~76行目で行っています。

        # 転移学習に使用する vgg16 の読み込み
        self.model = models.vgg16(pretrained=True)
 
        # 追加する層の宣言
        self.classifier = nn.Linear(1000, 5)

# 転移学習に使用する vgg16 の読み込み

self.model = models.vgg16(pretrained=True)

# 追加する層の宣言

self.classifier = nn.Linear(1000, 5)

73行目の self.model に、転移学習に使用するモデルを入力します。

ちなみに、転移学習に使用できるモデルは、 torchvision.models に格納されているので、興味があればいろいろ試してみてください。

76行目では、転移学習に使用するモデルに追加する層を定義しています。

これは、元のモデルが1000クラス分類用のモデルであるため、出力結果を女優の人数分にするために追加しています。

78~83行目では、パラメータの一部を再学習するように設定しています。

        for i, param in enumerate(self.model.parameters()):
            # 学習済みパラメータの一部を固定
            if i < 18:
                param.requires_grad = False
            else:
                param.requires_grad = True

for i, param in enumerate(self.model.parameters()):

# 学習済みパラメータの一部を固定

if i < 18:

param.requires_grad = False

else:

param.requires_grad = True

というのも、転移学習では、別の分野で学習したモデルを使うわけですが、その際に学習済みのパラメータを使わなければほとんど恩恵を受けません。

画像認識モデルでは、はじめの層付近では大抵の場合、どんな分野であっても共通した特徴を抽出することが知られています。

そのため、なるべく学習済みパラメータをそのまま使いつつ、後半部分だけを再学習させることが一般的です。

それほど、膨大な量のパラメータがあるため、どこまで再学習させるかを明示的に示す必要があるというわけです。

デフォルトでは、すべてのパラメータが再学習する設定になっているので、上で紹介したコードで後半部分のみを再学習させるように、 param.requires_grad = True として設定し直しています。

学習し終わった後、114行目でパラメータを保存しています。

    # 学習済みモデルのパラメータの保存
    torch.save(net.state_dict(), "./model.pt")

113

114

# 学習済みモデルのパラメータの保存

torch.save(net.state_dict(), "./model.pt")

ちなみに、今回紹介したコードは、CPUで実行するとめちゃくちゃ時間がかかるので、必ずGoogle colabratoryを使用してください。

使用する際はランタイムをGPUに切り替えることを忘れずに！

おわりに

今回までで、画像収集、データセット作り、モデル構築までの作業がすべて終わりました。

次回から、このモデルをLINEbotに組み込むところを解説するのですが、ぶっちゃけそこはちょっとした応用になるだけなので、メイン部分は今回で終了といった感じになりますね。

ただ、学習モデルをどのように予測用として扱うのかを解説していないので、気になる方は次回も見ていただけるとありがたいです。

では、今回はここまでとします。

お疲れさまでした。

追記：第５回を更新しました。

>>【LINEbot】Pythonで女優識別botを作ろう Part5【Bot作成編】

PyTorchの扱い方が一通り学べるサイトはこちら