深度学习中的正则化方法与卷积神经网络基础

郜太素2025-05-21 13:30

笔记

1 正则化方法

1.1 什么是正则化

  • 防止模型过拟合(训练集效果好, 测试集效果差), 提高模型泛化能力

  • 一种防止过拟合, 提高模型泛化能力的策略

    • L1正则: 需要通过手动写代码实现

    • L2正则: SGD(weight_decay=)

    • dropout

    • BN

1.2 Dropout正则化

  • 让神经元以p概率随机死亡, 每批次样本训练模型时, 死亡的神经元都是随机, 防止预测结果受某个神经元影响(防止过拟合)

  • p概率->[0.2, 0.5], 简单模型概率低, 复杂模型概率高

  • 不失活的神经元计算结果除以(1-p), 让训练时输出结果和测试时(dropout不生效)结果一致

    • 训练模型 -> model.train()

    • 测试模型 -> model.eval()

  • dropout是在激活层后使用

    python 复制代码 
    import torch
import torch.nn as nn
​
​
# dropout随机失活: 每批次样本训练时,随机让一部分神经元死亡,防止一些特征对结果影响大(防止过拟合)
def dm01():
    # todo:1-创建隐藏层输出结果
    # float(): 转换成浮点类型张量
    t1 = torch.randint(low=0, high=10, size=(1, 4)).float()
    print('t1->', t1)
    # todo:2-进行下一层加权求和计算
    linear1 = nn.Linear(in_features=4, out_features=4)
    l1 = linear1(t1)
    print('l1->', l1)
    # todo:3-进行激活值计算
    output = torch.sigmoid(l1)
    print('output->', output)
    # todo:4-对激活值进行dropout处理  训练阶段
    # p: 失活概率
    dropout = nn.Dropout(p=0.4)
    d1 = dropout(output)
    print('d1->', d1)
​
​
if __name__ == '__main__':
    dm01()

1.3 批量归一正则化(Batch Normalization)

  • 计算每个batch样本的均值和标准差, 利用均值和标准差计算出标准化的值

  • 每个batch的均值和标准差都不一样, 会引入噪声样本数据, 降低训练模型效果(防止过拟合)

  • 引入两个自学习的γ和β参数, 让每层的样本分布不一样(每层的激活函数可以不一样)

  • 加速模型训练效果, 数据分布越均匀, 加权求和结果落入到合理区间(导数最大)

  • 训练时进行标准化, 测试时不进行标准化

    python 复制代码 
    """
正则化: 每批样本的均值和方差不一样, 引入噪声样本
加快模型收敛: 样本标准化后, 落入激活函数的合理区间, 导数尽可能最大
"""
import torch
import torch.nn as nn
​
​
# nn.BatchNorm1d(): 处理一维样本, 每批样本数最少是2个, 否则无法计算均值和标准差
# nn.BatchNorm2d(): 处理二维样本, 图像(每个通道由二维矩阵组成), 计算二维矩阵每列均值和标准差
# nn.BatchNorm3d(): 处理三维样本, 视频
# 处理二维数据
def dm01():
    # todo:1-创建图像样本数据集 2个通道,每个通道3*4列特征图, 卷积层处理的特征图样本
    # 数据集只有一张图像, 图像是由2个通道组成, 每个通道由3*4像素矩阵
    input_2d = torch.randn(size=(1, 2, 3, 4))
    print('input_2d->', input_2d)
    # todo:2-创建BN层, 标准化 ->一定是在激活函数前进行标准化
    # num_features: 输入样本的通道数
    # eps: 小常数, 避免除0
    # momentum: 指数移动加权平均值
    # affine: 默认True, 引入可学习的γ和β参数
    bn2d = nn.BatchNorm2d(num_features=2, eps=1e-5, momentum=0.1, affine=True)
    ouput_2d = bn2d(input_2d)
    print('ouput_2d->', ouput_2d)
