深層学習 - 畳み込みニューラル ネットワーク

畳み込みニューラル ネットワーク 

従来、多層ニューラル ネットワークには、入力層、非表示層、および出力層のみが含まれていました。隠れ層の数は必要に応じて異なり、適切な層の数を説明する明確な理論的導出はありません。

畳み込みニューラル ネットワーク CNN は、元の多層ニューラル ネットワークに基づいて、より効果的な特徴学習部分を追加しました. 具体的な操作は、元の全結合層の前に畳み込み層とプーリング層を追加することです. 畳み込みニューラル ネットワークの出現により、ニューラル ネットワークの層数が深まり、「深い」学習はこれから生まれます。

畳み込みニューラル ネットワークの構造

ニューラルネットワークの基本構成は入力層、隠れ層、出力層であり、畳み込みニューラルネットワークは隠れ層が畳み込み層、プーリング層（ダウンサンプリング層とも呼ばれる）に分かれているのが特徴です。そして活性化層。

• 畳み込み層: 元の画像を変換して特徴を抽出します
• 活性化層: 非線形セグメンテーション能力を高める
• プーリング層: 学習のパラメーターを減らし、ネットワークの複雑さを軽減します (最大プーリングと平均プーリング)

分類効果を達成するために、損失計算を実行して分類結果を出力するための最終出力層である完全接続層 (Full Connection) もあります。

畳み込み層

畳み込みニューラル ネットワークの各畳み込み層は、いくつかの畳み込みユニット (畳み込みカーネル) で構成され、各畳み込みユニットのパラメーターは逆伝播アルゴリズムによって最適化されます。

畳み込み操作の目的は特徴抽出です. 最初の畳み込み層は, エッジ, ライン, コーナーなどのいくつかの低レベルの特徴のみを抽出できます. ネットワークのより多くの層は, 低レベルの特徴からより複雑な特徴を繰り返し抽出できます.

畳み込みカーネルの 4 つの要素 (フィルターはフィルターとも呼ばれます)

• 畳み込みカーネル サイズ
• 畳み込みカーネルのステップ サイズ
• 畳み込みカーネルの数
• 畳み込みカーネルのゼロ パディング サイズ

チャネル数が 1 の場合は一般にコンボリューション カーネルと呼ばれ、チャネル数が 1 より大きい場合は一般にフィルタと呼ばれます。

畳み込みカーネルの計算

畳み込みカーネルは、特徴の重み付け操作を実行するために、いくつかの重みとバイアスで観察するオブザーバーとして理解できます。

注: 一般的に使用される畳み込みカーネルのサイズは、1*1、3*3、5*5 です。

画像を観察するにはパンする必要があり、必要なパラメーターはstep sizeです。

動きのステップ サイズが 1 ピクセルであると仮定すると、この人物の最終的な観察結果は次のようになります。

移動ステップ サイズが 2 の場合、結果は次のようになります。

ある層構造において、一人だけでなく複数の人（畳み込みカーネル）が一緒に観察すると、複数の観察結果が得られます。

• 異なる畳み込みカーネルの重みとバイアスは異なります。つまり、ランダムな初期化のパラメーターです。 

さらに、出力結果のサイズはサイズとステップ サイズによって決まり、ゼロ パディングもあります。フィルター観察ウィンドウのサイズと移動ステップにより、画像のピクセル幅を超える場合があるためです。

ゼロ パディングは、画像のピクセルの周囲のピクセルを値 0 で埋めることであり、埋められる円の数は実際の状況によって異なります。

畳み込みカーネルの計算コード例: 

import torch
import torch.nn.functional as F

# Input表示输入的图像颜色值
Input = torch.tensor([[23, 12, 220, 43, 2],
                      [45, 57, 25, 122, 91],
                      [189, 15, 149, 222, 76],
                      [12, 35, 57, 29, 20],
                      [4, 34, 65, 8, 18]])
