用仿站工具做网站,电话号码查询企业,网站log文件示例,自己制作个人网站前言
在上一篇课程《【课程总结】Day7#xff1a;深度学习概述》中#xff0c;我们了解到#xff1a;
模型训练过程→本质上是固定w和b参数的过程#xff1b;让模型更好→本质上就是让模型的损失值loss变小#xff1b;让loss变小→本质上就是求loss函数的最小值#xf…前言
在上一篇课程《【课程总结】Day7深度学习概述》中我们了解到
模型训练过程→本质上是固定w和b参数的过程让模型更好→本质上就是让模型的损失值loss变小让loss变小→本质上就是求loss函数的最小值
本篇文章我们将继续深入了解深度学习的项目流程包括批量化打包数据、模型定义、损失函数、优化器以及训练模型等内容。
求函数最小值回顾
以 y 2 x 2 y2x^2 y2x2我们回顾使用pytorch框架求函数最小值其过程大致如下 备注代码不再重复赘述回顾代码请见使用pytorch求函数最小值 深度学习基本流程
由于训练的本质求loss函数的最小值所以我们类比求 y 2 x 2 y2x^2 y2x2最小值的过程来看一下线性回归训练也就是求loss最小值的过程其流程如下 相比于求 y 2 x 2 y2x^2 y2x2最小值的过程我们有如下调整
替换随机选择出生点→准备训练数据(本例中训练数据先模拟生成)替换定义原始函数→定义模型增加初始化优化器训练时要定义损失函数我们常用MSE替换输出最小值位置→输出训练后的模型权重和偏置
具体代码如下
import torch
import torch.nn as nn
import torch.optim as optim# 生成模拟数据
torch.manual_seed(42)
x_train torch.randn(100, 13) # 100个样本每个样本有13个特征
y_train torch.randn(100, 1) # 每个样本对应一个输出值# 定义模型
model nn.Linear(13, 1) # 输入特征数为13输出特征数为1# 初始化优化器
criterion nn.MSELoss() # 均方误差损失
optimizer optim.SGD(model.parameters(), lr0.01) # 随机梯度下降优化器# 迭代次数和学习率
epochs 1000
learning_rate 1e-2# 使用 PyTorch 进行梯度下降
for _ in range(epochs):optimizer.zero_grad() # 梯度清零outputs model(x_train) # 正向传播loss criterion(outputs, y_train) # 计算损失loss.backward() # 反向传播optimizer.step() # 更新参数# 输出最终模型参数
print(线性回归模型的权重, model.weight)
print(线性回归模型的偏置, model.bias)运行结果 至此我们完成了线性回归模型的训练。接下来我们参照上面代码再深入理解一下相关的基础理论。
模型 model 前向传播的定义把特征 X 带入模型 model 得到预测结果 y_pred 训练时自动在底层构建计算图(把正向传播的流程记录下来方便进行后续的分布求导/链式求导。 例如在导数中对于一个复合函数h( g( f(x)))我们需要进行链式求导即h( g( f(x))) f’ * g’ * h’ 推理时直接调用正向传播即可不需要构建计算图 反向传播的定义本质是计算每个参数的梯度是通过损失函数发起的 模型的作用只负责前向传播 forward不负责后向传播 backward
训练流程
从训练集中取一批 batch 样本(x, y)把样本特征 X 送入模型 model得到预测结果 y_pred计算损失函数 loss f(y_pred, y) 计算当前的误差 loss通过loss 反向传播计算每个参数(w, b)的梯度利用优化器 optimizer 通过梯度下降法更新参数利用优化器 optimizer 清空参数的梯度重复1-6 直至迭代结束(各项指标满足要求或是误差很小)
预测流程
拿到待测样本 X推理时没有标签只有特征把样本特征 X 送入模型 model 得到预测结果 y_pred根据 y_pred 解析并返回预测结果即可
深度学习项目流程
通过上述内容梳理我们已经了解深度学习的一个基本流程包括定义模型、训练、预测。
但是在实际工程使用中由于训练数据比较庞大所以我们还需要一些额外的步骤例如增加批量化打包流程。
为了更好地理解深度学习的整体流程我们仍然使用机器学习中使用的《波士顿房价预测》案例来看一下深度学习下应该如何实现。
批量化打包数据
背景
在实际的工程中由于深度学习是要进行大数据量的训练所以我们需要基于以下原因进行批量化打包数据。
提高训练效率通过批量化处理数据可以充分利用GPU的并行计算能力加快模型训练速度。稳定模型训练批量化处理可以降低训练过程中的方差使模型更加稳定。减少内存消耗批量化处理可以减少在每个迭代中需要存储的数据量节省内存消耗。
原理 使用生成器来打包数据 生成器记录了一个规则每次调用生成器就会返回一个批次数据。
实现
先自定义dataset再定义dataloader
from torch.utils.data import DataLoader, TensorDataset
# 批量化打包数据示例代码
# 创建数据集和数据加载器
dataset TensorDataset(x_tensor, y_tensor)
data_loader DataLoader(dataset, batch_size16, shuffleTrue)构建模型
定义
在深度学习中构建模型是指设计神经网络结构确定网络的层数、每层的神经元数量、激活函数等参数以实现特定的学习任务。
常见方式
Sequential模型Sequential模型是一种简单的线性堆叠模型层按顺序依次堆叠在一起适用于顺序处理的神经网络结构。Class子类化模型通过继承框架提供的模型基类用户可以自定义模型的结构和计算逻辑实现更加灵活和定制化的模型构建。 除上述方式之外还有迁移学习、模型组合、模型集成、自动机器学习AutoML、**超网络Hypernetwork**等方式由于不是本章内容重点暂不展开。 筹备训练
定义损失函数
目的损失函数用于衡量模型预测结果与真实标签之间的差异是优化算法的目标函数帮助模型学习正确的参数。
常见损失函数
均方误差损失(Mean Squared Error, MSE)交叉熵损失(Cross Entropy Loss)
定义优化器
目的优化器用于更新模型参数通过最小化损失函数来提高模型性能调整模型参数使得损失函数达到最小值。
常见优化算法
随机梯度下降(SGD)AdamAdagrad等
定义训练次数Epochs 定义训练次数指的是将整个训练数据集在模型上反复训练的次数每次完整地遍历整个数据集称为一个训练周期Epoch。 作用通过增加训练次数模型可以更好地学习数据集中的模式和特征提高模型的泛化能力减少过拟合的风险。
定义学习率Learning Rate
定义学习率是优化算法中的一个重要超参数控制模型参数在每次迭代中更新的步长大小即参数沿着梯度方向更新的幅度。目的学习率的选择影响模型训练的速度和性能合适的学习率能够使模型更快地收敛到最优解而过大或过小的学习率可能导致训练不稳定或陷入局部最优解。
训练模型 训练过程中需要监控模型指标如准确率、损失值等 训练过程中需要保存模型参数方便后续推理 避免过拟合
推理模型
训练好模型之后直接使用模型进行推理即可。
回归问题深度学习实现房价预测案例
1. 数据预处理
1.1 数据读取
file_name ./housing.data# 原始数据读取
X []
y []
with open(filefile_name, moder, encodingutf8) as f:
# f.readline()for line in f:line line.strip()if line:sample [float(ele) for ele in line.split( ) if ele]X.append(sample[:-1])y.append(sample[-1])
1.2 数据切分
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2,random_state0)1.3 数据预处理(规范化)
# 规范化
import numpy as np# 转numpy数组
X_train np.array(X_train)
X_test np.array(X_test)# 提取参数
_mean X_train.mean(axis0)
_std X_train.std(axis0) 1e-9 # 为了避免除零此处加上一个非常小的数# 执行规范化处理
X_train (X_train - _mean) / _std
X_test (X_test - _mean) / _std2. 批量化打包数据
通过定义一个继承Dataset的数据集类方便数据的常见操作如len()、index()等。
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader# 1. 继承Dataset 自定义一个数据集类
class HouseDataset(Dataset):自定义一个房价数据集def __init__(self, X, y):接受参数定义静态属性self.X Xself.y ydef __len__(self):返回数据集样本的个数return len(self.X)def __getitem__(self, idx):通过索引读取第idx个样本x self.X[idx]y self.y[idx]# 转张量x torch.tensor(datax, dtypetorch.float32)y torch.tensor(data[y], dtypetorch.float32)return x, y此处__len__和__getitem__方法是Python的魔法方法他们是回调(callback)函数不需要用户自己调用而由系统调用。即 告诉系统我定义的数据集在取长度和按index取元素调用哪个方法当系统触发这两种情况(取长度和按index取元素)时会自动调用类里的__len__和__getitem__方法。 # 训练集加载器
house_train_dataset HouseDataset(XX_train, yy_train)
house_train_dataloader DataLoader(datasethouse_train_dataset, batch_size12,shuffleTrue)# 测试集加载器
house_test_dataset HouseDataset(XX_test, yy_test)
house_test_dataloader DataLoader(datasethouse_test_dataset, batch_size32,shuffleTrue)
通过下面的测试代码可以查看上述训练集和测试集的数据形状
# 测试代码
for X, y in house_train_dataset:print(X)print(X.shape)print(y)print(y.shape)break运行结果 3. 模型搭建
模型的构建方法有以下三种写法一般情况下我们使用第三种class的方法这种方法可以自定义模型的结构和计算逻辑实现更加灵活和定制化的模型。
from torch import nn# # 搭建方法1
# model nn.Linear(in_features13, out_features1)# # 搭建方法2
# model nn.Sequential(
# nn.Linear(in_features13, out_features1)
# )# 搭建方法3
class Model(nn.Module):自定义一个类- 必须继承 nn.Moduledef __init__(self, n_features13):接收超参定义处理的层# 先初始化父类super(Model, self).__init__()# 定义一个线性层(做一次矩阵变换)self.linear nn.Linear(in_featuresn_features, out_features1)def forward(self, x):模型前向传播逻辑x self.linear(x)return x实例化模型
model Model(n_features13)通过一下测试代码可以看到模型的运行结果
# 测试代码
for X, y in house_train_dataloader:y_pred model(X)print(y_pred)print(y)break运行结果 4. 筹备训练
这一步骤我们将定义模型(实例化上述自定义模型)、定义损失函数、定义优化器、定义训练次数和定义学习率。
# 定义模型
model Model(n_features13)# 定义训练的轮次
epochs 100# 定义学习率
learing_rate 1e-3# 定义损失函数
loss_fn nn.MSELoss()# 定义优化器
optimizer torch.optim.SGD(paramsmodel.parameters(), lrlearing_rate)5. 训练模型
5.1 定义监控指标和方法
在训练的过程中我们需要对训练过程的重要指标加以监控以避免训练有问题。
# 定义查看损失函数的方法用于监控训练过程
def get_loss(dataloader):# 模型设置为评估模式# (BatchNorm LayNorm Dropout层在train模式和eval模式下行为是不一样)model.eval()# 收集每个批量的损失losses []# 构建一个无梯度的环境(底层不会默认自动创建计算图节约资源)with torch.no_grad():for X, y in dataloader:y_pred model(X)loss loss_fn(y_pred, y)losses.append(loss.item())# 计算每个批量损失的平均值final_loss sum(losses) / len(losses)# 保留小数点后5位final_loss round(final_loss, ndigits5)return final_loss5.2 实现训练过程
def train():# 记录训练过程train_losses []test_losses []# 每一轮次for epoch in range(epochs):#模型设为训练模式model.train()# 每一批量for X, y in house_train_dataloader:# 1. 正向传播y_pred model(X)# 2. 损失计算loss loss_fn(y_pred, y)# 3. 反向传播loss.backward()# 4. 优化一步optimizer.step()# 5. 清空梯度optimizer.zero_grad()# 计算模型当前的损失情况train_loss get_loss(dataloaderhouse_train_dataloader)test_loss get_loss(dataloaderhouse_test_dataloader)train_losses.append(train_loss)test_losses.append(test_loss)print(f当前是第{epoch1}轮训练集损失为{train_loss}, 测试集损失为{test_loss})return train_losses, test_losses5.3 开始训练
至此我们已经完成整体训练前的重要步骤实现接下来就可以训练启动
train_losses, test_losses train()运行结果 5.4 图形化监控数据
为了方便查看训练过程变化情况可以使用matplotlib绘制损失函数的变化曲线。 from matplotlib import pyplot as pltplt.plot(train_losses, cblue, labeltrain_loss)
plt.plot(test_losses, cred, labeltest_loss)
plt.title(The Losses)
plt.xlabel(xlabelepoches)
plt.ylabel(ylabelloss)
plt.legend()运行结果 由上图可以看到
在一开始的训练中损失值快速下降当训练次数到40次左右后损失值已经下降不明显。
我们可以通过加入激活函数引入非线性因素来优化模型。
5.5 激活函数 定义激活函数是神经网络中的一种非线性函数通常应用在神经元的输出上将输入信号转换为输出信号。激活函数引入了非线性因素使神经网络可以学习和表达复杂的非线性关系。 举个例子 想象一下神经网络就像是一个复杂的拼图游戏每个神经元就像是拼图中的一个小块。当我们只使用线性函数比如直线作为激活函数时就好比每个小块都是直线无法拼出复杂的图案只能表达简单的线性关系。 但是当我们引入非线性的激活函数时就好比在每个小块上加入了各种形状和曲线使得每个小块可以表达更加复杂的形状和关系。这样当我们把许多这样的小块神经元组合在一起时就可以拼出更加复杂和多样的图案非线性关系从而让神经网络能够学习和表达更加复杂的模式和特征。 因此激活函数的作用就是为神经网络引入了这种非线性因素使得神经网络可以更好地学习和表达复杂的非线性关系就像在拼图游戏中加入了各种形状和曲线让我们能够拼出更加丰富多彩的图案一样。 常见激活函数有Sigmoid函数、Tanh函数、ReLU函数、Softmax函数相关内容在补充知识段落展开。 使用方法
在自定义模型类的forward函数中增加
class Model(nn.Module):自定义一个类- 必须继承 nn.Moduledef __init__(self, n_features13):接收超参定义处理的层# 先初始化父类super(Model, self).__init__()# 定义一个线性层(做一次矩阵变换)self.linear nn.Linear(in_featuresn_features, out_features1)def forward(self, x):模型前向传播逻辑x self.linear(x)x nn.ReLU()(x) # 添加ReLU激活函数return x运行结果 对比加入激活函数前后的图形其训练集的损失仍然在19左右只是下降过程不如之前那么快了。
5.6 多层感知机
定义
由于无法模拟诸如异或以及其他复杂函数的功能使得单层感知机的应用较为单一。一个简单的想法是如果能在感知机模型中增加若干隐藏层增强神经网络的非线性表达能力就会让神经网络具有更强拟合能力。 大脑是一个多层感知机每一层都在学习不同级别的特征。 输入层输入层就像你的眼睛它接收到动物的各种特征信息比如颜色、大小等。隐藏层隐藏层就像你的大脑皮层它处理输入的特征信息并尝试从中提取出更加抽象和复杂的特征比如动物的轮廓、纹理等。输出层输出层就像你的嘴巴它根据隐藏层提取的特征信息做出判断比如判断输入的动物是狗还是猫。 通过多次学习和训练你的大脑多层感知机会逐渐调整隐藏层中的神经元神经元就像大脑中的神经元的连接权重从而更好地识别不同类型的动物。 实现方法
修改自定义模型的初始化方法加入一个新的线性层
class Model(nn.Module):自定义一个类- 必须继承 nn.Moduledef __init__(self, n_features13):接收超参定义处理的层# 先初始化父类super(Model, self).__init__()# 定义两个线性层 self.linear1 nn.Linear(in_featuresn_features, out_features8)self.linear2 nn.Linear(in_features8, out_features1)def forward(self, x):模型前向传播逻辑x self.linear1(x)x torch.relu(x) # 添加ReLU激活函数x self.linear2(x)return x重新执行训练过程并绘制损失值图形 由上图可以看到多层感知机引入激活函数损失值已经降到8左右对比之前未优化的模型模型的损失值变小预测准确性得到提升。
深度学习 vs 机器学习
至此我们借助房价预测的示例已经完整地实现了深度学习的整体流程接下来我们对比一下深度学习和机器学习在同一问题房价预测问题上的结果。
from sklearn.tree import DecisionTreeRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as pltfile_name ./housing.data# 原始数据读取
X []
y []
with open(filefile_name, moder, encodingutf8) as f:
# f.readline()for line in f:line line.strip()if line:sample [float(ele) for ele in line.split( ) if ele]X.append(sample[:-1])y.append(sample[-1])from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2,random_state0)# 规范化
import numpy as np# 转numpy数组
X_train np.array(X_train)
X_test np.array(X_test)# 提取参数
_mean X_train.mean(axis0)
_std X_train.std(axis0) 1e-9# 执行规范化处理
X_train (X_train - _mean) / _std
X_test (X_test - _mean) / _std # 决策树
dt_model DecisionTreeRegressor()
dt_model.fit(X_train, y_train)
dt_pred dt_model.predict(X_test)
dt_loss mean_squared_error(y_test, dt_pred)# KNN
knn_model KNeighborsRegressor()
knn_model.fit(X_train, y_train)
knn_pred knn_model.predict(X_test)
knn_loss mean_squared_error(y_test, knn_pred)# 支持向量机
svm_model SVR()
svm_model.fit(X_train, y_train)
svm_pred svm_model.predict(X_test)
svm_loss mean_squared_error(y_test, svm_pred)# 随机森林
rf_model RandomForestRegressor()
rf_model.fit(X_train, y_train)
rf_pred rf_model.predict(X_test)
rf_loss mean_squared_error(y_test, rf_pred)models [Decision Tree, KNN, SVM, Random Forest]
loss_values [dt_loss, knn_loss, svm_loss, rf_loss]plt.figure(figsize(10, 6))
bars plt.bar(models, loss_values, colorskyblue)
plt.xlabel(Models)
plt.ylabel(Mean Squared Error)
plt.title(Comparison of Mean Squared Error for Different Models)# 添加数据标签
for bar, loss in zip(bars, loss_values):plt.text(bar.get_x() bar.get_width() / 2 - 0.1, bar.get_height() 0.001, f{loss:.4f}, hacenter, colorblack, fontsize10)plt.show()运行结果 通过对比机器学习和深度学习的平均平方偏差MSE深度学习是明显优于机器学习的。
分类问题深度学习实现鸢尾花分类案例
上述案例中我们以房价预测为例使用深度学习实现了线性回归的训练和预测。接下来我们将以《鸢尾花分类》为例学习了解深度学习如何实现分类问题。
流程回顾与对比
深度学习实现分类问题与深度学习实现回归问题流程基本一致对比不同点如下
流程步骤回归问题分类问题说明1.数据预处理\\1.1 数据读取✔✔读取数据源不同1.2数据切分✔✔相同1.3数据预处理✔✔相同2. 批量化数据打包✔⭕️标签数据类型不同1.回归问题标签数据类型为torch.float322.分类问题需要将标签y定义类型改为torch.long3. 模型搭建✔⭕️超参定义不同1.回归问题预测结果是1个out_features12.分类问题预测结果有N类out_featuresN4. 筹备训练✔⭕️损失不同1.回归问题使用的是MSE2.分类问题使用的是交叉熵5.训练模型\\5.1定义监控指标和方法✔⭕️监控指标不同1.回归问题监控MSE2.分类问题监控准确率5.2实现训练过程✔✔相同5.3开始训练✔✔相同5.4图形化监控数据✔✔相同5.5激活函数✔✔相同
代码实现
import numpy as np
import torch
from torch import nn
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from matplotlib import pyplot as plt# 1. 继承Dataset 自定义一个数据集类
class IrisDataset(Dataset):自定义一个鸢尾花数据集def __init__(self, X, y):接受参数定义静态属性self.X Xself.y ydef __len__(self):返回数据集样本的个数return len(self.X)def __getitem__(self, idx):通过索引读取第idx个样本x self.X[idx]y self.y[idx]# 转张量x torch.tensor(datax, dtypetorch.float32)# 索引号long类型y torch.tensor(datay, dtypetorch.long)return x, y# 搭建方法3
class Model(nn.Module):自定义一个类- 必须继承 nn.Moduledef __init__(self, n_features4, n_classes3):接收超参定义处理的层# 先初始化父类super(Model, self).__init__()# 定义一个线性层(做一次矩阵变换)self.linear nn.Linear(in_featuresn_features, out_featuresn_classes)def forward(self, x):模型前向传播逻辑x self.linear(x)return xdef get_acc(dataloader):# 模型设置为评估模式# (BatchNorm LayNorm Dropout层在train模式和eval模式下行为是不一样)model.eval()# 收集每个批量的损失accs []# 构建一个无梯度的环境(底层不会默认自动创建计算图节约资源)with torch.no_grad():for X, y in dataloader:y_pred model(X)y_pred y_pred.argmax(dim-1)acc (y_pred y).to(dtypetorch.float32).mean().item()accs.append(acc)# 计算每个批量损失的平均值final_acc sum(accs) / len(accs)# 保留小数点后5位final_acc round(final_acc, ndigits5)return final_accdef train():# 记录训练过程train_accs []test_accs []# 每一轮次for epoch in range(epochs):#模型设为训练模式model.train()# 每一批量for X, y in iris_train_dataloader:# 1. 正向传播y_pred model(X)# 2. 损失计算loss loss_fn(y_pred, y)# 3. 反向传播loss.backward()# 4. 优化一步optimizer.step()# 5. 清空梯度optimizer.zero_grad()# 计算模型当前的损失情况train_acc get_acc(dataloaderiris_train_dataloader)test_acc get_acc(dataloaderiris_test_dataloader)train_accs.append(train_acc)test_accs.append(test_acc)print(f当前是第{epoch1}轮训练集准确率为{train_acc}, 测试集准确率为{test_acc})return train_accs, test_accsX,y load_iris(return_X_yTrue)
X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2,random_state0)# 转numpy数组
X_train np.array(X_train)
X_test np.array(X_test)# 提取参数
_mean X_train.mean(axis0)
_std X_train.std(axis0) 1e-9# 执行规范化处理
X_train (X_train - _mean) / _std
X_test (X_test - _mean) / _std# 训练集加载器
iris_train_dataset IrisDataset(XX_train, yy_train)
iris_train_dataloader DataLoader(datasetiris_train_dataset, batch_size4,shuffleTrue)# 测试集加载器
iris_test_dataset IrisDataset(XX_test, yy_test)
iris_test_dataloader DataLoader(datasetiris_test_dataset, batch_size8,shuffleTrue)# 定义模型
model Model(n_features4)# 定义训练的轮次
epochs 50# 定义学习率
learing_rate 1e-3# 定义损失函数:分类问题使用交叉熵
loss_fn nn.CrossEntropyLoss()# 定义优化器
optimizer torch.optim.SGD(paramsmodel.parameters(), lrlearing_rate)train_accs, test_accs train()plt.plot(train_accs, cblue, labeltrain_acc)
plt.plot(test_accs, cred, labeltest_acc)
plt.title(The Accs)
plt.xlabel(xlabelepoches)
plt.ylabel(ylabelacc)
plt.legend()运行结果 补充知识
概率模拟
由于分类问题模型是不会直接输出预测类别而是输出每个类别的数字(或者叫权重)此时我们需要通过模拟概率将每个类别的数字转换为[0, 1]之间的概率。
常见方法
二分类概率模拟Sigmoid函数 σ ( x ) 1 1 e − x \sigma(x) \frac{1}{1 e^{-x}} σ(x)1e−x1取值范围在(0, 1)。 def sigmod(x):sigmoid- (0, 1) - 单调递增函数- x为0时模拟概率为0.5- x 0时模拟概率0.5- x 0时模拟概率0.5return 1 / (1 np.exp(-x))x np.linspace(start-5, stop5, num30)plt.plot(x, sigmod(x))plt.grid()多分类概率模拟Softmax函数 import numpy as npdef softmax(logits):softmax:- 原来比较大的数模拟概率也比较大# 转化为np数组logits np.array(logits)# 转化为正数logits np.exp(logits)# 模拟概率return logits /logits.sum()# 模型输出的都是原始数据logits [0.6 , -3.6, 18.9 ]logtis np.array(logits)softmax(logits)运行结果 one-hot编码
在《【课程总结】Day6(上)机器学习项目实战–外卖点评情感分析预测》中我们曾接触过one-hot编码。本次我们再做下回顾 这是一种状态编码适合于离散量内涵 特征编码时 以汽车的行驶状态举例 三个状态左转0右转1直行2左转[1, 0, 0]右转[0, 1, 0]直行[0, 0, 1] 标签编码时 以鸢尾花类别举例 三种花第一种0第二种1第三种2第一种[1, 0, 0]第二种[0, 1, 0]第三种[0, 0, 1] 特点 互相垂直的向量没有鲜艳的远近关系都是比较长的向量跟类别数量一致每个向量只有1位是1其余都是0(这种状态被称为高度稀疏sparse)从计算和存储上来说都比较浪费性能
神经网络在预测多类别分类任务时n_classes个类别的预测问题模型会输出n_classes个概率。 以鸢尾花为例神经网络不会直接输出预测的结果是哪个花的类别而是给出三种花各自的概率只不过最高概率的哪种花可能就是我们需要的预测结果类别。 交叉熵
作用从分布的角度来衡量两个概率的远近程度
计算过程
# 以鸢尾花分类举例
# 假设我们有一个真实结果y_true结果是第2类索引号是1
# 真实结果y_true: 第2类索引号为1
# 预测结果1y_pred1: [12.5, -0.5, 2.7]
# 预测结果2y_pred2: [-12.5, 6.4, 2.7]# 第一步使用one-hot对类别进行编码
y_true np.array( [0, 1, 0])# 第二步进行第一次预测
# 1、对预测结果使用softmax进行概率模拟
y_pred1 np.array([12.5, -0.5, 2.7])
y_pred1 softmax(y_pred1) # 执行结果
# y_pred1
# array([9.99942291e-01, 2.26019897e-06, 5.54483994e-05])# 2、计算交叉熵损失 y_true y_pred1
loss1 -(0 * np.log(9.99942291e-01) 1 * np.log(2.26019897e-06) 0 * np.log(5.54483994e-05))
# 执行结果
# loss1
# 13.00005770873235# 第三步进行第二次预测
y_pred2 np.array( [-12.5, 6.4, 2.7])
y_pred2 softmax(y_pred2) # 执行结果
# y_pred2
# array([6.04265198e-09, 9.75872973e-01, 2.41270213e-02])loss1 -(np.log(9.75872973e-01))
# 执行结果
# loss1
# 0.024422851654124902通过上面计算可以看到
loss1交叉损失熵最低时也就是预测结果[-12.5, 6.4, 2.7]与真实结果(第2类)相匹配由此得到交叉熵越低预测结果与真实值差异越小。交叉熵相比MSE交叉熵计算代码要小。 在计算交叉熵时计算方法是进行第i个类别one-hot编码与第i个类别概率相乘最后再相加表面上看求了多个熵实际上只求1个熵(因为one-hot编码为0的位置实际没有参与计算)
激活函数 Sigmoid 函数 公式 s i g m o i d ( x ) 1 1 e − x {sigmoid}(x) \frac{1}{1 e^{-x}} sigmoid(x)1e−x1 特点将输入值压缩到 0 到 1 之间常用于输出层的二分类问题但容易出现梯度消失问题. import numpy as npimport matplotlib.pyplot as pltx np.linspace(-5, 5, 100)sigmoid 1 / (1 np.exp(-x))plt.plot(x, sigmoid, labelSigmoid Function)plt.xlabel(x)plt.ylabel(sigmoid(x))plt.legend()plt.show()Tanh 函数 公式 t a n h ( x ) e x − e − x e x e − x {tanh}(x) \frac{e^{x} - e^{-x}}{e^{x} e^{-x}} tanh(x)exe−xex−e−x 特点将输入值压缩到 -1 到 1 之间解决了 Sigmoid 函数的零中心问题但仍存在梯度消失问题。 import numpy as npimport matplotlib.pyplot as plt# 生成 x 值x np.linspace(-5, 5, 100)# 计算双曲正切函数的 y 值y np.tanh(x)# 绘制双曲正切函数图像plt.figure(figsize(8, 6))plt.plot(x, y, labeltanh(x))plt.xlabel(x)plt.ylabel(tanh(x))plt.title(Plot of Hyperbolic Tangent Function)plt.grid(True)plt.legend()plt.show()ReLU 函数Rectified Linear Unit 公式 R e L U ( x ) max ( 0 , x ) {ReLU}(x) \max(0, x) ReLU(x)max(0,x) 特点简单且高效解决了梯度消失问题但可能导致神经元死亡问题输出恒为 0 import numpy as npimport matplotlib.pyplot as plt# 定义 ReLU 函数def relu(x):return np.maximum(0, x)# 生成 x 值x np.linspace(-5, 5, 100)# 计算 ReLU 函数的 y 值y relu(x)# 绘制 ReLU 函数图像plt.figure(figsize(8, 6))plt.plot(x, y, labelReLU(x))plt.xlabel(x)plt.ylabel(ReLU(x))plt.title(Plot of Rectified Linear Unit (ReLU) Function)plt.grid(True)plt.legend()plt.show()内容小结 模型训练本质固定w和b参数的过程 让模型更好→本质上就是让模型的损失值loss变小让loss变小→本质上就是求loss函数的最小值 深度学习的整体项目路程 第一步读取数据、切分数据、数据规范化第二步批量化打包数据第三步构建模型第四步筹备训练定义损失函数、定义优化器、定义训练次数、定义学习率第五步训练模型在训练的过程中需要对损失值进行监控第六步推理模型即直接将待预测样本数据代入模型求预测值y_pred即可 第三步构建模型时 一般常用自定义class类的方法这种方法更加灵活为了降低模型的损失值可以采用加入激活函数以及多层感知机的方式 第五步实现训练模型时 基本的五步法1.正向传播→2.损失计算→3.反向传播→4.优化一步→5.清空梯度 使用深度学习进行分类问题时流程与回归问题基本一致不同的地方在于 损失函数计算方法不同回归问题使用的是MSE分类问题使用的是交叉熵。训练过程中监控的指标不同回归问题监控MSE分类问题监控的是准确率。 神经网络在处理分类问题时输出的不是某个类别而是不同类别的概率。 在输出概率时需要进行概率模拟二分类问题概率模拟时使用Sigmoid函数多分类概率模拟时使用的是softmax函数
参考资料
多层感知机
百度百科ReLU函数
百度百科Sigmoid函数