​
# 处理一维数据
def dm02():
    # 创建样本数据集
    input_1d = torch.randn(size=(2, 2))
    # 创建线性层
    linear1 = nn.Linear(in_features=2, out_features=4)
    l1 = linear1(input_1d)
    print('l1->', l1)
    # 创建BN层
    bn1d = nn.BatchNorm1d(num_features=4)
    # 对线性层的结果进行标准化处理
    output_1d = bn1d(l1)
    print('output_1d->', output_1d)
​
​
​
if __name__ == '__main__':
    # dm01()
    dm02()

2 手机价格分类案例

2.1 案例需求

  • 分类问题 0,1,2,3 四个类别

  • 实现步骤

    • 准备数据集 -> 数据集分割, 转换成张量数据集

    • 构建神经网络模型 -> 继承nn.module

    • 模型训练

    • 模型评估

2.2 构建张量数据集

python 复制代码 
# 导入相关模块
import torch
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import torch.nn as nn
from torchsummary import summary
import torch.optim as optim
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd
import time
​
​
# todo:1-构建数据集
def create_dataset():
    print('===========================构建张量数据集对象===========================')
    # todo:1-1 加载csv文件数据集
    data = pd.read_csv('data/手机价格预测.csv')
    print('data.head()->', data.head())
    print('data.shape->', data.shape)
    # todo:1-2 获取x特征列数据集和y目标列数据集
    # iloc属性 下标取值
    x, y = data.iloc[:, :-1], data.iloc[:, -1]
    # 将特征列转换成浮点类型
    x = x.astype(np.float32)
    print('x->', x.head())
    print('y->', y.head())
    # todo:1-3 数据集分割 8:2
    x_train, x_valid, y_train, y_valid = train_test_split(x, y, train_size=0.8, random_state=88)
    # todo:1-4 数据集转换成张量数据集
    # x_train,y_train类型是df对象, df不能直接转换成张量对象
    # x_train.values():获取df对象的数据值, 得到numpy数组
    # torch.tensor(): numpy数组对象转换成张量对象
    train_dataset = TensorDataset(torch.tensor(data=x_train.values), torch.tensor(data=y_train.values))
    valid_dataset = TensorDataset(torch.tensor(data=x_valid.values), torch.tensor(data=y_valid.values))
    # todo:1-5 返回训练数据集, 测试数据集, 特征数, 类别数
    # shape->(行数, 列数) [1]->元组下标取值
    # np.unique()->去重 len()->去重后的长度 类别数
    print('x.shape[1]->', x.shape[1])
    print('len(np.unique(y)->', len(np.unique(y)))
    return train_dataset, valid_dataset, x.shape[1], len(np.unique(y))
​
​
if __name__ == '__main__':
    train_dataset, valid_dataset, input_dim, class_num = create_dataset()

2.3 构建分类神经网络模型

python 复制代码 
# todo:2-构建神经网络分类模型
class PhonePriceModel(nn.Module):
    print('===========================构建神经网络分类模型===========================')
    # todo:2-1 构建神经网络  __init__()
    def __init__(self, input_dim, output_dim):
        # 继承父类的构造方法
        super().__init__()
        # 第一层隐藏层
        self.linear1 = nn.Linear(in_features=input_dim, out_features=128)
        # 第二层隐藏层
        self.linear2 = nn.Linear(in_features=128, out_features=256)
        # 输出层
        self.output = nn.Linear(in_features=256, out_features=output_dim)
    # todo:2-2 前向传播方法 forward()
    def forward(self, x):
        # 第一层隐藏层计算
        x = torch.relu(input=self.linear1(x))
        # 第二层隐藏层计算
        x = torch.relu(input=self.linear2(x))
        # 输出层计算
        # 没有进行softmax激活计算, 后续创建损失函数时CrossEntropyLoss=softmax+损失计算
        output = self.output(x)
        return output
