pytorch中構(gòu)建模型的3種方法詳解

更新時(shí)間：2023年09月22日 16:00:20 作者：hxh207

這篇文章主要介紹了pytorch中構(gòu)建模型的3種方法,分別是使用繼承nn.Module基類構(gòu)建自定義模型，使用nn.Sequential按層順序構(gòu)建模型或者，繼承nn.Module基類構(gòu)建模型并輔助應(yīng)用模型容器進(jìn)行封裝(nn.Sequential,nn.ModuleList,nn.ModuleDict)，需要的朋友可以參考下

一、繼承nn.Module基類構(gòu)建自定義模型

以下是繼承nn.Module基類構(gòu)建自定義模型的一個(gè)范例。模型中的用到的層一般在__init__函數(shù)中定義，然后在forward方法中定義模型的正向傳播邏輯。

from torch import nn 
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3)
        self.pool1 = nn.MaxPool2d(kernel_size = 2,stride = 2)
        self.conv2 = nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5)
        self.pool2 = nn.MaxPool2d(kernel_size = 2,stride = 2)
        self.dropout = nn.Dropout2d(p = 0.1)
        self.adaptive_pool = nn.AdaptiveMaxPool2d((1,1))
        self.flatten = nn.Flatten()
        self.linear1 = nn.Linear(64,32)
        self.relu = nn.ReLU()
        self.linear2 = nn.Linear(32,1)
    def forward(self,x):
        x = self.conv1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = self.dropout(x)
        x = self.adaptive_pool(x)
        x = self.flatten(x)
        x = self.linear1(x)
        x = self.relu(x)
        y = self.linear2(x)
        return y
net = Net()
print(net)

from torchkeras import summary 
summary(net,input_shape= (3,32,32));

nn.Conv1d：普通一維卷積，常用于文本。參數(shù)個(gè)數(shù) = 輸入通道數(shù)×卷積核尺寸(如3)×卷積核個(gè)數(shù) + 卷積核尺寸(如3）=卷積核尺寸(如3乘3)x輸出通道數(shù)+輸出通道數(shù)（偏置數(shù)量）

nn.Conv2d：普通二維卷積，常用于圖像。參數(shù)個(gè)數(shù) = 輸入通道數(shù)×卷積核尺寸(如3乘3)×卷積核個(gè)數(shù) + 卷積核尺寸(如3乘3)。=卷積核尺寸(如3乘3)x輸入通道數(shù)x輸出通道數(shù)+輸出通道數(shù)（偏置數(shù)量）) 通過調(diào)整dilation參數(shù)大于1，可以變成空洞卷積，增加感受野。通過調(diào)整groups參數(shù)不為1，可以變成分組卷積。分組卷積中每個(gè)卷積核僅對(duì)其對(duì)應(yīng)的一個(gè)分組進(jìn)行操作。當(dāng)groups參數(shù)數(shù)量等于輸入通道數(shù)時(shí)，相當(dāng)于tensorflow中的二維深度卷積層tf.keras.layers.DepthwiseConv2D。利用分組卷積和1乘1卷積的組合操作，可以構(gòu)造相當(dāng)于Keras中的二維深度可分離卷積層tf.keras.layers.SeparableConv2D。

二、使用nn.Sequential按層順序構(gòu)建模型

使用nn.Sequential按層順序構(gòu)建模型無需定義forward方法。僅僅適合于簡單的模型。以下是使用nn.Sequential搭建模型的一些等價(jià)方法。

利用add_module方法

net = nn.Sequential()
net.add_module("conv1",nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3))
net.add_module("pool1",nn.MaxPool2d(kernel_size = 2,stride = 2))
net.add_module("conv2",nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5))
net.add_module("pool2",nn.MaxPool2d(kernel_size = 2,stride = 2))
net.add_module("dropout",nn.Dropout2d(p = 0.1))
net.add_module("adaptive_pool",nn.AdaptiveMaxPool2d((1,1)))
net.add_module("flatten",nn.Flatten())
net.add_module("linear1",nn.Linear(64,32))
net.add_module("relu",nn.ReLU())
net.add_module("linear2",nn.Linear(32,1))
print(net)

利用變長參數(shù)

