2. 深度学习的项目流程(批量化打包数据、构建模型、训练模型、波士顿房价预测、激活函数、多层感知机)

深度学习流程

  • 1. 深度学习基本流程
    • 1.1 流程图
    • 1.2 代码实现
    • 1.3 基本概念
  • 2. 深度学习项目流程
    • 2.1 批量化打包数据
    • 2.2 构建模型
    • 2.3 训练模型
      • (1)筹备训练
      • (2)开始训练
    • 2.4 模型推理
  • 3. 深度学习实现波士顿房价预测
    • 3.1 数据读取、切分、预处理
    • 3.2 批量化打包数据
    • 3.3 搭建模型
    • 3.4 训练模型
      • (1)筹备训练
      • (2)定义监控指标和方法
      • (3)实现训练过程
      • (4)开始训练
    • 3.5 图形化监控数据
    • 3.6 激活函数
    • 3.7 多层感知机

原文链接:https://blog.csdn.net/Deadwalk/article/details/139649117?spm=1001.2014.3001.5502

1. 深度学习基本流程

1.1 流程图

  • 由于训练的本质就是求loss函数的最小值;所以,我们类比求 y = 2 x 2 y = 2x^2 y=2x2 最小值的过程,来看一下线性回归训练(也就是求loss最小值)的过程,其流程如下:
    在这里插入图片描述

1.2 代码实现

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(), lr=0.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)

