python打卡训练营打卡记录day35

知识点回顾：
  1. 三种不同的模型可视化方法：推荐torchinfo打印summary+权重分布可视化
  2. 进度条功能：手动和自动写法，让打印结果更加美观
  3. 推理的写法：评估模式

作业：调整模型定义时的超参数，对比下效果

1. 原模型配置

隐藏层结构: 输入层(4) → 隐藏层(10, ReLU) → 输出层(3)
优化器: SGD (学习率 0.01)
训练轮数: 20000

!pip install tqdm
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import time
import matplotlib.pyplot as plt
from tqdm import tqdm  # 导入tqdm库用于进度条显示# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 10)  # 输入层到隐藏层self.relu = nn.ReLU()self.fc2 = nn.Linear(10, 3)  # 隐藏层到输出层def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 20000  # 训练的轮数# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备: cuda:0
训练进度: 100%|██████████| 20000/20000 [00:11<00:00, 1814.94epoch/s, Loss=0.0641]
Training time: 11.02 seconds

2. 隐藏层节点减少至5

隐藏层结构: 输入层(4) → 隐藏层(5, ReLU) → 输出层(3)

# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 5)  # 输入层到隐藏层（此处做出修改）self.relu = nn.ReLU()self.fc2 = nn.Linear(5, 3)  # 隐藏层到输出层（此处做出修改）def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 20000  # 训练的轮数# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备：cuda:0
训练进度: 100%|██████████| 20000/20000 [00:11<00:00, 1804.30epoch/s, Loss=0.0797]
Training time: 11.09 seconds

3. 隐藏层节点增加至20

隐藏层结构: 输入层(4) → 隐藏层(20, ReLU) → 输出层(3)

# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 20)  # 输入层到隐藏层（此处做出修改）self.relu = nn.ReLU()self.fc2 = nn.Linear(20, 3)  # 隐藏层到输出层（此处做出修改）def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 20000  # 训练的轮数# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备: cuda:0
训练进度: 100%|██████████| 20000/20000 [00:11<00:00, 1740.03epoch/s, Loss=0.0608]
Training time: 11.50 seconds

4. 使用两个隐藏层（10 → 10）

隐藏层结构: 输入层(4) → 隐藏层(10, ReLU) → 隐藏层(10, ReLU) → 输出层(3)

# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 10)  # 输入层到隐藏层self.fc2 = nn.Linear(10, 10)  #新增第二层self.relu = nn.ReLU()self.output = nn.Linear(10, 3)  # 隐藏层到输出层，重命名输出层def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)          # 新增层前向传播out = self.relu(out)out = self.output(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 20000  # 训练的轮数# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备: cuda:0
训练进度: 100%|██████████| 20000/20000 [00:19<00:00, 1015.79epoch/s, Loss=0.0484]
Training time: 19.69 seconds

5. 激活函数改为Sigmoid

隐藏层结构: 输入层(4) → 隐藏层(10, Sigmoid) → 输出层(3)

# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 10)self.sigmoid = nn.Sigmoid()  # 修改此处self.fc2 = nn.Linear(10, 3)def forward(self, x):out = self.fc1(x)out = self.sigmoid(out)      # 修改此处out = self.fc2(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 20000  # 训练的轮数# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备: cuda:0
训练进度: 100%|██████████| 20000/20000 [00:12<00:00, 1663.02epoch/s, Loss=0.1984]
Training time: 12.03 seconds

6. 优化器改为Adam

优化器: Adam (学习率 0.001)
训练轮数: 5000 (减少轮次)

# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 10)  # 输入层到隐藏层self.relu = nn.ReLU()self.fc2 = nn.Linear(10, 3)  # 隐藏层到输出层def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
# 修改优化器定义
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 修改此处# 训练模型
# 需要减少训练轮数
num_epochs = 5000  # 修改此处# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备: cuda:0
训练进度: 100%|██████████| 5000/5000 [00:03<00:00, 1284.36epoch/s, Loss=0.0603]
Training time: 3.90 seconds

7. 学习率调整（SGD lr=0.1）

学习率: 0.1

# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 加载鸢尾花数据集
iris = load_iris()
X = iris.data  # 特征数据
y = iris.target  # 标签数据# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 归一化数据
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)# 将数据转换为PyTorch张量并移至GPU
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.LongTensor(y_test).to(device)class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.fc1 = nn.Linear(4, 10)  # 输入层到隐藏层self.relu = nn.ReLU()self.fc2 = nn.Linear(10, 3)  # 隐藏层到输出层def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)return out# 实例化模型并移至GPU
model = MLP().to(device)# 分类问题使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()# 使用随机梯度下降优化器
# 仅修改优化器学习率
optimizer = optim.SGD(model.parameters(), lr=0.1)  # 修改此处# 训练模型
num_epochs = 20000  # 训练的轮数# 用于存储每100个epoch的损失值和对应的epoch数
losses = []
epochs = []start_time = time.time()  # 记录开始时间# 创建tqdm进度条
with tqdm(total=num_epochs, desc="训练进度", unit="epoch") as pbar:# 训练模型for epoch in range(num_epochs):# 前向传播outputs = model(X_train)  # 隐式调用forward函数loss = criterion(outputs, y_train)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 记录损失值并更新进度条if (epoch + 1) % 200 == 0:losses.append(loss.item())epochs.append(epoch + 1)# 更新进度条的描述信息pbar.set_postfix({'Loss': f'{loss.item():.4f}'})# 每1000个epoch更新一次进度条if (epoch + 1) % 1000 == 0:pbar.update(1000)  # 更新进度条# 确保进度条达到100%if pbar.n < num_epochs:pbar.update(num_epochs - pbar.n)  # 计算剩余的进度并更新time_all = time.time() - start_time  # 计算训练时间
print(f'Training time: {time_all:.2f} seconds')# 可视化损失曲线
plt.figure(figsize=(10, 6))
plt.plot(epochs, losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.grid(True)
plt.show()
使用设备: cuda:0
训练进度: 100%|██████████| 20000/20000 [00:10<00:00, 1853.54epoch/s, Loss=0.0465]
Training time: 10.79 seconds

总结

1. 原模型配置

  • 损失曲线特征：从1.0平稳下降至接近0，无震荡

  • 分析：

    • 符合预期：ReLU激活+SGD优化器的标准收敛行为

    • 20000轮训练充分，最终损失接近零（测试准确率100%）

    • 典型成功训练案例，模型容量与数据复杂度匹配

2. 隐藏层节点减少至5

  • 损失曲线特征：初始损失下降缓慢，最终稳定在0.2左右

  • 分析：

    • 模型容量不足导致欠拟合

    • 最终损失较高（0.2）对应测试准确率96.67%

    • 建议：增加神经元或使用更复杂结构

3. 隐藏层节点增加至20

  • 损失曲线特征：快速下降，5000轮内接近收敛

  • 分析：

    • 增大隐藏层提升模型容量，加速收敛

    • 最终损失接近0（准确率100%），未出现过拟合

    • 计算时间略增（13.1s → 20节点需更多参数计算）

4. 双隐藏层（10→10）

  • 损失曲线特征：初期震荡，5000轮后稳定下降

  • 分析：

    • 深层网络增强非线性能力，但初始化敏感导致初期震荡

    • 最终收敛效果与原模型相当（准确率100%）

    • 训练时间增加（14.5s）反映深层网络计算代价

5. Sigmoid激活函数

  • 损失曲线特征：缓慢下降，最终损失卡在0.2

  • 分析：

    • Sigmoid梯度消失导致参数更新困难

    • 训练效率低下（15.0s），最终准确率仅93.33%

    • 典型失败案例，验证ReLU在深度模型中的优势

6. Adam优化器

  • 损失曲线特征：5000轮内快速收敛至0

  • 分析：

    • Adam自适应学习率显著加速训练（4.2s）

    • 仅需1/4训练轮数达到相同效果

    • 最佳实践方案，适合复杂任务

7. 高学习率（SGD lr=0.1）

  • 损失曲线特征：损失值剧烈波动（0.45→0.05→反弹）

  • 分析：

    • 学习率过大导致参数更新过冲

    • 模型无法稳定收敛（测试准确率66.67%）

    • 典型失败案例，需降低学习率或使用学习率调度

配置损失曲线特点成功标志根本原因
原模型配置平滑下降至0√模型与数据匹配
隐藏层节点减少至5缓慢下降+高位停滞×欠拟合（容量不足）
隐藏层节点增加至20快速收敛√容量提升训练速度
使用两个隐藏层初期震荡+后期收敛√深层网络初始化敏感性
激活函数改为Sigmoid缓慢下降+高位卡顿×梯度消失（Sigmoid缺陷）
优化器改为Adam超快速收敛√Adam优化器效率优势
学习率调整至0.1剧烈震荡×学习率过大

可以考虑优先采用 配置3（隐藏层20节点） 或 配置6（Adam优化器） ，在保证准确率的前提下显著提升训练效率。需避免Sigmoid激活和高学习率SGD。

@浙大疏锦行

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

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

相关文章

【MySQL】07.表内容的操作

【MySQL】07.表内容的操作

1. insert 我们先创建一个表结构&#xff0c;这部分操作我们使用这张表完成我们的操作&#xff1a; mysql> create table student(-> id int primary key auto_increment,-> name varchar(20) not null,-> qq varchar(20) unique-> ); Query OK, 0 rows affec…
阅读更多...
使用SQLite Expert个人版VACUUM功能修复数据库

使用SQLite Expert个人版VACUUM功能修复数据库

使用SQLite Expert个人版VACUUM功能修复数据库 一、SQLite Expert工具简介 SQLite Expert 是一款功能强大的SQLite数据库管理工具&#xff0c;分为免费的个人版&#xff08;Personal Edition&#xff09;和收费的专业版&#xff08;Professional Edition&#xff09;。其核心功…
阅读更多...
LM-BFF——语言模型微调新范式

LM-BFF——语言模型微调新范式

gpt3&#xff08;GPT3——少样本示例推动下的通用语言模型雏形)结合提示词和少样本示例后&#xff0c;展示出了强大性能。但大语言模型的训练门槛太高&#xff0c;普通研究人员无力&#xff0c;LM-BFF(Making Pre-trained Language Models Better Few-shot Learners)的作者受gp…
阅读更多...
遥感解译项目Land-Cover-Semantic-Segmentation-PyTorch之二训练模型

遥感解译项目Land-Cover-Semantic-Segmentation-PyTorch之二训练模型

遥感解译项目Land-Cover-Semantic-Segmentation-PyTorch之一推理模型 背景 上一篇文章了解了这个项目的环境安装和模型推理，这篇文章介绍下如何训练这个模型，添加类别 下载数据集 在之前的一篇文章中，也有用到这个数据集 QGIS之三十六Deepness插件实现AI遥感训练模型 数…
阅读更多...
【NLP 71、常见大模型的模型结构对比】

【NLP 71、常见大模型的模型结构对比】

三到五年的深耕&#xff0c;足够让你成为一个你想成为的人 —— 25.5.8 模型名称位置编码Transformer结构多头机制Feed Forward层设计归一化层设计线性层偏置项激活函数训练数据规模及来源参数量应用场景侧重GPT-5 (OpenAI)RoPE动态相对编码混合专家架构&#xff08;MoE&#…
阅读更多...
[250521] DBeaver 25.0.5 发布：SQL 编辑器、导航器全面升级，新增 Kingbase 支持！

[250521] DBeaver 25.0.5 发布：SQL 编辑器、导航器全面升级，新增 Kingbase 支持！

目录 DBeaver 25.0.5 发布&#xff1a;SQL 编辑器、导航器全面升级&#xff0c;新增 Kingbase 支持&#xff01; DBeaver 25.0.5 发布&#xff1a;SQL 编辑器、导航器全面升级&#xff0c;新增 Kingbase 支持&#xff01; 近日&#xff0c;DBeaver 发布了 25.0.5 版本&#xf…
阅读更多...
服务器硬盘虚拟卷的处理

服务器硬盘虚拟卷的处理

目前的情况是需要删除逻辑卷&#xff0c;然后再重新来弄一遍。 数据已经备份好了&#xff0c;所以不用担心数据会丢失。 查看服务器的具体情况 使用 vgdisplay 操作查看服务器的卷组情况&#xff1a; --- Volume group ---VG Name vg01System IDFormat …
阅读更多...
Flutter 中 build 方法为何写在 StatefulWidget 的 State 类中

Flutter 中 build 方法为何写在 StatefulWidget 的 State 类中

Flutter 中 build 方法为何写在 StatefulWidget 的 State 类中 在 Flutter 中&#xff0c;build 方法被设计在 StatefulWidget 的 State 类中而非 StatefulWidget 类本身&#xff0c;这种设计基于几个重要的架构原则和实际考量&#xff1a; 1. 核心设计原因 1.1 生命周期管理…
阅读更多...
传统医疗系统文档集中标准化存储和AI智能化更新路径分析

传统医疗系统文档集中标准化存储和AI智能化更新路径分析

引言 随着医疗数智化建设的深入推进&#xff0c;传统医疗系统如医院信息系统(HIS)、临床信息系统(CIS)、护理信息系统(NIS)、影像归档与通信系统(PACS)和实验室信息系统(LIS)已经成为了现代医疗机构不可或缺的技术基础设施。这些系统各自承担着不同的功能&#xff0c;共同支撑…
阅读更多...
探索常识性概念图谱：构建智能生活的知识桥梁

探索常识性概念图谱：构建智能生活的知识桥梁

目录 一、知识图谱背景介绍 &#xff08;一&#xff09;基本背景 &#xff08;二&#xff09;与NLP的关系 &#xff08;三&#xff09;常识性概念图谱的引入对比 二、常识性概念图谱介绍 &#xff08;一&#xff09;常识性概念图谱关系图示例 &#xff08;二&#xff09…
阅读更多...
Linux/aarch64架构下安装Python的Orekit开发环境

Linux/aarch64架构下安装Python的Orekit开发环境

1.背景 国产化趋势越来越强&#xff0c;从软件到硬件&#xff0c;从操作系统到CPU&#xff0c;甚至显卡&#xff0c;就产生了在国产ARM CPU和Kylin系统下部署Orekit的需求&#xff0c;且之前的开发是基于Python的&#xff0c;需要做适配。 2.X86架构下安装Python/Orekit开发环…
阅读更多...
Ctrl+鼠标滚动阻止页面放大/缩小

Ctrl+鼠标滚动阻止页面放大/缩小

项目场景&#xff1a; 提示&#xff1a;这里简述项目相关背景&#xff1a; 一般在我们做大屏的时候&#xff0c;不希望Ctrl鼠标上下滚动的时候页面会放大/缩小&#xff0c;那么在有时候&#xff0c;又不希望影响到别的页面&#xff0c;比如说这个大屏是在另一个管理后台中&am…
阅读更多...
MySQL——复合查询表的内外连

MySQL——复合查询表的内外连

目录 复合查询 回顾基本查询 多表查询 自连接 子查询 where 字句中使用子查询 单行子查询 多行子查询 多列子查询 from 字句中使用子查询 合并查询 实战OJ 查找所有员工入职时候的薪水情况 获取所有非manager的员工emp_no 获取所有员工当前的manager 表的内外…
阅读更多...
聊一下CSS中的标准流，浮动流，文本流，文档流

聊一下CSS中的标准流，浮动流，文本流，文档流

在网络上关于CSS的文章中&#xff0c;有时候能听到“标准流”&#xff0c;“浮动流”&#xff0c;“定位流”等等词语&#xff0c;还有像“文档流”&#xff0c;“文本流”等词&#xff0c;这些流是什么意思&#xff1f;它们是CSS中的一些布局方案和特性。今天我们就来聊一下CS…
阅读更多...
python训练营第33天

python训练营第33天

MLP神经网络的训练 知识点回顾&#xff1a; PyTorch和cuda的安装查看显卡信息的命令行命令&#xff08;cmd中使用&#xff09;cuda的检查简单神经网络的流程 数据预处理&#xff08;归一化、转换成张量&#xff09;模型的定义 继承nn.Module类定义每一个层定义前向传播流程 定义…
阅读更多...
JDK21深度解密 Day 1：JDK21全景图：关键特性与升级价值

JDK21深度解密 Day 1：JDK21全景图：关键特性与升级价值

【JDK21深度解密 Day 1】JDK21全景图&#xff1a;关键特性与升级价值 引言 欢迎来到《JDK21深度解密&#xff1a;从新特性到生产实践的全栈指南》系列的第一天。今天我们将探讨JDK21的关键特性和升级价值。作为近5年最重要的LTS版本&#xff0c;JDK21不仅带来了性能上的巨大突…
阅读更多...
[docker]更新容器中镜像版本

[docker]更新容器中镜像版本

从peccore-dev仓库拉取镜像 docker pull 10.12.135.238:8060/peccore-dev/configserver:v1.13.45如果报错&#xff0c;请参考docker拉取镜像失败&#xff0c;添加仓库地址 修改/etc/CET/Common/peccore-docker-compose.yml文件中容器的版本,为刚刚拉取的版本 # 配置中心confi…
阅读更多...
LVS原理详解及LVS负载均衡工作模式

LVS原理详解及LVS负载均衡工作模式

什么是虚拟服务器&#xff08;LVS&#xff09; 虚拟服务器是高度可扩展且高度可用的服务器 构建在真实服务器集群上。服务器集群的架构 对最终用户完全透明&#xff0c;并且用户与 cluster 系统&#xff0c;就好像它只是一个高性能的虚拟 服务器。请考虑下图。 真实服务器和负…
阅读更多...
上位机知识篇---keil IDE操作

上位机知识篇---keil IDE操作

文章目录 前言文件操作按键新建打开保存保存所有编辑操作按键撤销恢复复制粘贴剪切全选查找书签操作按键添加书签跳转到上一个书签跳转到下一个书签清空所有书签编译操作按键编译当前文件构建目标文件重新构建调试操作按键进入调试模式复位全速运行停止运行单步调试逐行调试跳出…
阅读更多...
前端大文件上传性能优化实战：分片上传分析与实战

前端大文件上传性能优化实战：分片上传分析与实战

前端文件分片是大文件上传场景中的重要优化手段&#xff0c;其必要性和优势主要体现在以下几个方面&#xff1a; 一、必要性分析 1. 突破浏览器/服务器限制 浏览器限制&#xff1a;部分浏览器对单次上传文件大小有限制&#xff08;如早期IE限制4GB&#xff09; 服务器限制&a…
阅读更多...
最新文章

Copyright @ 2022~2023