【动手学深度学习】(十)PyTorch 神经网络基础

news2024/9/29 17:26:20

文章目录

  • 一、层和块
    • 1.自定义块
    • 2.顺序块
    • 3.在前向传播函数中执行代码
  • 二、参数管理
    • 1.参数访问
    • 2.参数初始化
    • 3.参数绑定
  • 三、自定义层
    • 1.不带参数的层
    • 2.带参数的层
  • 四、读写文件
    • 1.加载和保存张量
    • 2.加载和保存模型参数
  • [相关总结]
    • state_dict()

一、层和块

在这里插入图片描述
为了实现复杂神经网络块，引入了神经网络块的概念。使用块进行抽象的一个好处是可以将一些块组合成更大的组件。
从编程的角度来看，块由类表示。

import torch
from torch import nn
from torch.nn import functional as F

net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
# nn.Sequential定义了一种特殊的Module

X = torch.rand(2, 20)
# print(X)
net(X)

tensor([[ 0.0479, 0.0093, -0.0509, 0.0863, -0.0410, -0.0043, -0.1234, -0.0119,
0.0347, -0.0381],
[ 0.1190, 0.0932, -0.0282, 0.2016, -0.0204, -0.0272, -0.1753, 0.0427,
-0.1553, -0.0589]], grad_fn=)

1.自定义块

每个块必须提供的基本功能：

  • 1.将输入数据作为其前向传播函数的参数。
  • 2.通过前向传播函数来生成输出
  • 3.计算其输出关于输入的梯度，可通过其反向传播函数进行访问。通常这是自动发生的。
  • 4.存储和访问前向传播计算所需的参数。
  • 5.根据需要初始化模型参数。

ex:编写块

class MLP(nn.Module):
    def __init__(self):
        # 用模型参数声明层
        super().__init__() #调用父类
        self.hidden = nn.Linear(20, 256) #隐藏层
        self.out = nn.Linear(256, 10) #输出层
        
    def forward(self, X):
        return self.out(F.relu(self.hidden(X)))
    
#  实例化多层感知机的层， 然后在每次调用正向传播函数时调用这些层
net = MLP()
net(X)

tensor([[-0.1158, -0.1282, -0.1533,  0.0258,  0.0228,  0.0202, -0.0638, -0.1078,
          0.0511,  0.0913],
        [-0.1663, -0.0860, -0.2551,  0.1551, -0.0917, -0.0747, -0.2828, -0.2308,
          0.1149,  0.1360]], grad_fn=<AddmmBackward>)

2.顺序块

class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        for block in args:
#             _module的类型是OrderedDict
            self._modules[block] = block
        
    def forward(self, X):
#       OrderedDict保证了按照成员添加的顺序遍历它们
        for block in self._modules.values():
            X = block(X)
        return X
    
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
net(X)

当MySequential的前向传播函数被调用时， 每个添加的块都按照它们被添加的顺序执行。

3.在前向传播函数中执行代码

self.rand_weight在实例化中被随机初始化，之后为常量，因此它永远不会被反向传播

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
#       rand_weight不参加训练
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)
        
    def forward(self, X):
        X = self.linear(X)
#       将X和rand_weight做矩阵乘法
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        X = self.linear(X)
        while X.abs().sum() > 1:
            X /= 2
#       矩阵求和
        return X.sum()
    
net = FixedHiddenMLP()
net(X)

tensor(-0.1869, grad_fn=<SumBackward0>)

混合搭配各种组合块

class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
                                nn.Linear(64, 32), nn.ReLU())
        self.linear = nn.Linear(32, 16)
        
    def forward(self, X):
        return self.linear(self.net(X))
    
chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(X)

tensor(-0.1363, grad_fn=<SumBackward0>)

二、参数管理

在选择了架构并设置完超参数后，我们就进入了训练阶段。此时，我们的目标是找到损失函数最小的模型参数值。