# kernel表示卷积核
kernel = torch.tensor([[2.1, 0.7, 1.0],
                       [1.3, 1.2, 3.0],
                       [2.8, 0.3, 0.9]])
# 要转换成conv卷积接受的参数的维度形式，batch_size可以看作是一次训练有几张图片，这里一个矩阵故为1，而这里是灰度图片故channel也为1
Input = torch.reshape(Input, (1, 1, 5, 5)).float()  # 默认是long要转成float，变成batch_size=1,channel=1，高H=5，宽W=5
kernel = torch.reshape(kernel, (1, 1, 3, 3)).float()

output = F.conv2d(Input, kernel, stride=1)  # conv2d表示二维卷积（图像就是二维矩阵），stride=1表示步长为1
print(output)

output2 = F.conv2d(Input, kernel, stride=2)  # 表示步长为2（默认是为1）
print(output2)

output3 = F.conv2d(Input, kernel, stride=1, padding=1)  # 表示步长为1且零填充了一圈（padding默认为0）
print(output3)

ニューラル ネットワークのコード例:

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 下载CIFAR10数据集中的测试集（因为训练集太大了），转化为tensor格式存在同路径的pytorch_data文件下
dataset = torchvision.datasets.CIFAR10("pytorch_data", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)  # 设置一组图片的数量为64


class Mynn(nn.Module):
    def __init__(self):  # 构造函数
        super(Mynn, self).__init__()  # 调用父类构造函数进行初始化
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):  # 前向传播
        x = self.conv1(x)
        return x


mynn = Mynn()

writer = SummaryWriter("logs")  # 将训练的中间过程的结果可视化（存在文件logs）

step = 0
for data in dataloader:
    imgs, targets = data
    output = mynn(imgs)
    # print(imgs.shape)
    # print(output.shape)

    # torch.Size([64, 3, 32, 32])
    writer.add_images("input", imgs, step)
    # torch.Size([64, 6, 30, 30])  -> [xxx, 3, 30, 30]
    output = torch.reshape(output, (-1, 3, 30, 30))  # batch_size根据后面channel、H、W的值推出，故这里的-1是占位符
    writer.add_images("output", output, step)

    step = step + 1

writer.close()

ディレクトリ ターミナルにtensorboard --logdir=logsと入力し(ここではファイル名が logs なので、=logs と記述します)、http://localhost:6006/ を開いて可視化を表示します。

ここで、速度を上げるために、torchboard はデフォルトでいくつかのグループ (ステップ) の画像結果のみを表示します。これは tensorboard --logdir=logs --samples_per_plugin=images=1000 として書き換えてすべての画像を表示できます。1000は表示する写真の数、大きく書いたほうがいいです。

開いた後、convolution conv 処理後の結果を確認できます: (画像は 8*8=64 のグループであることがわかります)

出力サイズの計算式 

注: D は、D1 などのチャネル数です。画像がカラー、つまり RGB タイプの場合、チャネル数は 3 に固定され、グレーの場合、チャネル数は 1 に固定されます。

マルチチャンネル画像の観察 

カラー写真だとR、G、Bの3つのテーブルがあります。本来は3*3程度のサイズの畳み込みカーネルを1人1つ持っていく必要がありますが、今は3*3の重みとバイアスを3つ持っていく必要があり、合計27個のウェイト。最終的には、全員が結果を出すことができました。

通道 channel

チャネル数は、深度次のいずれかとして理解できます。层数

たとえば、 カラー画像は、3 層の画像を重ね合わせることによって生成されます。

下図のフィルタの層数（3×3×3）も3  （幅×高さ×チャンネル数）

フィルターの数 = 特徴マップの数(特徴マップの数は、出力画像の数、つまり出力チャネル out_channel の数です) 

畳み込みの後に生成されたグラフが呼び出され特征图 (元の画像の特徴を抽出)、フィルターによって特徴マップを生成できます。

