Skip to content
Closed
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
299 changes: 184 additions & 115 deletions src/driverless_car_yb/main_speed.py

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

没有实质改进,没有有训练效果。

模块名driverless_car_yb不符合要求

Original file line number Diff line number Diff line change
@@ -1,161 +1,230 @@
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
# 导入必要的库
import torch # PyTorch核心库,用于构建和训练神经网络
import torch.nn as nn # PyTorch神经网络模块,包含层、损失函数等
import torch.optim as optim # PyTorch优化器模块
import numpy as np # 数值计算库,用于数据生成和处理
import pandas as pd # 数据处理库(本示例未直接使用,保留用于扩展真实数据读取)
from sklearn.model_selection import train_test_split # 划分训练集/测试集
from sklearn.preprocessing import StandardScaler # 数据标准化预处理
import matplotlib.pyplot as plt # 绘图库,用于结果可视化

# 设置随机种子,保证结果可复现
torch.manual_seed(42)
np.random.seed(42)
# 设置随机种子,保证实验结果可复现(固定随机数生成器的初始状态)
torch.manual_seed(42) # PyTorch随机种子
np.random.seed(42) # NumPy随机种子


class SpeedPredictor(nn.Module):
"""无人车速度预测模型:使用LSTM处理时序数据"""
"""
无人车速度预测模型:基于LSTM(长短期记忆网络)的时序预测模型
LSTM适合处理时序数据,能捕捉时间序列中的长期依赖关系,适合速度这类连续变化的时序预测任务
"""

def __init__(self, input_size, hidden_size, num_layers, output_size=1):
super(SpeedPredictor, self).__init__()
"""
初始化模型参数
Args:
input_size (int): 输入特征维度(每个时间步的特征数量,如速度、加速度等)
hidden_size (int): LSTM隐藏层神经元数量(控制模型容量)
num_layers (int): LSTM网络的层数(多层LSTM可捕捉更复杂的时序特征)
output_size (int): 输出维度(默认1,预测未来1个时间步的速度)
"""
super(SpeedPredictor, self).__init__() # 调用父类nn.Module的初始化方法

# 定义LSTM层
self.lstm = nn.LSTM(
input_size=input_size, # 输入特征数(如速度、加速度、方向盘角度等)
hidden_size=hidden_size, # LSTM隐藏层大小
num_layers=num_layers, # LSTM层数
batch_first=True # 输入格式为(batch, seq_len, input_size)
input_size=input_size, # 输入特征数
hidden_size=hidden_size, # 隐藏层神经元数
num_layers=num_layers, # LSTM层数
batch_first=True # 输入数据格式为(batch_size, seq_len, input_size),便于批量处理
)
self.fc = nn.Linear(hidden_size, output_size) # 输出层(预测未来速度)

# 定义全连接层:将LSTM的隐藏层输出映射到最终预测结果
self.fc = nn.Linear(hidden_size, output_size)

def forward(self, x):
# x shape: (batch_size, seq_len, input_size)
lstm_out, _ = self.lstm(x) # lstm_out shape: (batch_size, seq_len, hidden_size)
# 取最后一个时间步的输出用于预测
last_out = lstm_out[:, -1, :] # shape: (batch_size, hidden_size)
pred = self.fc(last_out) # shape: (batch_size, output_size)
"""
前向传播过程(模型的核心计算逻辑)
Args:
x (torch.Tensor): 输入数据,形状为(batch_size, seq_len, input_size)
batch_size: 批次大小(每次训练的样本数)
seq_len: 输入序列长度(用过去多少个时间步的数据进行预测)
input_size: 每个时间步的特征数
Returns:
torch.Tensor: 预测结果,形状为(batch_size, output_size)
"""
# LSTM层前向传播:输出包含所有时间步的隐藏状态,以及最后一个时间步的隐藏态和细胞态
# lstm_out形状:(batch_size, seq_len, hidden_size),_表示忽略的隐藏态和细胞态
lstm_out, _ = self.lstm(x)

# 取最后一个时间步的隐藏状态作为全连接层的输入(因为要预测下一个时间步的速度)
last_out = lstm_out[:, -1, :] # 切片操作,形状变为(batch_size, hidden_size)

# 全连接层映射:将隐藏层特征转换为最终预测值
pred = self.fc(last_out) # 输出形状:(batch_size, output_size)

return pred