# 首先关注具有单隐层的多层感知机
import torch
from torch import nn
#                    net[0]           net[1]       net[2]
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)


tensor([[ 0.0699],
        [-0.0591]], grad_fn=<AddmmBackward>)

1.参数访问

当通过Sequential类定义模型时， 我们可以通过索引来访问模型的任意层。 这就像模型是一个列表一样，每层的参数都在其属性中。 如下所示，我们可以检查第二个全连接层的参数

# net[2]为最后一个输出层
print(net[2].state_dict())

目标参数

# 目标参数
# 访问具体参数
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)

参数是复合的对象，包含值、梯度和额外信息。 这就是我们需要显式参数值的原因。

net[2].weight.grad == None
# 未进行反向传播,所以没有梯度

True

一次性访问所有参数

# 访问第一个全连接层的参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
# 访问所有层
print(*[(name, param.shape) for name, param in net.named_parameters()])
# ReLU没有参数

('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))

# net 根据名字获取参数
net.state_dict()['2.bias'].data

tensor([0.1021])

从嵌套块收集参数

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):
#       向nn.Sequential中添加4个block1
        net.add_module(f'block {i}', block1())
    return net

rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)

tensor([[-0.2192],
        [-0.2192]], grad_fn=<AddmmBackward>)

# 通过print了解网络结构
print(rgnet)

Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)

2.参数初始化

1.内置初始化

# _:表示替换函数
def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, mean=0, std=0.01)
        nn.init.zeros_(m.bias)
        
net.apply(init_normal)
net[0].weight.data[0], net[0].bias.data[0]

(tensor([0.0033, 0.0066, 0.0160, 0.0042]), tensor(0.))

我们还可以将所有参数初始化为给定的常数

def init_constant(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)
        
net.apply(init_constant)
net[0].weight.data[0], net[0].bias.data[0]

(tensor([1., 1., 1., 1.]), tensor(0.))

对某些块应用不同的初始化方法

def xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_normal(m.weight)

def init_42(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 42)

net[0].apply(xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)

tensor([ 0.6464,  0.5056, -0.7737, -0.7057])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

2.自定义初始化
有时,深度学习框架没有需要的初始化方法,如下:
在这里插入图片描述

# 自定义初始化
def my_init(m):
    if type(m) == nn.Linear:
        print(
            "Init",
            *[(name, param.shape) for name, param in m.named_parameters()][0])
        nn.init.uniform_(m.weight, -10, 10)
        m.weight.data *= m.weight.data.abs() >= 5
        
net.apply(my_init)
net[0].weight[:2]

Init weight torch.Size([8, 4])
Init weight torch.Size([1, 8])
tensor([[-0.0000, -0.0000,  0.0000,  0.0000],
        [ 6.8114,  0.0000, -7.4551, -9.6630]], grad_fn=<SliceBackward>)

也可以直接设置参数

net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]

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))
net(X)
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
print(net[2].weight.data[0] == net[4].weight.data[0])

tensor([True, True, True, True, True, True, True, True])
tensor([True, True, True, True, True, True, True, True])

三、自定义层

1.不带参数的层

import torch
import torch.nn.functional as F
from torch import nn

class CenteredLayer(nn.Module):
    def __init__(self):
        super().__init__()
        
    def forward(self, X):
        return X - X.mean()
        
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))

tensor([-2., -1.,  0.,  1.,  2.])

将层作为组件合并到更复杂的模型中

# 将层作为组件合并到构建更复杂的模型中
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())

Y = net(torch.rand(4, 8))
# print(Y)
Y.mean()

tensor(3.2596e-09, grad_fn=<MeanBackward0>)

2.带参数的层

# 带参数的图层
class MyLinear(nn.Module):
    def __init__(self, in_units, units):
        super().__init__()
        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.data
        return F.relu(linear)
    
dense = MyLinear(5, 3)
dense.weight

