PyTorch基础之网络模块torch.nn中函数和模板类的使用详解（附源码）

╰半橙微兮° 2023-10-09 20:37 2阅读 0赞

> **需要源码请点赞关注收藏后评论区留言私信~~~**

PyTorch中的torch.nn模块有许多自带的函数，如全连接层，卷积层，归一化层等，都已经被封装在该模块下，可以直接使用，在编写代码的过程中十分简便，下面对他们进行介绍

## 一、torch.nn函数简介 ##

（1） nn.Linear()

用于设置网络中的全连接层

import torch
    from torch import nn
    linear = torch.nn.Linear(in_features=64, out_features=1)
    input = torch.rand(10, 64)
    output = linear(input)
    print(output.shape)  # torch.Size([10, 1])

（2） nn.Conv1d()

在由多个输入平面组成的信号上应用一维卷积

conv1 = nn.Conv1d(in_channels=256, out_channels=10, kernel_size=2, stride=1, padding=0)
    input = torch.randn(32, 32, 256)  # [batch_size, L_in, in_channels]
    input = input.permute(0, 2, 1)  # 交换维度：[batch_size, embedding_dim, max_len]
    out = conv1(input)  # [batch_size, out_channels, L_out]
    print(out.shape)  # torch.Size([32, 10, 31]),31=(32+2*0-1*1-1)/1+1

（3） nn.Conv2d()

在由多个输入平面组成的输入信号上应用二维卷积

import torch
    x = torch.randn(3, 1, 5, 4)  # [N, in_channels, H_in, W_in]
    conv = torch.nn.Conv2d(1, 4, (2, 3))  # [in_channels, out_channels, kernel_size]
    output = conv(x)
    print(output.shape)  # torch.Size([3, 4, 4, 2]), [N, out_channels, H_out, W_out]

（4） nn.BatchNorm1d

为了加速神经网络的收敛过程以及提高训练过程中的稳定性

Bat = nn.BatchNorm1d(2)
    input = torch.randn(2, 2)
    output = Bat(input)
    print(input, output)
    # tensor([[ 0.5476, -1.9766],
    #         [ 0.7412, -0.0297]]) tensor([[-0.9995, -1.0000],
    #         [ 0.9995,  1.0000]], grad_fn=<NativeBatchNormBackward>)

（5） nn.BatchNorm2d

二维批归一化层

Bat = nn.BatchNorm2d(2)
    input = torch.randn(1, 2, 2, 2)
    output = Bat(input)
    print(input, output)
    # tensor([[[[ 0.6798,  0.8453],
    #           [-0.1841, -1.3340]],
    # 
    #          [[ 1.9479,  1.2375],
    #           [ 1.0671,  0.9406]]]]) tensor([[[[ 0.7842,  0.9757],
    #           [-0.2150, -1.5449]],
    # 
    #          [[ 1.6674, -0.1560],
    #           [-0.5933, -0.9181]]]], grad_fn=<NativeBatchNormBackward>)

（6）nn.RNN 循环神经网络

feature_size = 32
    num_steps = 35
    batch_size = 2
    num_hiddens = 2
    X = torch.rand(num_steps, batch_size, feature_size)
    RNN_layer = nn.RNN(input_size=feature_size, hidden_size=num_hiddens)
    Y, state_new = RNN_layer(X)
    print(X.shape, Y.shape, len(state_new), state_new.shape)
    # torch.Size([35, 2, 32]) torch.Size([35, 2, 2]) 1 torch.Size([1, 2, 2])

（7） nn.LSTM

长短时记忆网络

import torch
    from torch import nn
    # 构建4层的LSTM,输入的每个词用10维向量表示,隐藏单元和记忆单元的尺寸是20
    lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=4)
    
    # 输入的x:其中batch_size是3表示有三句话,seq_len=5表示每句话5个单词,feature_len=10表示每个单词表示为长10的向量
    x = torch.randn(5, 3, 10)
    # 前向计算过程,这里不传入h_0和C_0则会默认初始化
    out, (h, c) = lstm(x)
    print(out.shape)  # torch.Size([5, 3, 20]) 最后一层10个时刻的输出
    print(h.shape)  # torch.Size([4, 3, 20]) 隐藏单元
    print(c.shape)  # torch.Size([4, 3, 20]) 记忆单元

（8） nn.ConvTranspose1d

一维转置卷积神经网络（反卷积）

dconv1 = nn.ConvTranspose1d(1, 1, kernel_size=3, stride=3, padding=1, output_padding=1)
    
    x = torch.randn(16, 1, 8)
    print(x.size())  # torch.Size([16, 1, 8])
    
    output = dconv1(x)
    print(output.shape)  # torch.Size([16, 1, 23])

（9） nn.ConvTranspose2d

二维转置卷积神经网络（反卷积）