def create_sequences(data, seq_len, pred_len=1):
"""
将时序数据转换为输入序列和标签
data: 原始数据(特征矩阵)
seq_len: 输入序列长度(用过去多少个时间步预测未来)
pred_len: 预测未来多少个时间步(这里简化为1)
将原始时序数据转换为LSTM模型所需的输入序列(X)和标签(y)
核心逻辑:用过去seq_len个时间步的特征数据,预测未来pred_len个时间步的速度
Args:
data (np.ndarray): 原始特征矩阵,形状为(total_samples, input_size)
total_samples: 总样本数(时间步数量)
input_size: 特征数
seq_len (int): 输入序列长度(过去多少个时间步)
pred_len (int): 预测长度(未来多少个时间步,默认1,即单步预测)
Returns:
tuple: (X, y),均为NumPy数组
X: 输入序列,形状为(num_sequences, seq_len, input_size)
y: 标签(待预测的速度),形状为(num_sequences, pred_len)
"""
xs, ys = [], []
xs, ys = [], [] # 存储输入序列和对应的标签

# 遍历原始数据,生成所有可能的序列(避免索引越界)
# 循环终止条件:i + seq_len + pred_len - 1 < len(data)
for i in range(len(data) - seq_len - pred_len + 1):
x = data[i:(i + seq_len)] # 输入序列(过去seq_len个时间步的特征)
y = data[i + seq_len:i + seq_len + pred_len, 0] # 标签(未来1个时间步的速度,假设第0列是速度)
# 输入序列:从i开始,取seq_len个连续时间步的特征数据
x = data[i:(i + seq_len)] # 形状:(seq_len, input_size)
# 标签:从i+seq_len开始,取pred_len个时间步的速度(假设第0列是速度特征)
y = data[i + seq_len:i + seq_len + pred_len, 0] # 形状:(pred_len,)

xs.append(x)
ys.append(y)

# 转换为NumPy数组返回(便于后续转换为PyTorch张量)
return np.array(xs), np.array(ys)


def main():
# 1. 数据准备(这里使用模拟数据,实际应用中替换为真实传感器数据)
# 模拟特征:[速度(m/s), 加速度(m/s²), 方向盘角度(°), 油门开度(%), 刹车压力(bar)]
num_samples = 10000
time = np.linspace(0, 100, num_samples)
speed = 10 + 5 * np.sin(time) + np.random.normal(0, 0.5, num_samples) # 带噪声的正弦曲线模拟速度
acceleration = np.gradient(speed, time) # 加速度(速度的导数)
steering = 10 * np.sin(time/2) + np.random.normal(0, 1, num_samples) # 方向盘角度
throttle = 30 + 10 * np.sin(time/3) + np.random.normal(0, 2, num_samples) # 油门开度
brake = np.where(speed < 8, 5 + np.random.normal(0, 1, num_samples), np.random.normal(0, 0.5, num_samples)) # 刹车压力

# 组合成特征矩阵
"""主函数:完整的模型训练和评估流程"""
# ===================== 1. 数据准备 =====================
# 说明:本示例使用模拟数据验证模型,实际应用中需替换为真实传感器数据(如CSV文件读取)
# 模拟的无人车特征包括:[速度(m/s), 加速度(m/s²), 方向盘角度(°), 油门开度(%), 刹车压力(bar)]
num_samples = 10000 # 总时间步数量(模拟10000个连续的传感器采样点)
time = np.linspace(0, 100, num_samples) # 时间轴(0到100秒,均匀分布10000个点)

# 模拟各特征数据(添加随机噪声模拟真实传感器误差)
speed = 10 + 5 * np.sin(time) + np.random.normal(0, 0.5, num_samples) # 基础速度10m/s,叠加正弦波动和噪声
acceleration = np.gradient(speed, time) # 加速度:速度对时间的导数
steering = 10 * np.sin(time / 2) + np.random.normal(0, 1, num_samples) # 方向盘角度:慢波动+噪声
throttle = 30 + 10 * np.sin(time / 3) + np.random.normal(0, 2, num_samples) # 油门开度:30%左右波动
brake = np.where(
speed < 8, # 当速度低于8m/s时,刹车压力增大
5 + np.random.normal(0, 1, num_samples), # 低速时刹车压力(5bar左右)
np.random.normal(0, 0.5, num_samples) # 高速时刹车压力(接近0)
)

# 组合所有特征为特征矩阵(形状:(num_samples, 5))
data = np.column_stack([speed, acceleration, steering, throttle, brake])

# 2. 数据预处理
scaler = StandardScaler() # 标准化(均值为0,方差为1)
data_scaled = scaler.fit_transform(data)