Parameter containing:
tensor([[ 0.7481,  0.6183,  0.0382],
        [ 0.6040,  2.3991,  1.3484],
        [-0.3165,  0.0117, -0.4763],
        [-1.3920,  0.6106,  0.9668],
        [ 1.4701,  0.3283, -2.1701]], requires_grad=True)

# 使用自定义层直接执行正向传播计算
dense(torch.rand(2,5))

tensor([[1.5235, 2.6890, 0.0000],
[0.9825, 0.3581, 0.0000]])

# 使用自定义层构建模型
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))

tensor([[11.0573],
[25.9441]])

四、读写文件

有时我们希望保存训练的模型， 以备将来在各种环境中使用（比如在部署中进行预测）。 此外，当运行一个耗时较长的训练过程时， 最佳的做法是定期保存中间结果， 以确保在服务器电源被不小心断掉时，不会损失几天的计算结果。

1.加载和保存张量

单个张量：直接调用load和save进行读写，

# 这两个函数都要求我们提供一个名称，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')
x2

tensor([0, 1, 2, 3])
存储一个张量列表,读回内存

y = torch.zeros(4)
torch.save([x, y], 'x-files')
x2, y2 = torch.load('x-files')
(x2, y2)

(tensor([0, 1, 2, 3]), tensor([0., 0., 0., 0.]))

写入或读取从字符串映射到张量的字典

# 写入或读取从字符串映射到张量的字
# 读取或写入模型中的所有权重时，这很方便
mydict = {'x':x, 'y': y}
torch.save(mydict, 'mydict')
mydict2 = torch.load('mydict')
mydict2

{‘x’: tensor([0, 1, 2, 3]), ‘y’: tensor([0., 0., 0., 0.])}

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()
    X = torch.randn(size=(2, 20))
    Y = net(X)

将模型的参数存储在一个叫做“mlp.params”的文件中

# print(net.state_dict())
torch.save(net.state_dict(), 'mlp.params')

# 恢复模型，我们需要实例化原始多层感知机模型的一个备份
clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
# 从train模式调整为test模式
clone.eval()

MLP(
(hidden): Linear(in_features=20, out_features=256, bias=True)
(output): Linear(in_features=256, out_features=10, bias=True)
)

Y_clone = clone(X)
Y_clone == Y

tensor([[True, True, True, True, True, True, True, True, True, True],
[True, True, True, True, True, True, True, True, True, True]])

[相关总结]

state_dict()

torch.nn.Module模块中的state_dict可以用来存放训练过程中需要学习的权重和偏执系数,(模型参数,超参数,优化器等的状态信息),但是需要注意只有具有学习参数的层才有,比如:卷积层和线性层等

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1283702.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FacetWP Hierarchy Select网站内容层次结构选择插件

FacetWP Hierarchy Select网站内容层次结构选择插件

点击阅读FacetWP Hierarchy Select网站内容层次结构选择插件原文 FacetWP Hierarchy Select网站内容层次结构选择插件可让您基于分层分类法创建引导下拉菜单。 FacetWP Hierarchy Select网站内容层次结构选择插件功能 通过引导式下拉菜单过滤结果&#xff0c;一次一个深度级…
阅读更多...
现在的00后，实在是太卷了......

现在的00后，实在是太卷了......

现在的小年轻真的卷得过分了。前段时间我们公司来了个00年的&#xff0c;工作没两年&#xff0c;跳槽到我们公司起薪18K&#xff0c;都快接近我了。后来才知道人家是个卷王&#xff0c;从早干到晚就差搬张床到工位睡觉了。 最近和他聊了一次天&#xff0c;原来这位小老弟家里条…
阅读更多...
[Unity数据管理]自定义菜单创建Unity内部数据表（ScriptableObject）

[Unity数据管理]自定义菜单创建Unity内部数据表（ScriptableObject）