# todo:3-模型训练
# todo:4-模型评估
​
if __name__ == '__main__':
    # 创建张量数据集对象
    train_dataset, valid_dataset, input_dim, class_num = create_dataset()
    # 创建模型对象
    model = PhonePriceModel(input_dim=input_dim, output_dim=class_num)
    # 计算模型参数
    # input_size: 输入层样本形状
    summary(model, input_size=(16, input_dim))

2.4 模型训练

python 复制代码 
# todo:3-模型训练
def train(train_dataset, input_dim, class_num):
    print('===========================模型训练===========================')
    # todo:3-1 创建数据加载器 批量训练
    dataloader = DataLoader(dataset=train_dataset, batch_size=8, shuffle=True)
    # todo:3-2 创建神经网络分类模型对象, 初始化w和b
    model = PhonePriceModel(input_dim=input_dim, output_dim=class_num)
    print("======查看模型参数w和b======")
    for name, parameter in model.named_parameters():
        print(name, parameter)
    # todo:3-3 创建损失函数对象 多分类交叉熵损失=softmax+损失计算
    criterion = nn.CrossEntropyLoss()
    # todo:3-4 创建优化器对象 SGD
    optimizer = optim.SGD(params=model.parameters(), lr=1e-3)
    # todo:3-5 模型训练 min-batch 随机梯度下降
    # 训练轮数
    num_epoch = 50
    for epoch in range(num_epoch):
        # 定义变量统计每次训练的损失值, 训练batch数
        total_loss = 0.0
        batch_num = 0
        # 训练开始的时间
        start = time.time()
        # 批次训练
        for x, y in dataloader:
            # 切换模型模式
            model.train()
            # 模型预测 y预测值
            y_pred = model(x)
            # print('y_pred->', y_pred)
            # 计算损失值
            loss = criterion(y_pred, y)
            # print('loss->', loss)
            # 梯度清零
            optimizer.zero_grad()
            # 计算梯度
            loss.backward()
            # 更新参数 梯度下降法
            optimizer.step()
            # 统计每次训练的所有batch的平均损失值和和batch数
            # item(): 获取标量张量的数值
            total_loss += loss.item()
            batch_num += 1
        # 打印损失变换结果
        print('epoch: %4s loss: %.2f, time: %.2fs' % (epoch + 1, total_loss / batch_num, time.time() - start))
    # todo:3-6 模型保存, 将模型参数保存到字典, 再将字典保存到文件
    torch.save(model.state_dict(), 'model/phone.pth')
​
​
if __name__ == '__main__':
    # 创建张量数据集对象
    train_dataset, valid_dataset, input_dim, class_num = create_dataset()
    # 创建模型对象
    # model = PhonePriceModel(input_dim=input_dim, output_dim=class_num)
    # 计算模型参数
    # input_size: 输入层样本形状
    # summary(model, input_size=(16, input_dim))
    # 模型训练
    train(train_dataset=train_dataset, input_dim=input_dim, class_num=class_num)

2.5 模型评估

python 复制代码 
# todo:4-模型评估
def test(valid_dataset, input_dim, class_num):
    # todo:4-1 创建神经网络分类模型对象
    model = PhonePriceModel(input_dim=input_dim, output_dim=class_num)
    # todo:4-2 加载训练模型的参数字典
    model.load_state_dict(torch.load(f='model/phone.pth'))
    # todo:4-3 创建测试集数据加载器
    # shuffle: 不需要为True, 预测, 不是训练
    dataloader = DataLoader(dataset=valid_dataset, batch_size=8, shuffle=False)
    # todo:4-4 定义变量, 初始值为0, 统计预测正确的样本个数
    correct = 0
    # todo:4-5 按batch进行预测
    for x, y in dataloader:
        print('y->', y)
        # 切换模型模式为预测模式
        model.eval()
        # 模型预测 y预测值 -> 输出层的加权求和值
        output = model(x)
        print('output->', output)
        # 根据加权求和值得到类别, argmax() 获取最大值对应的下标就是类别 y->0,1,2,3
        # dim=1:一行一行处理, 一个样本一个样本
        y_pred = torch.argmax(input=output, dim=1)
        print('y_pred->', y_pred)
        # 统计预测正确的样本个数
        print(y_pred == y)
        # 对布尔值求和, True->1 False->0
        print((y_pred == y).sum())
        correct += (y_pred == y).sum()
        print('correct->', correct)
    # 计算预测精度 准确率
    print('Acc: %.5f' % (correct.item() / len(valid_dataset)))