# 创建序列数据(用过去10个时间步预测未来1个时间步的速度)
seq_len = 10
X, y = create_sequences(data_scaled, seq_len)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False) # 时序数据不打乱顺序

# 转换为PyTorch张量
X_train = torch.FloatTensor(X_train)
y_train = torch.FloatTensor(y_train)
X_test = torch.FloatTensor(X_test)
y_test = torch.FloatTensor(y_test)

# 3. 模型初始化
input_size = X_train.shape[2] # 特征数(这里是5)
hidden_size = 64
num_layers = 2
model = SpeedPredictor(input_size, hidden_size, num_layers)

# 4. 定义损失函数和优化器
criterion = nn.MSELoss() # 均方误差损失(回归任务)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 5. 模型训练
epochs = 50
batch_size = 32
train_losses = []
test_losses = []
# ===================== 2. 数据预处理 =====================
# 标准化:将所有特征转换为均值=0、方差=1的分布,避免不同量纲特征影响模型训练
scaler = StandardScaler() # 初始化标准化器
data_scaled = scaler.fit_transform(data) # 拟合训练数据并转换(注意:仅用训练数据拟合,避免数据泄露)

# 生成LSTM输入序列和标签:用过去10个时间步预测未来1个时间步的速度
seq_len = 10 # 输入序列长度(可根据数据特性调整,如5、15等)
X, y = create_sequences(data_scaled, seq_len) # X形状:(num_sequences, 10, 5),y形状:(num_sequences, 1)

# 划分训练集和测试集:时序数据禁止shuffle(保持时间顺序),测试集占比20%
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, shuffle=False
)

# 转换为PyTorch张量(模型仅支持张量输入)
X_train = torch.FloatTensor(X_train) # 训练集输入:(train_samples, 10, 5)
y_train = torch.FloatTensor(y_train) # 训练集标签:(train_samples, 1)
X_test = torch.FloatTensor(X_test) # 测试集输入:(test_samples, 10, 5)
y_test = torch.FloatTensor(y_test) # 测试集标签:(test_samples, 1)

# ===================== 3. 模型初始化 =====================
input_size = X_train.shape[2] # 输入特征数:5(速度、加速度、方向盘、油门、刹车)
hidden_size = 64 # LSTM隐藏层神经元数(超参数,可调整:32、64、128等)
num_layers = 2 # LSTM层数(超参数,1或2层较常用,过多易过拟合)
model = SpeedPredictor(input_size, hidden_size, num_layers) # 实例化模型

# ===================== 4. 定义训练组件 =====================
criterion = nn.MSELoss() # 损失函数:均方误差(MSE),适用于回归任务(预测连续值)
optimizer = optim.Adam( # 优化器:Adam(自适应学习率,训练稳定性好)
model.parameters(), # 待优化的模型参数
lr=0.001 # 学习率(超参数,可调整:0.0001、0.001、0.01等)
)

# ===================== 5. 模型训练与验证 =====================
epochs = 50 # 训练轮数(整个训练集遍历50次)
batch_size = 32 # 批次大小(每次训练用32个样本更新参数,平衡速度和稳定性)
train_losses = [] # 记录每轮训练损失(用于后续可视化)
test_losses = [] # 记录每轮测试损失(用于后续可视化)

for epoch in range(epochs):
model.train() # 训练模式
epoch_loss = 0
# 分批训练
# 训练模式:启用Dropout(本模型无Dropout,但保留规范)、BatchNorm更新
model.train()
epoch_loss = 0 # 累计当前轮次的总损失

# 分批训练(避免一次性加载所有数据导致内存溢出)
for i in range(0, len(X_train), batch_size):
batch_X = X_train[i:i+batch_size]
batch_y = y_train[i:i+batch_size]
# 截取当前批次的训练数据
batch_X = X_train[i:i + batch_size] # 批次输入:(batch_size, 10, 5)
batch_y = y_train[i:i + batch_size] # 批次标签:(batch_size, 1)

optimizer.zero_grad() # 清零梯度
outputs = model(batch_X)
loss = criterion(outputs, batch_y)
loss.backward() # 反向传播
optimizer.step() # 更新参数
optimizer.zero_grad() # 清零梯度(避免梯度累积)
outputs = model(batch_X) # 模型前向传播:计算预测值
loss = criterion(outputs, batch_y) # 计算当前批次的损失
loss.backward() # 反向传播:计算梯度
optimizer.step() # 梯度下降:更新模型参数