Unity 在开发的时候如果数据量比较大&#xff0c;或者一部分数据需要存在云端&#xff0c;那么就需要一些数据库 轻量型到大型的包括&#xff1a; 数组-内存存储读取 列表-内存存储读取 List<T> tList new List<T>(); XML-硬盘存储读取 JSON-硬盘存储读取 …
阅读更多...
时间序列预测实战(二十三)进阶版LSTM多元和单元预测（课程设计毕业设计首选）

时间序列预测实战(二十三)进阶版LSTM多元和单元预测（课程设计毕业设计首选）

一、本文介绍 本篇文章给大家带来的是利用我个人编写的架构进行LSTM模型进行时间序列建模&#xff08;专门为了时间序列领域新人编写的架构&#xff0c;简单且不同于市面上大家用GPT写的代码&#xff09;&#xff0c;包括结果可视化、支持单元预测、多元预测、模型拟合效果检测…
阅读更多...
Tecplot绘制涡结构（Q准则）

Tecplot绘制涡结构（Q准则）

文章目录 目的步骤1步骤2步骤3步骤4步骤5步骤6结果 目的 Tecplot绘制涡结构(Q准则判别)并用温度进行染色 Q准则计算公式 步骤1 步骤2 步骤3 步骤4 步骤5 步骤6 结果
阅读更多...
网络初识：局域网广域网网络通信基础

网络初识：局域网广域网网络通信基础

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、局域网LAN是什么&#xff1f;二、广域网是什么&#xff1a;三. IP地址四.端口号五.认识协议5.1五元组 总结 前言 一、局域网LAN是什么&#xff1f; 局域网…
阅读更多...
k8s安装学习环境

k8s安装学习环境