活性化機能 

ニューラルネットワークの発展に伴い、本来のシグモイドなどの活性化関数ではうまくいかないことがわかったため、新しい活性化関数を採用しました。

履歴書

ReluAdvantages

• 勾配消失の問題を効果的に解決します。
• 計算速度は非常に速く、SGD (バッチ勾配降下法) の解速度はシグモイドや tanh よりもはるかに高速です。

シグモイドの欠点

• 計算量が多く、逆伝播時に勾配が消失しやすい。

アクティベーション関数のサンプル コード:

import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("pytorch_data", train=False, download=True,
                                       transform=torchvision.transforms.ToTensor())

dataloader = DataLoader(dataset, batch_size=64)


class Mynn(nn.Module):
    def __init__(self):
        super(Mynn, self).__init__()
        # self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()  # 因为这个数据集的数都是非负的relu没用，所以就用sigmoid示例了

    def forward(self, input):
        output = self.sigmoid1(input)
        return output


mynn = Mynn()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, global_step=step)
    output = mynn(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()

プーリング層 (ポーリング) 

注: たとえば、右側の 4 つのピンク色のセル (つまり、4 つのピクセル) にはピクセル 1、1、5、および 6 があるため、最大値は 6 です。 

最大プーリングのコード例:

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("./pytorch_data", train=False, download=True,
                                       transform=torchvision.transforms.ToTensor())  # ./也表示同级目录

dataloader = DataLoader(dataset, batch_size=64)


class Mynn(nn.Module):
    def __init__(self):
        super(Mynn, self).__init__()
        # 默认的步长就是卷积核大小，比如这里的默认步长就是3，ceil_mode表示移动窗口超出图片外的时侯是否对图片内窗口包含的矩阵取最大值，默认为false
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False)

    def forward(self, input):
        output = self.maxpool1(input)
        return output


mynn = Mynn()

writer = SummaryWriter("./logs")
step = 0

for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = mynn(imgs)
    writer.add_images("output", output, step)
    step = step + 1

writer.close()

プーリング後、ビデオの占有スペースを 1080p から 720p に減らすのと同様に、画像がぼやけることがわかります。

全結合層 (全結合)

前の畳み込みとプーリングは特徴量エンジニアリングと同等であり、最後の完全に接続された層はニューラル ネットワーク全体で「分類器」として機能します。

モデル パラメーターの調整

オプティマイザのサンプル コード:

import torch
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10("pytorch_data", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)

dataloader = DataLoader(dataset, batch_size=1)


class Mynn(nn.Module):
    def __init__(self):
        super(Mynn, self).__init__()
        self.model1 = Sequential(  # 将一系列网络层放在Sequential序列里，代码更简洁
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),  # 将数据展平成一行
            Linear(1024, 64),  # 线性层
            Linear(64, 10)
        )

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


loss = nn.CrossEntropyLoss()
mynn = Mynn()
optim = torch.optim.SGD(mynn.parameters(), lr=0.01)  # SGD为随机梯度下降，lr为学习率
for epoch in range(20):  # 表示20次训练
    running_loss = 0.0
    for data in dataloader:
        imgs, targets = data
        outputs = mynn(imgs)
        result_loss = loss(outputs, targets)
        optim.zero_grad()  # 将优化器梯度清零
        result_loss.backward()  # 反向传播，通过损失去调参数的权重以达到更小的损失
        optim.step()  # 将优化器的参数调优
        running_loss = running_loss + result_loss
    print(running_loss)  # 每轮训练后的总损失

既存のネットワーク モデルの使用と変更 

vgg16 分類モデルのコード例:

import torchvision
from torch import nn
from torchvision.models import VGG16_Weights

vgg16_false = torchvision.models.vgg16(weights=None)  # vgg16是分类模型，weights是权重参数
vgg16_true = torchvision.models.vgg16(weights=VGG16_Weights.DEFAULT)  # 表示是已经经过预训练的模型（DEFAULT表示使用默认的权重参数），表现的会比较好点