​
​
if __name__ == '__main__':
    # 创建张量数据集对象
    train_dataset, valid_dataset, input_dim, class_num = create_dataset()
    # 创建模型对象
    # model = PhonePriceModel(input_dim=input_dim, output_dim=class_num)
    # 计算模型参数
    # input_size: 输入层样本形状
    # summary(model, input_size=(16, input_dim))
    # 模型训练
    # train(train_dataset=train_dataset, input_dim=input_dim, class_num=class_num)
    # 模型评估
    test(valid_dataset=valid_dataset, input_dim=input_dim, class_num=class_num)

2.6 网络性能优化

  • 输入层数据进行标准化

  • 神经网络层数增加, 神经元个数增加

  • 梯度下降优化方法由SGD调整为Aam

  • 学习率由1e-3调整为1e-4

  • 正则化

  • 增加训练轮数

  • ...

3 图像基础知识

3.1 图像概念

  • 计算机中图像分类表示

    • 二值图像 1通道(1个二维矩阵) 像素值:0或1

    • 灰度图像 1通道 像素值:0-255

    • 索引图像 1通道 索引值->RGB二维矩阵行下标 彩色图像 像素值:0-255

    • RGB真彩色图像(最常用) 3通道(3个二维矩阵) R G B三个二维矩阵 像素值:0-255

3.2 图像加载

python 复制代码 
import numpy as np
import matplotlib.pyplot as plt
import torch
​
​
# 创建全黑和全白图片
def dm01():
    # 全黑图片
    # 创建3通道二维矩阵, 黑色 0像素点
    # H W C: 200, 200, 3
    # 高 宽 通道
    img1 = np.zeros(shape=(200, 200, 3))
    print('img1->', img1)
    print('img1.shape->', img1.shape)
    # 展示图像
    plt.imshow(img1)
    plt.show()
​
    # 全白图片
    # 放到全连接层就是 200*200*3=120000个特征值的一维向量
    img2 = torch.full(size=(200, 200, 3), fill_value=255)
    print('img2->', img2)
    print('img2.shape->', img2.shape)
    # 展示图像
    plt.imshow(img2)
    plt.show()
​
​
def dm02():
    # 加载图片
    img1 = plt.imread(fname='data/img.jpg')
    print('img1->', img1)
    print('img1.shape->', img1.shape)
    # 保存图像
    plt.imsave(fname='data/img1.png', arr=img1)
    # 展示图像
    plt.imshow(img1)
    plt.show()
​
​
if __name__ == '__main__':
    # dm01()
    dm02()

4 卷积神经网络(CNN)介绍

4.1 什么是CNN

  • 包含卷积层,池化层以及全连接层的神经网络计算模型

  • 组成

    • 卷积层: 提取图像特征图

    • 池化层: 降维, 减少特征图的特征值, 减少模型参数

    • 全连接层: 进行预测, 只能接受二维数据集, 1个样本就是1维向量

      • 将池化层的特征图(1张图像)转换成一维 200*200*3->120000个特征值

4.2 CNN应用场景

  • 图像分类

  • 目标检测

  • 面部解锁

  • 自动驾驶

  • ...

5 卷积层

作用: 提取特征图

5.1 卷积计算