1.3 基本概念

  • 模型 model
    • 前向传播:把特征 X 带入模型 model ,得到预测结果 y_pred
      • 训练时:自动在底层构建计算图(把正向传播的流程记录下来,方便进行后续的分布求导/链式求导
      • 例如:在导数中,对于一个复合函数 h ( g ( f ( x ) ) ) h( g( f(x))) h(g(f(x))) ,我们需要进行链式求导,即 h ( g ( f ( x ) ) ) = f ′ ∗ g ′ ∗ h ′ h( g( f(x))) = f' * g' * h' h(g(f(x)))=fgh
    • 反向传播:本质是计算每个参数的梯度,是通过损失函数发起的
    • 模型的作用:只负责前向传播 forward,不负责后向传播 backward
  • 训练流程
    1. 从训练集中,取一批 batch 样本 (x, y)
    2. 把样本特征 X 送入模型 model,得到预测结果 y_pred
    3. 计算损失函数 loss = f(y_pred, y),计算当前的误差 loss
    4. 通过 loss , 反向传播,计算每个参数 (w, b) 的梯度
    5. 利用优化器 optimizer ,通过梯度下降法,更新参数
    6. 利用优化器 optimizer 清空参数的梯度
    7. 重复1-6 直至迭代结束(各项指标满足要求或是误差很小)
  • 预测流程
    1. 拿到待测样本 X(推理时,没有标签,只有特征)
    2. 把样本特征 X 送入模型 model ,得到预测结果 y_pred
    3. 根据 y_pred 解析并返回预测结果即可

2. 深度学习项目流程

  • 通过上述内容梳理,我们已经了解深度学习的一个基本流程,包括:定义模型、训练、预测。
  • 但是在实际工程使用中,由于训练数据比较庞大,所以我们还需要一些额外的步骤,例如:增加批量化打包流程。
  • 为了更好地理解深度学习的整体流程,我们仍然使用机器学习中使用的《波士顿房价预测》案例,来看一下深度学习下应该如何实现。

2.1 批量化打包数据

  • 原因:在实际的工程中,深度学习要进行大数据量的训练,批量化打包数据有以下优点:
    • 提高训练效率:通过批量化处理数据,可以充分利用GPU的并行计算能力,加快模型训练速度;
    • 稳定模型训练:批量化处理可以降低训练过程中的方差,使模型更加稳定;
    • 减少内存消耗:批量化处理可以减少在每个迭代中需要存储的数据量,节省内存消耗。
  • 原理:使用生成器来打包数据
    • 生成器记录了一个规则,每次调用生成器就会返回一个批次数据。
  • 实现
    1. 先自定义dataset
    2. 再定义dataloader
    from torch.utils.data import DataLoader, TensorDataset
    # 批量化打包数据示例代码
    # 创建数据集和数据加载器
    dataset = TensorDataset(x_tensor, y_tensor)
    data_loader = DataLoader(dataset, batch_size=16, shuffle=True)	
    

2.2 构建模型

  • 定义
    • 在深度学习中构建模型是指设计神经网络结构,确定网络的层数、每层的神经元数量、激活函数等参数,以实现特定的学习任务。
  • 常见方式
    • Sequential模型:Sequential模型是一种简单的线性堆叠模型,层按顺序依次堆叠在一起,适用于顺序处理的神经网络结构。
    • Class子类化模型:通过继承框架提供的模型基类,用户可以自定义模型的结构和计算逻辑,实现更加灵活和定制化的模型构建。
    • 除上述方式之外,还有迁移学习、模型组合、模型集成、自动机器学习(AutoML)、超网络(Hypernetwork) 等方式,由于不是本章内容重点,暂不展开。

2.3 训练模型

(1)筹备训练

  • a. 定义损失函数
    • 目的:损失函数用于衡量模型预测结果与真实标签之间的差异,是优化算法的目标函数,帮助模型学习正确的参数。
    • 常见损失函数:
      • 均方误差损失(Mean Squared Error, MSE)
      • 交叉熵损失(Cross Entropy Loss)
  • b. 定义优化器
    • 目的:优化器用于更新模型参数,通过最小化损失函数来提高模型性能,调整模型参数使得损失函数达到最小值。
    • 常见优化器:
      • 随机梯度下降(SGD)
      • Adam
      • Adagrad等
  • c. 设置训练次数
    • 定义:训练次数指的是将整个训练数据集在模型上反复训练的次数,每次完整地遍历整个数据集称为一个训练周期(Epoch)。
    • 作用:通过增加训练次数,模型可以更好地学习数据集中的模式和特征,提高模型的泛化能力,减少过拟合的风险。
  • d. 设置学习率
    • 定义:学习率是优化算法中的一个重要超参数,控制模型参数在每次迭代中更新的步长大小,即参数沿着梯度方向更新的幅度。
    • 目的:学习率的选择影响模型训练的速度和性能,合适的学习率能够使模型更快地收敛到最优解,而过大或过小的学习率可能导致训练不稳定或陷入局部最优解。

(2)开始训练

  • 训练过程中需要监控模型指标,如:准确率、损失值等
  • 训练过程中需要保存模型参数,方便后续推理
  • 避免过拟合

2.4 模型推理

  • 训练好模型之后,直接使用模型进行推理即可。

3. 深度学习实现波士顿房价预测

3.1 数据读取、切分、预处理

# 数据读取
file_name = './housing.data'
X = []
y = []
with open(file=file_name, mode='r', encoding='utf8') 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_size=0.2,random_state=0)# 数据预处理(规范化)
import numpy as np# 转numpy数组
X_train = np.array(X_train)
X_test = np.array(X_test)# 提取参数
_mean = X_train.mean(axis=0)
_std = X_train.std(axis=0) + 1e-9  # 为了避免除零,此处加上一个非常小的数# 执行规范化处理
X_train = (X_train - _mean) / _std
X_test = (X_test - _mean) / _std

3.2 批量化打包数据

  • 通过定义一个继承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(data=x, dtype=torch.float32)y = torch.tensor(data=[y], dtype=torch.float32)return x, y

此处__len__和__getitem__方法是Python的魔法方法,他们是回调(callback)函数,不需要用户自己调用而由系统调用。即:

告诉系统我定义的数据集在取长度和按index取元素调用哪个方法;
当系统触发这两种情况(取长度和按index取元素)时,会自动调用类里的__len__和__getitem__方法。