epoch_loss += loss.item() * batch_X.size(0) # 累计损失
# 累计损失(乘以批次大小,最后求平均)
epoch_loss += loss.item() * batch_X.size(0)

# 计算当前轮次的平均训练损失
train_loss = epoch_loss / len(X_train)
train_losses.append(train_loss)

# 测试集验证
model.eval() # 评估模式
with torch.no_grad():
y_pred = model(X_test)
test_loss = criterion(y_pred, y_test).item()
# 测试集验证(不更新模型参数,仅评估性能)
model.eval() # 评估模式:禁用Dropout、BatchNorm固定
with torch.no_grad(): # 禁用梯度计算(节省内存,加速计算)
y_pred = model(X_test) # 测试集预测
test_loss = criterion(y_pred, y_test).item() # 测试集损失
test_losses.append(test_loss)

# 每5轮打印一次训练/测试损失(监控训练进度)
if (epoch + 1) % 5 == 0:
print(f'Epoch [{epoch+1}/{epochs}], Train Loss: {train_loss:.6f}, Test Loss: {test_loss:.6f}')
print(f'Epoch [{epoch + 1}/{epochs}], Train Loss: {train_loss:.6f}, Test Loss: {test_loss:.6f}')

# 6. 结果可视化
# 反标准化(将预测结果转换为原始速度尺度)
# 构造反标准化需要的虚拟特征矩阵(仅用于恢复速度的尺度)
dummy = np.zeros_like(data_scaled[:len(y_test)])
dummy[:, 0] = y_test.numpy().flatten() # 测试集真实速度(标准化后)
y_test_original = scaler.inverse_transform(dummy)[:, 0] # 原始尺度真实速度
# ===================== 6. 结果可视化 =====================
# 反标准化:将标准化后的预测值和真实值转换为原始速度尺度(便于直观理解)
# 说明:StandardScaler需要完整的特征向量才能反标准化,因此构造虚拟矩阵仅恢复速度列
dummy = np.zeros_like(data_scaled[:len(y_test)]) # 虚拟矩阵:(test_samples, 5),全0
dummy[:, 0] = y_test.numpy().flatten() # 仅在速度列(第0列)填入标准化后的真实速度
y_test_original = scaler.inverse_transform(dummy)[:, 0] # 反标准化得到原始尺度的真实速度

# 对预测值执行同样的反标准化操作
dummy_pred = np.zeros_like(data_scaled[:len(y_test)])
dummy_pred[:, 0] = y_pred.numpy().flatten() # 预测速度(标准化后)
y_pred_original = scaler.inverse_transform(dummy_pred)[:, 0] # 原始尺度预测速度

# 绘制预测 vs 真实值
dummy_pred[:, 0] = y_pred.numpy().flatten()
y_pred_original = scaler.inverse_transform(dummy_pred)[:, 0]

# 绘制预测值 vs 真实值曲线(直观对比预测效果)
plt.figure(figsize=(12, 6)) # 设置图大小
plt.plot(y_test_original, label='真实速度', alpha=0.7) # 真实速度曲线(透明度0.7避免重叠)
plt.plot(y_pred_original, label='预测速度', alpha=0.7) # 预测速度曲线
plt.xlabel('时间步') # x轴标签
plt.ylabel('速度 (m/s)') # y轴标签(原始尺度)
plt.title('无人车速度预测结果') # 图标题
plt.legend() # 显示图例
plt.show() # 显示图像

# 绘制训练/测试损失曲线(监控模型收敛情况,判断是否过拟合)
plt.figure(figsize=(12, 6))
plt.plot(y_test_original, label='真实速度', alpha=0.7)
plt.plot(y_pred_original, label='预测速度', alpha=0.7)
plt.xlabel('时间步')
plt.ylabel('速度 (m/s)')
plt.title('无人车速度预测结果')
plt.legend()
plt.show()

# 绘制损失曲线
plt.figure(figsize=(12, 6))
plt.plot(train_losses, label='训练损失')
plt.plot(test_losses, label='测试损失')
plt.xlabel('Epoch')
plt.ylabel('MSE损失')
plt.plot(train_losses, label='训练损失') # 训练损失趋势
plt.plot(test_losses, label='测试损失') # 测试损失趋势
plt.xlabel('Epoch') # x轴:训练轮次
plt.ylabel('MSE损失') # y轴:均方误差
plt.title('训练与测试损失曲线')
plt.legend()
plt.show()


# 程序入口:当脚本直接运行时,执行main函数
if __name__ == '__main__':
main()
Loading