卷积计算等同于线性层加权求和计算

  • 通过带有权重的卷积核和图像的特征值进行点乘运算, 得到新特征图上的一个特征值

  • 卷积核/滤波器 -> 带有权重参数的神经元

  • w1x1 + w2x2 + .... + b

    • w1->卷积核一个权重参数

    • x1->特征图的一个特征值(像素点)

5.2 Padding(填充)

  • 在原图像特征图周围补充特征值(默认补0)

  • 作用

    • 使新特征图和原特征图形状保持一致

    • 减少边缘特征值信息丢失问题

      • 未padding, 边缘特征值只参与一次计算, 经过padding后, 边缘特征值参与多次计算

  • 实现方式

    • 不进行padding处理: 新特征图比原图像特征图小

    • same padding: 原图像特征图形状和新特征图形状一致

    • full padding: 新特征图形状比原图像特征图大, 新增特征

5.3 Stride(步长)

  • stride指卷积核(神经元)在特征图上滑动的步伐 默认1

  • 作用:

    • 减少计算量

    • 减少特征, 新特征图特征值减少(降维)

  • 一般默认1, 可以设置2或4

  • 原图像特征图5*5, stride=1->新特征图3*3, stride=2->新特征图2*2

5.4 多通道卷积计算

  • RGB彩色图像是由3个通道组成 -> 3个二维矩阵, 每个矩阵分别代表R/G/B

  • 卷积核通道数和原图像通道数一致

  • 卷积计算 -> 对应通道二维矩阵进行卷积计算, 将每个通道卷积计算的结果加到一起, 得到新特征图的一个特征值

  • 新特征图是1个二维矩阵, 不是3个二维矩阵

5.5 多卷积核卷积计算

  • 有多少个卷积核就是有多少个神经元, 就会提取到多少个二维的特征图

5.6 特征图大小计算

  • N = (W-F+2P)/S + 1

  • N: 新特征图高或宽

  • W: 原特征图高或宽

  • F: 卷积核高或宽

  • P: padding值

  • S: stride值

  • N如果为小数, 向下取整, 内部封装floor函数

5.7 卷积层API使用

python 复制代码 
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
​
"""
in_channels:原图像的通道数,RGB彩色图像是3
out_channels:卷积核/神经元个数 输出的新图像是由n个通道的二维矩阵组成
kernel_size:卷积核形状 (3,3) (3,5)
stride:步长 默认为1
padding:填充圈数 默认为0  1  same->stride=1  2,3...
nn.Conv2d(in_channels=,out_channels=,kernel_size=,stride=,padding=)
"""
​
​
def dm01():
    # todo:1-加载RGB彩色图像 (H,W,C)
    img = plt.imread(fname='data/img.jpg')
    print('img->', img)
    print('img.shape->', img.shape)
    # todo:2-将图像的形状(H,W,C)转换成(C,H,W)  permute()方法
    img2 = torch.tensor(data=img, dtype=torch.float32).permute(dims=(2, 0, 1))
    print('img2->', img2)
    print('img2.shape->', img2.shape)
    # todo:3-将这张图像保存到数据集中 (batch_size,C,H,W)  unsqueeze()方法
    # 数据集只有一个样本
    img3 = img2.unsqueeze(dim=0)
    print('img3->', img3)
    print('img3.shape->', img3.shape)
    # todo:4-创建卷积层对象, 提取特征图
    conv = nn.Conv2d(in_channels=3,
                     out_channels=4,
                     kernel_size=(3, 3),
                     stride=2,
                     padding=0)
    conv_img = conv(img3)
    print('conv_img->', conv_img)
    print('conv_img.shape->', conv_img.shape)
​
    # 查看提取到的4个特征图
    # 获取数据集中第一张图像
    img4 = conv_img[0]
    # 转换形状 (H,W,C)
    img5 = img4.permute(1, 2, 0)
    print('img5->', img5)
    print('img5.shape->', img5.shape)
    # img5->(H,W,C)
    # img5[:, :, 0]->第1个通道的二维矩阵特征图 第一个特征图
    feature1 = img5[:, :, 0].detach().numpy()
    plt.imshow(feature1)
    plt.show()
