深度学习(13)PyTorch神经网络基础

1. 层和块

① nn.Sequential 定义了一种特殊的Module。

python 复制代码

# 回顾一下多层感知机
import torch  #基础计算（类似 numpy）
from torch import nn  #神经网络工具（层、模型）
from torch.nn import functional as F   #一些函数（比如激活函数）
#搭建神经网络结构
net = nn.Sequential(nn.Linear(20,256),nn.ReLU(),nn.Linear(256,10))

#造输入数据
#生成随机数据：2行 × 20列
#2个样本，每个样本有20个特征
X = torch.rand(2,20)
net(X)

🧱 第1层：线性层
复制代码
nn.Linear(20,256)
👉 意思是：
复制代码
输入：20个数
输出：256个数
数学上：
复制代码
y = Wx + b
👉 本质就是：

把 20 维 → 变成 256 维

相当于"扩展信息"

⚡ 第2层：激活函数
复制代码
nn.ReLU()
👉 ReLU 规则：
复制代码
小于0 → 变成0
大于0 → 保留
比如：
复制代码
[-2, 3, -1, 5] → [0, 3, 0, 5]
👉 作用：

加入"非线性"

不然模型太简单（只能学直线）

🧱 第3层：线性层
复制代码
nn.Linear(256,10)
👉 意思是：
复制代码
输入：256个数
输出：10个数
👉 最终得到：

10维输出（比如10个类别 / 10个预测值）

🧩 Sequential 是什么？
复制代码
nn.Sequential(...)
👉意思是：

按顺序执行这些层

就像流水线：
复制代码
输入
 ↓
Linear(20→256)
 ↓
ReLU
 ↓
Linear(256→10)
 ↓
输出

X (2×20)
↓
Linear(20→256)
→ 变成 (2×256)
↓
ReLU
→ 还是 (2×256)
↓
Linear(256→10)
→ 变成 (2×10)

复制代码

tensor([[-0.0214, -0.1789, -0.0700, -0.0238, -0.2697,  0.0381,  0.3078, -0.2082,
         -0.1502,  0.0433],
        [ 0.0200, -0.1466, -0.0633,  0.0031, -0.2042,  0.0993,  0.3137, -0.1206,
         -0.1057,  0.0434]], grad_fn=<AddmmBackward0>)

2. 自定义块

把第一个刚才的 Sequential 写法，换成"手写版"。本质一样，但更灵活。

自己定义一个神经网络类（MLP），然后用它处理数据

python 复制代码

#定义一个"神经网络模型"，名字叫 MLP ；
#nn.Module 是所有模型的"基类"（必须继承
class MLP(nn.Module):
    #初始化函数
    def __init__(self):
        super().__init__()  # 调用父类的__init__函数
        #定义层
        self.hidden = nn.Linear(20,256)#输入20 → 输出256
        self.out = nn.Linear(256,10)#输入256 → 输出10
    #定义前向传播    
    def forward(self, X):
        return self.out(F.relu(self.hidden(X)))
    
# 实例化多层感知机的层，然后在每次调用正向传播函数调用这些层
net = MLP()
#造数据
X = torch.rand(2,20)
#喂数据；自动执行：forward(X)
net(X)

复制代码

tensor([[-0.1600,  0.0363,  0.0851,  0.0364,  0.0189,  0.1590,  0.1519,  0.1299,
         -0.1382, -0.2075],
        [-0.1956,  0.0779, -0.0385, -0.0741,  0.0229,  0.0116,  0.1271,  0.0273,
         -0.0867, -0.0511]], grad_fn=<AddmmBackward0>)

3. 顺序块

自己写了一个"按顺序执行层"的容器（模仿 nn.Sequential）

python 复制代码

#定义一个模型类
class MySequential(nn.Module):
    #初始化（收集所有层）
    #*args可以传"任意多个参数
    def __init__(self, *args):
        super().__init__()
        for block in args:
            #_modules PyTorch 内部的一个"字典，专门用来存模型里的"层"
            #把每一层存进去 
            self._modules[block] = block # block 本身作为它的key，存在_modules里面的为层，以字典的形式
   #定义数据怎么流动         
    def forward(self, X):
        #取出所有层（按顺序）
        for block in self._modules.values():
            print(block)
            X = block(X)
        return X
 #创建模型把三层传进去   
net = MySequential(nn.Linear(20,256),nn.ReLU(),nn.Linear(256,10))
X = torch.rand(2,20)
net(X)

