ニューラル ネットワーク モデルのトレーニング手順を完了する - CIFAR10 データセットを例として取り上げます (pytorch バージョン)

完全な手順

データセットの準備
DataLoader データセットの読み込み
ネットワーク モデルの構築
ネットワーク モデル インスタンスの作成
損失関数の定義
オプティマイザーの定義
ネットワーク トレーニング パラメーターの設定
トレーニングの開始
モデルの検証 モデル
の保存
トレーニング結果の視覚化 (テンソルボードを使用して完了)

データセットの紹介

        CIFAR10 は、ヒントンの学生である Alex Krizhevsky と Ilya Sutskever が普遍的な物体認識のために収集したコンピューター ビジョン データセットで、合計 10 のカテゴリー、60,000 枚の 32 X 32 RGB カラー画像が含まれています。そのうち、トレーニング セットには 50,000 枚の画像が使用され、テスト セットには 10,000 枚の画像が使用されます。

CIFAR10データセットの部分表示

CIFARモデルの構造 

CIFAR10モデルの構造

 完全なコード

CIFAR10 ネットワーク モデルの構造:

# model.py文件

# 搭建CIFAR10神经网络
import torch
from torch import nn


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平
            nn.Linear(1024, 64),  # 1024=64*4*4
            nn.Linear(64, 10)
        )

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

# 验证搭建的网络是否正确
if __name__ == '__main__':
    tudui = Tudui()
    input = torch.ones((64, 3, 32, 32))
    output = tudui(input)
    print(output.shape)

 CPUバージョンのトレーニングコード

# train.py文件
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *



# 准备数据集
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=False,
                                          transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=False,
                                         transform=torchvision.transforms.ToTensor())
# 观察训练数据集、测试数据集中的图像有多少张
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size)) # 训练数据集的长度为：50000
print("测试数据集的长度为：{}".format(test_data_size)) # 测试数据集的长度为：10000

# 使用dataloader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64) # 训练数据集加载
test_dataloader = DataLoader(test_data, batch_size=64)  # 测试数据集加载

# 创建网络模型
tudui = Tudui()

# 创建损失函数
# 分类问题采用交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()

# 设定优化器
learning_rate = 0.01 # 0.01=1e-2
# learning_rate = 1e-2
optimizer = torch.optim.SGD(params=tudui.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练轮数
epoch = 10

# 添加tensorboard

writer = SummaryWriter("./CIFAR10_train")
for i in range(epoch):
    print("———————第{}轮训练开始——————".format(i+1))

    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        optimizer.zero_grad() # 梯度清零
        loss.backward()
        optimizer.step()
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    # 测试步骤
    total_test_loss = 0
    total_accuracy_num = 0
    with torch.no_grad():
       for data in test_dataloader:
            imgs, targets = data
            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy_num = total_accuracy_num + accuracy

    print("整体测试集上的Loss：{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy_num/test_data_size))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar(("test_accuracy", (total_accuracy_num/test_data_size), total_test_step))
    total_test_step = total_test_step + 1

    # 保存每轮运行的模型
    torch.save(tudui, "tudui_{}.pth".format(i))
    print("模型已保存！")

writer.close()

GPU_1 バージョン

CPU版のネットワークモデル、データ、損失関数にcudaをインポートする方法です。
例:
ネットワーク モデルの場合: CPU バージョンでは、ネットワークをインスタンス化するときに tudui = Tudui() するだけで済みますが、GPU_1 バージョンでは、ネットワークをインスタンス化するときに tudui = Tudui() を tudui = Tudui に書き直す必要があります。クダ()。

データの場合: CPU バージョンでは、トレーニングとテストで使用するデータのみが必要です。

train_dataloader のデータの場合: # 训练
    imgs、ターゲット = データ
    出力 = tudui(imgs)

test_dataloader のデータの場合: # 测试
     imgs、ターゲット = データ
     出力 = tudui(imgs)

以上です。GPU_1 バージョンでは次のようになります。

train_dataloader のデータの場合: # 训练
    imgs, target = data 
    # GPU の使用
    imgs = imgs.cuda() 
    target = target.cuda() 
    Outputs = tudui(imgs)

test_dataloader のデータの場合: # 测试
     imgs, Targets = data 
     # GPU の使用
     imgs = imgs.cuda() 
     Targets = Targets.cuda() 
     Outputs = tudui(imgs)

損失関数の場合: CPU バージョンでは、使用する損失関数は必要なものだけです。

#損失関数の作成
# 分類問題ではクロスエントロピー損失関数を使用します
loss_fn = nn.CrossEntropyLoss()

以上です。GPU_1 バージョンには次のものがあります。

#損失関数を作成する
#分類問題はクロスエントロピー損失関数を使用します
loss_fn = nn.CrossEntropyLoss() 
loss_fn = loss_fn.cuda() #GPUを使用する

GPU_1 バージョンのトレーニング コード

# train_GPU_1.py文件
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 准备数据集
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=False,
                                          transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=False,
                                         transform=torchvision.transforms.ToTensor())
# 观察训练数据集、测试数据集中的图像有多少张
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size)) # 训练数据集的长度为：50000
print("测试数据集的长度为：{}".format(test_data_size)) # 测试数据集的长度为：10000

