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/7] 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/7] 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/7] 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/7] 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的随机数生成(数据模拟、索引打乱等) From 4f996ecc0da480b725e3aca1e60d3c7e968bb363 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Sun, 21 Dec 2025 21:38:39 +0800 Subject: [PATCH 5/7] 4499 --- .../main_speed.py | 230 ++++++++++++++++ .../main_speed.py | 248 ------------------ 2 files changed, 230 insertions(+), 248 deletions(-) create mode 100644 src/driverless_vehicle_management/main_speed.py delete mode 100644 src/unclaimed_vehicle_management/main_speed.py diff --git a/src/driverless_vehicle_management/main_speed.py b/src/driverless_vehicle_management/main_speed.py new file mode 100644 index 0000000000..31d56ffe06 --- /dev/null +++ b/src/driverless_vehicle_management/main_speed.py @@ -0,0 +1,230 @@ +# 导入必要的库 +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_vehicle_management/main_speed.py b/src/unclaimed_vehicle_management/main_speed.py deleted file mode 100644 index 0f96743bcc..0000000000 --- a/src/unclaimed_vehicle_management/main_speed.py +++ /dev/null @@ -1,248 +0,0 @@ -# 导入必要的库(按功能分类,便于查找) -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 990ebb1e58053e89e86dc1f5e0db41acda6b79f5 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Mon, 22 Dec 2025 20:48:17 +0800 Subject: [PATCH 6/7] 4490 --- src/driverless_car_yb/main.turn.py | 148 ------------- .../main.turn.py | 202 ++++++++++++++++++ 2 files changed, 202 insertions(+), 148 deletions(-) delete mode 100644 src/driverless_car_yb/main.turn.py create mode 100644 src/driverless_vehicle_management/main.turn.py diff --git a/src/driverless_car_yb/main.turn.py b/src/driverless_car_yb/main.turn.py deleted file mode 100644 index e83651322c..0000000000 --- a/src/driverless_car_yb/main.turn.py +++ /dev/null @@ -1,148 +0,0 @@ -import numpy as np -import matplotlib.pyplot as plt -import matplotlib.animation as animation -from matplotlib.patches import Rectangle, Circle - -# -------------------------- 初始化参数设置 -------------------------- -# 道路参数 -road_width = 6 # 道路总宽度(m) -lane_width = 3 # 单车道宽度(m) -road_length = 100 # 道路长度(m) - -# 车辆参数 -car_width = 1.8 # 车宽(m) -car_length = 4.5 # 车长(m) -car_speed = 15 # 行驶速度(m/s) -lane_change_duration = 2.0 # 变道总时长(s) -blinker_duration = 0.5 # 转向灯闪烁周期(s) - -# 初始状态 -start_lane = 1 # 起始车道(1=左车道,2=右车道) -target_lane = 2 # 目标车道(1=左车道,2=右车道) -initial_x = 10 # 初始x坐标(道路起始位置) -initial_y = (start_lane - 1) * lane_width + lane_width / 2 # 初始y坐标(车道中心线) -target_y = (target_lane - 1) * lane_width + lane_width / 2 # 目标车道中心线y坐标 - -# 安全距离参数 -safety_distance_front = 20 # 前车安全距离(m) -safety_distance_back = 15 # 后车安全距离(m) - -# 动画参数 -fps = 30 # 帧率 -total_time = 5 # 动画总时长(s) -num_frames = int(fps * total_time) # 总帧数 - -# -------------------------- 创建画布和坐标轴 -------------------------- -fig, ax = plt.subplots(figsize=(12, 6)) -ax.set_xlim(0, road_length) -ax.set_ylim(-1, road_width + 1) -ax.set_xlabel('距离 (m)') -ax.set_ylabel('道路宽度 (m)') -ax.set_title('无人车自动变道模拟') -ax.grid(True, alpha=0.3) - -# 绘制道路(灰色背景) -road = Rectangle((0, 0), road_length, road_width, facecolor='#f0f0f0', edgecolor='black', linewidth=2) -ax.add_patch(road) - -# 绘制车道线(白色虚线) -dashed_x = np.arange(0, road_length, 5) # 虚线分段x坐标 -for y in [lane_width]: # 中间车道线 - for x in dashed_x: - lane_line = Rectangle((x, y - 0.1), 3, 0.2, facecolor='white', linewidth=0) - ax.add_patch(lane_line) - -# -------------------------- 初始化车辆和元素 -------------------------- -# 无人车(蓝色车身) -car = Rectangle((initial_x - car_length / 2, initial_y - car_width / 2), - car_length, car_width, facecolor='royalblue', edgecolor='black', linewidth=2) -ax.add_patch(car) - -# 转向灯(左右各一个,初始透明) -left_blinker = Circle((initial_x - car_length / 2 + 0.5, initial_y), 0.3, facecolor='yellow', alpha=0) -right_blinker = Circle((initial_x + car_length / 2 - 0.5, initial_y), 0.3, facecolor='yellow', alpha=0) -ax.add_patch(left_blinker) -ax.add_patch(right_blinker) - -# 前车(灰色,用于安全距离检测演示) -front_car = Rectangle((initial_x + safety_distance_front + car_length, target_y - car_width / 2), - car_length, car_width, facecolor='gray', edgecolor='black', linewidth=2) -ax.add_patch(front_car) - -# 后车(灰色,用于安全距离检测演示) -back_car = Rectangle((initial_x - safety_distance_back - car_length, target_y - car_width / 2), - car_length, car_width, facecolor='gray', edgecolor='black', linewidth=2) -ax.add_patch(back_car) - -# 状态文本(显示变道状态) -status_text = ax.text(road_length - 30, road_width - 1, '状态:正常行驶', - fontsize=12, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8)) - - -# -------------------------- 动画更新函数 -------------------------- -def update(frame): - # 计算当前时间 - t = frame / fps - - # 基础行驶:x方向匀速移动 - current_x = initial_x + car_speed * t - - # 变道逻辑(0.5s准备→1.5s变道→2.5s后结束) - if t < 0.5: - # 阶段1:检测安全距离,准备变道(转向灯闪烁) - current_y = initial_y - blinker_alpha = 1 if (t % blinker_duration) < blinker_duration / 2 else 0 - if start_lane < target_lane: # 向右变道→右转向灯 - right_blinker.set_alpha(blinker_alpha) - left_blinker.set_alpha(0) - else: # 向左变道→左转向灯 - left_blinker.set_alpha(blinker_alpha) - right_blinker.set_alpha(0) - status_text.set_text('状态:检测安全距离') - - elif 0.5 <= t < 0.5 + lane_change_duration: - # 阶段2:平稳变道(正弦曲线平滑过渡y坐标) - lane_change_t = t - 0.5 # 变道时间(0~2s) - # 正弦函数实现平滑变道(0→π,y从初始→目标) - y_ratio = (1 - np.cos(np.pi * lane_change_t / lane_change_duration)) / 2 - current_y = initial_y + (target_y - initial_y) * y_ratio - # 转向灯常亮 - if start_lane < target_lane: - right_blinker.set_alpha(1) - else: - left_blinker.set_alpha(1) - status_text.set_text('状态:正在变道') - - else: - # 阶段3:变道完成,恢复正常行驶 - current_y = target_y - left_blinker.set_alpha(0) - right_blinker.set_alpha(0) - status_text.set_text('状态:变道完成') - - # 更新车辆位置 - car.set_xy((current_x - car_length / 2, current_y - car_width / 2)) - - # 更新前后车位置(随道路同步移动,模拟相对静止) - front_car.set_xy((current_x + safety_distance_front + car_length / 2, target_y - car_width / 2)) - back_car.set_xy((current_x - safety_distance_back - 3 * car_length / 2, target_y - car_width / 2)) - - # 边界处理:车辆驶出画面后重置x坐标 - if current_x > road_length + car_length / 2: - car.set_xy((-car_length / 2, current_y - car_width / 2)) - - return car, left_blinker, right_blinker, front_car, back_car, status_text - - -# -------------------------- 生成动画 -------------------------- -# 创建动画(blit=True加速渲染) -ani = animation.FuncAnimation( - fig, update, frames=num_frames, interval=1000 / fps, blit=True, repeat=True -) - -# 显示动画 -plt.tight_layout() -plt.show() - -# (可选)保存动画为GIF(需要安装ffmpeg或pillow) -# ani.save('autonomous_lane_change.gif', writer='pillow', fps=fps, dpi=150)s \ No newline at end of file diff --git a/src/driverless_vehicle_management/main.turn.py b/src/driverless_vehicle_management/main.turn.py new file mode 100644 index 0000000000..e92635e67b --- /dev/null +++ b/src/driverless_vehicle_management/main.turn.py @@ -0,0 +1,202 @@ +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.animation as animation +from matplotlib.patches import Rectangle, Circle + +# -------------------------- 初始化参数设置 -------------------------- +# 道路参数:定义道路物理尺寸 +road_width = 6 # 道路总宽度(单位:米) +lane_width = 3 # 单车道宽度(单位:米),双车道总宽=3*2=6m,与road_width一致 +road_length = 100 # 道路总长度(单位:米),即动画横向范围 + +# 车辆参数:定义无人车物理属性和运动特性 +car_width = 1.8 # 车身宽度(单位:米),小于车道宽度保证安全 +car_length = 4.5 # 车身长度(单位:米),符合常见轿车尺寸 +car_speed = 15 # 恒定行驶速度(单位:米/秒),约54km/h,城市道路常见速度 +lane_change_duration = 2.0 # 完成一次变道的总时间(单位:秒),保证平稳性 +blinker_duration = 0.5 # 转向灯闪烁周期(单位:秒),0.5秒亮/0.5秒灭 + +# 初始状态:定义车辆起始和目标状态 +start_lane = 1 # 起始车道(1=左车道,2=右车道) +target_lane = 2 # 目标车道(1=左车道,2=右车道),此处为左→右变道 +initial_x = 10 # 初始x坐标(道路起始方向位置),距离道路左端10m +# 初始y坐标:计算起始车道中心线位置(车道索引*车道宽 - 车道宽/2) +initial_y = (start_lane - 1) * lane_width + lane_width / 2 +# 目标y坐标:计算目标车道中心线位置,与初始y坐标相差一个车道宽(3m) +target_y = (target_lane - 1) * lane_width + lane_width / 2 + +# 安全距离参数:变道时与前后车的安全间隔 +safety_distance_front = 20 # 与前车的最小安全距离(单位:米) +safety_distance_back = 15 # 与后车的最小安全距离(单位:米) + +# 动画参数:控制动画播放效果 +fps = 30 # 帧率(单位:帧/秒),30fps为流畅动画标准 +total_time = 5 # 动画总时长(单位:秒),包含变道全流程 +num_frames = int(fps * total_time) # 总帧数 = 帧率*时长,用于动画迭代 + +# -------------------------- 创建画布和坐标轴 -------------------------- +# 创建绘图画布和子图,设置尺寸为12x6英寸(宽x高) +fig, ax = plt.subplots(figsize=(12, 6)) +# 设置x轴范围(道路长度),y轴范围(略大于道路宽度,留出边界) +ax.set_xlim(0, road_length) +ax.set_ylim(-1, road_width + 1) +# 设置坐标轴标签和标题,明确图表含义 +ax.set_xlabel('距离 (m)') +ax.set_ylabel('道路宽度 (m)') +ax.set_title('无人车自动变道模拟') +ax.grid(True, alpha=0.3) # 显示网格线,透明度0.3避免遮挡 + +# 绘制道路背景:灰色矩形表示路面 +road = Rectangle( + (0, 0), # 左下角坐标(x=0, y=0) + road_length, road_width, # 宽=道路长度,高=道路宽度 + facecolor='#f0f0f0', # 路面颜色(浅灰色) + edgecolor='black', linewidth=2 # 道路边界线(黑色,线宽2) +) +ax.add_patch(road) # 将道路图形添加到子图 + +# 绘制车道线:白色虚线分隔双车道 +dashed_x = np.arange(0, road_length, 5) # 虚线分段x坐标(每5m一段) +for y in [lane_width]: # 中间车道线的y坐标(3m处,即两车道分界) + for x in dashed_x: + # 每个虚线段:长3m、宽0.2m的白色矩形 + lane_line = Rectangle( + (x, y - 0.1), # 左下角坐标(x, 2.9m) + 3, 0.2, # 长3m,宽0.2m(覆盖3m±0.1m范围) + facecolor='white', linewidth=0 # 白色填充,无边框 + ) + ax.add_patch(lane_line) # 添加虚线到子图 + +# -------------------------- 初始化车辆和元素 -------------------------- +# 无人车主车身:蓝色矩形(代表本车) +car = Rectangle( + (initial_x - car_length / 2, initial_y - car_width / 2), # 左下角坐标(基于中心偏移) + car_length, car_width, # 长=车身长,宽=车身宽 + facecolor='royalblue', # 车身颜色(宝蓝色) + edgecolor='black', linewidth=2 # 车身边框(黑色,线宽2) +) +ax.add_patch(car) # 添加车身到子图 + +# 转向灯:左右各一个黄色圆形,初始透明(alpha=0) +# 左转向灯:位于车身左上角(x=车头左前+0.5m,y=车身中心) +left_blinker = Circle( + (initial_x - car_length / 2 + 0.5, initial_y), # 圆心坐标 + 0.3, # 半径(0.3m,符合转向灯实际尺寸) + facecolor='yellow', alpha=0 # 黄色填充,初始透明 +) +# 右转向灯:位于车身右上角(x=车尾右后-0.5m,y=车身中心) +right_blinker = Circle( + (initial_x + car_length / 2 - 0.5, initial_y), # 圆心坐标 + 0.3, # 半径 + facecolor='yellow', alpha=0 # 黄色填充,初始透明 +) +ax.add_patch(left_blinker) # 添加左转向灯 +ax.add_patch(right_blinker) # 添加右转向灯 + +# 前车:灰色矩形(用于演示变道时的前车安全距离) +front_car = Rectangle( + (initial_x + safety_distance_front + car_length, target_y - car_width / 2), # 初始位置(目标车道前车) + car_length, car_width, # 尺寸与本车一致 + facecolor='gray', edgecolor='black', linewidth=2 # 灰色车身,黑色边框 +) +ax.add_patch(front_car) # 添加前车到子图 + +# 后车:灰色矩形(用于演示变道时的后车安全距离) +back_car = Rectangle( + (initial_x - safety_distance_back - car_length, target_y - car_width / 2), # 初始位置(目标车道后车) + car_length, car_width, # 尺寸与本车一致 + facecolor='gray', edgecolor='black', linewidth=2 # 灰色车身,黑色边框 +) +ax.add_patch(back_car) # 添加后车到子图 + +# 状态文本:显示当前变道阶段,位于画面右上角 +status_text = ax.text( + road_length - 30, road_width - 1, # 文本位置(x=70m,y=5m) + '状态:正常行驶', # 初始文本 + fontsize=12, # 字体大小 + bbox=dict(boxstyle='round', facecolor='white', alpha=0.8) # 白色圆角背景,透明度0.8 +) + +# -------------------------- 动画更新函数 -------------------------- +def update(frame): + """ + 动画每一帧的更新逻辑:根据当前帧数计算车辆状态并更新图形 + 参数frame:当前帧数(从0到num_frames-1) + 返回:所有需要更新的图形元素(用于blit优化) + """ + # 计算当前时间t:帧数/帧率(单位:秒) + t = frame / fps + + # 基础行驶逻辑:x方向匀速移动(v*t,初始位置+速度*时间) + current_x = initial_x + car_speed * t + + # 变道三阶段逻辑:准备→变道→完成 + if t < 0.5: + # 阶段1:安全距离检测(前0.5秒)- 准备变道 + current_y = initial_y # y坐标保持初始车道(不变道) + # 转向灯闪烁:根据时间取模控制亮灭(0~0.25s亮,0.25~0.5s灭) + blinker_alpha = 1 if (t % blinker_duration) < blinker_duration / 2 else 0 + # 根据变道方向激活对应转向灯(左→右变道激活右转向灯) + if start_lane < target_lane: # 起始车道 < 目标车道 → 向右变道 + right_blinker.set_alpha(blinker_alpha) # 右转向灯闪烁 + left_blinker.set_alpha(0) # 左转向灯关闭 + else: # 起始车道 > 目标车道 → 向左变道 + left_blinker.set_alpha(blinker_alpha) # 左转向灯闪烁 + right_blinker.set_alpha(0) # 右转向灯关闭 + status_text.set_text('状态:检测安全距离') # 更新状态文本 + + elif 0.5 <= t < 0.5 + lane_change_duration: + # 阶段2:平稳变道(0.5~2.5秒,共2秒变道时长) + lane_change_t = t - 0.5 # 变道时间偏移(从0开始计算变道时长) + # 正弦曲线平滑过渡y坐标:实现"慢-快-慢"的平稳变道 + # 原理:cos(0)=1 → cos(π)=-1,因此y_ratio从0→1线性过渡(平滑) + y_ratio = (1 - np.cos(np.pi * lane_change_t / lane_change_duration)) / 2 + # 当前y坐标 = 初始y + 变道幅度*过渡比例(从初始车道→目标车道) + current_y = initial_y + (target_y - initial_y) * y_ratio + # 转向灯常亮(变道过程中持续提示) + if start_lane < target_lane: + right_blinker.set_alpha(1) # 右转向灯常亮 + else: + left_blinker.set_alpha(1) # 左转向灯常亮 + status_text.set_text('状态:正在变道') # 更新状态文本 + + else: + # 阶段3:变道完成(2.5秒后)- 正常行驶 + current_y = target_y # y坐标固定在目标车道中心线 + left_blinker.set_alpha(0) # 关闭左转向灯 + right_blinker.set_alpha(0) # 关闭右转向灯 + status_text.set_text('状态:变道完成') # 更新状态文本 + + # 更新本车位置:根据当前x、y坐标调整矩形左下角位置(基于中心偏移) + car.set_xy((current_x - car_length / 2, current_y - car_width / 2)) + + # 更新前后车位置:模拟相对静止(随本车同步移动,保持安全距离) + # 前车位置:本车x + 安全距离 + 车身长度/2(保证前车尾部与本车头部距离) + front_car.set_xy((current_x + safety_distance_front + car_length / 2, target_y - car_width / 2)) + # 后车位置:本车x - 安全距离 - 3*车身长度/2(保证后车头部与本车尾部距离) + back_car.set_xy((current_x - safety_distance_back - 3 * car_length / 2, target_y - car_width / 2)) + + # 边界处理:当本车完全驶出道路右端(x>100+2.25m)时,重置到道路左端 + if current_x > road_length + car_length / 2: + car.set_xy((-car_length / 2, current_y - car_width / 2)) # 左端重置位置 + + # 返回所有需要更新的图形元素(blit=True时只重绘这些元素,加速渲染) + return car, left_blinker, right_blinker, front_car, back_car, status_text + +# -------------------------- 生成动画 -------------------------- +# 创建动画对象:基于FuncAnimation(逐帧更新) +ani = animation.FuncAnimation( + fig, # 绘图画布 + update, # 每一帧的更新函数 + frames=num_frames, # 总帧数(0到num_frames-1) + interval=1000 / fps, # 帧间隔(单位:毫秒)=1000ms/帧率 + blit=True, # 开启blit优化(只重绘变化的元素,提升流畅度) + repeat=True # 动画循环播放 +) + +# 调整子图布局(避免元素重叠)并显示动画 +plt.tight_layout() +plt.show() + +# (可选)保存动画为GIF文件(需要安装pillow库) +# ani.save('autonomous_lane_change.gif', writer='pillow', fps=fps, dpi=150) \ No newline at end of file From f110e2dc438805caf8e1f885a142c63ebcfba838 Mon Sep 17 00:00:00 2001 From: ybnfsh <2329959058@qq.com> Date: Tue, 23 Dec 2025 15:12:26 +0800 Subject: [PATCH 7/7] 4491 --- src/driverless_car_yb/README.md | 21 --------------------- src/driverless_vehicle_management/README.md | 16 ++++++++++++++++ 2 files changed, 16 insertions(+), 21 deletions(-) delete mode 100644 src/driverless_car_yb/README.md create mode 100644 src/driverless_vehicle_management/README.md diff --git a/src/driverless_car_yb/README.md b/src/driverless_car_yb/README.md deleted file mode 100644 index bcc99b1b20..0000000000 --- a/src/driverless_car_yb/README.md +++ /dev/null @@ -1,21 +0,0 @@ -# 无人车项目 - -## 项目简介 -无人车(自动驾驶汽车)是一种集成了人工智能、传感器技术、计算机视觉和机器学习等前沿技术的智能交通工具。该项目旨在开发能够在复杂道路环境中自主导航、避障、识别交通标志并安全行驶的无人驾驶系统。 - -## 核心技术 -- **计算机视觉**:通过摄像头识别道路标志、车辆、行人等 -- **传感器融合**:整合激光雷达、毫米波雷达等传感器数据 -- **路径规划**:基于实时环境信息规划最优行驶路径 -- **决策系统**:处理复杂交通场景并做出驾驶决策 -- **机器学习**:通过深度学习模型提升驾驶安全性 - -## 主要功能 -- 自动跟车与变道 -- 智能避障与紧急制动 -- 自动泊车 -- 语音控制与导航 -- 实时路况分析 - -- ## 技术优势 -本项目采用模块化架构设计,支持多种传感器配置和算法策略,确保系统的可扩展性和稳定性 \ No newline at end of file diff --git a/src/driverless_vehicle_management/README.md b/src/driverless_vehicle_management/README.md new file mode 100644 index 0000000000..fc9f9f8326 --- /dev/null +++ b/src/driverless_vehicle_management/README.md @@ -0,0 +1,16 @@ +# 无人驾驶汽车项目 + +## 项目概述 + +无人驾驶汽车(Autonomous Vehicle)是一种集成了人工智能、传感器技术、计算机视觉和深度学习等前沿科技的智能交通工具。本项目旨在开发能够在复杂道路环境中实现完全自主导航、决策和控制的无人驾驶系统,为未来智能交通出行提供创新解决方案。 + +## 技术架构 + +本项目采用模块化的技术架构,主要包括以下核心模块: +… +本系统具备以下核心功能:自动跟车与智能变道、复杂场景下的障碍物检测与避让、自动泊车入位、语音控制与导航、实时交通状况分析与响应、以及紧急情况下的安全制动。这些功能共同构成了一个完整的自动驾驶解决方案,能够应对城市道路、高速公路、停车场等多种驾驶场景。 + +## 应用前景与价值 + +无人驾驶技术的发展将深刻改变人们的出行方式,提高道路安全性,缓解交通拥堵,降低能源消耗和碳排放。本项目将继续优化算法性能,拓展应用场景,推动自动驾驶技术的普及与商业化落地,为智能交通生态系统的建设贡献力量。 +