3000个样本的时候，训练得到的结果：
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
import os
import gc
# ----------------------------
# 1. 参数配置
# ----------------------------
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {DEVICE}")
INPUT_LENGTH = 3000 # 每个样本长度
NUM_SAMPLES = 3000 # 总样本数
BATCH_SIZE = 16 # 减小批处理大小
GRAD_ACCUM_STEPS = 2 # 梯度累积步数
EPOCHS = 50 # 训练次数
LEARNING_RATE = 1e-3
# ----------------------------
# 2. 读取 Excel 数据
# ----------------------------
print("Loading data from Excel...")
train_df = pd.read_excel('train_data.xlsx', header=None) # (3000, 3000)
label_df = pd.read_excel('label_data.xlsx', header=None) # (3000, 2)
# 转为 numpy
X = train_df.values.astype(np.float32) # shape: (3000, 3000)
y = label_df.values.astype(np.float32) # shape: (3000, 2)
assert X.shape == (NUM_SAMPLES, INPUT_LENGTH), f"Expected ({NUM_SAMPLES}, {INPUT_LENGTH}), got {X.shape}"
assert y.shape[1] == 2, "Label should have 2 columns: [slice_width, sampling_interval]"
# ----------------------------
# 3. 划分训练/验证集 (80% / 20%)
# ----------------------------
X_train, X_val, y_train, y_val = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 转为 PyTorch 张量
X_train = torch.from_numpy(X_train)
y_train = torch.from_numpy(y_train)
X_val = torch.from_numpy(X_val)
y_val = torch.from_numpy(y_val)
# 创建 Dataset 和 DataLoader
train_dataset = TensorDataset(X_train, y_train)
val_dataset = TensorDataset(X_val, y_val)
train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)
# ----------------------------
# 4. 定义改进的参数回归网络
# ----------------------------
class ParamRegressionModule(nn.Module):
def __init__(self, input_length=3000):
super().__init__()
# 第一层卷积：1 → 64通道
self.conv1 = nn.Conv1d(1, 64, kernel_size=16, padding=8) # padding='same'
self.bn1 = nn.BatchNorm1d(64)
# 第二层卷积：64 → 128通道
self.conv2 = nn.Conv1d(64, 128, kernel_size=16, padding=8)
self.bn2 = nn.BatchNorm1d(128)
# 第三层卷积：128 → 64通道
self.conv3 = nn.Conv1d(128, 64, kernel_size=16, padding=8)
self.bn3 = nn.BatchNorm1d(64)
# 池化层
self.pool1 = nn.MaxPool1d(2)
self.pool2 = nn.MaxPool1d(2)
self.pool3 = nn.MaxPool1d(2)
# 全局池化
self.global_pool = nn.AdaptiveAvgPool1d(50) # 将长度池化到固定值50
# Dropout
self.dropout = nn.Dropout(0.3)
# 计算全连接层输入维度
self.fc_input_dim = 64 * 50 # 64通道 * 50长度
# 全连接层
self.fc = nn.Sequential(
nn.Linear(self.fc_input_dim, 128),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(128, 64),
nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(64, 2)
)
# 初始化权重
self._initialize_weights()
def _initialize_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv1d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm1d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.constant_(m.bias, 0)
def forward(self, x):
# 输入形状: (batch_size, input_length)
x = x.unsqueeze(1) # (B, 1, L)
# 第一层
x = F.relu(self.bn1(self.conv1(x)))
x = self.pool1(x)
x = self.dropout(x) # (B, 64, L/2)
# 第二层
x = F.relu(self.bn2(self.conv2(x)))
x = self.pool2(x)
x = self.dropout(x) # (B, 128, L/4)
# 第三层
x = F.relu(self.bn3(self.conv3(x)))
x = self.pool3(x) # (B, 64, L/8)
# 全局池化到固定长度
x = self.global_pool(x) # (B, 64, 50)
# 展平
x = x.view(x.size(0), -1) # (B, 64*50)
# 全连接层
x = self.fc(x)
return x
# ----------------------------
# 5. 初始化模型、损失函数、优化器
# ----------------------------
model = ParamRegressionModule(input_length=INPUT_LENGTH).to(DEVICE)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
# 学习率调度器（移除了verbose参数）
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer, mode='min', factor=0.5, patience=5
)
# 打印模型信息
print("Model architecture:")
print(model)
print(f"Total parameters: {sum(p.numel() for p in model.parameters())}")
print(f"Trainable parameters: {sum(p.numel() for p in model.parameters() if p.requires_grad)}")
# ----------------------------
# 6. 训练循环（使用梯度累积）
# ----------------------------
print(f"\nStart training with batch size {BATCH_SIZE} and grad accumulation {GRAD_ACCUM_STEPS}...")
print(f"Effective batch size: {BATCH_SIZE * GRAD_ACCUM_STEPS}")
# 用于记录训练历史
train_history = []
val_history = []
best_val_loss = float('inf')
best_epoch = 0
for epoch in range(EPOCHS):
# 训练阶段
model.train()
train_loss = 0.0
optimizer.zero_grad() # 在epoch开始时清零梯度
for batch_idx, (batch_x, batch_y) in enumerate(train_loader):
batch_x = batch_x.to(DEVICE)
batch_y = batch_y.to(DEVICE)
# 前向传播
outputs = model(batch_x)
loss = criterion(outputs, batch_y)
# 梯度累积：标准化损失
loss = loss / GRAD_ACCUM_STEPS
loss.backward()
train_loss += loss.item() * batch_x.size(0) * GRAD_ACCUM_STEPS
# 每 GRAD_ACCUM_STEPS 步更新一次参数
if (batch_idx + 1) % GRAD_ACCUM_STEPS == 0:
optimizer.step()
optimizer.zero_grad()
# 清理GPU缓存
if torch.cuda.is_available():
torch.cuda.empty_cache()
# 如果还有未更新的梯度，再更新一次
if len(train_loader) % GRAD_ACCUM_STEPS != 0:
optimizer.step()
optimizer.zero_grad()
# 计算平均训练损失
train_loss /= len(train_loader.dataset)
train_history.append(train_loss)
# 验证阶段
model.eval()
val_loss = 0.0
with torch.no_grad():
for batch_x, batch_y in val_loader:
batch_x = batch_x.to(DEVICE)
batch_y = batch_y.to(DEVICE)
outputs = model(batch_x)
loss = criterion(outputs, batch_y)
val_loss += loss.item() * batch_x.size(0)
# 清理GPU缓存
if torch.cuda.is_available():
torch.cuda.empty_cache()
# 计算平均验证损失
val_loss /= len(val_loader.dataset)
val_history.append(val_loss)
# 更新学习率
scheduler.step(val_loss)
# 打印进度
current_lr = optimizer.param_groups[0]['lr']
print(f"Epoch [{epoch + 1:03d}/{EPOCHS}] | "
f"Train Loss: {train_loss:.6f} | "
f"Val Loss: {val_loss:.6f} | "
f"LR: {current_lr:.2e}")
# 保存最佳模型
if val_loss < best_val_loss:
best_val_loss = val_loss
best_epoch = epoch + 1
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'train_loss': train_loss,
'val_loss': val_loss,
'train_history': train_history,
'val_history': val_history
}, 'best_model.pth')
print(f" -> New best model saved at epoch {best_epoch} with val loss: {val_loss:.6f}")
# 强制垃圾回收
gc.collect()
if torch.cuda.is_available():
torch.cuda.empty_cache()
# ----------------------------
# 7. 保存最终模型
# ----------------------------
torch.save({
'epoch': EPOCHS,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'train_history': train_history,
'val_history': val_history
}, 'final_model.pth')
print(f"\nFinal model saved as 'final_model.pth'")
print(f"Best model at epoch {best_epoch} with val loss: {best_val_loss:.6f}")
# 绘制训练曲线（可选）
try:
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 8))
# 绘制损失曲线
plt.subplot(2, 1, 1)
plt.plot(train_history, label='Train Loss', linewidth=2)
plt.plot(val_history, label='Val Loss', linewidth=2)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training History')
plt.legend()
plt.grid(True)
# 标记最佳epoch
plt.axvline(x=best_epoch - 1, color='r', linestyle='--', alpha=0.5, label=f'Best Epoch: {best_epoch}')
plt.legend()
# 绘制损失对数值
plt.subplot(2, 1, 2)
plt.semilogy(train_history, label='Train Loss', linewidth=2)
plt.semilogy(val_history, label='Val Loss', linewidth=2)
plt.xlabel('Epoch')
plt.ylabel('Loss (log scale)')
plt.title('Training History (Log Scale)')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.savefig('training_history.png', dpi=300, bbox_inches='tight')
plt.show()
print("Training history plot saved as 'training_history.png'")
except ImportError:
print("Matplotlib not installed. Skipping plot.")
print("\nTraining completed!")
每种JSR有100个样本进行预测，得到的结果：
将样本增加至5500，得到的训练过程的曲线如下所示：
最终的结果：
