一，torch.nn组成和属性

nn模块组成

nn.Module的属性

nn.Module的特点和注意点：

• 一个module可以包含多个子module
• 一个module相当于一个运算，必须实现forward（）函数
• 每个module都有8个字典管理他的属性

二，模型的容器，装有子module

nn.Sequential:按顺序包装多个网络层

• 顺序性
• 自带forward（）–》自动通过for循环依次执行前向传播运算

import torch
import torchvision
import torch.nn as nn
from collections import OrderedDict

class LeNetSequential(nn.Module):
    def __init__(self, classes):
        super(LeNetSequential, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 6, 5),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(6, 16, 5),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),)

        self.classifier = nn.Sequential(
            nn.Linear(16*5*5, 120),
            nn.ReLU(),
            nn.Linear(120, 84),
            nn.ReLU(),
            nn.Linear(84, classes),)

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size()[0], -1)
        x = self.classifier(x)
        return x


class LeNetSequentialOrderDict(nn.Module):
    def __init__(self, classes):
        super(LeNetSequentialOrderDict, self).__init__()

        self.features = nn.Sequential(OrderedDict({ #通过有序字典对网络中的操作进行命名，这样可以很容易的索引到
            'conv1': nn.Conv2d(3, 6, 5),
            'relu1': nn.ReLU(inplace=True),
            'pool1': nn.MaxPool2d(kernel_size=2, stride=2),

            'conv2': nn.Conv2d(6, 16, 5),
            'relu2': nn.ReLU(inplace=True),
            'pool2': nn.MaxPool2d(kernel_size=2, stride=2),
        }))

        self.classifier = nn.Sequential(OrderedDict({
            'fc1': nn.Linear(16*5*5, 120),
            'relu3': nn.ReLU(),

            'fc2': nn.Linear(120, 84),
            'relu4': nn.ReLU(inplace=True),

            'fc3': nn.Linear(84, classes),
        }))

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size()[0], -1)
        x = self.classifier(x)
        return x


net = LeNetSequential(classes=2)
net = LeNetSequentialOrderDict(classes=2)

fake_img = torch.randn((4, 3, 32, 32), dtype=torch.float32)#4张3通道大小为32*32

output = net(fake_img)

print(net)
print(output)

nn.ModuleList:像Python的list一样包装多个网络层

• append（）：在ModuleList后面添加网络层
• extend（）：拼接两个ModuleList
• insert（）：指定在ModuleList中位置插入网络层

import torch
import torchvision
import torch.nn as nn
from collections import OrderedDict

class ModuleList(nn.Module):
    def __init__(self):
        super(ModuleList, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(20)])#20个全连接层，每一个是10个神经元

    def forward(self, x):
        for i, linear in enumerate(self.linears):
            x = linear(x)
        return x


net = ModuleList()

print(net)

fake_data = torch.ones((10, 10))

output = net(fake_data)

print(output)

nn.ModuleDict:像Python的dict一样包装多个网络层

• clear（）：清空ModuleDict
• items（）：返回可迭代的键值对
• keys（）：返回键
• values（）：返回值
• pop（）：返回一对键值，并从字典中删除

import torch
import torchvision
import torch.nn as nn
from collections import OrderedDict

class ModuleDict(nn.Module):
    def __init__(self):
        super(ModuleDict, self).__init__()
        self.choices = nn.ModuleDict({
            'conv': nn.Conv2d(10, 10, 3),
            'pool': nn.MaxPool2d(3)
        })

        self.activations = nn.ModuleDict({
            'relu': nn.ReLU(),
            'prelu': nn.PReLU()
        })

    def forward(self, x, choice, act):
        x = self.choices[choice](x)
        x = self.activations[act](x)
        return x


net = ModuleDict()

fake_img = torch.randn((4, 10, 32, 32))

output = net(fake_img, 'conv', 'relu')

print(output)

三，常用nn网络层

nn.Conv2d():二维卷积

• in_channels:输入通道数
• out_channels:输出通道数
• kernel_size:卷积核尺寸
• stride:步长
• padding:填充个数
• dilation:空洞卷积大小
• groups:分组卷积设置
• bias:偏置

nn.ConvTranspose2d:转置卷积，实现上采样

• in_channels:输入通道数
• out_channels:输出通道数
• kernel_size:卷积核尺寸
• stride:步长
• padding:填充个数
• dilation:空洞卷积大小
• groups:分组卷积设置
• bias:偏置

nn.MaxPool2d:二维最大池化

• kernel_size：池化核尺寸
• stride：步长
• padding：填充个数
• dilation：池化核间隔大小
• ceil_mode:尺寸向上取整
• return_indices:记录池化像素索引（取出最大值时当时最大的值所处的位置索引）

nn.AvgPool2d:二维平均池化

• kernel_size：池化核尺寸
• stride：步长
• padding：填充个数
• dilation：池化核间隔大小
• ceil_mode:尺寸向上取整
• count_include_pad:填充值用于计算
• divisor_override:除法因子–》当设置了除法因子之后，全部权值加和之后不除以权值个数而除以因子

nn.MaxUnpool2d:反池化—》对二维图像进行最大池化上采样

• kernel_size:池化核尺寸
• stride：步长
• padding：填充个数
• 需将正常池化以后记录的索引值传入反池化函数

nn.Linear:线性层—》对一维信号进行线性组合

• in_features:输入节点数
• out_features:输出节点数
• bias：是否需要偏置