​
​
if __name__ == '__main__':
    dm01()

6 池化层

池化层没有神经元参与, 只是实现降维, 不进行特征提取

6.1 池化计算

  • 卷积层提取到的特征图进行降维操作

  • 最大池化 -> 二维矩阵中最大的特征作为输出特征

  • 平均池化 -> 二维矩阵中平均特征值作为输出特征

6.2 多通道池化计算

  • 池化只在高和宽维度计算, 通道维度不参与池化

  • 卷积层提取到的特征图像有多少通道, 经过池化后还是多少通道

6.3 池化层API使用

python 复制代码 
import torch
import torch.nn as nn
"""
最大池化
kernel_size:窗口形状大小, 不是神经元形状大小, 池化层没有神经元参与
nn.MaxPool2d(kernel_size=, stride=, padding=)
平均池化
nn.AVGPool2d(kernel_size=, stride=, padding=)
"""
​
# 单通道卷积层特征图池化
def dm01():
    # 创建1通道的3*3二维矩阵, 一张特征图
    inputs = torch.tensor([[[0, 1, 2], [3, 4, 5], [6, 7, 8]]], dtype=torch.float)
    print('inputs->', inputs)
    print('inputs.shape->', inputs.shape)
    # 创建池化层
    # kernel_size: 窗口的形状大小
    pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=1, padding=0)
    outputs = pool1(inputs)
    print('outputs->', outputs)
    print('outputs.shape->', outputs.shape)
    pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=1, padding=0)
    outputs = pool2(inputs)
    print('outputs->', outputs)
    print('outputs.shape->', outputs.shape)
​
​
# 多通道卷积层特征图池化
def dm02():
    # size(3,3,3)
    inputs = torch.tensor([[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
                           [[10, 20, 30], [40, 50, 60], [70, 80, 90]],
                           [[11, 22, 33], [44, 55, 66], [77, 88, 99]]], dtype=torch.float)
    # 创建池化层
    # kernel_size: 窗口的形状大小
    pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=1, padding=0)
    outputs = pool1(inputs)
    print('outputs->', outputs)
    print('outputs.shape->', outputs.shape)
    pool2 = nn.AvgPool2d(kernel_size=(2, 2), stride=1, padding=0)
    outputs = pool2(inputs)
    print('outputs->', outputs)
    print('outputs.shape->', outputs.shape)
​
​
if __name__ == '__main__':
    # dm01()
    dm02()
相关推荐
扫地僧9853 分钟前
基于大模型微调的智能医疗诊断协助系统（LLM,RAG,Agent）
人工智能·llm·agent·arg
开利网络7 分钟前
产业互联网+三融战略：重构企业增长密码
大数据·运维·服务器·人工智能·重构·1024程序员节
AIGC方案15 分钟前
人工智能、深度学习、机器学习的联系与区别
人工智能·深度学习·机器学习
web1508541593517 分钟前
Python异步编程详解
开发语言·python
金色旭光18 分钟前
f-string 高效的字符串格式化
python
是小菜呀！36 分钟前
一文讲清python、anaconda的安装以及pycharm创建工程
开发语言·python·pycharm
m0_7136963637 分钟前
python训练 60天挑战-day31
开发语言·人工智能·python·python学习打卡
riri19191 小时前
机器学习：逻辑回归
机器学习
deephub1 小时前
5个开源MCP服务器：扩展AI助手能力，高效处理日常工作
人工智能·深度学习·大语言模型·mcp
Ai野生菌1 小时前
MCP专题 | 探索MCP服务器世界：增强AI能力的精选推荐
服务器·人工智能·mcp·mcp server
热门推荐
01从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06DeepSeek各版本说明与优缺点分析07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09Coze扣子平台完整体验和实践（附国内和国际版对比）10YOLOV11改进1-检测头篇