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
繁體地址，請注明出處：http://hk.pswp.cn/news/906804.shtml
英文地址，請注明出處：http://en.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