手机网站制作方法,民治网站建设,实训百度搜索引擎的总结,网站设计手机主要参考学习资料#xff1a; 《动手学深度学习》阿斯顿张 等 著 【动手学深度学习 PyTorch版】哔哩哔哩跟李牧学AI 概述
为了实现更复杂的网络#xff0c;我们需要研究比层更高一级的单元块#xff0c;在编程中由类表示。通过自定义层和块#xff0c;我们能更灵活地搭建网… 主要参考学习资料 《动手学深度学习》阿斯顿·张 等 著 【动手学深度学习 PyTorch版】哔哩哔哩跟李牧学AI 概述
为了实现更复杂的网络我们需要研究比层更高一级的单元块在编程中由类表示。通过自定义层和块我们能更灵活地搭建网络。我们有多种方法可以访问、初始化和绑定模型参数。为了加载和保存权重向量和整个模型我们需要进行文件读写。将计算设备指定为GPU而不是CPU可以更高效地完成深度学习的计算任务。 目录 4.1 层和块4.1.1 自定义块4.1.2 顺序块 4.2 参数管理4.2.1 参数访问1.目标参数2.一次性访问所有参数3.从嵌套块收集参数 4.2.2 参数初始化1.内置初始化2.自定义初始化 4.2.3 参数绑定 4.3 自定义层4.3.1 不带参数的层4.3.2 带参数的层 4.4 读写文件4.4.1 加载和保存张量4.4.2 加载和保存模型参数 4.5 GPU4.5.1 计算设备4.5.2 张量与GPU4.5.3 神经网络与GPU 4.1 层和块
事实证明研究讨论“比单个层大”但“比整个模型小”的组件更有价值。计算机视觉中广泛流行的ResNet-152架构有数百层这些层是由层组的重复模式组成。为了实现更复杂的网络我们引入神经网络块的概念。
块可以描述单个层、由多个层组成的组件或整个模型本身。使用块的好处是可以将一些块组成更大的组件这一过程通常是递归的。 在编程中块由类表示类的任何子类都必须定义一个将其输入转换为输出的前向传播函数并且必须存储任何必需的参数。为了计算梯度块必须具有反向传播函数。在自定义块时由于自动微分提供了一些后端实现我们只需要考虑前向传播函数和必须的参数。
4.1.1 自定义块
块必须提供的基本功能
将输入数据作为其前向传播函数的参数。通过前向传播函数来生成输出。计算其输出关于输入的梯度可通过其反向传播函数进行访问通常是自动完成的。存储和访问前向传播计算所需的参数。根据需要初始化模型参数。
import torch
from torch import nn
#functional模块提供一些函数化的神经网络操作可直接应用于张量
from torch.nn import functional as F #以Module为父类定义MLP类
class MLP(nn.Module): def __init__(self): #初始化继承自Module的数据属性super().__init__() #实例化两个全连接层self.hidden nn.Linear(20, 256) self.out nn.Linear(256, 10) #定义模型的前向传播根据输入X返回模型输出def forward(self, X): return self.out(F.relu(self.hidden(X)))下面这个例子展示了自定义块的灵活性
class FixedHiddenMLP(nn.Module)def __init__(self):super().__init__()#设置不随梯度更新的固定的权重即常量参数self.rand_weight torch.rand((20, 20), requires_gradFalse)self.linear nn.Linear(20, 20)#在前向传播函数中执行自定义代码def forward(self, X):X self.linear(X)X F.relu(torch.mm(X, self.rand_weight) 1)#复用全连接层相当于这两个全连接层共享参数X self.linear(X)#控制流while X.abs().sum() 1:X / 2return X.sum()4.1.2 顺序块
Sequential类的设计目的是将其他模块串起来。构建自己的简化的MySequential只需定义如下函数
将块逐个追加到列表中的函数。前向传播函数用于将输入按追加块的顺序传递给块组成的“链条”。
class MySequential(nn.Module): #args传入任意数量的模块def __init__(self, *args): super().__init__() #遍历模块并为每个模块分配一个字符串键存入_modules#_modules的变量类型是OrderedDictfor idx, module in enumerate(args): self._modules[str(idx)] module def forward(self, X): #OrderedDict保证按照成员添加的顺序遍历它们for block in self._modules.values(): X block(X) return X4.2 参数管理
4.2.1 参数访问
import torch
from torch import nnnet nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X torch.rand(size(2, 4))通过索引访问模型的任意层state_dict返回所访问层的参数
print(net[2].state_dict())OrderedDict([(weight, tensor([[ 0.2889, -0.2738, -0.3096, -0.3151, 0.2594, 0.1743, -0.2288, -0.1173]])), (bias, tensor([0.0921]))])1.目标参数
每个参数都表示为参数类的一个实例
print(type(net[2].bias))class torch.nn.parameter.Parameter参数是复合的对象如下访问参数实例并进一步访问该参数的值张量类型和梯度
print(net[2].bias)
print(net[2].bias.data)
net[2].weight.grad TrueParameter containing:
tensor([0.0921], requires_gradTrue)
tensor([0.0921])
False另一种访问网络参数的方式
net.state_dict()[2.bias].datatensor([0.0921])2.一次性访问所有参数
访问一个全连接层的参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])(weight, torch.Size([8, 4])) (bias, torch.Size([8]))访问所有层的参数
print(*[(name, param.shape) for name, param in net.named_parameters()])(0.weight, torch.Size([8, 4])) (0.bias, torch.Size([8])) (2.weight, torch.Size([1, 8])) (2.bias, torch.Size([1]))3.从嵌套块收集参数
定义生成块的函数
def block1():return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),nn.Linear(8, 4), nn.ReLU())def block2():net nn.Sequential()for i in range(4):net.add_module(fblock {i}, block1())return net设计一个嵌套块的网络并观察其架构
rgnet nn.Sequential(block2(), nn.Linear(4, 1))
print(rgnet)Sequential((0): Sequential((block 0): Sequential((0): Linear(in_features4, out_features8, biasTrue)(1): ReLU()(2): Linear(in_features8, out_features4, biasTrue)(3): ReLU())(block 1): Sequential((0): Linear(in_features4, out_features8, biasTrue)(1): ReLU()(2): Linear(in_features8, out_features4, biasTrue)(3): ReLU())(block 2): Sequential((0): Linear(in_features4, out_features8, biasTrue)(1): ReLU()(2): Linear(in_features8, out_features4, biasTrue)(3): ReLU())(block 3): Sequential((0): Linear(in_features4, out_features8, biasTrue)(1): ReLU()(2): Linear(in_features8, out_features4, biasTrue)(3): ReLU()))(1): Linear(in_features4, out_features1, biasTrue)
)因为层是分层嵌套的因此可以像通过嵌套列表索引一样访问层。下面访问第一个主要的块中第二个子块的第一层的偏置
rgnet[0][1][0].bias.datatensor([ 0.1969, -0.0747, -0.1520, 0.0474, -0.2245, -0.2320, -0.2794, 0.3429])4.2.2 参数初始化
1.内置初始化
normal_将权重参数初始化为标准差为0.01的高斯随机变量zeros_将偏置参数设置为0
def init_normal(m):if type(m) nn.Linear:nn.init.normal_(m.weight, mean0, std0.01)nn.init.zeros_(m.bias)constant_将所有参数初始化为给定的常量
def init_constant(m):if type(m) nn.Linear:nn.init.constant_(m.weight, 1)nn.init.zeros_(m.bias)xavier_uniform_为上一章中介绍的Xavier均匀分布初始化
def init_xavier(m):if type(m) nn.Linear:nn.init.xavier_uniform_(m.weight)2.自定义初始化
以如下分布为例为任意权重参数 w w w定义初始化方法 w ∼ { U ( 5 , 10 ) , 可能性为 1 4 0 , 可能性为 1 2 U ( − 10 , − 5 ) , 可能性为 1 4 w\sim\left\{\begin{matrix}U(5,10),\displaystyle可能性为\frac14\\0,\displaystyle可能性为\frac12\\U(-10,-5),\displaystyle可能性为\frac14\end{matrix}\right. w∼⎩ ⎨ ⎧U(5,10),0,U(−10,−5),可能性为41可能性为21可能性为41
def my_init(m):if type(m) nn.Linear:#以(-10, 10)为边界的均匀分布nn.init.uniform_(m.weight, -10, 10)#将绝对值小于5的权重清零m.weight.data * m.weight.data.abs() 54.2.3 参数绑定
定义一个层并使用这个层的参数来设置另一个层的参数可以实现参数共享
shared nn.Linear(8, 8)
net nn.Sequential(nn.Linear(4, 8), nn.ReLU(),shared, nn.ReLU,shared, nn.ReLU,nn.Linear(8, 1))改变shared的参数也会同步改变net中两个对应层的参数。
4.3 自定义层
4.3.1 不带参数的层
构建一个从其输入中减去均值的层
import torch
import torch.nn.functional as F
from torch import nnclass CenteredLayer(nn.Module):def __init__(self):super().__init__()def forward(self, X):return X - X.mean()将自定义层作为组件合并到更复杂的模型中
net nn.Sequential(nn.Linear(8, 128), CenteredLayer())该自定义层没有指定输入维度但框架会在数据第一次通过模型传递时动态地推断出每个层的大小即延迟初始化。
4.3.2 带参数的层
下面是自定义版本的全连接层
class MyLinear(nn.Module):#传入输入数和输出数作为参数def __init__(self, in_units, units):super().__init__()#通过Parameter实例创建参数self.weight nn.Parameter(torch.randn(in_units, units))self.bias nn.Parameter(torch.randn(units,))def forward(self, X):linear torch.matmul(X, self.weight.data) self.bias.datareturn F.relu(linear)4.4 读写文件
4.4.1 加载和保存张量
张量通过load和save函数保存到内存并分别读写它们。
import torch
from torch import nn
from torch.nn import functional as F#单个张量
x torch.arange(4)
torch.save(x, x-file)
x2 torch.load(x-file)#张量列表
y torch.zeros(4)
torch.save([x, y], x-files)
x2, y2 torch.load(x-files)#从字符串映射到张量的字典
mydict {x: x, y: y}
torch.save(mydict, mydict)
mydict2 torch.load(mydict)4.4.2 加载和保存模型参数
深度学习框架提供了内置函数来保存和加载整个网络但这只保存模型的参数而不是模型因此架构需要自己生成。先定义一个多层感知机模型
class MLP(nn.Module):def __init__(self):super().__init__()self.hidden nn.Linear(20, 256)self.output nn.Linear(256, 10)def forward(self, X):return self.output(F.relu(self.hidden(X)))net MLP()将模型参数存储在文件mlp.params中
torch.save(net.state_dict(), mlp.params)实例化原多层感知机模型的一个备份并通过直接读取文件中存储的参数来恢复模型
clone MLP()
clone.load_state_dict(torch.load(mlp.params))4.5 GPU
GPU具有强大的并行处理能力、浮点运算速度和内存带宽在处理人工智能这样的复杂计算任务上相较于CPU有无可比拟的优势。首先确保至少安装了一个NVIDIA GPU然后下载NVIDIA驱动和CUDA最后使用nvidia-smi命令查看显卡信息
!nvidia-smi在pytorch中每个数组都有一个设备我们通常称其为环境。默认情况下所有变量和相关的计算都分配给CPU有时环境可能是GPU。
4.5.1 计算设备
我们可以指定用于存储和计算的设备。在pytorch中CPU和GPU可以使用torch.device(‘cpu’)和torch.device(‘cuda’))表示。如果有多个GPU我们使用torch.device(f’cuda:{i})来表示第i块GPUi从0开始以及cuda:0和cuda等价。
import torch
from torch import nntorch.device(cpu), torch.device(cuda), torch.device(cuda:0)(device(typecpu), device(typecuda), device(typecuda, index0))查询可用GPU的数量
torch.cuda.device_count()1定义两个函数以允许在不存在所需GPU的情况下执行代码
def try_gpu(i0):如果存在返回第i个GPU否则返回CPUif torch.cuda.device_count() i 1:return torch.device(fcuda:{i})return torch.device(cpu)def try_all_gpus():返回所有可用的GPU如果没有GPU则返回CPUdevices [torch.device(fcuda:{i}) for i in range(torch.cuda.device_count())]return devices if devices else [torch.device(cpu)]try_gpu(), try_gpu(10), try_all_gpus()(device(typecuda, index0),device(typecpu),[device(typecuda, index0)])4.5.2 张量与GPU
默认情况下张量是在内存中创建并使用CPU进行计算的。
x torch.tensor([1, 2, 3])
x.devicedevice(typecpu)在创建张量时指定存储设备来在GPU上存储张量
X torch.ones(2, 3, devicetry_gpu())
Xtensor([[1., 1., 1.],[1., 1., 1.]], devicecuda:0)假设我们有两个GPU博主没有所以移用示例代码如下在第二个GPU上创建一个随机张量
Y torch.rand(2, 3, devicetry_gpu(1))
Ytensor([[0.2506, 0.4556, 0.9745],[0.2359, 0.6094, 0.0410]] devicecuda:1)如果要计算XY我们需要决定在哪里执行这个操作。张量的计算只能在同一设备上运行因此要将X复制到第二个GPU才能执行
Z X.cuda(1)
print(X)
print(Z)tensor([[1., 1., 1.],[1., 1., 1.]], devicecuda:0)
tensor([[1., 1., 1.],[1., 1., 1.]], devicecuda:1)现在可以在同一个GPU上将其相加
Y Ztensor([[1.2506, 1.4556, 1.9745],[1.2359, 1.6094, 1.0410]] devicecuda:1)4.5.3 神经网络与GPU
类似地神经网络模型可以指定设备将模型参数放在GPU上
net nn.Sequential(nn.Linear(3, 1))
net net.to(devicetry_gpu())