目录 环境准备 配置hosts 关闭防火墙 关闭交换分区 调整swappiness参数 关闭setlinux Ipv4转发 时钟同步 安装Docker 配置Yum源 安装 配置 启动 日志 安装k8s 配置Yum源 Master节点 安装 初始化 配置kubectl 部署CNI网络插件 Node节点 检查 环境准备 准…
阅读更多...
Leetcode1038. 从二叉搜索树到更大和树(每日一题）

Leetcode1038. 从二叉搜索树到更大和树(每日一题）

目录 ⚽题目&#xff1a; &#x1f3d0;题目分析&#xff1a; &#x1f3c0;题目解答&#xff1a; &#x1f94e;代码如下&#xff1a; ⚽题目&#xff1a; 给定一个二叉搜索树 root (BST)&#xff0c;请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值…
阅读更多...
五、分支和循环

五、分支和循环

目录 1. if 语句 1.1 if 1.2 else 1.3 分支中包含多条语句 1.4 嵌套 if 1.5 悬空 else 问题 2. 关系操作符 3. 条件操作符 4. 逻辑操作符&#xff1a; &&&#xff0c;|| &#xff0c;&#xff01; 4.1 逻辑取反运算符 &#xff01; 4.2 与运算符 &&…
阅读更多...
家政服务预约小程序系统的开发；

家政服务预约小程序系统的开发；

家政服务预约小程序系统的开发&#xff0c;既是对传统加盟服务模式的创新&#xff0c;也是家政商家企业营销推广服务的升级。它推动整个家政服务行业实现线上线下深度融合&#xff0c;提升用户消费体验&#xff0c;实现了雇主、服务提供者、家政企业商家三者之间的无缝衔接&…
阅读更多...
新媒体营销教学模拟实训平台解决方案

新媒体营销教学模拟实训平台解决方案

一、背景与目标 随着新媒体的快速发展&#xff0c;营销人才需求旺盛&#xff0c;而具备新媒体营销能力的人才供给却相对不足。为了解决这一矛盾&#xff0c;本方案旨在构建一个新媒体营销教学模拟实训平台&#xff0c;帮助学生掌握新媒体营销的实际操作技能&#xff0c;提高就…
阅读更多...
JSP项目中集成mybatis查询数据库表 将数据库数据渲染到jsp界面中

JSP项目中集成mybatis查询数据库表 将数据库数据渲染到jsp界面中

首先 我们需要两个JAR包 这里 我们在项目 pom.xml 文件dependencies标签下加入代码如下 导入mybatis与mysql-connector-java <dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.7</version&g…
阅读更多...
Python3 GUI 自制音乐播放器 图片浏览 图片轮播 PyQt5（附下载地址）

Python3 GUI 自制音乐播放器 图片浏览 图片轮播 PyQt5（附下载地址）

目录 Part1&#xff1a; 介绍 Part2: create window Part2: create window Adv Part4: Music Play Part5&#xff1a; 图片加载&#xff1a; Part1&#xff1a; 介绍 在这篇文章中&#xff0c;我们将学习如何使用PyQt 库创建一个基本的窗口应用程序&#xff0c;并进行一些…
阅读更多...
FCRP第二题

FCRP第二题

【题目要求】 数据库中有一张地区数据统计表&#xff0c;但是并不规则 &#xff0c;记录类似于&#xff0c;225100:02:3:20160725是一串代码&#xff0c;以&#xff1a;分割&#xff0c;第1位为地区代码&#xff0c;第2位为分类代码&#xff0c;第3位为数量&#xff0c;第4位为…
阅读更多...
vivado分析-在 Versal 器件中执行 NoC 服务质量分析

vivado分析-在 Versal 器件中执行 NoC 服务质量分析

AMD Vivado ™ 中的服务质量 (QoS) 用于将片上网络 (NoC) 编译器生成的当前 NoC 解决方案估算所得 QoS 与 AXI NoCIP 和 / 或 AXI4 ‑ Stream NoC IP 中指定的 QoS 要求进行对比。一旦 NoC 解决方案过时 &#xff0c; 就需要调用 NoC 编译器并生成新的 NoC 解决方案以…
阅读更多...
Vue3使用vue-baidu-map-3x百度地图

Vue3使用vue-baidu-map-3x百度地图

安装vue-baidu-map-3x&#xff1a; // vue3 $ npm install vue-baidu-map-3x --save// vue2 $ npm install vue2-baidu-map --save 全局注册/局部注册&#xff1a; import { createApp } from vue import App from ./App.vue import BaiduMap from vue-baidu-map-3xconst app …
阅读更多...
教育领域UPS监控技巧，这个也太厉害了！

教育领域UPS监控技巧，这个也太厉害了！

在当今数字化时代&#xff0c;企业对信息技术的依赖程度不断加深&#xff0c;而电力作为支撑一切运行的基础&#xff0c;显得尤为重要。 随着电力网络的不断演变和企业规模的扩大&#xff0c;UPS监控不仅仅是对电力设备的监测&#xff0c;更是一项战略性的管理工具&#xff0c;…
阅读更多...
学习率设置(写给自己看）

学习率设置(写给自己看）

现往你的.py文件上打上以下代码&#xff1a; import torch import numpy as np from torch.optim import SGD from torch.optim import lr_scheduler from torch.nn.parameter import Parametermodel [Parameter(torch.randn(2, 2, requires_gradTrue))] optimizer SGD(mode…
阅读更多...
Redis 分布式锁测试

Redis 分布式锁测试

一、前提依赖&#xff08;除去SpringBoot项目基本依赖外&#xff09;&#xff1a; <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId> </dependency><!-- 配置使用redis启动…
阅读更多...
进入软件的世界

进入软件的世界

选择计算机 上高中的时候&#xff0c;因为沉迷于网络游戏&#xff0c;于是对计算机产生了浓厚的兴趣&#xff0c;但是那个时候对于计算机的了解还是非常肤浅的。上大学的时候&#xff0c;也就义无反顾的选择了计算机专业&#xff0c;其实并不是一个纯粹的计算机专业&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023