Linear(in_features=20, out_features=256, bias=True)

ReLU()

Linear(in_features=256, out_features=10, bias=True)

复制代码

tensor([[-0.0651,  0.0377, -0.0348, -0.0377,  0.1602,  0.0022, -0.0904,  0.1742,
         -0.0520,  0.0189],
        [-0.0192,  0.1056, -0.0497,  0.0301,  0.2464,  0.0126, -0.1700,  0.4147,
          0.0703, -0.0013]], grad_fn=<AddmmBackward0>)

4. 正向传播

这段代码比前面的更"自由"，它在 forward 里加了矩阵运算 + 循环 + 自定义逻辑

做两次线性变换，中间插入随机矩阵计算，还会把结果不断缩小，最后输出一个数

python 复制代码

# 在正向传播函数中执行代码
class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        #定义一个"随机权重，创建一个 20×20 的随机矩阵
        #requires_grad=False这个矩阵不会被训练，是"固定的"
        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 = WX + b
        #矩阵乘法 + ReLU
        #self.rand_weight + 1把随机矩阵每个元素 +1
        #torch.mm(X, ...)矩阵乘法：相当于"再变换一次数据"
        #F.relu(...)负数变0
        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()
X = torch.rand(2,20)
net(X)

复制代码

tensor(0.3770, grad_fn=<SumBackward0>)

5. 混合组合块

模型可以"套娃"------一个模型里面再放模型

先用一个小网络处理 → 再接一层 → 再接一个"怪模型" → 得到最终结果

python 复制代码

# 混合代培各种组合块的方法
class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        #一个"小网络"： 20 → 64 → 32
        self.net = nn.Sequential(nn.Linear(20,64),nn.ReLU(),
                                nn.Linear(64,32),nn.ReLU())
        #再加一层：32 → 16
        self.linear = nn.Linear(32,16)
        
    def forward(self, X):
        return self.linear(self.net(X))
#第1块：NestMLP()输入 20 → 输出 16  
#第2块：nn.Linear(16,20)输入 16 → 输出 20
#第3块：FixedHiddenMLP()输入 20 → 输出 1（一个数）
chimear = nn.Sequential(NestMLP(),nn.Linear(16,20),FixedHiddenMLP())
X = torch.rand(2,20)
chimear(X)

复制代码

tensor(-0.1488, grad_fn=<SumBackward0>)

6. 参数管理

这段代码的核心是在教你一件事：

如何"看见"和"操作"神经网络里的参数（权重和偏置）

python 复制代码

# 首先关注具有单隐藏层的多层感知机
import torch
from torch import nn

#输入4维 → 变成8维 → ReLU → 变成1维
net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))
#2个样本，每个4个特征
X = torch.rand(size=(2,4))
print(net(X))    
#state_dict()返回这一层的参数：weight': 权重矩阵,'bias': 偏置
print(net[2].state_dict()) # 访问参数，net[2]就是最后一个输出层net[2] → Linear(8→1)
print(type(net[2].bias)) # 目标参数
print(net[2].bias)
print(net[2].bias.data)#打印纯数据，只看"数值"，不管梯度
print(net[2].weight.grad == None) # 还没进行反向计算，所以grad为None
print(*[(name, param.shape) for name, param in net[0].named_parameters()])  # 一次性访问所有参数         
print(*[(name, param.shape) for name, param in net.named_parameters()])  # 0是第一层名字，1是ReLU，它没有参数
print(net.state_dict()['2.bias'].data) # 通过名字获取参数

复制代码

tensor([[0.3941],
        [0.4224]], grad_fn=<AddmmBackward0>)
OrderedDict([('weight', tensor([[ 4.7564e-02, -5.3226e-02,  1.4919e-04, -2.8679e-01,  1.7408e-01,
          3.0859e-01, -1.2281e-01,  5.6171e-02]])), ('bias', tensor([0.3129]))])
<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([0.3129], requires_grad=True)
tensor([0.3129])
True
('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]))
tensor([0.3129])

7. 嵌套块

"把小模块重复组合，变成一个很深的网络"

先造一个小网络（block1） → 复制4份 → 串起来 → 最后再接一层输出

python 复制代码

# 从嵌套块收集参数
#这是一个"小网络"：4 → 8 → 4
def block1():
    return nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,4),nn.ReLU())

def block2():
    net = nn.Sequential()#先创建一个"空容器"
    #循环添加4个 block1
    for i in range(4):
        net.add_module(f'block{i}',block1()) # f'block{i}' 可以传一个字符串名字过来，block2可以嵌套四个block1                                      
    return net