# 使用dataloader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64) # 训练数据集加载
test_dataloader = DataLoader(test_data, batch_size=64)  # 测试数据集加载

# 创建网络模型
# 搭建CIFAR10神经网络
import torch
from torch import nn


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平
            nn.Linear(1024, 64),  # 1024=64*4*4
            nn.Linear(64, 10)
        )

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


tudui = Tudui()
tudui = tudui.cuda() # 使用GPU

# 创建损失函数
# 分类问题采用交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.cuda() # 使用GPU
# 设定优化器
learning_rate = 0.01 # 0.01=1e-2
# learning_rate = 1e-2
optimizer = torch.optim.SGD(params=tudui.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练轮数
epoch = 10

# 添加tensorboard

writer = SummaryWriter("./CIFAR10_train")
for i in range(epoch):
    print("———————第{}轮训练开始——————".format(i+1))

    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        # 使用GPU
        imgs = imgs.cuda()
        targets = targets.cuda()
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        optimizer.zero_grad() # 梯度清零
        loss.backward()
        optimizer.step()
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    # 测试步骤
    total_test_loss = 0
    total_accuracy_num = 0
    with torch.no_grad():
       for data in test_dataloader:
            imgs, targets = data
            # 使用GPU
            imgs = imgs.cuda()
            targets = targets.cuda()

            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy_num = total_accuracy_num + accuracy

    print("整体测试集上的Loss：{}".format(total_test_loss))
    test_accuracy = total_accuracy_num/test_data_size # 测试准确率
    print("整体测试集上的正确率：{}".format(test_accuracy))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", test_accuracy, total_test_step)
    total_test_step = total_test_step + 1

    # 保存每轮运行的模型
    torch.save(tudui, "tudui_{}.pth".format(i))
    print("模型已保存！")

writer.close()

GPU_2 バージョン

CPU版のネットワークモデル、データ、損失関数にto.(device)メソッドを使用する方法です。
例:
    まず、デバイス、つまり device = torch.device("cpu") (CPU バージョン) または device = torch.device("cuda") (GPU バージョン) を定義する必要があります。

ネットワーク モデルの場合: CPU バージョンでは、tudui = Tudui() でネットワークをインスタンス化するだけで済みますが、GPU_2 バージョンでは、ネットワークをインスタンス化するときに tudui = Tudui() を書き換える必要があります。

tudui = Tudui() 
tudui.to(device)# GPU を使用する

データの場合: CPU バージョンでは、トレーニングとテストで使用するデータのみが必要です。

train_dataloader のデータの場合: # 训练
    imgs、ターゲット = データ
    出力 = tudui(imgs)

test_dataloader のデータの場合: # 测试
     imgs、ターゲット = データ
     出力 = tudui(imgs)

GPU_2 バージョンでは次のようになります。

train_dataloader のデータの場合: # 训练
    imgs, target = data 
    # GPU の使用
    imgs = imgs.to(device) 
    target = target.to(device) 
    Outputs = tudui(imgs)

test_dataloader のデータの場合: # 测试
     imgs, target = data 
     # GPU の使用
     imgs = imgs.to(device) 
     target = target.to(device) 
     Outputs = tudui(imgs)

損失関数の場合: CPU バージョンでは、使用する損失関数は必要なものだけです。

#損失関数の作成
# 分類問題ではクロスエントロピー損失関数を使用します
loss_fn = nn.CrossEntropyLoss()

以上です。GPU_2 バージョンには次のものがあります。

# 損失関数を作成します
# 分類問題はクロスエントロピー損失関数を使用します
loss_fn = nn.CrossEntropyLoss() 
loss_fn.to(device) # GPU を使用します

GPU_2 バージョンのトレーニング コード

# train_GPU_2.py文件
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

device = torch.device("cuda") # 定义训练设备

# 准备数据集
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=False,
                                          transform=torchvision.transforms.ToTensor())
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=False,
                                         transform=torchvision.transforms.ToTensor())