# 训练集加载器
house_train_dataset = HouseDataset(X=X_train, y=y_train)
house_train_dataloader = DataLoader(dataset=house_train_dataset, batch_size=12,shuffle=True)# 测试集加载器
house_test_dataset = HouseDataset(X=X_test, y=y_test)
house_test_dataloader = DataLoader(dataset=house_test_dataset, batch_size=32,shuffle=True)# 测试代码:查看上述训练集和测试集的数据形状
for X, y in house_train_dataset:print(X)print(X.shape)print(y)print(y.shape)break

tensor([-0.3726, -0.4996, -0.7049, 3.6645, -0.4249, 0.9357, 0.6937, -0.4372,
-0.1622, -0.5617, -0.4846, 0.3717, -0.4110])
torch.Size([13])
tensor([26.7000])
torch.Size([1])

3.3 搭建模型

# 模型搭建
from torch import nn# # 搭建方法1:
# model = nn.Linear(in_features=13, out_features=1)# # 搭建方法2:
# model = nn.Sequential(
#     nn.Linear(in_features=13, out_features=1)
# )# 搭建方法3:
class Model(nn.Module):"""自定义一个类- 必须继承 nn.Module"""def __init__(self, n_features=13):"""接收超参定义处理的层"""# 先初始化父类super(Model, self).__init__()# 定义一个线性层(做一次矩阵变换)self.linear = nn.Linear(in_features=n_features, out_features=1)def forward(self, x):"""模型前向传播逻辑"""x = self.linear(x)return x# 实例化模型
model = Model(n_features=13)
# 测试代码:可以看到模型的运行结果
for X, y in house_train_dataloader:y_pred = model(X)print(y_pred)print(y)break

tensor([[-0.3277],
[-0.3072],
[ 0.0355],
[-0.0539],
[-0.1478],
[-0.2848],
[ 0.5001],
[ 0.8047],
[ 0.2635],
[-0.2561],
[-0.1742],
[-0.4823]], grad_fn=)
tensor([[33.1000],
[14.5000],
[35.4000],
[39.8000],
[22.5000],
[23.8000],
[36.5000],
[14.6000],
[35.1000],
[25.0000],
[20.3000],
[18.8000]])

3.4 训练模型

(1)筹备训练

  • 定义模型(实例化上述自定义模型)、定义损失函数、定义优化器、定义训练次数和定义学习率
# 定义模型
model = Model(n_features=13)# 定义训练的轮次
epochs = 100# 定义学习率
learing_rate = 1e-3# 定义损失函数
loss_fn = nn.MSELoss()# 定义优化器
optimizer = torch.optim.SGD(params=model.parameters(), lr=learing_rate)

(2)定义监控指标和方法

  • 在训练的过程中,我们需要对训练过程的重要指标加以监控,以避免训练有问题。
# 定义查看损失函数的方法,用于监控训练过程
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, ndigits=5)return final_loss

(3)实现训练过程

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(dataloader=house_train_dataloader)test_loss = get_loss(dataloader=house_test_dataloader)train_losses.append(train_loss)test_losses.append(test_loss)print(f"当前是第{epoch+1}轮,训练集损失为:{train_loss}, 测试集损失为:{test_loss}")return train_losses, test_losses

(4)开始训练

train_losses, test_losses = train()