#构建大模型
rgnet = nn.Sequential(block2(), nn.Linear(4,1))
#每个样本 → 一个结果
print(rgnet(X))
#打印结构
print(rgnet)

复制代码

tensor([[-0.1750],
        [-0.1750]], grad_fn=<AddmmBackward0>)
Sequential(
  (0): Sequential(
    (block0): 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()
    )
    (block1): 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()
    )
    (block2): 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()
    )
    (block3): 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)
)

8 内置初始化

三种初始化 + "给不同层用不同初始化
第一部分：随机初始化

python 复制代码

net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))

#定义初始化函数
def init_normal(m):
    if type(m) == nn.Linear:
        #weight：小随机数（接近0）;bias：全0
        nn.init.normal_(m.weight, mean=0, std=0.01) # 下划线表示把m.weight的值替换掉   
        nn.init.zeros_(m.bias)
 #应用到整个模型       
net.apply(init_normal) # 会递归调用 直到所有层都初始化
print(net[0].weight.data[0])
print(net[0].bias.data[0])

tensor([ 0.0012, -0.0112, -0.0153, 0.0218])#权重都接近0

tensor(0.)#偏差都是0

第二部分：常数初始化（全部=1）

python 复制代码

net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))

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

复制代码

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

第三部分：不同层用不同初始化（重点！）
**#Xavier 初始化（推荐）：**根据输入输出维度自动调整范围

作用：

✔ 防止梯度爆炸/消失

✔ 训练更稳定

**42 初始化（演示用）：**所有权重 = 42（只是演示）

关键操作：只初始化某一层
🔥 apply 的两种用法

✅ 全局初始化
复制代码
net.apply(func)
👉 所有层都会执行

✅ 局部初始化
复制代码
net[某一层].apply(func)
👉 只改这一层

python 复制代码

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

def xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(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.0479, -0.1771,  0.5267, -0.0020])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

9. 参数替换

自己定义一套"奇怪的初始化规则"，再手动修改权重

python 复制代码

# 自定义初始化
#第一部分：自定义初始化函数
def my_init(m):
    #只处理 Linear 层；只对有权重的层操作（Linear）
    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 # 这里*=的代码相当于先计算一个布尔矩阵(先判断>=)，然后再用布尔矩阵的对应元素去乘以原始矩阵的每个元素。保留绝对值大于5的权重，不是的话就设为0

#应用初始化
net.apply(my_init)
#查看前两行权重
print(net[0].weight[:2])
#手动修改参数 所有权重 +1
net[0].weight.data[:] += 1 # 参数替换
net[0].weight.data[0,0] = 42#修改一个元素
print(net[0].weight.data[0])

最关键一行（重点！！）
复制代码
m.weight.data *= m.weight.data.abs() >= 5
👉 这一行很重要，我给你拆到最简单👇

🧠 第一步：生成"筛选条件"
复制代码
m.weight.data.abs() >= 5
👉 生成一个"布尔矩阵"：
复制代码
True  → 保留
False → 删除
举例：

原始权重：
复制代码
[ 2, 7, -8, 3 ]
判断：
复制代码
abs >= 5 → [False, True, True, False]
🧠 第二步：乘上这个布尔矩阵
复制代码
m.weight.data *= (True/False)
👉 等价于：
复制代码
True  → ×1
False → ×0
结果：
复制代码
[ 2, 7, -8, 3 ]
→ [0, 7, -8, 0]
🎯 这一行的本质：
复制代码
只保留"绝对值 ≥ 5"的权重，其它全部变0

复制代码

Init weight torch.Size([8, 4])
Init weight torch.Size([1, 8])
tensor([[ 0.0000,  7.1240,  0.0000,  5.1135],
        [-8.6745, -7.3974,  0.0000, -0.0000]], grad_fn=<SliceBackward0>)
tensor([42.0000,  8.1240,  1.0000,  6.1135])

10. 参数绑定

让两个层"用同一份权重"

python 复制代码

# 参数绑定
#第一步：创建一个共享层，里面有weight（8×8）bias（8）
shared = nn.Linear(8,8)
#第二步：构建网络
net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),shared,nn.ReLU(),shared,nn.ReLU(),nn.Linear(8,1))  # 第2个隐藏层和第3个隐藏层是share权重的，第一个和第四个是自己的  
net(X)
#第三步：验证是否共享
print(net[2].weight.data[0] == net[4].weight.data[0])
#第四步：修改一个地方
net[2].weight.data[0,0] = 100#改的是shared 的某一个权重
#第五步：再检查；结果仍然：全 True
#因为：net[2] 和 net[4] 指向同一个对象
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])