# 观察训练数据集、测试数据集中的图像有多少张
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size)) # 训练数据集的长度为：50000
print("测试数据集的长度为：{}".format(test_data_size)) # 测试数据集的长度为：10000

# 使用dataloader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64) # 训练数据集加载
test_dataloader = DataLoader(test_data, batch_size=64)  # 测试数据集加载

# 创建网络模型
# 搭建CIFAR10神经网络
import torch
from torch import nn


class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平
            nn.Linear(1024, 64),  # 1024=64*4*4
            nn.Linear(64, 10)
        )

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


tudui = Tudui()
tudui.to(device)# 使用GPU

# 创建损失函数
# 分类问题采用交叉熵损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn.to(device) # 使用GPU
# 设定优化器
learning_rate = 0.01 # 0.01=1e-2
# learning_rate = 1e-2
optimizer = torch.optim.SGD(params=tudui.parameters(), lr=learning_rate)

# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练轮数
epoch = 10

# 添加tensorboard

writer = SummaryWriter("./CIFAR10_train")
for i in range(epoch):
    print("———————第{}轮训练开始——————".format(i+1))

    # 训练步骤开始
    for data in train_dataloader:
        imgs, targets = data
        # 使用GPU
        imgs = imgs.to(device)
        targets = targets.to(device)
        outputs = tudui(imgs)
        loss = loss_fn(outputs, targets)
        # 优化器优化模型
        optimizer.zero_grad() # 梯度清零
        loss.backward()
        optimizer.step()
        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    # 测试步骤
    total_test_loss = 0
    total_accuracy_num = 0
    with torch.no_grad():
       for data in test_dataloader:
            imgs, targets = data
            # 使用GPU
            imgs = imgs.to(device)
            targets = targets.to(device)

            outputs = tudui(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss = total_test_loss + loss
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy_num = total_accuracy_num + accuracy

    print("整体测试集上的Loss：{}".format(total_test_loss))
    test_accuracy = total_accuracy_num/test_data_size # 测试准确率
    print("整体测试集上的正确率：{}".format(test_accuracy))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", test_accuracy, total_test_step)
    total_test_step = total_test_step + 1

    # 保存每轮运行的模型
    torch.save(tudui, "tudui_{}.pth".format(i))
    print("模型已保存！")

writer.close()

テンソルボードに基づく結果の視覚化

        GPU バージョンのコード (モード 1 と 2 の両方が利用可能) を使用して、テンソルボード視覚化トレーニング プロセスとテスト結果を完了します。
        コードを実行すると、プロジェクト フォルダーに CIFAR10_train フォルダーが作成されます。

このコードのおかげです! ！Writer = SummaryWriter("./CIFAR10_train")

        ターミナルでコマンド tensorboard --logdir=CIFAR10_train を実行し、URL: http://localhost:6006/ を取得して、URL を開きます。

以下の図に示すように、視覚化の結果を取得します。 

テンソルボードのビジュアルインターフェイス

 ネットワーク モデルの学習損失を取得する

トレーニングセット上のモデルの損失

テストセット上のモデルの損失

テストセット上のモデルの精度

上記の結果は、10 ラウンドのモデル トレーニングの結果です。 

実際の戦闘を予測する

        トレーニングされたモデルをランダムな画像でテストして、どのように機能するかを確認してみましょう。
        トレーニング データ セットでネットワークを 30 ラウンドトレーニングしたところ、30 ラウンドでトレーニングされたモデルの方が優れていることがわかり、テスト セットでのモデルの正解率は 64.56% に達したため、30 ラウンドのモデルを使用しました。ランダムな写真を確認します。

ラウンドごとにモデルをトレーニングします (合計 30 ラウンド)

        以下の図に示すように、インターネットから犬の写真、飛行機の写真、猫の写真をランダムに選択します。

犬

飛行機

猫

 

 以下の図に示すように、これら 3 つのイメージをプロジェクト フォルダーのイメージ フォルダーに保存します。

これら 3 つの画像を pycharm で表示します。 

 

10 カテゴリのグラウンド トゥルース ラベル。

犬のコードを確認する 

import torch
import torchvision.transforms
from PIL import Image
from torch import nn

img_path = "./images/dog.png" # .表示当前目录
image = Image.open(img_path)
# print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=405x303 at 0x2834CC62F48>

image = image.convert("RGB") # 该代码的作用：
# 因为png格式的图片是四个通道，除了RGB三通道外，还有一个透明度通道。
# 所以我们调用image = image.convert("RGB")，保留其颜色通道。

# print(image) # <PIL.Image.Image image mode=RGB size=405x303 at 0x2834CD7AB88>

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])
image = transform(image)
# print(image.size)