這種方式構(gòu)建時(shí)不能給每個(gè)層指定名稱。

net = nn.Sequential(
    nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3),
    nn.MaxPool2d(kernel_size = 2,stride = 2),
    nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5),
    nn.MaxPool2d(kernel_size = 2,stride = 2),
    nn.Dropout2d(p = 0.1),
    nn.AdaptiveMaxPool2d((1,1)),
    nn.Flatten(),
    nn.Linear(64,32),
    nn.ReLU(),
    nn.Linear(32,1)
)
print(net)

利用OrderedDict

鍵值對(duì)形式：鍵為層的名字，值為層的定義

from collections import OrderedDict
net = nn.Sequential(OrderedDict(
          [("conv1",nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3)),
            ("pool1",nn.MaxPool2d(kernel_size = 2,stride = 2)),
            ("conv2",nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5)),
            ("pool2",nn.MaxPool2d(kernel_size = 2,stride = 2)),
            ("dropout",nn.Dropout2d(p = 0.1)),
            ("adaptive_pool",nn.AdaptiveMaxPool2d((1,1))),
            ("flatten",nn.Flatten()),
            ("linear1",nn.Linear(64,32)),
            ("relu",nn.ReLU()),
            ("linear2",nn.Linear(32,1))
          ])
        )
print(net)

三、繼承nn.Module基類構(gòu)建模型并輔助應(yīng)用模型容器進(jìn)行封裝

當(dāng)模型的結(jié)構(gòu)比較復(fù)雜時(shí)，我們可以應(yīng)用模型容器(nn.Sequential,nn.ModuleList,nn.ModuleDict)對(duì)模型的部分結(jié)構(gòu)進(jìn)行封裝。

這樣做會(huì)讓模型整體更加有層次感，有時(shí)候也能減少代碼量。（復(fù)雜模型的時(shí)候比較常用）注意，在下面的范例中我們每次僅僅使用一種模型容器，但實(shí)際上這些模型容器的使用是非常靈活的，可以在一個(gè)模型中任意組合任意嵌套使用。

相當(dāng)于結(jié)合以上兩種方式。

nn.Sequential作為模型容器

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3),
            nn.MaxPool2d(kernel_size = 2,stride = 2),
            nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5),
            nn.MaxPool2d(kernel_size = 2,stride = 2),
            nn.Dropout2d(p = 0.1),
            nn.AdaptiveMaxPool2d((1,1))
        )
        self.dense = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64,32),
            nn.ReLU(),
            nn.Linear(32,1)
        )
    def forward(self,x):
        x = self.conv(x)
        y = self.dense(x)
        return y 
net = Net()
print(net)

nn.ModuleList作為模型容器

注意下面中的ModuleList不能用Python中的列表代替。（即不用省略）

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.layers = nn.ModuleList([
            nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3),
            nn.MaxPool2d(kernel_size = 2,stride = 2),
            nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5),
            nn.MaxPool2d(kernel_size = 2,stride = 2),
            nn.Dropout2d(p = 0.1),
            nn.AdaptiveMaxPool2d((1,1)),
            nn.Flatten(),
            nn.Linear(64,32),
            nn.ReLU(),
            nn.Linear(32,1)]
        )
    def forward(self,x):
        for layer in self.layers:
            x = layer(x)
        return x
net = Net()
print(net)

nn.ModuleDict作為模型容器

注意下面中的ModuleDict不能用Python中的字典代替。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.layers_dict = nn.ModuleDict({"conv1":nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3),
               "pool": nn.MaxPool2d(kernel_size = 2,stride = 2),
               "conv2":nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5),
               "dropout": nn.Dropout2d(p = 0.1),
               "adaptive":nn.AdaptiveMaxPool2d((1,1)),
               "flatten": nn.Flatten(),
               "linear1": nn.Linear(64,32),
               "relu":nn.ReLU(),
               "linear2": nn.Linear(32,1)
              })
    def forward(self,x):
        layers = ["conv1","pool","conv2","pool","dropout","adaptive",
                  "flatten","linear1","relu","linear2","sigmoid"]
        for layer in layers:
            x = self.layers_dict[layer](x) # 只找有的 sigmoid是沒有的
        return x
net = Net()
print(net)