当前是第1轮,训练集损失为:512.23866, 测试集损失为:470.53479
当前是第2轮,训练集损失为:441.68754, 测试集损失为:414.82328
当前是第3轮,训练集损失为:387.13285, 测试集损失为:417.94884
当前是第4轮,训练集损失为:339.7604, 测试集损失为:321.25851
当前是第5轮,训练集损失为:295.34212, 测试集损失为:283.35604
当前是第6轮,训练集损失为:259.63065, 测试集损失为:304.31802
当前是第7轮,训练集损失为:229.71633, 测试集损失为:274.742
当前是第8轮,训练集损失为:201.60888, 测试集损失为:213.39904
当前是第9轮,训练集损失为:179.15055, 测试集损失为:193.0374
当前是第10轮,训练集损失为:158.91308, 测试集损失为:154.98766
当前是第11轮,训练集损失为:140.94878, 测试集损失为:143.02044
当前是第12轮,训练集损失为:125.19098, 测试集损失为:144.65741
当前是第13轮,训练集损失为:112.88125, 测试集损失为:129.76349
当前是第14轮,训练集损失为:100.19187, 测试集损失为:131.55499
当前是第15轮,训练集损失为:90.06036, 测试集损失为:96.69405
当前是第16轮,训练集损失为:81.32993, 测试集损失为:88.38998
当前是第17轮,训练集损失为:73.30434, 测试集损失为:83.43338
当前是第18轮,训练集损失为:66.68453, 测试集损失为:94.52958
当前是第19轮,训练集损失为:60.70854, 测试集损失为:111.13627
当前是第20轮,训练集损失为:55.5599, 测试集损失为:75.72988
当前是第21轮,训练集损失为:51.33824, 测试集损失为:102.07828
当前是第22轮,训练集损失为:47.48327, 测试集损失为:59.70907
当前是第23轮,训练集损失为:44.18092, 测试集损失为:53.83336
当前是第24轮,训练集损失为:41.14358, 测试集损失为:94.82549
当前是第25轮,训练集损失为:38.32627, 测试集损失为:89.27538
当前是第26轮,训练集损失为:36.4985, 测试集损失为:47.11266
当前是第27轮,训练集损失为:33.95471, 测试集损失为:44.56353
当前是第28轮,训练集损失为:32.83847, 测试集损失为:49.46564
当前是第29轮,训练集损失为:30.80773, 测试集损失为:77.49344
当前是第30轮,训练集损失为:29.49684, 测试集损失为:74.35186
当前是第31轮,训练集损失为:29.75533, 测试集损失为:45.33565
当前是第32轮,训练集损失为:27.50819, 测试集损失为:40.49028
当前是第33轮,训练集损失为:26.46446, 测试集损失为:37.61283
当前是第34轮,训练集损失为:25.75421, 测试集损失为:38.15598
当前是第35轮,训练集损失为:25.35517, 测试集损失为:42.44055
当前是第36轮,训练集损失为:24.32058, 测试集损失为:35.23858
当前是第37轮,训练集损失为:23.8545, 测试集损失为:45.60548
当前是第38轮,训练集损失为:23.91668, 测试集损失为:34.84441
当前是第39轮,训练集损失为:23.40606, 测试集损失为:44.46604
当前是第40轮,训练集损失为:22.6011, 测试集损失为:36.04847
当前是第41轮,训练集损失为:22.31131, 测试集损失为:34.43374
当前是第42轮,训练集损失为:22.0708, 测试集损失为:33.82917
当前是第43轮,训练集损失为:22.30289, 测试集损失为:37.85688
当前是第44轮,训练集损失为:21.53935, 测试集损失为:38.87277
当前是第45轮,训练集损失为:21.3713, 测试集损失为:33.417
当前是第46轮,训练集损失为:21.23279, 测试集损失为:31.88459
当前是第47轮,训练集损失为:21.06997, 测试集损失为:40.63353
当前是第48轮,训练集损失为:21.41602, 测试集损失为:36.13148
当前是第49轮,训练集损失为:21.15649, 测试集损失为:36.81873
当前是第50轮,训练集损失为:20.78297, 测试集损失为:70.94823
当前是第51轮,训练集损失为:20.58092, 测试集损失为:33.10058
当前是第52轮,训练集损失为:20.60467, 测试集损失为:35.11913
当前是第53轮,训练集损失为:20.43625, 测试集损失为:33.78005
当前是第54轮,训练集损失为:20.52897, 测试集损失为:34.07798
当前是第55轮,训练集损失为:20.64655, 测试集损失为:39.28524
当前是第56轮,训练集损失为:20.30059, 测试集损失为:33.22317
当前是第57轮,训练集损失为:20.25821, 测试集损失为:36.61137
当前是第58轮,训练集损失为:20.17982, 测试集损失为:31.30995
当前是第59轮,训练集损失为:20.7384, 测试集损失为:61.73834
当前是第60轮,训练集损失为:20.29678, 测试集损失为:31.74056
当前是第61轮,训练集损失为:20.14952, 测试集损失为:36.40789
当前是第62轮,训练集损失为:20.14775, 测试集损失为:34.92755
当前是第63轮,训练集损失为:20.2442, 测试集损失为:35.53998
当前是第64轮,训练集损失为:20.06632, 测试集损失为:64.03114
当前是第65轮,训练集损失为:19.99748, 测试集损失为:33.22721
当前是第66轮,训练集损失为:19.96938, 测试集损失为:30.25136
当前是第67轮,训练集损失为:19.99487, 测试集损失为:31.36242
当前是第68轮,训练集损失为:20.17933, 测试集损失为:58.25826
当前是第69轮,训练集损失为:19.93474, 测试集损失为:38.55068
当前是第70轮,训练集损失为:20.28924, 测试集损失为:40.849
当前是第71轮,训练集损失为:20.0135, 测试集损失为:31.5855
当前是第72轮,训练集损失为:19.83351, 测试集损失为:34.03661
当前是第73轮,训练集损失为:20.40153, 测试集损失为:30.72532
当前是第74轮,训练集损失为:19.93389, 测试集损失为:29.66065
当前是第75轮,训练集损失为:19.84209, 测试集损失为:31.01681
当前是第76轮,训练集损失为:19.76584, 测试集损失为:29.77414
当前是第77轮,训练集损失为:19.99292, 测试集损失为:35.58202
当前是第78轮,训练集损失为:20.03342, 测试集损失为:29.54016
当前是第79轮,训练集损失为:19.84374, 测试集损失为:34.61122
当前是第80轮,训练集损失为:19.78551, 测试集损失为:57.45225
当前是第81轮,训练集损失为:19.99286, 测试集损失为:38.98204
当前是第82轮,训练集损失为:20.83931, 测试集损失为:37.50468
当前是第83轮,训练集损失为:19.8902, 测试集损失为:32.13173
当前是第84轮,训练集损失为:20.81494, 测试集损失为:36.72431
当前是第85轮,训练集损失为:19.76138, 测试集损失为:32.56446
当前是第86轮,训练集损失为:19.93493, 测试集损失为:32.25109
当前是第87轮,训练集损失为:19.87319, 测试集损失为:29.45971
当前是第88轮,训练集损失为:19.76319, 测试集损失为:30.47269
当前是第89轮,训练集损失为:19.66747, 测试集损失为:31.15023
当前是第90轮,训练集损失为:19.99098, 测试集损失为:58.56397
当前是第91轮,训练集损失为:19.69602, 测试集损失为:28.64936
当前是第92轮,训练集损失为:19.76346, 测试集损失为:29.46989
当前是第93轮,训练集损失为:19.72865, 测试集损失为:39.08675
当前是第94轮,训练集损失为:19.64981, 测试集损失为:30.54216
当前是第95轮,训练集损失为:19.74504, 测试集损失为:29.54564
当前是第96轮,训练集损失为:19.93373, 测试集损失为:29.28439
当前是第97轮,训练集损失为:19.62625, 测试集损失为:43.54383
当前是第98轮,训练集损失为:19.64032, 测试集损失为:40.3629
当前是第99轮,训练集损失为:19.62572, 测试集损失为:32.7787
当前是第100轮,训练集损失为:19.59034, 测试集损失为:34.74736

