目次
モデル ナゲットを使用して複雑なネットワークをすばやく構築する
PyTorch モデルの定義方法
基本知識
- Module クラスは、torch.nn モジュールで提供されるモデル構築クラス (nn.Module) です. これは、すべてのニューラル ネットワーク モジュールの基本クラスであり、モデルを定義するために継承できます。
- PyTorch モデル定義には以下が含まれている必要があります: 各パーツの初期化 (__init__); データ フロー定義 (フォワード)
nn.Module に基づいて、PyTorch モデルは Sequential、ModuleList、および ModuleDict の 3 つの方法で定義できます。
一連
対応するモジュールは nn.Sequential() です。モデルの前方計算が各層を単純に連結する計算である場合、Sequential クラスはより単純な方法でモデルを定義できます。サブモジュールの順序付けられた辞書 (OrderedDict) または一連のサブモジュールをパラメーターとして受け入れて、Module インスタンスを 1 つずつ追加できます。モデルの前方計算は、これらのインスタンスを追加の順序で 1 つずつ計算することです。
class MySequential(nn.Module):
from collections import OrderedDict
def __init__(self, *args):
super(MySequential, self).__init__()
if len(args)==1 and isinstance(args[0], OrderedDict):
#如果传入的是一个OrderedDict
for key, module in args[0].items():
self.add_module(key, module)
# add_module方法会将module添加进self._modules(一个OrderedDict)
else:
for idx, module in enumerate(args):
self.add_module(str(idx), module)
def forward(self, input):
# self._modules返回一个OrderedDict，保证会按照成员添加顺序遍历成
for module in self._modules.values():
input = module(input)
return inputSequential を使用してモデルを定義するには、モデルのレイヤーを順番に配置するだけで済みます。異なるレイヤー名に応じて、次の 2 つの方法で配置できます。
#直接排列
import torch.nn as nn
net = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 10),
)
print(net)
#使用OrderedDict
import collections
import torch.nn as nn
net2 = nn.Sequential(collections.OrderedDict([
('fc1', nn.Linear(784, 256)),
('relu1', nn.ReLU()),
('fc2', nn.Linear(256, 10))
]))
print(net2)Sequential を使用してモデルを定義する利点は、単純で読みやすく、シーケンスが既に定義されているため、書き出す必要がないことです。ただし、Sequential を使用するとモデル定義の自由度が失われますので、例えばモデルの途中に外部入力を追加する必要がある場合、Sequential で実装するのは適していません。
モジュールリスト
対応するモジュールは nn.ModuleList() です。ModuleList は、サブモジュールのリストを入力として受け入れ、操作を追加および拡張することもできます。同時に、サブモジュールまたはレイヤーの重みが自動的にネットワークに追加されます。
net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10))
print(net[-1])
print(net)nn.ModuleList はネットワークを定義しませんが、異なるモジュールをまとめて格納します。
ModuleList 内の要素の順序は、ネットワーク内での実際の位置順序を表すものではなく、モデルの定義は、フォワード関数によって各層の順序を指定した後にのみ完了します。特定の実装は for ループで完了することができます
class model(nn.Module):
def __init__(self, ...):
super().__init__()
self.modulelist = ...
...
def forward(self, x):
for layer in self.modulelist:
x = layer(x)
return xModuleDict
対応するモジュールは nn.ModuleDict() で、ニューラル ネットワークのレイヤーに名前を追加しやすくします。
net = nn.ModuleDict({
'linear':nn.Linear(784, 256),
'act':nn.ReLU(),
})
net['output'] = nn.Linear(256, 10)
print(net['linear'])
print(net.output)
print(net)3 つの方法の比較と適用シナリオ
Sequential は、__init__ と forward を同時に書き込まずに、迅速な検証結果に適しています。
ModuleList と ModuleDict は、特定の同一のレイヤーを複数回繰り返す必要がある場合、「最大 1 行」にすることができます。
ResNets の残差計算など、前のレイヤーの情報が必要な場合、通常は ModuleList/ModuleDict を使用して、現在のレイヤーの結果を前のレイヤーの結果と融合する必要があります。
モデル ナゲットを使用して複雑なネットワークをすばやく構築する
モデルの深さが非常に大きい場合、Sequential を使用してモデル構造を定義するには、数百行のコードを追加する必要があり、あまり便利ではありません。ほとんどのモデル構造では、モデルに多くのレイヤーがありますが、多くの繰り返し構造があります。各層には入力と出力があることを考えると、複数の層が直列に接続されたモジュールにも入力と出力があります。これらの繰り返しレイヤーが「モジュール」として定義されている場合、モデルを構築するために対応するモジュールをネットワークに追加するだけでよく、モデル構築のプロセスが大幅に容易になります。
このセクションでは、U-Net を例として、モデル ブロックの作成方法と、モデル ブロックを使用して複雑なモデルをすばやく作成する方法を紹介します。
U-Net はセグメンテーション モデルの傑作であり、ニューラル ネットワークの深さを継続的に拡張できるように、モデル学習における回帰問題を残差結合構造によって解決します。
モデル解析: モデルは上から下までいくつかの層に分割され、各層は左右の 2 つのモデル ブロックで構成され、両側のモデル ブロックと上下のモデル ブロックの間に接続があります。同時に同じレイヤーの左側と右側に 「スキップ接続」と呼ばれるブロック間の接続もあります。入出力処理などの他のコンポーネントもあります。
U-Netを構成するモデルブロックは、主に各サブブロック内の二重畳み込み（Double Convolution）、左側のモデルブロック間のダウンサンプリング接続、つまりMaxpooling、右側のモデルブロック間のアップリンクを含みます。 -sampling) と出力層の処理。モデルブロック以外にも、モデルブロック間の水平接続、入力とU-Net底部の接続などの計算があり、これらの個々の操作はフォワード機能によって実現できます。
コード：
import torch
import torch.nn as nn
import torch.nn.functional as F
class DoubleConv(nn.Module):
# (convolution => [BN] => ReLU) * 2
def __init__(self, in_channels, out_channels, mid_channels=None):
super().__init__()
if not mid_channels:
mid_channels = out_channels
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, mie_channels, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(mid_channels),
nn.ReLU(inplace=True),
nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x):
return self.double_conv(x)
class Down(nn.Module):
# Downscaling with maxpool then double conv
def __init__(self, in_channels, out_channels):
super().__init__()
self.maxpool_conv = nn.Sequential(
nn.MaxPool2d(2),
DoubleConv(in_channels, out_channels)
)
def forward(self, x):
return self.maxpool_conv(x)
class Up(nn.Module):
# Upscaling then double conv
def __init__(self, in_channels, out_channels, bilinear=False):
super().__init__()
# if bilinear, use the normal convolutions to reduce the number of channels
if bilinear:
self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
self.conv = DoubleConv(in_channels, out_channels, in_channels//2)
else:
self.up = nn.ConvTranspose2d(in_channels, in_channels//2, kernel_size=2, stride=2)
self.conv = DoubleConv(in_channels, out_channels)
def forward(self, x1, x2):
x1 = self.up(x1)
# input is CHW
diffY = x2.size()[2] - x1.size()[2]
diffX = x2.size()[3] - x1.size()[3]
x1 = F.pad(x1, [diffX//2, diffX-diffX//2, diffY//2, diffY-diffY//2])
x = torch.cat([x2, x1], dim=1)
return self.conv(x)
class OutConv(nn.Module):
def __init__(self, in_channels, out_channels):
super(OutConv, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
def forward(self, x):
return self.conv(x)
class UNet(nn.Module):
def __init__(self, n_channels, n_classes, bilinear=False):
super(UNet, self).__init__()
self.n_channels = n_channels
self.n_classes = n_classes
self.bilinear = bilinear
self.inc = DoubleConv(n_channels, 64)
self.down1 = Down(64, 128)
self.down2 = Down(128, 256)
self.down3 = Down(256, 512)
factor = 2 if bilinear else 1
self.down4 = Down(512, 1024//factor)
self.up1 = Up(1024, 512//factor, bilinear)
self.up2 = Up(512, 256//factor, bilinear)
self.up3 = Up(256, 128//facotr, bilinear)
self.up4 = Up(128, 64, bilinear)
self.outc = OutConv(64, n_classes)
def forward(self, x):
x1 = self.inc(x)
x2 = self.down1(x1)
x3 = self.down2(x2)
x4 = self.down3(x3)
x5 = self.down4(x4)
x = self.up1(x5, x4)
x = self.up2(x, x3)
x = self.up3(x, x2)
x = self.up4(x, x1)
logits = self.outc(x)
return logins
PyTorch 変更モデル
モデルレイヤーを修正
pytroch の公式ビジョン ライブラリ torchvision の定義済みモデル ResNet50 を例として、モデルの特定のレイヤーまたは複数のレイヤーを変更する方法を調べます。
import torch vision.models as models
net = models.resnet50()
print(net)ResNet(
(conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
(bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
(layer1): Sequential(
(0): Bottleneck(
(conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
(bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
(bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
(bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
(downsample): Sequential(
(0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
(1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)
)
..............
(avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
(fc): Linear(in_features=2048, out_features=1000, bias=True)
)ここでのモデル構造は、ImageNet 事前トレーニングの重みに適応するためのものであるため、最後の全結合層 (fc) の出力ノードは 1000 です。resnet を使用して 10 個の分類を行う場合、モデルの fc レイヤーを変更し、出力ノードの数を 10 に置き換える必要があります。さらに、追加の全結合層が必要です。
from collections import OrderedDict
classifier = nn.Sequential(OrderedDict([('fc1', nn.Linear(2048, 128)),
('relu1', nn.ReLU()),
('dropout1', nn.Dropout(0.5)),
('fc2', nn.Linear(128, 10)),
('output', nn.Softmax(dim=1))
]))
net.fc = classifier最後の操作は、'fc' という名前のモデル (ネット) の最後の層を 'classifier' という名前の構造に置き換えることと同じです。修正されたモデルは、10 個の分類タスクを実行できます。
外部入力を追加
モデルのトレーニングでは、既存のモデルの入力に加えて、追加の情報を入力する必要があります。基本的な考え方は、入力位置を全体として追加する前に元のモデルの一部を取得し、同時に元のモデルの変更されていない部分、追加された入力、および前方の後続レイヤー間の接続関係を定義し、モデルの修正を完了します。
torchvision の resnet50 モデルに基づいて、タスクは依然として 10 に分類されます; 違いは、既存のモデル構造を使用して、追加の入力変数 add_variable が最後から 2 番目のレイヤーに追加され、予測を支援することです。
class Model(nn.Module):
def __init__(self, net):
super(Model, self).__init__()
self.net = net
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
self.fc_add = nn.Linear(1001, 10, bias=True)
self.output = nn.Softmax(dim=1)
def forward(self, x, add_variable):
x = self.net(x)
x = torch.cat((self.dropout(self.relu(x)), add_variable.unsqueeze(1)),1)
x = self.fc_add(x)
x = self.output(x)
return x実装の主なポイントは、torch.cat を通じてテンソル スプライシングを実現することです。
torchvision の resnet50 出力は 1000 次元のテンソルです. forward 関数を変更することにより、最初に 1000 次元のテンソルを活性化関数レイヤーとドロップアウト レイヤーに渡し、次に外部入力変数「add_variable」でスプライスし、最後に指定された出力ディメンション 10 にマップします。
また、外部入力変数「add_variable」の unsqueeze 操作は、net が出力するテンソルと同じ次元を維持するためのもので、add_variable が単一の値 (スカラー) の場合によく使用されます。 torch.cat 操作をテンソルで実行できるように、2 番目の次元にある必要がある (batch_size, )。
次に、変更されたモデル構造をインスタンス化します
import torchvision.models as models
net = models.resnet50()
model = Model(net).cuda()トレーニング中、データを入力するときに 2 つの入力が必要です。
outputs = model(input, add_var)余分な出力を追加する
モデルのトレーニングでは、モデルの最終的な出力に加えて、モデルの特定の中間層の結果を出力する必要があり、より良い中間層の結果を得るために追加の監視が適用されています。基本的な考え方は、モデル定義で forward 関数の戻り変数を変更することです。
class Model(nn.Module):
def __init__(self, net):
super(Model, self).__init__()
self.net = net
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
self.fc1 = nn.Linear(1000, 10, bias=True)
self.output = nn.Softmax(dim=1)
def forward(self, x, add_variable):
x1000 = self.net(x)
x10 = self.dropout(self.relu(x1000))
x10 = self.fc1(x10)
x10 = self.output(x10)
return x10, x1000変更されたモデル構造をインスタンス化した後、それを使用できます
import torchvision.models as models
net = models.resnet50()
model = Model(net).cuda()トレーニングの入力データの後に 2 つの出力があります。
out10, out1000 = model(inputs, add_var)PyTorch モデルの保存と読み込み
モデルの保存形式
主に pkl、pt、pth の 3 つの形式を使用します。
モデル ストレージ コンテンツ
PyTorch モデルは、主にモデル構造と重みの 2 つの部分で構成されます。ここで、モデルは nn.module から継承したクラスであり、重みのデータ構造は辞書です (キーはレイヤー名、値は重みベクトル)。ストレージには、モデル全体の格納とモデルの重みのみの格納の 2 種類があります。
import torchvision import models
model = models.resnet152(pretrained=True)
torch.save(model, save_dir)#保存整个模型
torch.save(model.state_dict, save_dir)#保存模型权重PyTorch の場合、pt、pth、pkl の 3 つのデータ形式はすべて、モデルの重みとモデル全体のストレージをサポートしているため、使用方法に違いはありません。
シングルカードモデルとマルチカードモデルのストレージの違い
モデルとデータを PyTorch で GPU に配置する方法は 2 つあります: .cuda() と .to(device). マルチカード トレーニングを使用する場合は、モデルに torch.nn.DataParallel を使用する必要があります。
os.environ['CUDA_VISIBLE_DEVICES'] = '0' #如果是多卡改成类似0，1，2
model = model.cuda() #单卡
model = torch.nn.DataParallel(model).cuda() #多卡状況に応じたディスカッション
トレーニングとテストに使用されるハードウェア条件が異なるため、モデルの保存と読み込み時に、シングル GPU とマルチ GPU の環境の違いにより、モデルの不一致などの問題が発生する場合があります。ここでは、PyTorch フレームワークの下でシングルカード/マルチカードの下でモデルを保存およびロードする問題を整理して結合します. サンプルモデルは torchvision で事前にトレーニングされたモデル resnet152 です.
- シングルカードセーブとシングルカードロード
import os, torch
from torchvision import models
os.environ['CUDA_VISIBLE_DEVICES'] = '0'#这里替换成希望使用的GPU编号
model = models.resnet152(pretrained=True)
model.cuda()
#保存+读取整个模型
torch.save(model, save_dir)
loaded_model = torch.load(save_dir)
loaded_model.cuda()
#保存+读取模型权重
torch.save(model.state_dict(), save_dir)
loaded_dict = torch.load(save_dir)
loaded_model = models.resnet152()
loaded_model.state_dict = loaded_dict
loaded_model.cuda()
- シングルカードセーブ＋マルチカードロード
import os, torch
from torchvision import models
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
model = models.resnet152(pretrained=True)
model.cuda()
#保存+读取整个模型
torch.save(model, save_dir)
os.environ['CUDA_VISIBLE_DEVICES'] = '1,2'
loaded_model = torch.load(save_dir)
loaded_model = nn.DataParallel(loaded_model).cuda()
#保存+读取模型权重
torch.save(model.state_dict(), save_dir)
os.environ['CUDA_VISIBLE_DEVICES'] = '1,2'# 替换成希望使用的GPU编号
loaded_dict = torch.load(save_dir)
loaded_model = models.resnet152()# 注意这里需要对模型结构有定义
loaded_model.state_dict = loaded_dict
loaded_model = nn.DataParallel(loaded_model).cuda()- マルチカード保存＋シングルカード読み込み
重要な問題は、モデルの統一性を確保するために、重み辞書のキー名から「モジュール」を削除する方法です。
モデル全体をロードするには、モデルのモジュール属性を直接抽出するだけです
import os, torch
from torchvision import models
os.environ['CUDA_VISIBLE_DEVICES'] = '1,2' #这里替换成希望使用的GPU编号
model = models.resnet152(pretrained=True)
model = nn.DataParallel(model).cuda()
# 保存+读取整个模型
torch.save(model, save_dir)
os.environ['CUDA_VISIBLE_DEVICES'] = '0' #这里替换成希望使用的GPU编号
loaded_model = torch.load(save_dir)
loaded_model = loaded_model.moduleモデルの重みをロードするには、いくつかのアイデアがあります。
ディクショナリのモジュールを削除する方が面倒ですが、モジュールをモデルに追加するのは簡単です
import os, torch
from torchvision import models
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2'
model = models.resnet152(pretrained=True)
model = nn.DataParallel(model).cuda()
#保存+读取模型权重
torch.save(model.state_dict(), save_dir)
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
loaded_dict = torch.load(save_dir)
loaded_model = models.resnet152()
loaded_model = nn.DataParallel(loaded_model).cuda()
loaded_model.state_dict = loaded_dictディクショナリをトラバースしてモジュールを削除します
from collections import OrderedDict
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
loaded_dict = torch.load(save_dir)
new_state_dict = OrderedDict()
for k, v in loaded_dict.items():
name = k[7:] # module字段在最前面，从第7个字符开始就可以去掉module
new_state_dict[name] = v # 新字典的key值对应的value一一对应
loaded_model = models.resnet152()
loaded_model.state_dict = new_state_dict
loaded_model = loaded_model.cuda()置換操作を使用してモジュールを削除します
loaded_model = models.resnet152()
loaded_dict = torch.load(save_dir)
loaded_model.load_state_dict({k.replace('module.',''): v for k, v in loaded_dict.items()})- マルチカード保存＋マルチカード読み込み
マルチカードはモデルの保存と読み込みの両方に使用されるため、モデル レイヤー名のプレフィックスが異なるという問題はありません。ただし、マルチカード状態でのデバイス(使用GPU)マッチングの問題、つまりモデル全体を保存する際に、使用GPU idなどの情報も同時に保存されるため、情報が一致しない場合は、読み取り時に現在使用されている GPU 情報を読み取ると、エラーが報告されるか、プログラムが意図したとおりに実行されません。具体的には、次の 2 点です。
モデル全体を読み取り、分散トレーニング設定に nn.DataParallel を使用します
この状況は、保存されたモデルの GPU id と読み取り環境で設定された GPU id の間に不一致が発生する可能性があり、データが配置されているデバイスがトレーニング中にモデルが配置されているデバイスと一致しなくなり、結果としてエラー。
分散トレーニングのセットアップに nn.DataParallel を使用せずにモデル全体を読み取る
In this case, an error may not be reported. テスト中に、プログラムがデバイスの最初の n 個の GPU をトレーニングに自動的に使用することがわかりました (n は、保存されたモデルで使用される GPU の数です)。このとき、指定された GPU の数が n 未満の場合、エラーが報告されます。この場合、モデルを保存するときの環境のデバイス ID が、モデルを読み取るときの環境のデバイス ID と同じ場合にのみ、プログラムは指定された GPU で分散トレーニングを期待どおりに実行します。
対照的に、モデルの重みを読み取ってから、分散トレーニングのセットアップに nn.DataParallel を使用することは問題ありません。したがって、マルチカード モードでは、モデルの保存と読み取りに weight メソッドを使用することをお勧めします。
import os, torch
from torchvision import models
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2'
model = models.resnet152(pretrained=True)
model = nn.DataParallel(model).cuda()
#保存+读取模型权重，强烈建议！！
torch.save(model.state_dict(), save_dir)
loaded_dict = torch.load(save_dir)
loaded_model = models.resnet152()
loaded_model = nn.DataParallel(loaded_model).cuda()
loaded_model.state_dict = loaded_dictモデル全体しか保存されていない場合は、重みを抽出して新しいモデルを構築することもできます。
#读取整个模型
loaded_whole_model = torch.load(save_dir)
loaded_model = models.resnet152()
loaded_model.state_dict = loaded_whole_model.state_dict
loaded_model = nn.DataParallel(loaded_model).cuda()さらに、loaded_model の重みディクショナリを変更するすべての形式は代入によって実現され、PyTorch の「load_state_dict」関数によっても実現できます。
loaded_model.load_state_dict(loaded_dict)添付資料：テスト環境 OS：Ubuntu 20.02 LTS GPU：GeForce RTX 2080 Ti(x3)