11. 自定义层

👉 学习如何在 PyTorch 里"自己造层 + 组装神经网络"

它分成三步：
复制代码
1️⃣ 自定义一个没有参数的层  
2️⃣ 自定义一个有参数的层  
3️⃣ 把这些层拼成一个完整神经网络  

python 复制代码

# 构造一个没有任何参数的自定义层
import torch
import torch.nn.functional as F
from torch import nn

#第一部分：无参数层 CenteredLayer
class CenteredLayer(nn.Module):
    #构造函数（初始化）
    def __init__(self):
        super().__init__()
    #定义"前向传播"    
    def forward(self, X):
        #让数据变成"均值为0，X.mean()为均值
        return X - X.mean()
#测试这个层，创建一个实例    
layer = CenteredLayer()
print(layer(torch.FloatTensor([1,2,3,4,5])))

#第二部分：把层放进模型
# 将层作为组件合并到构建更复杂的模型中
net = nn.Sequential(nn.Linear(8,128),CenteredLayer())#CenteredLayer()：把输出变成均值0
#输入4个样本，每个样本8个特征
Y = net(torch.rand(4,8))
print(Y.mean())

#第三部分：自定义"有参数层"
# 带参数的图层
class MyLinear(nn.Module):
    def __init__(self, in_units, units):#in_units：输入维度；units：输出维度
        super().__init__()
        #创建权重矩阵：形状：(输入维度, 输出维度)
        self.weight = nn.Parameter(torch.randn(in_units,units)) # nn.Parameter使得这些参数加上了梯度    
        #偏置；形状：(输出维度,)
        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)
print(dense.weight)

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

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

复制代码

tensor([-2., -1.,  0.,  1.,  2.])
tensor(-6.2864e-09, grad_fn=<MeanBackward0>)
Parameter containing:
tensor([[-2.8449,  0.1887,  0.7945],
        [ 0.4226,  1.6180, -0.5880],
        [-0.4794, -0.0817, -0.3648],
        [-0.1979,  0.8702, -0.3515],
        [-1.4943,  0.3618,  0.2969]], requires_grad=True)
tensor([[0.0000, 0.0000, 1.3957],
        [0.8225, 0.0000, 0.9089]])
tensor([[0.],
        [0.]])

12. 读写文件

① 保存 / 读取数据（张量）

② 保存 / 恢复模型参数（神经网络）

python 复制代码

# 加载和保存张量
import torch
from torch import nn
from torch.nn import functional as F

#保存一个张量
x = torch.arange(4)
torch.save(x, 'x-file') #把x存到硬盘文件 "x-file" 里
x2 = torch.load("x-file")#从文件读回来
print(x2)         #输出刚刚恢复的数据

#保存多个张量
#存储一个张量列表，然后把它们读回内存
y = torch.zeros(4)#y = [0,0,0,0]
torch.save([x,y],'x-files') #一个列表：[x, y]
x2, y2 = torch.load('x-files')#x2 = x，y2 = y
print(x2)
print(y2)

#保存字典
# 写入或读取从字符串映射到张量的字典
mydict = {'x':x,'y':y}
torch.save(mydict,'mydict')
mydict2 = torch.load('mydict')
print(mydict2)

复制代码

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

python 复制代码

# 加载和保存模型参数
#1. 定义模型
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)))
  
#2. 跑一遍模型
net = MLP()
#输入2个样本，每个20维
X = torch.randn(size=(2,20))
Y = net(X)

# 将模型的参数存储为一个叫做"mlp.params"的文件
torch.save(net.state_dict(),'mlp.params')#只保存"参数"，不保存模型结构

#4. 加载模型参数
# 实例化了原始多层感知机模型的一个备份。直接读取文件中存储的参数
clone = MLP() # 必须要先声明一下，才能导入参数
#clone = 原来那个模型的复制品
clone.load_state_dict(torch.load("mlp.params"))
#eval() 作用：进入"测试模式"（关闭 dropout / batchnorm 等）
print(clone.eval()) # eval()是进入测试模式

#5. 验证是否成功
#用同一个输入
Y_clone = clone(X)
#检查：两个输出是否一样
print(Y_clone == Y)

复制代码

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