3.5 图形化监控数据

  • 为了方便查看训练过程变化情况,可以使用matplotlib绘制损失函数的变化曲线。
from matplotlib import pyplot as pltplt.plot(train_losses, c="blue", label="train_loss")
plt.plot(test_losses, c="red", label="test_loss")
plt.title("The Losses")
plt.xlabel(xlabel="epoches")
plt.ylabel(ylabel="loss")
plt.legend()

在这里插入图片描述

  • 由上图可以看到:在一开始的训练中,损失值快速下降;当训练次数到40次左右后,损失值已经下降不明显。
  • 我们可以通过加入激活函数,引入非线性因素来优化模型。

3.6 激活函数

  • 定义:
    • 激活函数是神经网络中的一种非线性函数,通常应用在神经元的输出上,将输入信号转换为输出信号。激活函数引入了非线性因素,使神经网络可以学习和表达复杂的非线性关系。
  • 举个例子:
    • 想象一下,神经网络就像是一个复杂的拼图游戏,每个神经元就像是拼图中的一个小块。当我们只使用线性函数(比如直线)作为激活函数时,就好比每个小块都是直线,无法拼出复杂的图案,只能表达简单的线性关系。
      但是,当我们引入非线性的激活函数时,就好比在每个小块上加入了各种形状和曲线,使得每个小块可以表达更加复杂的形状和关系。这样,当我们把许多这样的小块(神经元)组合在一起时,就可以拼出更加复杂和多样的图案(非线性关系),从而让神经网络能够学习和表达更加复杂的模式和特征。
      因此,激活函数的作用就是为神经网络引入了这种非线性因素,使得神经网络可以更好地学习和表达复杂的非线性关系,就像在拼图游戏中加入了各种形状和曲线,让我们能够拼出更加丰富多彩的图案一样。
  • 常见激活函数有:Sigmoid函数、Tanh函数、ReLU函数、Softmax函数,相关内容在补充知识段落展开。
  • 使用方法:
