需要源码请点赞关注收藏后评论区留言私信~~~
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])创作不易 觉得有帮助请点赞关注收藏~~~