dconv2 = nn.ConvTranspose2d(1, 1, kernel_size=3, stride=3, padding=1, output_padding=1)
    
    x = torch.randn(16, 1, 8, 8)
    print(x.size()) # torch.Size([16, 1, 8, 8])
    
    output = dconv2(x)
    print(output.shape) # torch.Size([16, 1, 23, 23])

## 二、借助torch.nn.Module构建深度学习模型的类class ##

torch.nn.Module是nn中十分重要的类，包含网络各层的定义及forward方法，可以借助torch.nn.Module构建深度学习模型的类class，当面对复杂的模型，比如：多输入多输出、多分支模型、带有自定义层的模型时，需要自己来定义一个模型

nn.Module的一般定义如下：

> class Module(object):
> 
> def \_\_init\_\_(self):
> 
> def forward(self, \*input):
> 
> def \_\_call\_\_(self, \*input, \*\*kwargs):
> 
> def \_\_repr\_\_(self):
> 
> def \_\_dir\_\_(self):

接下来对于上述nn.Module中每个函数进行介绍：

def \_\_init\_\_(self)：\_\_init\_\_是一个特殊方法用于在创建对象时进行初始化操作；

def forward(self,\*input)：forward函数为前向传播函数，需要自己重写，它用来实现模型的功能，并实现各个层的连接关系；

def \_\_call\_\_(self, \*input, \*\*kwargs)：\_\_call\_\_()的作用是使class实例能够像函数一样被调用，以“对象名()”的形式使用；

def \_\_repr\_\_(self)：\_\_repr\_\_函数为Python的一个内置函数，它能把一个对象用字符串的形式表达出来；

def \_\_dir\_\_(self)：dir()也是Python提供的一个内置函数，它可以查看某个对象具有哪些属性。

部分示例代码如下

import torch
    from torch import nn
    class MyNet(nn.Module):
        def __init__(self):
            super(MyNet, self).__init__() # 使用父类的方法初始化子类
            self.linear1 = torch.nn.Linear(96, 1024)  # [96,1024]
            self.relu1 = torch.nn.ReLU(True)
            self.batchnorm1d_1 = torch.nn.BatchNorm1d(1024)
            self.linear2 = torch.nn.Linear(1024, 7 * 7 * 128)  # [1024,6272]
            self.relu2 = torch.nn.ReLU(True)
            self.batchnorm1d_2 = torch.nn.BatchNorm1d(7 * 7 * 128)
            self.ConvTranspose2d = nn.ConvTranspose2d(128, 64, 4, 2, padding=1)
    
        def forward(self, x):
            x = self.linear1(x)
            x = self.relu1(x)
            x = self.batchnorm1d_1(x)
            x = self.linear2(x)
            x = self.relu2(x)
            x = self.batchnorm1d_2(x)
            x = self.ConvTranspose2d(x)
            return x
    
    model = MyNet()
    print(model)
    # 运行结果为：
    # MyNet(
    #   (linear1): Linear(in_features=96, out_features=1024, bias=True)
    #   (relu1): ReLU(inplace=True)
    #   (batchnorm1d_1): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    #   (linear2): Linear(in_features=1024, out_features=6272, bias=True)
    #   (relu2): ReLU(inplace=True)
    #   (batchnorm1d_2): BatchNorm1d(6272, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    #   (ConvTranspose2d): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))
    # )

## 三、模型类Class的使用 ##

在前面介绍完class中各个函数并学习了如何构建class之后，接下来进一步介绍模型类class的使用。

model = MyNet()  # 实例化的过程中没有传入参数
    input = torch.rand([32, 96])  # 输入的最后一个维度要与nn.Linear(96, 1024)中第一个维度96相同
    target = model(input)
    print(target.shape)  # torch.Size([32, 1, 28, 28])

上述实例化的过程中是没有参数输入的，也就是在构造类的过程中使用构造函数的第一种形式def\_\_init\_\_(self)。此外，在构造类的过程中很多情况下使用构造函数的第二种形式def\_\_init\_\_(self, 参数1，参数2，···，参数n)，在这种情况下，对类实例化的过程中也需要输入相应的参数，举例代码如下：

#构建网络
    class MyNet(nn.Module):
        def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
            super(MyNet, self).__init__()
            self.layer1 = nn.Sequential(nn.Linear(in_dim,n_hidden_1),nn.BatchNorm1d(n_hidden_1))
            self.layer2 = nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),nn.BatchNorm1d(n_hidden_2))
            self.layer3 = nn.Sequential(nn.Linear(n_hidden_2,out_dim))
    
        def forward(self,x):
            x = torch.relu(self.layer1(x))
            x = torch.relu(self.layer2(x))
            x = self.layer3(x)
            return x
    
    # 实例化网络层
    model = MyNet(28 * 28, 300, 100, 10)  # 实例化的过程中传入参数
    input = torch.rand(10, 28 * 28)
    target = model(input)
    print(target.shape)  # torch.Size([10, 10])

**创作不易 觉得有帮助请点赞关注收藏~~~**