class Model(nn.Module):"""自定义一个类- 必须继承 nn.Module"""def __init__(self, n_features=13):"""接收超参定义处理的层"""# 先初始化父类super(Model, self).__init__()# 定义一个线性层(做一次矩阵变换)self.linear = nn.Linear(in_features=n_features, out_features=1)def forward(self, x):"""模型前向传播逻辑"""x = self.linear(x)x = nn.ReLU()(x)  # 添加ReLU激活函数return x

当前是第495轮,训练集损失为:19.04356, 测试集损失为:38.45236
当前是第496轮,训练集损失为:19.29613, 测试集损失为:31.20161
当前是第497轮,训练集损失为:19.03669, 测试集损失为:30.85609
当前是第498轮,训练集损失为:19.01585, 测试集损失为:29.17376
当前是第499轮,训练集损失为:19.03183, 测试集损失为:28.62275
当前是第500轮,训练集损失为:19.10681, 测试集损失为:32.04256

在这里插入图片描述

3.7 多层感知机

  • 由于无法模拟诸如异或以及其他复杂函数的功能,使得单层感知机的应用较为单一。一个简单的想法是,如果能在感知机模型中增加若干隐藏层,增强神经网络的非线性表达能力,就会让神经网络具有更强拟合能力。
    请添加图片描述

  • 大脑是一个多层感知机,每一层都在学习不同级别的特征。

    • 输入层:输入层就像你的眼睛,它接收到动物的各种特征信息,比如颜色、大小等。
    • 隐藏层:隐藏层就像你的大脑皮层,它处理输入的特征信息,并尝试从中提取出更加抽象和复杂的特征,比如动物的轮廓、纹理等。
    • 输出层:输出层就像你的嘴巴,它根据隐藏层提取的特征信息做出判断,比如判断输入的动物是狗还是猫。
    • 通过多次学习和训练,你的大脑(多层感知机)会逐渐调整隐藏层中的神经元(神经元就像大脑中的神经元)的连接权重,从而更好地识别不同类型的动物。
  • 实现方法:修改自定义模型的初始化方法,加入一个新的线性层

