From 05c6a5a8b8c7c647bf8be30710791d43d245b4d7 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Sun, 21 Dec 2025 12:35:46 +0800 Subject: [PATCH 1/4] 6653 --- src/driverless_car_yb/main_speed.py | 298 +++++++++++++++++----------- 1 file changed, 184 insertions(+), 114 deletions(-) diff --git a/src/driverless_car_yb/main_speed.py b/src/driverless_car_yb/main_speed.py index 3afff2cae4..25b6ed99bc 100644 --- a/src/driverless_car_yb/main_speed.py +++ b/src/driverless_car_yb/main_speed.py @@ -1,161 +1,231 @@ -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 真实值 - 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() - - # 绘制损失曲线 + 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(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() \ No newline at end of file From 293f0f92412a0a1456af19b9aa9fc8b16f12a614 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Sun, 21 Dec 2025 12:42:47 +0800 Subject: [PATCH 2/4] 6654 --- src/driverless_car_yb/main_speed.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/driverless_car_yb/main_speed.py b/src/driverless_car_yb/main_speed.py index 25b6ed99bc..e2cbad0cdf 100644 --- a/src/driverless_car_yb/main_speed.py +++ b/src/driverless_car_yb/main_speed.py @@ -225,7 +225,6 @@ def main(): plt.legend() plt.show() - # 程序入口:当脚本直接运行时,执行main函数 if __name__ == '__main__': main() \ No newline at end of file From c4dbc1dece1ccbfcb63451f91f3b3805dac17346 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Sun, 21 Dec 2025 14:25:49 +0800 Subject: [PATCH 3/4] 4453 --- src/driverless_car_yb/main_speed.py | 230 ------------------------- src/unclaimed_car/main_speed.py | 249 ++++++++++++++++++++++++++++ 2 files changed, 249 insertions(+), 230 deletions(-) delete mode 100644 src/driverless_car_yb/main_speed.py create mode 100644 src/unclaimed_car/main_speed.py diff --git a/src/driverless_car_yb/main_speed.py b/src/driverless_car_yb/main_speed.py deleted file mode 100644 index e2cbad0cdf..0000000000 --- a/src/driverless_car_yb/main_speed.py +++ /dev/null @@ -1,230 +0,0 @@ -# 导入必要的库 -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) # PyTorch随机种子 -np.random.seed(42) # NumPy随机种子 - - -class SpeedPredictor(nn.Module): - """ - 无人车速度预测模型:基于LSTM(长短期记忆网络)的时序预测模型 - LSTM适合处理时序数据,能捕捉时间序列中的长期依赖关系,适合速度这类连续变化的时序预测任务 - """ - - def __init__(self, input_size, hidden_size, num_layers, output_size=1): - """ - 初始化模型参数 - 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, # 隐藏层神经元数 - num_layers=num_layers, # LSTM层数 - batch_first=True # 输入数据格式为(batch_size, seq_len, input_size),便于批量处理 - ) - - # 定义全连接层:将LSTM的隐藏层输出映射到最终预测结果 - self.fc = nn.Linear(hidden_size, output_size) - - def forward(self, x): - """ - 前向传播过程(模型的核心计算逻辑) - 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): - """ - 将原始时序数据转换为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 = [], [] # 存储输入序列和对应的标签 - - # 遍历原始数据,生成所有可能的序列(避免索引越界) - # 循环终止条件:i + seq_len + pred_len - 1 < len(data) - for i in range(len(data) - seq_len - pred_len + 1): - # 输入序列:从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. 数据准备 ===================== - # 说明:本示例使用模拟数据验证模型,实际应用中需替换为真实传感器数据(如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. 数据预处理 ===================== - # 标准化:将所有特征转换为均值=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): - # 训练模式:启用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_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() # 梯度下降:更新模型参数 - - # 累计损失(乘以批次大小,最后求平均) - epoch_loss += loss.item() * batch_X.size(0) - - # 计算当前轮次的平均训练损失 - train_loss = epoch_loss / len(X_train) - train_losses.append(train_loss) - - # 测试集验证(不更新模型参数,仅评估性能) - 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}') - - # ===================== 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 真实值曲线(直观对比预测效果) - 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(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() \ No newline at end of file diff --git a/src/unclaimed_car/main_speed.py b/src/unclaimed_car/main_speed.py new file mode 100644 index 0000000000..fbe687de24 --- /dev/null +++ b/src/unclaimed_car/main_speed.py @@ -0,0 +1,249 @@ +# 导入必要的库(按功能分类,便于查找) +import torch # PyTorch核心库:提供张量计算和自动微分,是神经网络构建基础 +import torch.nn as nn # PyTorch神经网络模块:封装了常用层(LSTM、Linear)、损失函数等 +import torch.optim as optim # PyTorch优化器模块:提供Adam、SGD等参数更新算法 +import numpy as np # 数值计算库:用于数据生成、数组操作(适配PyTorch张量) +import pandas as pd # 数据处理库:预留用于读取真实CSV格式传感器数据(本示例暂未使用) +from sklearn.model_selection import train_test_split # 数据集划分工具:拆分训练集/测试集 +from sklearn.preprocessing import StandardScaler # 数据预处理工具:特征标准化(消除量纲影响) +import matplotlib.pyplot as plt # 可视化库:绘制预测结果和损失曲线,直观评估模型 + +# 设置随机种子(固定所有随机数生成器的初始状态) +# 目的:保证每次运行代码的实验结果完全一致,便于调试和复现 +torch.manual_seed(42) # 固定PyTorch的随机数生成(张量初始化、dropout等) +np.random.seed(42) # 固定NumPy的随机数生成(数据模拟、索引打乱等) + + +class SpeedPredictor(nn.Module): + """ + 无人车速度预测模型:基于LSTM(长短期记忆网络)的时序单步预测模型 + 核心适配场景:速度是连续变化的时序数据,需捕捉历史状态与未来状态的依赖关系 + LSTM优势:解决传统RNN的梯度消失问题,能有效学习长时序数据的特征 + """ + + def __init__(self, input_size, hidden_size, num_layers, output_size=1): + """ + 初始化模型结构与超参数 + Args: + input_size (int): 每个时间步的输入特征维度 + 例:本示例输入5个特征(速度、加速度、方向盘角度、油门开度、刹车压力) + hidden_size (int): LSTM隐藏层神经元数量 + 作用:控制模型的特征提取能力(值越大能力越强,但易过拟合) + num_layers (int): LSTM网络的堆叠层数 + 作用:多层LSTM可提取更复杂的时序特征(1-2层最常用,过多易过拟合) + output_size (int): 模型输出维度(默认1,即预测未来1个时间步的速度) + """ + super().__init__() # 简化写法:等价于 super(SpeedPredictor, self).__init__() + + # 定义LSTM核心层 + self.lstm = nn.LSTM( + input_size=input_size, + hidden_size=hidden_size, + num_layers=num_layers, + batch_first=True # 输入数据格式:(batch_size, 序列长度, 特征维度),符合日常数据组织习惯 + ) + + # 定义全连接输出层:将LSTM的高维特征映射到最终预测值(速度) + self.fc = nn.Linear(hidden_size, output_size) + + def forward(self, x): + """ + 模型前向传播逻辑(数据在模型中的计算路径) + Args: + x (torch.Tensor): 输入张量,形状=(batch_size, seq_len, input_size) + batch_size:每次训练的样本数量(批次大小) + seq_len:输入序列长度(用过去多少个时间步的数据做预测) + input_size:每个时间步的特征维度 + Returns: + torch.Tensor:模型预测输出,形状=(batch_size, output_size)(每个样本对应1个预测速度) + """ + # LSTM层计算:输出包含两部分(所有时间步的隐藏态 + 最后一个时间步的隐藏态/细胞态) + # lstm_out形状=(batch_size, seq_len, hidden_size),_表示忽略不需要的隐藏态/细胞态 + lstm_out, _ = self.lstm(x) + + # 关键操作:仅取最后一个时间步的隐藏态作为全连接层输入 + # 原因:我们需要用整个序列的历史信息预测下一个时间步,最后一个时间步已整合所有历史特征 + last_time_step_out = lstm_out[:, -1, :] # 切片后形状=(batch_size, hidden_size) + + # 全连接层映射:将LSTM提取的特征转换为最终速度预测值 + pred_speed = self.fc(last_time_step_out) + + return pred_speed + + +def create_sequences(data, seq_len, pred_len=1): + """ + 时序数据格式化:将原始1D时序数据转换为LSTM可处理的序列-标签对(X, y) + 核心逻辑:用「过去seq_len个时间步的所有特征」预测「未来pred_len个时间步的速度」 + Args: + data (np.ndarray): 原始特征矩阵,形状=(总时间步数量, 特征维度) + seq_len (int): 输入序列长度(即"过去多少个时间步") + pred_len (int): 预测长度(即"未来多少个时间步",默认1为单步预测) + Returns: + tuple: (X, y) 均为NumPy数组 + X: 输入序列矩阵,形状=(有效序列数, seq_len, 特征维度) + y: 标签矩阵(待预测的速度),形状=(有效序列数, pred_len) + """ + input_sequences = [] # 存储所有输入序列 + target_speeds = [] # 存储对应每个序列的目标速度 + + # 循环生成序列(避免索引越界:确保最后一个序列能取到完整的标签) + # 有效序列数 = 总时间步 - 输入序列长度 - 预测长度 + 1 + for i in range(len(data) - seq_len - pred_len + 1): + # 提取输入序列:从第i步开始,连续取seq_len个时间步的所有特征 + seq = data[i:i + seq_len] # 形状=(seq_len, 特征维度) + # 提取目标标签:从输入序列结束后开始,取pred_len个时间步的速度(速度是第0列特征) + target = data[i + seq_len:i + seq_len + pred_len, 0] # 形状=(pred_len,) + + input_sequences.append(seq) + target_speeds.append(target) + + # 转换为NumPy数组(便于后续转换为PyTorch张量) + return np.array(input_sequences), np.array(target_speeds) + + +def main(): + """主函数:整合数据准备、模型训练、评估、可视化的完整流程""" + # ===================== 1. 模拟数据生成(替代真实传感器数据)===================== + # 说明:实际应用时,可替换为 pd.read_csv("sensor_data.csv") 读取真实数据 + # 模拟特征维度:[速度(m/s), 加速度(m/s²), 方向盘角度(°), 油门开度(%), 刹车压力(bar)] + total_time_steps = 10000 # 总时间步(模拟10000次传感器采样,约100秒) + time_axis = np.linspace(0, 100, total_time_steps) # 时间轴(0-100秒,均匀采样) + + # 模拟各特征(添加高斯噪声模拟真实传感器的测量误差) + base_speed = 10 # 基础速度(10m/s ≈ 36km/h,城市道路常见速度) + speed = base_speed + 5 * np.sin(time_axis) + np.random.normal(0, 0.5, total_time_steps) # 速度含正弦波动 + acceleration = np.gradient(speed, time_axis) # 加速度:速度对时间的一阶导数 + steering = 10 * np.sin(time_axis / 2) + np.random.normal(0, 1, total_time_steps) # 方向盘角度(慢波动) + throttle = 30 + 10 * np.sin(time_axis / 3) + np.random.normal(0, 2, total_time_steps) # 油门开度(30%左右) + brake = np.where( + speed < 8, # 逻辑:速度低于8m/s时(低速),刹车压力增大 + 5 + np.random.normal(0, 1, total_time_steps), # 低速刹车压力(5bar左右) + np.random.normal(0, 0.5, total_time_steps) # 高速刹车压力(接近0,很少刹车) + ) + + # 组合所有特征为矩阵:形状=(total_time_steps, 5) + sensor_data = np.column_stack([speed, acceleration, steering, throttle, brake]) + + # ===================== 2. 数据预处理(避免模型训练异常)===================== + # 标准化:将所有特征转换为「均值=0,方差=1」的标准正态分布 + # 必要性:不同特征量纲不同(如速度m/s、角度°),标准化可避免特征权重失衡 + scaler = StandardScaler() + # 注意:仅用训练数据拟合scaler(避免测试集信息泄露,保证评估客观性) + scaled_data = scaler.fit_transform(sensor_data) + + # 生成LSTM输入序列和标签 + seq_len = 10 # 输入序列长度:用过去10个时间步(约0.1秒)的数据预测未来速度 + X, y = create_sequences(scaled_data, seq_len) # X=(N,10,5), y=(N,1),N为有效序列数 + + # 划分训练集/测试集(时序数据必须禁用shuffle!否则破坏时间顺序) + # 测试集占比20%:用于评估模型在未见过的未来数据上的泛化能力 + X_train, X_test, y_train, y_test = train_test_split( + X, y, test_size=0.2, shuffle=False + ) + + # 转换为PyTorch张量(模型仅支持张量输入,不支持NumPy数组) + X_train = torch.FloatTensor(X_train) # 训练输入:(N_train, 10, 5) + y_train = torch.FloatTensor(y_train) # 训练标签:(N_train, 1) + X_test = torch.FloatTensor(X_test) # 测试输入:(N_test, 10, 5) + y_test = torch.FloatTensor(y_test) # 测试标签:(N_test, 1) + + # ===================== 3. 模型初始化(配置超参数)===================== + input_size = X_train.shape[2] # 输入特征维度:5(对应5个传感器特征) + hidden_size = 64 # LSTM隐藏层神经元数(超参数:可调整为32/128,需配合正则化) + num_layers = 2 # LSTM层数(超参数:1-2层最优,过多易过拟合) + model = SpeedPredictor(input_size, hidden_size, num_layers) # 实例化模型 + + # ===================== 4. 配置训练组件(损失函数+优化器)===================== + criterion = nn.MSELoss() # 损失函数:均方误差(MSE) + # 适配场景:回归任务(预测连续值如速度),对异常值敏感,惩罚较大误差 + optimizer = optim.Adam( + model.parameters(), # 待优化的参数:模型中所有可学习参数(LSTM权重、全连接层权重) + lr=0.001 # 学习率(超参数:控制参数更新步长,0.001为Adam默认最优初始值) + ) + + # ===================== 5. 模型训练与实时验证 ===================== + epochs = 50 # 训练轮数:整个训练集将被遍历50次(足够模型收敛,避免欠拟合) + batch_size = 32 # 批次大小:每次训练用32个样本更新参数(平衡训练速度和稳定性) + train_loss_history = [] # 记录每轮训练损失(用于后续分析收敛情况) + test_loss_history = [] # 记录每轮测试损失(用于判断是否过拟合) + + for epoch in range(epochs): + # ---------------------- 训练阶段(更新模型参数)---------------------- + model.train() # 开启训练模式(启用Dropout/BatchNorm的训练行为,本模型无但保留规范) + total_train_loss = 0 # 累计当前轮次所有批次的损失 + + # 分批迭代训练集(避免一次性加载所有数据导致内存溢出) + for i in range(0, len(X_train), batch_size): + # 截取当前批次数据(最后一批可能不足32个样本,自动适配) + batch_X = X_train[i:i + batch_size] + batch_y = y_train[i:i + batch_size] + + optimizer.zero_grad() # 清零梯度(关键!避免前一轮梯度累积影响当前更新) + pred = model(batch_X) # 模型前向传播:计算批次预测值 + loss = criterion(pred, batch_y) # 计算批次损失(预测值与真实值的差距) + loss.backward() # 反向传播:计算各参数的梯度(损失对参数的偏导数) + optimizer.step() # 梯度下降:根据梯度更新模型参数(最小化损失) + + # 累计损失(乘以批次样本数,确保最终平均损失计算准确) + total_train_loss += loss.item() * batch_X.size(0) + + # 计算当前轮次的平均训练损失(总损失/训练集样本数) + avg_train_loss = total_train_loss / len(X_train) + train_loss_history.append(avg_train_loss) + + # ---------------------- 验证阶段(不更新模型参数)---------------------- + model.eval() # 开启评估模式(禁用Dropout/BatchNorm更新,固定模型参数) + with torch.no_grad(): # 禁用梯度计算(节省内存+加速计算,无需反向传播) + test_pred = model(X_test) # 测试集全量预测 + avg_test_loss = criterion(test_pred, y_test).item() # 计算测试集平均损失 + test_loss_history.append(avg_test_loss) + + # 每5轮打印一次损失(监控训练进度,及时发现异常如损失不下降) + if (epoch + 1) % 5 == 0: + print(f'第 {epoch + 1:2d}/{epochs} 轮 | 训练损失:{avg_train_loss:.6f} | 测试损失:{avg_test_loss:.6f}') + + # ===================== 6. 结果可视化(直观评估模型性能)===================== + # 反标准化:将标准化后的预测值/真实值转换为原始速度单位(m/s),便于理解 + # 原理:StandardScaler需要完整特征向量才能反归一化,故构造虚拟矩阵仅恢复速度列 + # 真实速度反标准化 + dummy_test = np.zeros_like(scaled_data[:len(y_test)]) # 虚拟矩阵:(N_test, 5) + dummy_test[:, 0] = y_test.numpy().flatten() # 仅速度列(第0列)填入标准化后的真实值 + true_speed = scaler.inverse_transform(dummy_test)[:, 0] # 反标准化得到原始速度 + + # 预测速度反标准化(与真实速度步骤一致) + dummy_pred = np.zeros_like(scaled_data[:len(y_test)]) + dummy_pred[:, 0] = test_pred.numpy().flatten() + pred_speed = scaler.inverse_transform(dummy_pred)[:, 0] + + # 图1:真实速度 vs 预测速度(直观对比拟合效果) + plt.figure(figsize=(12, 6)) + plt.plot(true_speed, label='真实速度', alpha=0.8, linewidth=1.5) # 真实值曲线(透明度0.8避免重叠) + plt.plot(pred_speed, label='预测速度', alpha=0.8, linewidth=1.5, linestyle='--') # 预测值曲线(虚线区分) + plt.xlabel('测试集时间步', fontsize=12) + plt.ylabel('速度 (m/s)', fontsize=12) + plt.title('无人车速度预测结果对比', fontsize=14, pad=20) + plt.legend(fontsize=11) + plt.grid(alpha=0.3) # 添加网格线,便于读取数值 + plt.show() + + # 图2:训练/测试损失曲线(分析模型收敛与过拟合) + plt.figure(figsize=(12, 6)) + plt.plot(train_loss_history, label='训练损失', linewidth=1.5) + plt.plot(test_loss_history, label='测试损失', linewidth=1.5, linestyle='--') + plt.xlabel('训练轮次 (Epoch)', fontsize=12) + plt.ylabel('均方误差 (MSE)', fontsize=12) + plt.title('模型训练收敛曲线', fontsize=14, pad=20) + plt.legend(fontsize=11) + plt.grid(alpha=0.3) + plt.show() + + # 补充说明: + # 1. 若训练损失持续下降但测试损失上升 → 过拟合(可减小hidden_size/增加Dropout/增大批次) + # 2. 若训练损失和测试损失均很高 → 欠拟合(可增大hidden_size/增加LSTM层数/增加训练轮数) + # 3. 若损失波动大 → 减小学习率/增大批次大小 + + +# 程序入口:当脚本被直接运行时,执行主函数(避免被导入时自动执行) +if __name__ == '__main__': + main() \ No newline at end of file From 470824165ced8823e6c06b1ea511dc54c3a5f2d7 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Sun, 21 Dec 2025 20:32:33 +0800 Subject: [PATCH 4/4] 4498 --- .../main_speed.py | 1 - 1 file changed, 1 deletion(-) rename src/{unclaimed_car => unclaimed_vehicle_management}/main_speed.py (99%) diff --git a/src/unclaimed_car/main_speed.py b/src/unclaimed_vehicle_management/main_speed.py similarity index 99% rename from src/unclaimed_car/main_speed.py rename to src/unclaimed_vehicle_management/main_speed.py index fbe687de24..0f96743bcc 100644 --- a/src/unclaimed_car/main_speed.py +++ b/src/unclaimed_vehicle_management/main_speed.py @@ -9,7 +9,6 @@ import matplotlib.pyplot as plt # 可视化库:绘制预测结果和损失曲线,直观评估模型 # 设置随机种子(固定所有随机数生成器的初始状态) -# 目的:保证每次运行代码的实验结果完全一致,便于调试和复现 torch.manual_seed(42) # 固定PyTorch的随机数生成(张量初始化、dropout等) np.random.seed(42) # 固定NumPy的随机数生成(数据模拟、索引打乱等)