# CIFAR10网络模型结构
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平
            nn.Linear(1024, 64),  # 1024=64*4*4
            nn.Linear(64, 10)
        )

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

# 加载网络模型参数
model = torch.load("tudui_29.pth", map_location=torch.device("cpu"))
# map_location=torch.device("cpu") 将GPU版本的模型对应到CPU上
# print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
    output = model(image)
print(output) # tensor([[ -3.3239,  -5.6744,   5.5848,   3.1388,   4.8541,  13.1417,  -3.0066,  4.5897, -14.3501,  -7.2900]])
print(output.argmax(1)) # tensor([5]) 标签5对应的是狗

検証成功！ 

 飛行機のコードを確認する

import torch
import torchvision.transforms
from PIL import Image
from torch import nn

img_path = "./images/plane.png" # .表示当前目录
image = Image.open(img_path)
# print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=405x303 at 0x2834CC62F48>

image = image.convert("RGB") # 该代码的作用：
# 因为png格式的图片是四个通道，除了RGB三通道外，还有一个透明度通道。
# 所以我们调用image = image.convert("RGB")，保留其颜色通道。

# print(image) # <PIL.Image.Image image mode=RGB size=405x303 at 0x2834CD7AB88>

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])
image = transform(image)
# print(image.size)

# CIFAR10网络模型结构
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平
            nn.Linear(1024, 64),  # 1024=64*4*4
            nn.Linear(64, 10)
        )

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

# 加载网络模型参数
model = torch.load("tudui_29.pth", map_location=torch.device("cpu"))
# map_location=torch.device("cpu") 将GPU版本的模型对应到CPU上
# print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
    output = model(image)
print(output) # tensor([[10.6781, -2.0109,  4.5609,  1.3858, -1.3748, -1.3599,  3.4883, -7.2311,  -3.5088, -3.3030]])
print(output.argmax(1)) # tensor([0]) 标签0对应的是飞机

検証成功！

catのコードを確認する

import torch
import torchvision.transforms
from PIL import Image
from torch import nn

img_path = "./images/cat.png" # .表示当前目录
image = Image.open(img_path)
# print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=405x303 at 0x2834CC62F48>

image = image.convert("RGB") # 该代码的作用：
# 因为png格式的图片是四个通道，除了RGB三通道外，还有一个透明度通道。
# 所以我们调用image = image.convert("RGB")，保留其颜色通道。

# print(image) # <PIL.Image.Image image mode=RGB size=405x303 at 0x2834CD7AB88>

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])
image = transform(image)
# print(image.size)

# CIFAR10网络模型结构
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平
            nn.Linear(1024, 64),  # 1024=64*4*4
            nn.Linear(64, 10)
        )

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

# 加载网络模型参数
model = torch.load("tudui_29.pth", map_location=torch.device("cpu"))
# map_location=torch.device("cpu") 将GPU版本的模型对应到CPU上
# print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
    output = model(image)
print(output) # tensor([[-1.4196, -5.0211,  1.2063,  4.8532, -2.0156,  2.7169,  0.4598,  0.5168,  -0.3567, -0.8418]])
print(output.argmax(1)) # tensor([3]) 标签3对应的是猫

検証成功！

        テスト セットで 30 ラウンドトレーニングされたモデルの正解率はわずか 64.56% ですが、ランダムな検証を通じて、モデルの効果が依然として非常に優れていることがわかります。私たちは 3 枚の写真だけを確認しましたが、もちろん、さらに多くの写真を確認することもできます。