class Model(nn.Module):"""自定义一个类- 必须继承 nn.Module"""def __init__(self, n_features=13):"""接收超参定义处理的层"""# 先初始化父类super(Model, self).__init__()# 定义两个线性层     self.linear1 = nn.Linear(in_features=n_features, out_features=8)self.linear2 = nn.Linear(in_features=8, out_features=1)def forward(self, x):"""模型前向传播逻辑"""x = self.linear1(x)x = torch.relu(x)  # 添加ReLU激活函数x = self.linear2(x)return x

当前是第95轮,训练集损失为:7.32678, 测试集损失为:18.07006
当前是第96轮,训练集损失为:7.16269, 测试集损失为:33.28857
当前是第97轮,训练集损失为:7.33148, 测试集损失为:23.29867
当前是第98轮,训练集损失为:7.24137, 测试集损失为:17.90972
当前是第99轮,训练集损失为:7.30563, 测试集损失为:17.59436
当前是第100轮,训练集损失为:7.21022, 测试集损失为:18.19897

在这里插入图片描述

  • 由上图可以看到,多层感知机+引入激活函数,损失值已经降到8左右;对比之前未优化的模型,模型的损失值变小,预测准确性得到提升。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/bicheng/49641.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

数据库之PHP联动

目录 一、软件安装 二、软件讲解 三、搭配环境 四、编辑软件配置 五、成果展示 如果有人问:为什么非要用xampp、VS code编辑软件?不用phpstudy等其他工具。 那么我只想说:因为xampp、VS code编辑软件免费(ಡωಡ)hiahiahia 一、软件安装 下载连…

Java语言程序设计基础篇_编程练习题**15.19 (游戏:手眼协调)

**15.19 (游戏:手眼协调) 请编写一个程序,显示一个半径为10像素的实心圆,该圆放置在面板上的随机位置,并填充随机的顔色,如图15-29b所示。单击这个圆时,它会消失,然后在另一个随机的位置显示新的随机颜色的…

Python task

任务1 实现wordcount: 代码如下: import re def wordcount(text):#全部小写text text.lower()text re.sub(r[^\w\s], , text)#切分words text.split()#计算频率word_count {}for word in words:if word in word_count:word_count[word] 1else:wo…

MPI框架以及PIPE数据流向细节

一、海思MPP内部处理流程图 各模块功能介绍: (1)VI:捕获视频图像,可对其做剪切、缩放、镜像等处理,并输出多路不同分辨率的图像数据. (2)AI:捕获⾳频数据,然后AENC 模块⽀持按多种⾳…

华盈生物-小分子靶点筛选服务:助力药物发现的利器

在药物发现的过程中,确定小分子化合物的靶点是至关重要的一步。华盈生物为科学家们提供了两种高效的小分子靶点筛选方案,助力研究人员精准锁定靶点,加速新药研发进程。 方案一:荧光标记与HuProt人类蛋白质组芯片结合 华盈生物的H…

lua 游戏架构 之 游戏 AI (三)ai_attack

这段Lua脚本定义了一个名为 ai_attack 的类,继承自 ai_base 类。 lua 游戏架构 之 游戏 AI (一)ai_base-CSDN博客文章浏览阅读119次。定义了一套接口和属性,可以基于这个基础类派生出具有特定行为的AI组件。例如,可以…

MongoDB教程(十六):MongoDB高级索引

💝💝💝首先,欢迎各位来到我的博客,很高兴能够在这里和您见面!希望您在这里不仅可以有所收获,同时也能感受到一份轻松欢乐的氛围,祝你生活愉快! 文章目录 引言一、全文索…

开源软件项目:趋势、参与经验与收获

在当今这个全球经济与科技日新月异的时代,开源软件项目(Open Source Software, OSS)正以前所未有的速度蓬勃发展,成为推动技术创新、促进产业合作、加速知识共享的重要力量。随着云计算、大数据、人工智能等技术的兴起&#xff0c…

matlab 绘制参数方程

