pytorch 建立模型的几种方法

Conv2d的解释如下
"""
Conv2d(in_channels, out_channels, kernel_size, stride=1,
        padding=0, dilation=1, groups=1, bias=True)
        
in_channels(int) – 输入信号的通道数
out_channels(int) – 卷积产生的通道数
kerner_size(int or tuple) - 卷积核的大小
stride(int or tuple,optional) - 卷积步长，即要将输入扩大的倍数。
padding(int or tuple, optional) - 输入的每一条边补充0的层数，高宽都增加2*padding
"""
Linear函数的解释如下
"""
Linear(in_features, out_features, bias=True)
in_features: size of each input sample，一般输入是[B,in_features]
out_features: size of each output sample,经过Linear输出的tensor是[B,out_features]
"""

from torch.nn import *
class Network(Module):
    def __init__(self):
        super(Network, self).__init__()
        self.conv = Conv2d(3, 16, 3, 1, 1)
        self.dense =Linear(16 * 3, 2)
        self.pool=MaxPool2d(kernel_size=2)
        self.relu=ReLU(inplace=True)#inplace为True，将会改变输入的数据 ，否则不会改变原输入，只会产生新的输出

    #前向传播方法
    def forward(self, x):
        x=self.conv(x)
        x=  self.relu(x)
        x = MaxPool2d(x, 2)
        x = x.view(x.size(0), -1)#设置成为[B,-1]格式
        x=  self.dense(x)
        x = self.relu(x)
        return x
model = Network()
print(model)

Network(
  (conv): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (dense): Linear(in_features=48, out_features=2, bias=True)
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (relu): ReLU(inplace)
)

import torch
class Network(torch.nn.Module):
    def __init__(self):
        super(Network, self).__init__()
        self.conv = torch.nn.Sequential(
            torch.nn.Conv2d(3, 16, 3, 1, 1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )
        self.dense = torch.nn.Sequential(
            torch.nn.Linear(16 * 3, 2),
            torch.nn.ReLU()
        )

    def forward(self, x):
        x = self.conv(x)
        x = x.view(x.size(0), -1)
        x = self.dense(x)
        return x
model = Network()
print(model)

Network(
  (conv): Sequential(
    (0): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense): Sequential(
    (0): Linear(in_features=48, out_features=2, bias=True)
    (1): ReLU()
  )
)

import torch
class Network(torch.nn.Module):
    def __init__(self):
        super(Network, self).__init__()
        self.network=torch.nn.Sequential()
        self.network.add_module("conv_{}".format(1),torch.nn.Conv2d(3, 16, 3, 1, 1))
        self.network.add_module("relu_{}".format(1),torch.nn.ReLU())
        self.network.add_module("pool_{}".format(1),torch.nn.MaxPool2d(2))
        self.network.add_module("dense_{}".format(1),torch.nn.Linear(16 * 3, 2))
        self.network.add_module("relu_{}".format(2),torch.nn.ReLU())

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

Network(
  (network): Sequential(
    (conv_1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (relu_1): ReLU()
    (pool_1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (dense_1): Linear(in_features=48, out_features=2, bias=True)
    (relu_2): ReLU()
  )
)