《深度学习框架PyTorch入门与实践》学习笔记第四章torch.nn

作者：小么么和 | 来源：互联网 | 2023-10-10 16:49

#-------神经网络工具箱nn------------------------------------------#torch.nn是专门为深度学习而设计的模块，

# -------神经网络工具箱nn------------------------------------------ # torch.nn是专门为深度学习而设计的模块&＃xff0c;torch.nn的核心数据结构是Module # 既可以表示神经网络中的某个层&＃xff08;layer&＃xff09;&＃xff0c;也可以表示包含很多层的神经网络 # 实际使用中&＃xff0c;最常用的做法是继承nn.Module&＃xff0c;撰写自己的网络/层&＃xff0c; # 全连接层有名仿射层&＃xff0c;import torch as t from torch import nn import pylab# 全连接层的实现 # PyTorch的nn.Linear&＃xff08;&＃xff09;是用于设置网络中的全连接层的&＃xff0c; # 需要注意在二维图像处理的任务中&＃xff0c;全连接层的输入与输出一般都设置为二维张量&＃xff0c; # 形状通常为[batch_size, size]&＃xff0c;不同于卷积层要求输入输出是四维张量。 class Linear(nn.Module): # 继承nn.Module父类def __init__(self, in_features, out_features): # 必须初始化构造函数super(Linear, self).__init__() # 等价于nn.Module.__init__(self)self.w &＃61; nn.Parameter(t.randn(in_features, out_features)) # 自封装学习参数self.b &＃61; nn.Parameter(t.randn(out_features))def forward(self, x):x &＃61; x.mm(self.w)return x &＃43; self.b.expand_as(x)# 无需写后向传播过程&＃xff0c;nn.Module会利用autograd自动实现反向传播# in_features指的是输入的二维张量的大小&＃xff0c;即输入的[batch_size, size]中的size。 # out_features指的是输出的二维张量的大小&＃xff0c; # 即输出的二维张量的形状为[batch_size&＃xff0c;output_size]&＃xff0c; # 当然&＃xff0c;它也代表了该全连接层的神经元个数。 # 从输入输出的张量的shape角度来理解&＃xff0c; # 相当于一个输入为[batch_size, in_features]的张量 # 变换成了[batch_size, out_features]的输出张量。layer &＃61; Linear(4, 3) # in_features&＃61;4,out_features&＃61;3 input &＃61; t.randn(2, 4) # (batch_size,in_feature) output &＃61; layer(input) print(output)for name, parameter in layer.named_parameters():print(name, parameter) # w and b# 全连接层实现非常简单&＃xff0c;但是需要注意以下几点&＃xff1a; # &＃xff08;1&＃xff09;自定义层Linear必须继承nn.Module,并且在其构造函数中需调用nn.Module的构造函数&＃xff0c; # 即super(Linear,self).__init__() # (2)在构造函数__init__中必须自己定义课学习的参数&＃xff0c;并封装成Parameter# ---------多层感知机--------------------------------------------------------- # 它由两个全连接层组成&＃xff0c;采用sigmoid作为激活函数 class Perceptron(nn.Module): # 继承nn.Module父类def __init__(self, in_features, hidden_features, out_features):nn.Module.__init__(self) # 必须调用构造函数&＃xff0c;初始化参数# 必须封装自定义参数self.layer1 &＃61; Linear(in_features, hidden_features) # 此处的Linear是前面自定义的全连接层self.layer2 &＃61; Linear(hidden_features, out_features)def forward(self, x):x &＃61; self.layer1(x)x &＃61; t.sigmoid(x)return self.layer2(x)perceptron &＃61; Perceptron(3, 4, 1) for name, param in perceptron.named_parameters():print(name, param.size()) # layer1.w torch.Size([3, 4]) # layer1.b torch.Size([4]) # layer2.w torch.Size([4, 1]) # layer2.b torch.Size([1])# 构造函数__init__中&＃xff0c;可利用前面自定义的Linear层&＃xff08;module&＃xff09; # 作为当前module对象的一个子module&＃xff0c;它的可学习参数&＃xff0c;也会成为当前module的可学习参数# ---module中parameter的命名规范--------- # 输入输出的形状&＃xff0c;如nn.linear的输入形状是&＃xff08;N&＃xff0c;input_features&＃xff09;, # 输出为&＃xff08;N&＃xff0c;output_features)&＃xff0c;N是batch_size # 这些自定义Layer对输入形状都有形状&＃xff0c;输入的不是单个数据&＃xff0c;而是一个batch # 输入只有一个数据&＃xff0c;则必须调用tensor.unsqueeze(0)或tensor[None]将 # 将数据伪装成batch_size&＃61;1的batch# ------------4.1 常用神经网络层--------------------------------------------------- # ----------4.1.1 图像相关层------------------------------- # 图像相关层主要包括卷积层&＃xff08;Conv&＃xff09;\池化层&＃xff08;Pool&＃xff09;&＃xff0c;这些层在实际使用中可分为 # 一维&＃xff08;1D&＃xff09;&＃xff0c;二维&＃xff08;2D&＃xff09;&＃xff0c;三维&＃xff08;3D&＃xff09;&＃xff0c;池化方式又分为平均池化&＃xff08;AvgPool), # 最大值池化&＃xff08;MaxPool&＃xff09;&＃xff0c;自适应池化&＃xff08;Adaptive AvgPool&＃xff09;等 # 而卷积层除了常用的前向卷积之外&＃xff0c;还有逆卷积&＃xff08;TransposeConcv&＃xff09; # 一般来说&＃xff0c;一维卷积用于文本数据&＃xff0c;二维卷积用于图像数据&＃xff0c; # 对宽度和高度都进行卷积&＃xff0c;三维卷积用于视频及3D图像处理领域&＃xff08;检测动作及人物行为&＃xff09;&＃xff0c; # 对立方体的三个面进行卷积。二维卷积的用处范围最广&＃xff0c;在计算机视觉中广泛应用。 from PIL import Image from torchvision.transforms import ToTensor, ToPILImage import numpy as npto_tensor &＃61; ToTensor() # Img->tensor to_pil &＃61; ToPILImage() # tensor->Img lena &＃61; Image.open(&＃39;lena.png&＃39;) print(lena) # lena.show() # 显示图片 # 将PIL Image图片转换为numpy数组 im_arry &＃61; np.array(lena) print(im_arry.size) # 40000 # 也可以np.asarray(im)区别是np.array()是深拷贝&＃xff0c;np.asarray&＃xff08;&＃xff09;是浅拷贝# 输入是一个batch&＃xff0c;batch_size&＃61;1 # 大小为200*200 input &＃61; to_tensor(lena).unsqueeze(0) # 锐化卷积核 kernel &＃61; t.ones(3, 3) / -9. print(&＃39;kernel:&＃39;, kernel) kernel[1][1] &＃61; 1 print(&＃39;kernel:&＃39;, kernel) # 锐化卷积核 # kernel: tensor([[-0.1111, -0.1111, -0.1111], # [-0.1111, 1.0000, -0.1111], # [-0.1111, -0.1111, -0.1111]]) # 输入通道&＃xff0c;输出通道&＃xff0c;步长&＃xff0c;卷积核大小&＃xff0c;&＃xff0c;是否添加偏置进行参数学习 conv &＃61; nn.Conv2d(1, 1, (3, 3), 1, bias&＃61;False) conv.weight.data &＃61; kernel.view(1, 1, 3, 3) # 这里卷积核w的参数个数是(3*3*3&＃43;1)*1&＃xff0c; # (输入通道3&＃xff0c;卷积核大小3*3&＃xff0c;一个偏置&＃xff0c;输出通道1) print(conv.weight.data) out &＃61; conv(input) # to_pil(out.data.squeeze(0)).show()# 池化层可以看作一种特殊的卷积层&＃xff0c;用来下采样&＃xff0c; # # 但池化层没有可学习参数&＃xff0c;其weight是固定的 pool &＃61; nn.AvgPool2d(2, 2) # 2维最大化操作 print(list(pool.parameters())) # []没有参数 out &＃61; pool(input) # to_pil(out.data.squeeze(0)).show() # 转化为一维数组才可以&＃xff0c;squeeze(0),维度为1的压缩# 除了卷积层和池化层&＃xff0c;深度学习还将常用到 # Linear&＃xff1a;全连接层&＃xff1b; # BatchNorm&＃xff1a;批规范化层&＃xff0c;分为1D,2D,3D&＃xff0c; # 除了标准的BatchNorm之外&＃xff0c;还有风格迁移中常用InstanceNorm层 # Dropout层&＃xff0c;用来防止过拟合&＃xff0c;同样分为1D,2D,3D # 输入batch_size&＃61;2,维度3# &＃xff08;1&＃xff09;Linear层 input &＃61; t.randn(2, 3) # [-1,1] linear &＃61; nn.Linear(3, 4) # 输入&＃xff0c;输出 h &＃61; linear(input) print(h) # tensor([[-0.2813, -1.1104, -0.6374, 1.0212], # [ 0.1217, -1.2646, -0.1236, 0.5959]], grad_fn&＃61;)# &＃xff08;2&＃xff09;BatchNorm---批规范化层 # 4 channel&＃xff0c;初始化标准差为4&＃xff0c;均值为0 bn &＃61; nn.BatchNorm1d(4) bn.weight.data &＃61; t.ones(4) * 4 bn.bias.data &＃61; t.zeros(4) bn_out &＃61; bn(h) print(bn_out) # tensor([[ 3.9999, -4.0000, -3.9995, 3.9931], # [-3.9999, 4.0000, 3.9995, -3.9931]], # grad_fn&＃61;) print(bn_out.mean(0), "\n", bn_out.var(0, unbiased&＃61;False)) # 0/1代表维度 # 输出均值为0&＃xff0c;方差为16&＃xff08;有正负&＃xff09; # 方差是标准差的平方&＃xff0c;计算无偏分差分母会减一 # 使用unbiased&＃61;False,分母不减一# &＃xff08;3&＃xff09;Dropout层 dropout &＃61; nn.Dropout(0.5) # 每个元素以0.5的概率舍弃 out &＃61; dropout(bn_out) print(bn_out) print(out) # 有一半左右的数变为0 # tensor([[-7.9998, 7.9998, -7.9998, -0.0000], # [ 0.0000, -0.0000, 7.9998, 0.0000]], grad_fn&＃61;)# a&＃61;t.rand(2,4)*5 # print(a) # tensor([[4.4786, 4.4752, 3.1746, 3.7649], # [2.7463, 0.6550, 4.0261, 1.9380]]) # dropout &＃61; nn.Dropout(0.5) # out_a&＃61;dropout(a) # print(out_a) # tensor([[0.0000, 8.9505, 0.0000, 0.0000], # [5.4926, 0.0000, 8.0522, 0.0000]])# ----------------------4.1.2 激活函数------------------------------------------------- relu &＃61; nn.ReLU(inplace&＃61;True) input &＃61; t.randn(2, 3) print(input) output &＃61; relu(input) # max(0,x)&＃xff0c;小于0的都被截断为0 print(output) # 等价于input.clamp(min&＃61;0) # 在以上的例子中&＃xff0c;将每一层的输出直接作为下一层的输入&＃xff0c;这种网络称为前馈传播网络 # feedforward neural network # 对于此类网络如果每次都写复杂的forward函数比较&＃xff0c;简化方式为ModuleList和Sequential # 其中Sequential是一种特殊的Module&＃xff0c;包含几个子Module,前向传播时会将输入一层接一层的传递下去 # ModuleList一个特殊的module&＃xff0c;可以包含几个子module,可以像用list一样使用它 # 但不能直接把输入传给ModuleList# Sequential的三种写法 net1 &＃61; nn.Sequential() net1.add_module(&＃39;conv&＃39;, nn.Conv2d(3, 3, 3)) # 输入通道&＃xff0c;输出通道&＃xff0c;卷积核大小 net1.add_module(&＃39;batchnorm&＃39;, nn.BatchNorm2d(3)) # 均值0&＃xff0c;标准差3 net1.add_module(&＃39;activation_layer&＃39;, nn.ReLU()) # 激活层net2 &＃61; nn.Sequential(nn.Conv2d(3, 3, 3), nn.BatchNorm2d(3), nn.ReLU())from collections import OrderedDictnet3 &＃61; nn.Sequential(OrderedDict([(&＃39;conv1&＃39;, nn.Conv2d(3, 3, 3)),(&＃39;bn1&＃39;, nn.BatchNorm2d(3)),(&＃39;relu1&＃39;, nn.ReLU()) ]))print(&＃39;net1:&＃39;, net1) print(&＃39;net2:&＃39;, net2) print(&＃39;net3:&＃39;, net3) # net1: Sequential( # (conv): Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1)) # (batchnorm): BatchNorm2d(3, eps&＃61;1e-05, momentum&＃61;0.1, affine&＃61;True, track_running_stats&＃61;True) # (activation_layer): ReLU() # ) # net2: Sequential( # (0): Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1)) # (1): BatchNorm2d(3, eps&＃61;1e-05, momentum&＃61;0.1, affine&＃61;True, track_running_stats&＃61;True) # (2): ReLU() # ) # net3: Sequential( # (conv1): Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1)) # (bn1): BatchNorm2d(3, eps&＃61;1e-05, momentum&＃61;0.1, affine&＃61;True, track_running_stats&＃61;True) # (relu1): ReLU() # ) # BatchNorm1d(num_features, eps&＃61;1e-05, momentum&＃61;0.1, affine&＃61;True) # num_features&＃61;batch_size, # eps&＃xff1a;为保持数值稳定性&＃xff08;分母不能趋近或取0&＃xff09;&＃xff0c;给分母加上的数值&＃xff0c;默认为1e-5 # momentum:动态均值和动态方差使用的动量&＃xff0c;默认为0.1 # affine:一个布尔值&＃xff0c;当设为true,给该层添加可学习的仿射变换参数# 可根据名字或序号取出子module print(net1.conv, "\n", net2[0], "\n", net3.conv1) # Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1)) # Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1)) # Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1))input &＃61; t.rand(1, 3, 4, 4) print(input) print(net1(input)) # 4-3&＃43;1&＃61;2 # tensor([[[[0.9605, 0.9013], # [0.0000, 0.0000]], # # [[0.0758, 1.5793], # [0.0000, 0.0000]], # # [[0.0000, 1.2621], # [0.0000, 0.5575]]]], grad_fn&＃61;) output &＃61; net2(input) output &＃61; net3(input) output &＃61; net3.relu1(net1.batchnorm(net1.conv(input)))# ModuleList的写法 modellist &＃61; nn.ModuleList([nn.Linear(3, 4), nn.ReLU(), nn.Linear(4, 2)]) input &＃61; t.randn(1, 3) for model in modellist:input &＃61; model(input)# 下面会报错&＃xff0c;因为modelist没有实现forward方法 # output&＃61;modelist(input)# 不使用Python自带的list&＃xff0c;因为Modulelist是Module的子类&＃xff0c; # 当在Module中它时&＃xff0c;就能自动识别为子module # 举例说明 class MyModule(nn.Module): # 继承父类Moduledef __init__(self):super(MyModule, self).__init__() # 必须初始化构造函数self.list &＃61; [nn.Linear(3, 4), nn.ReLU()]self.module_list &＃61; nn.ModuleList([nn.Conv2d(3, 3, 3), nn.ReLU()])def forward(self):passmodel &＃61; MyModule() print(model) # MyModule( # (module_list): ModuleList( # (0): Conv2d(3, 3, kernel_size&＃61;(3, 3), stride&＃61;(1, 1)) # (1): ReLU() # ) # ) for name, param in model.named_parameters():print(name, param.size()) # module_list.0.weight torch.Size([3, 3, 3, 3]) # module_list.0.bias torch.Size([3]) # 可见&＃xff0c;list的子Module不能被主module所识别&＃xff0c;而Mdolelist中的子module能够被主module # 所识别&＃xff0c;这意味着如果用List保存子module,将无法调整参数&＃xff0c;因为并未加入到主Module的参数中# ------------------------4.1.3 循环神经网络&＃xff08;RNN&＃xff09;------------------------------------------------ # 说明&＃xff1a;LSTM有7个参数&＃xff0c;前三个是必须输入的参数 # (1)input_size:输入的特征维度 # &＃xff08;2&＃xff09;hidden_size:隐状态的特征维度 # &＃xff08;3&＃xff09;num_layer:层数&＃xff08;和时序展开要区分开&＃xff09; # &＃xff08;4&＃xff09;bias&＃xff1a;如果False&＃xff0c;那么LSTM不会使用b&＃xff0c;默认为True # &＃xff08;5&＃xff09;batch_first:如果为True&＃xff0c;输入输出形状为&＃xff08;batch&＃xff0c;seq&＃xff0c;feature&＃xff09; # &＃xff08;6&＃xff09;dropout-如果为非零的话&＃xff0c;将在RNN每层后加一个dropout&＃xff0c;最后一层除外 # &＃xff08;7&＃xff09;bidirectional如果为True&＃xff0c;将会变成双向RNN&＃xff0c;默认为False# 设置随机数种子 t.manual_seed(1000) # 输入&＃xff1a;batch_size&＃61;3,序列长度都为2&＃xff0c;序列中每个元素占4维 input &＃61; t.randn(2, 3, 4) # lstm输入层特征维度4维&＃xff0c;隐藏层特征维度为3,共堆叠1层 lstm &＃61; nn.LSTM(4, 3, 1) # lstm输入input&＃xff0c;&＃xff08;h0&＃xff0c;c0&＃xff09; # h_0保存着batch中每个元素的初始化隐状态的tensor # c_0保存着batch中每个元素的初始化细胞状态的tensor # 初始状态&＃xff1a;1层&＃xff0c;batch_size&＃61;3,3个隐藏元 h0 &＃61; t.randn(1, 3, 3) c0 &＃61; t.randn(1, 3, 3) out, hn &＃61; lstm(input, (h0, c0)) print(out) # tensor([[[-0.3610, -0.1643, 0.1631], # [-0.0613, -0.4937, -0.1642], # [ 0.5080, -0.4175, 0.2502]], # # [[-0.0703, -0.0393, -0.0429], # [ 0.2085, -0.3005, -0.2686], # [ 0.1482, -0.4728, 0.1425]]], grad_fn&＃61;) t.manual_seed(1000) input &＃61; t.randn(2, 3, 4) # LSTMCell的输入参数 # input_size:输入的特征维度 # hidden_size:隐状态的维度 # bias&＃xff1a;如果False&＃xff0c;将不会使用bias&＃xff0c;默认为True # 一个LSTMCell对应的层数只能是一层 lstm &＃61; nn.LSTMCell(4, 3) hx &＃61; t.randn(3, 3) cx &＃61; t.randn(3, 3) out &＃61; [] for i_ in input:hx, cx &＃61; lstm(i_, (hx, cx))out.append(hx) print(t.stack(out)) # tensor([[[-0.3610, -0.1643, 0.1631], # [-0.0613, -0.4937, -0.1642], # [ 0.5080, -0.4175, 0.2502]], # # [[-0.0703, -0.0393, -0.0429], # [ 0.2085, -0.3005, -0.2686], # [ 0.1482, -0.4728, 0.1425]]], grad_fn&＃61;)# -----------------------------4.1.4 损失函数---------------------------------------------------------- # 深度学习中损失函数&＃xff08;loss function)&＃xff0c;也可以看做一种特殊的layer&＃xff0c; # PyTorch也将这些损失函数实现为nn.Module的子类&＃xff0c; # 然而实际使用中通常将这些loss function专门提取出来&＃xff0c;与主模型相互独立# batch_size&＃61;3&＃xff0c;计算对应每个类别的分数&＃xff08;只有两个类别&＃xff09; score &＃61; t.randn(3, 2) # [正态分布] print(score) # 三个样本分别属于1,0,1类&＃xff0c;label必须是LongTensor label &＃61; t.Tensor([1, 0, 1]).long() # loss与普通的layer无差异 criterion &＃61; nn.CrossEntropyLoss() # 交叉熵损失函数 loss &＃61; criterion(score, label) print(loss)# --------------------------4.2 优化器-------------------------------------------------------------------- # PyTorch将深度学习中常用的优化方法封装在torch.optim中 # 所有的优化方法都是继承基类optim.Optimizer&＃xff0c;并实现了自己的优化步骤 # 最基本的优化方法&＃xff0c;随机梯度下降法&＃xff08;SGD&＃xff09; # 主要内容分别是&＃xff1a; # &＃xff08;1&＃xff09;优化方法的基本使用方法 # &＃xff08;2&＃xff09;对模型的不同部分设置不同的学习率 # &＃xff08;3&＃xff09;调整学习率 # 首先定义一个LetNet网络 class Net(nn.Module): # 继承基类Moduledef __init__(self): # 初始化构造函数super(Net, self).__init__()self.features &＃61; nn.Sequential( # Sequential会自动将一层的输出到下一层的输入nn.Conv2d(3, 6, 5), # 输入通道&＃xff0c;输出通道&＃xff0c;卷积核大小nn.ReLU(),nn.MaxPool2d(2, 2), # 池化窗口大小nn.Conv2d(6, 16, 5), # 输入通道&＃xff0c;输出通道&＃xff0c;卷积核大小nn.ReLU(),nn.MaxPool2d(2, 2) # 池化窗口大小)self.classifier &＃61; nn.Sequential(nn.Linear(16 * 5 * 5, 120), # 输入维度&＃xff0c;输出维度nn.ReLU(),nn.Linear(120, 84),nn.ReLU(),nn.Linear(84, 10))def forward(self, x):x &＃61; self.features(x)x &＃61; x.view(-1, 16 * 5 * 5)x &＃61; self.classifier(x)return xnet &＃61; Net() from torch import optimoptimizer &＃61; optim.SGD(params&＃61;net.parameters(), lr&＃61;1) optimizer.zero_grad() # 梯度清零&＃xff0c;等价于net.zeros_grad() input &＃61; t.randn(1, 3, 32, 32) output &＃61; net(input) output.backward(output) # fake backward optimizer.step() # 执行优化 print("----------------------") print(optimizer) # SGD ( # Parameter Group 0 # dampening: 0 # lr: 1 # momentum: 0 # nesterov: False # weight_decay: 0 # ) # ------------(1)为不同子网络设置不同的学习率&＃xff0c;在finetune中经常用到--------------- # 如果对某个参数不指定学习率&＃xff0c;就是用最外层的默认学习率 optimizer &＃61; optim.SGD([{&＃39;params&＃39;: net.features.parameters()},{&＃39;params&＃39;: net.classifier.parameters(), &＃39;lr&＃39;: 1e-2} ], lr&＃61;1e-5) print("----------------------") print(optimizer) # SGD ( # Parameter Group 0 # dampening: 0 # lr: 1e-05 # momentum: 0 # nesterov: False # weight_decay: 0 # # Parameter Group 1 # dampening: 0 # lr: 0.01 # momentum: 0 # nesterov: False # weight_decay: 0 # ) # --------------------(2)只为两个全连接层设置较大的学习率&＃xff0c;其余层的学习率较小-------------- special_layers &＃61; nn.ModuleList([net.classifier[0], net.classifier[3]]) special_layers_params &＃61; list(map(id, special_layers.parameters())) base_params &＃61; filter(lambda p: id(p) not in special_layers_params,net.parameters()) optimizer &＃61; t.optim.SGD([{&＃39;params&＃39;: base_params},{&＃39;params&＃39;: special_layers.parameters(), &＃39;lr&＃39;: 0.01} ], lr&＃61;0.001) print("------------------") print(optimizer) # SGD ( # Parameter Group 0 # dampening: 0 # lr: 0.001 # momentum: 0 # nesterov: False # weight_decay: 0 # # Parameter Group 1 # dampening: 0 # lr: 0.01 # momentum: 0 # nesterov: False # weight_decay: 0 # )# --------------调整学习率----------------------- # 对于如何调整学习率&＃xff0c;主要两种做法&＃xff1a; # &＃xff08;1&＃xff09;修改optimizer.params_groups中对应的学习率&＃xff0c; # &＃xff08;2&＃xff09;新建优化器--更简单&＃xff0c;较为推荐 # 由于optimizer十分轻量级&＃xff0c;构建开销很小&＃xff0c;故而可以构建新的optimizer # 但是后者对于使用动量的优化器&＃xff0c;会丢失动量等状态信息&＃xff0c; # 可能会造成损失函数的收敛出现震荡等情况 # --------------方法1&＃xff1a;调整学习率&＃xff0c;新建一个optimizer------------ old_lr &＃61; 0.01 optimizer1 &＃61; optim.SGD([{&＃39;params&＃39;: net.features.parameters()},{&＃39;params&＃39;: net.classifier.parameters(), &＃39;lr&＃39;: old_lr * 0.1} ], lr&＃61;1e-5) print(optimizer1) # SGD ( # Parameter Group 0 # dampening: 0 # lr: 1e-05 # momentum: 0 # nesterov: False # weight_decay: 0 # # Parameter Group 1 # dampening: 0 # lr: 0.001 # momentum: 0 # nesterov: False # weight_decay: 0 # ) # ----------方法2&＃xff1a;调整学习率&＃xff0c;手动decay,保存动量------------------------- for param_group in optimizer.param_groups:param_group[&＃39;lr&＃39;] *&＃61; 0.1 # 学习率为之前的0.1倍 print(optimizer) # SGD ( # Parameter Group 0 # dampening: 0 # lr: 0.0001 # momentum: 0 # nesterov: False # weight_decay: 0 # # Parameter Group 1 # dampening: 0 # lr: 0.001 # momentum: 0 # nesterov: False # weight_decay: 0 # )# -----------------------------4.3 nn.functional------------------------------------------------ # nn中很常用的模块&＃xff0c;nn.functional&＃xff0c;nn中多数layer在functional中都有一个与之相对应的函数 # nn.functional中的函数和nn.Module的主要区别在于&＃xff0c;用nn.Module实现的layers是一个特殊的类 # 都是由class layer(nn.Module)定义&＃xff0c;会自动提取可学习的参数&＃xff0c;而nn.functional中的函数 # 更像一个纯函数&＃xff0c;由def function(input)定义 input &＃61; t.randn(2, 3) model &＃61; nn.Linear(3, 4) output1 &＃61; model(input) output2 &＃61; nn.functional.linear(input, model.weight, model.bias) print(output1 &＃61;&＃61; output2) print(output1) print(output2) # 输出一模一样b &＃61; nn.functional.relu(input) b2 &＃61; nn.ReLU()(input) print(b &＃61;&＃61; b2) # 一样 # 如果模型&＃xff08;卷积&＃xff0c;全连接&＃xff09;有可学习的参数&＃xff0c;最好用nn.Module # 否则&＃xff08;激活函数&＃xff0c;池化&＃xff09;都可以&＃xff0c;二者在性能上没有太大差异 # 另外虽然dropout没有可学习参数&＃xff0c;但建议nn.Dropout # 因为dropout在训练和测试两个阶段的行为有所差别&＃xff0c; # 使用nn.Module对象能够通过model.eval操作加以区分 # 下列在模型中搭配使用nn.Module和nn.functional from torch.nn import functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 &＃61; nn.Conv2d(3, 6, 5),self.conv2 &＃61; nn.Conv2d(6, 16, 5)self.fc1 &＃61; nn.Linear(16 * 5 * 5, 120)self.fc2 &＃61; nn.Linear(120, 84)self.fc3 &＃61; nn.Linear(84, 10)def forward(self, x):x &＃61; F.pool(F.relu(self.conv1(x)), 2)x &＃61; F.pool(F.relu(self.conv2(x)), 2)x &＃61; x.view(-1, 16 * 5 * 5)x &＃61; F.relu(self.fc1(x))x &＃61; F.relu(self.fc2(x))x &＃61; self.fc3(x)return x# 对于不具备可学习参数的&＃xff08;激活、池化&＃xff09;&＃xff0c;将它们用函数代替&＃xff0c;这样可以不用放置在 # 构造函数__init__中&＃xff0c;对于由可学习参数的模块&＃xff0c;也可以用funciotnal代替 # 但是较为繁琐&＃xff0c;需要自定义参数parameter,如前面的实现的自定义全连接层 # 可以将weight和bias两个参数单独拿出来&＃xff0c;在构造函数中初始化parameter # class MyLinear(nn.Module): # 继承基类Module # def __init__(self): # 必须初始化构造函数 # super(MyLinear, self).__init__() # self.weight &＃61; nn.Parameter(t.randn(3, 4)) # self.bias &＃61; nn.Parameter(t.zeros(3)) # # def forward(self): ##----------&＃xff01;&＃xff01;&＃xff01;------------ # return F.linear(input, weight, bias)# --------------------------4.4 初始化策略----------------------------------------------- # 深度学习中参数的初始化&＃xff0c;良好的初始化能让模型更快收敛&＃xff0c;糟糕的初始化可能是的模型迅速瘫痪 # PyTorch中nn.Module的模块参数采取了较为合理的初始化策略 # PyTorch中nn.init模块就是专门为初始化而设计&＃xff0c; # 如果某种初始化策略nn.init不提供&＃xff0c;用户也可以自己直接初始化 # &＃xff08;1&＃xff09;利用nn.init初始化----------- from torch.nn import initlinear &＃61; nn.Linear(3, 4) # 设置随机数种子 t.manual_seed(1) # 等价于 linear.weight.data.normal_(0,std) # 用一个均匀分布生成之&＃xff0c;填充输入的张量或变量&＃xff0c;结果张量中的值采样子U(-bound,bound) init.xavier_normal_(linear.weight) print(linear.weight) # &＃xff08;2&＃xff09;直接初始化------------------ import matht.manual_seed(1) # xavier初始化的计算公式 std &＃61; math.sqrt(2) / math.sqrt(7.) linear.weight.data.normal_(0, std) print(linear.weight)# (3)对模型所有参数进行初始化 for name, params in net.named_parameters():if name.find(&＃39;linear&＃39;) !&＃61; -1:# 初始化Linearparam[0] # weightparam[1] # biaselif name.find(&＃39;conv&＃39;) !&＃61; -1:passelif name.find(&＃39;norm&＃39;) !&＃61; -1:pass# ---------------------------4.5 mm.Module深入分析----------------------------------------------------------- # nn.Module基类的构造函数 # def __init__(self): # self._parameters&＃61;OrderedDict() # self._modules&＃61;OrderedDict() # self._buffers&＃61;OrderedDict() # self._backward_hooks&＃61;OrderedDict() # self._forward_hooks&＃61;OrderedDict() # self.training&＃61;True # 对每个属性解释如下&＃xff1a; # &＃xff08;1&＃xff09;_parameters:字典&＃xff0c;保存用户直接设置的parameters&＃xff0c; # self.param1&＃61;nn.Parameter(t.randn(3,3))会被检测到&＃xff0c;在字典中 # 加入一个key为‘param&＃39;,value对应parameter的item&＃xff0c; # 而self.submodule&＃61;nn.Linear(3,4)中的parameter则不会存于此 # (2)_modules:子modules:子module, # 通过slef.submodel&＃61;nn.Linear(3,4)指定的子module会保存于此 # 下面举例说明 class Net(nn.Module): # 继承基类(Module)def __init__(self): # 初始化构造函数super(Net, self).__init__()# 等价与self.register_parameter(&＃39;param1&＃39;,nn.Parameter(t.randn(3,3)))self.param1 &＃61; nn.Parameter(t.rand(3, 3))self.submodule1 &＃61; nn.Linear(3, 4)def forward(self, input):x &＃61; self.param1.mm(input)x &＃61; self.submodule1(x)return xnet &＃61; Net() print(net) # Net( # (submodule1): Linear(in_features&＃61;3, out_features&＃61;4, bias&＃61;True) # ) print(net._modules) # OrderedDict([(&＃39;submodule1&＃39;, Linear(in_features&＃61;3, out_features&＃61;4, bias&＃61;True))]) print(net._parameters) # tensor([[0.3398, 0.5239, 0.7981], # [0.7718, 0.0112, 0.8100], # [0.6397, 0.9743, 0.8300]], requires_grad&＃61;True))]) print(net.param1) # 等价于net._patameters[&＃39;param1&＃39;] # Parameter containing: # tensor([[0.3398, 0.5239, 0.7981], # [0.7718, 0.0112, 0.8100], # [0.6397, 0.9743, 0.8300]], requires_grad&＃61;True) for name, param in net.named_parameters():print(name, param.size()) # param1 torch.Size([3, 3]) # submodule1.weight torch.Size([4, 3]) # submodule1.bias torch.Size([4]) for name, submodel in net.named_modules():print(name, submodel) # Net( # (submodule1): Linear(in_features&＃61;3, out_features&＃61;4, bias&＃61;True) # ) # submodule1 Linear(in_features&＃61;3, out_features&＃61;4, bias&＃61;True)# &＃xff08;3&＃xff09;_buffers:缓存&＃xff0c;------------------ # 如batchnorm使用momentum机制&＃xff0c;每次前向传播需用到上一次前向传播的结果 # batchNorm1d是对小批量进行批标准化操作&＃xff0c;在每个小批量数据中 # 计算输入各个维度的均值和标准差 # --在训练时--&＃xff0c;该层计算每次输入的均值和方差&＃xff0c;并进行移动平均&＃xff0c;移动平均默认的动量值为0.1 # --在验证时--&＃xff0c;训练求得的均值/方差用于标准化验证数据 # num_features:来自期望输入的特征数 # eps&＃xff0c;为保证数值稳定性&＃xff08;分母不能趋近或取0&＃xff09;&＃xff0c;给分母加上值&＃xff0c;默认为1e-5 # momentum:动态均值和动态方差所使用的动量&＃xff0c;默认为0.1 # affine,一个布尔值&＃xff0c;当设为true&＃xff0c;该给层添加可学习的仿射变换参数 bn &＃61; nn.BatchNorm1d(2) # 批量规范化&＃xff0c;2是输入的特征维度 input &＃61; t.rand(3, 2) print(input) # tensor([[0.4452, 0.0193], # [0.2616, 0.7713], # [0.3785, 0.9980]]) output &＃61; bn(input) print(bn._buffers) # 缓存作用 # OrderedDict([(&＃39;running_mean&＃39;, tensor([0.0362, 0.0596])),# 输入平均值 # (&＃39;running_var&＃39;, tensor([0.9009, 0.9262])),#输入方差 # (&＃39;num_batches_tracked&＃39;, tensor(1))])# nn.Module在实际使用中可能层层嵌套&＃xff0c;一个Module包含若干个子module&＃xff0c; # 每个子module又包含了更多的子module&＃xff0c; # 为方便用户访问各个子module&＃xff0c;nn.Module实现了很多方法&＃xff0c;如函数children可以查看直接子module # 函数module可以查看所有的子module(包括当前module), # 与之相对应的还有函数named_children和named_modules, # 其能够在返回module列表的同时返回它们的名字# ---(4)training:BatchNorm和Dropout层在训练阶段和测试阶段中采取的策略不同&＃xff0c;----------- # 通过判断training值来决定前向传播策略 input &＃61; t.arange(0, 12).view(3, 4) print(input) model &＃61; nn.Dropout() # 在训练阶段&＃xff0c;会有一半左右的数被随机置为0 # model(input) model.training &＃61; False # 在测试阶段&＃xff0c;dropout什么都不做 model(input) # tensor([[ 0, 1, 2, 3], # [ 4, 5, 6, 7], # [ 8, 9, 10, 11]]) # 对于batchnorm,dropout,instancenorm等在训练阶段和测试阶段行为差异巨大的层 # 如果测试中不将其training值设为True,可能会有很大影响。 print(net.training, net.submodule1.training) # True True net.eval() print(net.training, net.submodule1.training) # False False print(list(net.named_modules())) # [(&＃39;&＃39;, Net( # (submodule1): Linear(in_features&＃61;3, out_features&＃61;4, bias&＃61;True) # )), (&＃39;submodule1&＃39;, Linear(in_features&＃61;3, out_features&＃61;4, bias&＃61;True))]# (4——----&＃xff08;5&＃xff09;backward_hooks与__forward_hooks:钩子技术&＃xff0c;用来提取中间变量&＃xff0c;类似于variable的hook # register_forward_hook与register_backward_hook&＃xff0c;这两个函数功能类似于variable函数 # 的register_hook,可在module前向传播或反向传播时注册钩子&＃xff0c;每次前向传播执行结束后悔执行钩子函数&＃xff08;hook) # 前向传播的钩子函数具有如下形式&＃xff0c;hook(module,input,output)->None, # 反向传播如下形式&＃xff1a;hook(module,grad_input,grad_output)->Tensor or None # 钩子函数不应该修改输入和输出&＃xff0c;并且在使用后应及时删除&＃xff0c;以避免每次都运行钩子增加运行负载 # 钩子函数主要用在获取某些中间结果的情景&＃xff0c;如中间某一层的输出或某一层的梯度&＃xff0c; # 这些结果本应写在forward函数中&＃xff0c;但如果forward函数中专门加上这些处理&＃xff0c;可能会使处理逻辑比较复杂 # 假设&＃xff0c;有一个预训练好的模型&＃xff0c;需要提取模型的某一层&＃xff08;不是最后一层&＃xff09;的输出作为特征进行分类 # 但有不希望修改其原有的模型定义文件&＃xff0c;这时就可以利用钩子函数&＃xff0c;下面为实现的伪代码 # mode# l&＃61;VGG() # feat# ures&＃61;t.Tensor() # def # hook(module,input,output): # """把这层的输出拷贝到features""" # features.copy_(output.data) # handle&＃61;model.layer8.register&＃43;forward_hook(hook) # _&＃61;model(input) # 用完hook删除 # handle.remove()# --------setatter和getattr函数------------------ # nn.Module实现了自定义的__setattr__函数&＃xff0c;当执行module.name&＃61;value时&＃xff0c; # 会在__setattr__中判断value是否为Parameter或者nn.Module对象&＃xff0c; # 如果是则将这些对象加到_parameters和modules两个字典中&＃xff0c;而如果是其他类型的对象 # 如variable\list\dict等&＃xff0c;则调用默认的操作&＃xff0c;将这个值保存在__dict__中 module &＃61; nn.Module() module.param &＃61; nn.Parameter(t.ones(2, 2)) print(module._parameters) # OrderedDict([(&＃39;param&＃39;, Parameter containing: # tensor([[1., 1.], # [1., 1.]], requires_grad&＃61;True))]) submodule1 &＃61; nn.Linear(2, 2) submodule2 &＃61; nn.Linear(2, 2) module_list &＃61; [submodule1, submodule2] # 对于List对象&＃xff0c;调用building函数&＃xff0c;保存在__dict__中 module.submodules &＃61; module_list print(&＃39;_modules:&＃39;, module._modules) print("__dict__[&＃39;submodules&＃39;]:", module.__dict__.get(&＃39;submodules&＃39;)) # _modules: OrderedDict() # __dict__[&＃39;submodules&＃39;]: # [Linear(in_features&＃61;2, out_features&＃61;2, bias&＃61;True), # Linear(in_features&＃61;2, out_features&＃61;2, bias&＃61;True)]module_list &＃61; nn.ModuleList(module_list) # 开始嵌套 module.submodules &＃61; module_list # isinstance()函数&＃xff0c;Python内置函数&＃xff0c;用来判断一个函数是否为一个已知的类型 print(&＃39;ModuleList is instance of nn.Module:&＃39;, isinstance(module_list, nn.Module)) print(&＃39;_modules:&＃39;, module._modules) print("__dict__[&＃39;submodules&＃39;]:", module.__dict__.get(&＃39;submodules&＃39;)) # ModuleList is instance of nn.Module: True # _modules: OrderedDict([(&＃39;submodules&＃39;, ModuleList( # (0): Linear(in_features&＃61;2, out_features&＃61;2, bias&＃61;True) # (1): Linear(in_features&＃61;2, out_features&＃61;2, bias&＃61;True) # ))]) # __dict__[&＃39;submodules&＃39;]: None# 因为_modules和_parameters中的item为保存在__dict__中,所以默认的getatter方法无法获取它&＃xff0c; # 因为nn.Module实现了自定义__getatter__方法&＃xff0c;如果磨人的getatter无法处理 # 就调用自定义的__getatter__方法&＃xff0c;尝试从_modules\_parameters\_buffers这三个字典中获取 print(getattr(module, &＃39;training&＃39;)) # 等价于module.training # True# ---------------4.6 nn和auotgrad的关系---------- # nn.Module利用的autograd技术&＃xff0c;其主要工作实现前向传播&＃xff0c; # 在forward函数中&＃xff0c;nn.Module对输入的tensor进行的各种操作&＃xff0c;本质是用autograd技术 # autograd.Function和nn.Module之间的区别&＃xff1a; # &＃xff08;1&＃xff09;autograd.Function利用了Tensor对autograd技术的拓展&＃xff0c;为autogtad实现了新的运算op, # 不仅要实现前向传播还要手动实现反向传播 # &＃xff08;2&＃xff09;nn.Module利用了autograd技术&＃xff0c;对nn的功能进行拓展&＃xff0c;实现了深度学习中的更多层&＃xff0c; # 只需实现前向传播功能&＃xff0c;autograd会自动实现反向传播 # &＃xff08;3&＃xff09;nn.functional是一些autograd操作的集合&＃xff0c;是经过封装的函数 # 作为两大类的选取&＃xff0c;如果某一个操作在autograd尚未支持&＃xff0c;那么只能实现Function接口对应的前向传播和反向传播 # 如果某些利用autograd接口比较复杂&＃xff0c;可以利用Funtion将多个操作聚合&＃xff0c;实现优化 # 如果只是想在深度学习中增加某一层&＃xff0c;使用nn.Module进行封装则更为简单高效# ---------------------------4.7 搭建ReSet-深度残差网络------------------------------------------------------- # 考虑到Residual block和layer出现了多次&＃xff0c;将其实现为一个子Module或函数&＃xff0c;这里将Residual block # 实现为一个子Module&＃xff0c;而将Layer实现为一个函数&＃xff0c; # 跨层直连的shortcut # ResNet中将一个跨层直连的单元称为Residual block # 拥有多个Residual block单元的结构称之为layer&＃xff0c;这里的layer是几个层的集合 # 下面为实现代码&＃xff0c;规律总结如下&＃xff1a; # 1、对于模型中重复部分&＃xff0c;实现为子Module或用函数生成相应的module make_layer # 2、nn.Functianal和nn.Module结合使用 # 3、尽量使用nn.Sequrntial from torch import nn import torch as t from torch.nn import functional as Fclass ResidualBlock(nn.Module): # 继承基类nn.Module"""实现子module:Residual Block"""# 输入通道&＃xff0c;输出通道&＃xff0c;步长def __init__(self, inchannel, outchannel, stride&＃61;1, shortcut&＃61;None):super(ResidualBlock, self).__init__() # 构造函数初始化self.left &＃61; nn.Sequential(# 输入通道&＃xff0c;输出通道&＃xff0c;卷积核大小&＃xff0c;步长&＃xff0c;不学习参数偏差biasnn.Conv2d(inchannel, outchannel, 3, stride, 1, bias&＃61;None),nn.BatchNorm2d(outchannel), # 批量规范化&＃xff0c;计算平均值及标准差# 参数inplace&＃61;True&＃xff0c;将会改变输入的数据&＃xff0c;否则不会改变原输入&＃xff0c;只会产生新的输出nn.ReLU(inplace&＃61;True),# 卷积层参数&＃xff0c;padding图像四周填0的层数&＃xff1b;dilation控制卷积核元素点之间的空间距离# groups分组卷积&＃xff0c;默认输出输入的所有通道各为一组# 如果group&＃61;2&＃xff0c;输入通道&＃61;32&＃xff0c;输出通道&＃61;48&＃xff0c;那么对应要将输入的32个通道分为2个16通道&＃xff0c;# 将输出的通道分为2个24通道&＃xff0c;对输出的2个24通道&＃xff0c;第一个24通道与输入的第一个16通道进行全卷积# 第二个24通道与输入的第二个通道进行全卷积# 卷积核的深度&＃61;输入通道数# 卷积核的数量&＃61;输出通道数# 输出大小计算&＃xff1a;输出大小&＃61;&＃xff08;输入大小-卷积核大小&＃43;2*填充值大小&＃xff09;/步长大小&＃43;1nn.Conv2d(outchannel, outchannel, 3, 1, 1, bias&＃61;False),nn.BatchNorm2d(outchannel) # 批量规范化)self.right &＃61; shortcutdef forward(self, x):out &＃61; self.left(x)residual &＃61; x if self.right is None else self.right(x)out &＃43;&＃61; residualreturn F.relu(out)class ResNet(nn.Module): # 继承基类nn.Module"""实现主Module&＃xff1a;ResNet34ResNet34包含多个layer&＃xff0c;每个layer又包含多个residual block用子moudel实现residual block&＃xff0c;用_make_layer函数来实现layer(多个Residual block单元的结构)"""def __init__(self, num_classes&＃61;1000):super(ResNet, self).__init__()# 前几层图像转换self.pre &＃61; nn.Sequential(nn.Conv2d(3, 64, 7, 2, 3, bias&＃61;False),nn.BatchNorm2d(64),nn.ReLU(inplace&＃61;True), # 替换输入值nn.MaxPool2d(3, 2, 1) # 窗口大小&＃xff08;默认为窗口大小&＃xff09;&＃xff0c;移动步长&＃xff0c;补充0的层数)# 重复的layer,分别有3,4,6,3个residual blockself.layer1 &＃61; self._make_layer(64, 64, 3)self.layer2 &＃61; self._make_layer(64, 128, 4, stride&＃61;2)self.layer3 &＃61; self._make_layer(128, 256, 6, stride&＃61;2)self.layer4 &＃61; self._make_layer(256, 512, 3, stride&＃61;2)# 分类用的全连接self.fc &＃61; nn.Linear(512, num_classes)def _make_layer(self, inchannel, outchannel, block_num, stride&＃61;1):"""构建layer,包含多个residual block"""shortcut &＃61; nn.Sequential(nn.Conv2d(inchannel, outchannel, 1, stride, bias&＃61;False), # 卷积核大小为1&＃xff0c;相当于没有nn.BatchNorm2d(outchannel))layers &＃61; [] # append函数会在数组后加上相应的元素layers.append(ResidualBlock(inchannel, outchannel, stride, shortcut)) # 会修改原值for i in range(1, block_num):layers.append(ResidualBlock(outchannel, outchannel))return nn.Sequential(*layers)def forward(self, x):x &＃61; self.pre(x)x &＃61; self.layer1(x)x &＃61; self.layer2(x)x &＃61; self.layer3(x)x &＃61; self.layer4(x)x &＃61; F.avg_pool2d(x, 7)x &＃61; x.view(x.size(0), -1)return self.fc(x)model &＃61; ResNet() input &＃61; t.randn(1, 3, 224, 224) o &＃61; model(input) print(o)