matlab 绘制参数方程 绘制参数方程绘制结果 绘制参数方程 clc; clear; close all;axis_length 100;% 定义参数t的范围 t 0:0.01:100;% 计算x和y的值 x t.^2 1; y 4*t - t.^2;% 绘制函数图像 plot(x, y); xlabel(x); ylabel(y); title(Plot of the curve xt^21, y4t-t^2…

机器学习之主成分分析案例-红酒主成分分析

🍷 机器学习实战:使用PCA与sklearn红酒数据集进行特征降维与模型预测对比 在机器学习中,主成分分析(PCA)是一种有效的降维技术,它通过寻找数据中的主成分来减少特征数量,同时尽量保留数据的结构…

人工智能全景图2.0 | 一文了解人工智能学科

大家好,这是一节人工智能的科普视频,试图用40多分钟的时间,带你宏观了解人工智能学科,对人工智能有个初步的、全景式的把握,这对你学习具体人工智能细节大有裨益,也是我珍贵的总结。 视频链接(建…

灰色关联分析【系统分析+综合评价】

系统分析: 判断哪个因素影响最大 基本思想:根据序列曲线几何形状的相似程度来判断其练习是否紧密 绘制统计图并进行分析 确定子序列和母序列 对变量进行预处理(去量纲、缩小变量范围) 熟练使用excel与其公式和固定&#xff08…

一套成熟的实验室信息管理系统源码,.Net 检验系统LIS源码,实现从采集、检测、报告、归档的全程跟踪管理

一套成熟的实验室信息管理系统源码。在长期的医疗信息化实践中,我们分析总结了大量客户实例,建立了以病人为中心、以业务处理为基础、以提高检验科室管理水平和工作效率为目标的产品开发思路,将医学检验、科室管理和财务统计等检验科室/实验室…

电脑基础知识 | 电脑的基本组成

电脑作为我们日常工作和娱乐的重要工具,扮演着举足轻重的角色。当我们谈论电脑的基本组成时,其实是在探讨电脑硬件和软件两个核心部分。硬件是电脑看得见、摸得着的物理设备,而软件则是运行在这些硬件之上的程序和指令。两者相辅相成&#xf…

【GoLang】Golang 快速入门(第一篇)

目录 1.简介: 2.设计初衷: 3.Go语言的 特点 4.应用领域: 5.用go语言的公司: 6. 开发工具介绍以及环境搭建 1.工具介绍: 2.VSCode的安装: 3.安装过程: 4.Windows下搭建Go开发环境--安装和配置SDK 1.搭建Go开发环境 - 安装…

如何优化 PostgreSQL 中的连接查询性能?

🍅关注博主🎗️ 带你畅游技术世界,不错过每一次成长机会!📚领书:PostgreSQL 入门到精通.pdf 文章目录 如何优化 PostgreSQL 中的连接查询性能?一、理解连接查询的基本原理二、优化连接查询的关键…

Pyqt5新手教程

PyQt界面开发的两种方式:可视化UI 编程式UI (1)可视化UI:基于Qt Designer可视化编辑工具进行组件拖放、属性设置、布局管理等操作创建界面。 一是将其保存为.ui文件,然后在PyQt应用程序中加载和使用.ui文件。 二是使用…

企业级数据分析平台合集介绍

企业发展离不开数据分析,数据分析推动着企业运营、决策和战略规划。它正逐步深入到各行各业的核心业务流程中,从传统的金融、零售、制造业扩展到医疗健康、教育、能源等更多领域。企业正通过数据分析平台实现数据资源的最大化利用,推动业务与…

音频剪辑里的几种基础操作

音频对于视频的重要性,怎么强调都不为过,它在视频里扮演着举足轻重的角色,对观众有着极为深远的影响。下面为您阐述音频在视频中的关键意义: ① 情感传递:音频有强大的情感传达能力,借助声音的起伏变化、音…

项目标红,识别不了maven项目,解决办法

首先,检查 preferences 其次,检查IDEA 的 jdk。File-》Project Structure 最后: 1. 2. mvn clean install -Dmaven.test.skiptrue 跳过单元测试 maven跳过单元测试-maven.test.skip和skipTests的区别-CSDN博客