print(vgg16_true)

train_data = torchvision.datasets.CIFAR10('pytorch_data', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)

vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))  # 表示在classifier里添加一个线性层
print(vgg16_true)

print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)  # 表示将classifier里编号6这个层修改成nn.Linear(4096, 10)
print(vgg16_false)

注:たとえば、nn.Linear(1000, 10) のようなモデルのパラメーターを記述する場合、カーソルを括弧内に置き、Ctrl+p を押してパラメーター プロンプトを表示できます。

ネットワーク モデルの保存と読み込み 

保存：

import torch
import torchvision
from torch import nn

vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1,模型结构+模型参数
torch.save(vgg16, "vgg16_method1.pth")  # vgg16_method1.pth为保存的文件名，后缀一般为pth

# 保存方式2，模型参数（官方推荐）
torch.save(vgg16.state_dict(), "vgg16_method2.pth")  # state_dict()表示的就是将状态（参数）用字典的形式保存起来

ロード： 

import torch
import torchvision

# 方式1：保存方式1，加载模型
model = torch.load("vgg16_method1.pth")
# print(model)

# 方式2：加载模型
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
# model = torch.load("vgg16_method2.pth")
# print(vgg16)

注:自分で作成した保存済みのモデルを読み込む場合は、モデルのネットワーク構造の .py ファイルをインポートすることを忘れないでください.たとえば、.py ファイルが model.py という名前の場合、from model import *.

GPU を使用してモデルをトレーニングする

方法 1:ネットワーク モデル、データ、および損失関数の後に.cuda()を追加します。

mynn = Mynn()
mynn=mynn.cuda()

imgs, targets = data
imgs=imgs.cuda()
targets=targets.cuda()

loss = nn.CrossEntropyLoss()
loss=loss.cuda()

方法 2: 

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

mynn = Mynn()
mynn = Mynn.to(device)

loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)

imgs, targets = data
imgs = imgs.to(device)
targets = targets.to(device)

モデルの適用

model.py

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(64*4*4, 64),
            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)

train.py

import torchvision
from torch.utils.tensorboard import SummaryWriter
from model import *
from torch import nn
from torch.utils.data import DataLoader

# 准备数据集
train_data = torchvision.datasets.CIFAR10(root="../data", train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="../data", train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)

# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10, 训练数据集的长度为：10
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))

# 利用 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
# 1e-2=1 x (10)^(-2) = 1 /100 = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

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

# 添加tensorboard
writer = SummaryWriter("../logs_train")

for i in range(epoch):
    print("-------第 {} 轮训练开始-------".format(i + 1))

    # 训练步骤开始
    tudui.train()
    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)

    # 测试步骤开始
    tudui.eval()
    total_test_loss = 0
    total_accuracy = 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.item()
            accuracy = (outputs.argmax(1) == targets).sum()  # argmax(1)表示获取横向的最大值，0则竖向
            total_accuracy = total_accuracy + accuracy

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

    torch.save(tudui, "tudui_{}.pth".format(i))
    print("模型已保存")

writer.close()

 test.py 

import torch
import torchvision
from PIL import Image
from torch import nn

image_path = "../imgs/airplane.png"  # 这里是看能否预测出这个飞机的图片是不是属于飞机这个类别
image = Image.open(image_path)
print(image)
image = image.convert('RGB')  # 有时候的图片可能是四个通道的，多了透明层，为了保险保留RGB的三个层（通道）即可
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])

image = transform(image)
print(image.shape)


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(64 * 4 * 4, 64),
            nn.Linear(64, 10)
        )

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


model = torch.load("tudui_29_gpu.pth", map_location=torch.device('cpu'))  # gpu训练出的模型在cpu运行要加map_location
print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
    output = model(image)
print(output)

print(output.argmax(1))