深度学习核心技巧与实战指南

原创已于 2025-08-21 09:03:22 修改 · 154 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#人工智能 #机器学习

于 2025-08-20 12:08:43 首次发布

Learning Stage of 4 years 专栏收录该内容

24 篇文章

订阅专栏

1.Tensor

存储结构：storage（一维)和metadata

可以共享storage (DL数据量庞大，节省内存空间

查看数据

步长（根据维度来看

偏移量

eg:

ptr指针，指向起始地址

公用存储区，两个tensor(也就是说不同size,stride等

2.argparse 模块

执行命令行参数解析

2.打包在函数中

不使用(反复修改脚本，传参

使用

解析之后存入args对象，之后传这个对象即可

使用

文字说明

--help

参数全称和缩写及选项

位置参数（需要按照添加参数顺序赋值）

没有默认值，必须指定参数值

必填参数（requires=True

参数指定默认值和类型

开关action (bool

重定义变量名（dest=

debug(带参数

vscode中通过launch文件配置

3.BN层

1.RGB三通道分别归一化操作

2.预处理后也做BN（考虑到计算，只对Batch 计算

3.计算过程

只在batchsize个样本上进行的；

验证阶段（通常是一张而不是一个batch，利用的是训练阶段计算的全局均值和方差统计值

4.编程

加了BN，之前卷积的bias可以关掉

4.DataSet和DataLoader

dataset

dataloader

迭代出索引，找到set拿到结果

参数使用

pin_momory（False就存在虚拟内存中，转存花销

锁页内存被固定住，有效防止了页面交换问题，但会带来较大的性能开销。

num_workers(硬件配置

collate_fn

数据容器和数据加载器（按照一定规则加载数据）

from torch.utils.data import Dataset
class MyDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels
    def __len__(self):
        return len(self.data)
    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

from torch.utils.data import DataLoader
dataset = MyDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)
for batch_data, batch_labels in dataloader:
    # 训练模型
    print(batch_data.shape, batch_labels.shape)

import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 定义Dataset
train_dataset = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=transforms.ToTensor()
)

# 创建DataLoader
train_dataloader = DataLoader(
    dataset=train_dataset,
    batch_size=64,
    shuffle=True,
    num_workers=4
)

# 训练循环
for epoch in range(num_epochs):
    for images, labels in train_dataloader:
        # 模型训练代码
        print(images.shape, labels.shape)  # 输出: torch.Size([64, 1, 28, 28]) torch.Size([64])

5.优化器

1

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

# 模拟数据
X = torch.randn(100, 1)  # 特征
y = 2 * X + 1 + 0.1 * torch.randn(100, 1)  # 标签（加噪声）
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)

# 定义模型
model = nn.Linear(1, 1)
criterion = nn.MSELoss()  # 均方误差损失
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降

# 训练循环
for epoch in range(100):
    for batch_X, batch_y in dataloader:
        # 前向传播
        outputs = model(batch_X)
        loss = criterion(outputs, batch_y)
        
        # 反向传播与优化
        optimizer.zero_grad()  # 清空梯度
        loss.backward()        # 计算梯度
        optimizer.step()       # 更新参数
    
    if epoch % 10 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

# 输出最终参数
print(f"Learned parameters: w = {model.weight.item():.4f}, b = {model.bias.item():.4f}")

2

缺

具有鲁棒性

对不同参数使用不同学习率，梯度大的参数给较小学习率，减小步伐，避免振荡

RMS动量思想

Adam缝合

总结

是的，梯度下降法的本质是让参数沿着损失函数下降最快的方向（梯度的反方向）更新，以逐步减小损失函数的值，最终逼近最优解。这种方法在每次迭代中选择局部最优的下降方向，是优化算法的核心思想。

6.层增删改

1.删除网络中的模块

删整个模块（直接改forward模块就行

2.修改网络中的模块

3.添加模块 add_module 追加层

添加模块

eg:

7.切换网络模式

评估阶段一般不调用backward

8.Float32、Float16、BFloat16

精度

Bias

数值范围和精度

混合精度

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from torch.cuda.amp import autocast, GradScaler

# 模拟数据
X = torch.randn(1000, 10).cuda()
y = torch.randn(1000, 1).cuda()
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 定义模型
model = nn.Linear(10, 1).cuda()
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 初始化 GradScaler 用于损失缩放
scaler = GradScaler()

# 训练循环
for epoch in range(10):
    for batch_X, batch_y in dataloader:
        batch_X, batch_y = batch_X.cuda(), batch_y.cuda()
        
        # 前向传播使用 autocast 自动混合精度
        with autocast():
            outputs = model(batch_X)
            loss = criterion(outputs, batch_y)
        
        # 反向传播和优化
        optimizer.zero_grad()           # 清空梯度
        scaler.scale(loss).backward()   # 缩放损失并反向传播
        scaler.step(optimizer)          # 更新权重
        scaler.update()                 # 更新缩放因子
        
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

# 输出最终参数
print(f"Learned parameters: w = {model.weight.data}, b = {model.bias.data}")