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

笔记

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是在激活层后使用

  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的均值和标准差都不一样, 会引入噪声样本数据, 降低训练模型效果(防止过拟合)

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

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

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

  """
  正则化: 每批样本的均值和方差不一样, 引入噪声样本
  加快模型收敛: 样本标准化后, 落入激活函数的合理区间, 导数尽可能最大
  """
  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 构建张量数据集

# 导入相关模块
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:2x_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 构建分类神经网络模型

# 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 模型训练

# 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和bmodel = 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 创建优化器对象 SGDoptimizer = optim.SGD(params=model.parameters(), lr=1e-3)# todo:3-5 模型训练 min-batch 随机梯度下降# 训练轮数num_epoch = 50for epoch in range(num_epoch):# 定义变量统计每次训练的损失值, 训练batch数total_loss = 0.0batch_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 模型评估

# 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->0print((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 图像加载

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使用

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使用

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()