From 281345c3d9b4fc6261f03164cab5b8b14531077f Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Fri, 19 Dec 2025 14:35:25 +0800 Subject: [PATCH 1/7] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E9=80=89=E9=A2=98?= =?UTF-8?q?=E5=92=8CREADME=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/README.md | 61 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/mmap_drl_nav/README.md diff --git a/src/mmap_drl_nav/README.md b/src/mmap_drl_nav/README.md new file mode 100644 index 0000000000..b24190554a --- /dev/null +++ b/src/mmap_drl_nav/README.md @@ -0,0 +1,61 @@ +# 机器人导航系统 - 环境配置与运行手册 +## 一、环境设置 +运行本项目代码前,需确保开发环境满足以下依赖版本要求: +- Python 3.7 及以上版本 +- PyTorch 1.7 及以上版本 +- CARLA 模拟器 0.9.11 版本 +- 其余 Python 依赖项详见项目根目录下的 `requirements.txt` 文件 + +## 二、依赖安装步骤 +### 1. 克隆项目仓库 +```bash +git clone https://github.com/yourusername/robot_navigation_system.git +cd robot_navigation_system +``` + +### 2. 安装Python依赖 +```bash +pip install -r requirements.txt +``` + +> **重要提示**:需提前完成CARLA模拟器的安装,并正确配置相关环境变量。CARLA安装与配置可参考官方文档:[https://carla.readthedocs.io/en/latest/build_linux/](https://carla.readthedocs.io/en/latest/build_linux/) + +## 三、代码运行方法 +### 运行系统模拟 +执行以下命令可启动CARLA模拟器,加载完整的感知、注意力与决策模块,生成机器人导航策略: +```bash +python run_simulation.py +``` + +## 四、模型训练与测试 +### 1. 训练模型 +执行以下命令加载模拟数据集,训练感知、跨域注意力和决策模块: +```bash +python main.py --mode train +``` +> 说明:训练参数、超参数等可在 `main.py` 文件中按需配置。 + +### 2. 测试模型 +模型训练完成后,执行以下命令加载测试数据集,评估模型在新数据上的表现并输出测试损失: +```bash +python main.py --mode test +``` + +## 五、模型部署 +> 说明:智能车辆底层控制配置将后续发布,以下仅提供算法部署与推理的核心步骤。 + +### 1. Jetson_robot 模型训练与导出 +推理前需先训练模型,并将其导出为Jetson机器人兼容的ONNX格式: +```bash +python /_agent/_lightweight/train.py +``` + +### 2. 加载模型并推理 +```bash +python _jetson_robot/deploy.py --onnx_model_path /_model/mmap_model.onnx +``` + +### 总结 +1. 环境核心要求:Python 3.7+、PyTorch 1.7+、CARLA 0.9.11,需确保CARLA环境变量配置正确; +2. 核心操作命令:模拟运行用 `run_simulation.py`,模型训练/测试用 `main.py --mode [train/test]`; +3. Jetson部署关键步骤:先训练导出ONNX模型,再通过 `deploy.py` 指定模型路径加载推理。 \ No newline at end of file From 9289619176e9e6c0fb792cb0b7443581c0342821 Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Fri, 19 Dec 2025 15:53:06 +0800 Subject: [PATCH 2/7] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E9=80=89=E9=A2=98?= =?UTF-8?q?=E5=92=8CREADME=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/README.md | 25 +--- src/mmap_drl_nav/main.py | 59 ++++++++ src/mmap_drl_nav/run_simulation.py | 215 +++++++++++++++++++++++++++++ 3 files changed, 275 insertions(+), 24 deletions(-) create mode 100644 src/mmap_drl_nav/main.py create mode 100644 src/mmap_drl_nav/run_simulation.py diff --git a/src/mmap_drl_nav/README.md b/src/mmap_drl_nav/README.md index b24190554a..3ab8967222 100644 --- a/src/mmap_drl_nav/README.md +++ b/src/mmap_drl_nav/README.md @@ -7,19 +7,10 @@ - 其余 Python 依赖项详见项目根目录下的 `requirements.txt` 文件 ## 二、依赖安装步骤 -### 1. 克隆项目仓库 -```bash -git clone https://github.com/yourusername/robot_navigation_system.git -cd robot_navigation_system -``` - -### 2. 安装Python依赖 +### 1. 安装Python依赖 ```bash pip install -r requirements.txt ``` - -> **重要提示**:需提前完成CARLA模拟器的安装,并正确配置相关环境变量。CARLA安装与配置可参考官方文档:[https://carla.readthedocs.io/en/latest/build_linux/](https://carla.readthedocs.io/en/latest/build_linux/) - ## 三、代码运行方法 ### 运行系统模拟 执行以下命令可启动CARLA模拟器,加载完整的感知、注意力与决策模块,生成机器人导航策略: @@ -41,20 +32,6 @@ python main.py --mode train python main.py --mode test ``` -## 五、模型部署 -> 说明:智能车辆底层控制配置将后续发布,以下仅提供算法部署与推理的核心步骤。 - -### 1. Jetson_robot 模型训练与导出 -推理前需先训练模型,并将其导出为Jetson机器人兼容的ONNX格式: -```bash -python /_agent/_lightweight/train.py -``` - -### 2. 加载模型并推理 -```bash -python _jetson_robot/deploy.py --onnx_model_path /_model/mmap_model.onnx -``` - ### 总结 1. 环境核心要求:Python 3.7+、PyTorch 1.7+、CARLA 0.9.11,需确保CARLA环境变量配置正确; 2. 核心操作命令:模拟运行用 `run_simulation.py`,模型训练/测试用 `main.py --mode [train/test]`; diff --git a/src/mmap_drl_nav/main.py b/src/mmap_drl_nav/main.py new file mode 100644 index 0000000000..3756dc661d --- /dev/null +++ b/src/mmap_drl_nav/main.py @@ -0,0 +1,59 @@ +import torch +import torch.nn as nn +from torch.optim import Adam +from utils.dataloader import get_dataloader +from models.perception_module import PerceptionModule +from models.attention_module import CrossDomainAttention +from models.decision_module import DecisionModule +from models.sagm import SelfAssessmentGradientModel + +class IntegratedSystem: + def __init__(self, device='cpu', state_dim=128, action_dim=2): + self.device = device + self.perception = PerceptionModule().to(self.device) + self.attention = CrossDomainAttention(num_blocks=6).to(self.device) + self.decision = DecisionModule().to(self.device) + self.sagm = SelfAssessmentGradientModel(input_dim=state_dim + action_dim).to(self.device) + + def forward(self, image, lidar_data, imu_data, action): + scene_info, segmentation, odometry, obstacles, boundary = self.perception(imu_data, image, lidar_data) + fused_features = self.attention(scene_info, segmentation, odometry, obstacles, boundary) + + policy, value = self.decision(fused_features) + + sagm_q_value = self.sagm(fused_features, action) + return policy, value, sagm_q_value + +def train_model(model, dataloader, optimizer, device, num_epochs=10): + model.train() + for epoch in range(num_epochs): + running_loss = 0.0 + for i, (image, lidar_data, imu_data, target_action) in enumerate(dataloader): + image, lidar_data, imu_data, target_action = image.to(device), lidar_data.to(device), imu_data.to(device), target_action.to(device) + optimizer.zero_grad() + policy_output, value_output, sagm_q_value = model(image, lidar_data, imu_data, target_action) + + loss = (nn.MSELoss()(policy_output, target_action) + + nn.MSELoss()(value_output, target_action.sum(dim=1, keepdim=True)) + + nn.MSELoss()(sagm_q_value, target_action.sum(dim=1, keepdim=True))) + loss.backward() + optimizer.step() + running_loss += loss.item() + if i % 10 == 9: + print(f'Epoch [{epoch+1}/{num_epochs}], Batch [{i+1}/{len(dataloader)}], Loss: {running_loss / 10:.4f}') + running_loss = 0.0 + print('Training complete') + +def test_model(model, dataloader, device): + model.eval() + total_loss = 0.0 + with torch.no_grad(): + for image, lidar_data, imu_data, target_action in dataloader: + image, lidar_data, imu_data, target_action = image.to(device), lidar_data.to(device), imu_data.to(device), target_action.to(device) + policy_output, value_output, sagm_q_value = model(image, lidar_data, imu_data, target_action) + loss = (nn.MSELoss()(policy_output, target_action) + + nn.MSELoss()(value_output, target_action.sum(dim=1, keepdim=True)) + + nn.MSELoss()(sagm_q_value, target_action.sum(dim=1, keepdim=True))) + total_loss += loss.item() + avg_loss = total_loss / len(dataloader) + print(f'Test Average Loss: {avg_loss:.4f}') diff --git a/src/mmap_drl_nav/run_simulation.py b/src/mmap_drl_nav/run_simulation.py new file mode 100644 index 0000000000..f5d811617d --- /dev/null +++ b/src/mmap_drl_nav/run_simulation.py @@ -0,0 +1,215 @@ +import torch +import time +import logging +import carla +from typing import Tuple, Optional +from models.perception_module import PerceptionModule +from models.attention_module import CrossDomainAttention +from models.decision_module import DecisionModule +from models.dqn_agent import DQNAgent +from envs.carla_environment import CarlaEnvironment + +# 配置日志 +logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.StreamHandler() + ] +) +logger = logging.getLogger(__name__) + +# 系统配置 +CONFIG = { + "simulation_steps": 100, + "step_delay": 0.1, + "carla_host": "localhost", + "carla_port": 2000, + "image_size": (3, 256, 256), + "lidar_size": (1, 256, 256), + "imu_size": (1, 6), + "max_throttle": 1.0, + "max_steer": 1.0 +} + + +class IntegratedSystem: + """ + 自动驾驶集成系统,整合感知、注意力和决策模块 + """ + + def __init__(self, device: str = 'cpu'): + self.device = torch.device(device) + self.logger = logging.getLogger(self.__class__.__name__) + + # 初始化各个模块 + try: + self.perception = PerceptionModule().to(self.device) + self.attention = CrossDomainAttention(num_blocks=6).to(self.device) + self.decision = DecisionModule().to(self.device) + self.logger.info(f"成功初始化所有模块,使用设备: {self.device}") + except Exception as e: + self.logger.error(f"模块初始化失败: {e}") + raise + + def forward(self, image: torch.Tensor, lidar_data: torch.Tensor, imu_data: torch.Tensor) -> Tuple[ + torch.Tensor, torch.Tensor]: + """ + 前向传播,处理输入数据并输出策略和价值 + + Args: + image: 图像数据 [B, 3, H, W] + lidar_data: LiDAR数据 [B, 1, H, W] + imu_data: IMU数据 [B, 6] + + Returns: + policy: 决策策略 [B, num_actions] + value: 状态价值 [B, 1] + """ + try: + # 感知模块处理 + scene_info, segmentation, odometry, obstacles, boundary = self.perception(imu_data, image, lidar_data) + + # 跨域注意力融合特征 + fused_features = self.attention(scene_info, segmentation, odometry, obstacles, boundary) + + # 决策模块输出 + policy, value = self.decision(fused_features) + + return policy, value + except Exception as e: + self.logger.error(f"前向传播过程出错: {e}") + raise + + +def init_carla_environment(host: str = "localhost", port: int = 2000) -> Optional[CarlaEnvironment]: + """ + 初始化CARLA环境 + + Args: + host: CARLA服务器地址 + port: CARLA服务器端口 + + Returns: + 初始化后的CarlaEnvironment实例 + """ + try: + env = CarlaEnvironment(host=host, port=port) + # 等待环境加载完成 + time.sleep(2.0) + logger.info(f"成功连接到CARLA服务器 {host}:{port}") + + # 检查车辆是否正确初始化 + if hasattr(env, 'vehicle') and env.vehicle is not None: + logger.info("CARLA车辆已成功初始化") + else: + logger.error("CARLA车辆初始化失败") + return None + + return env + except Exception as e: + logger.error(f"CARLA环境初始化失败: {e}") + return None + + +def clamp_control_values(throttle: float, steer: float) -> Tuple[float, float]: + """ + 限制控制信号在合法范围内 + + Args: + throttle: 油门值 + steer: 转向值 + + Returns: + 限制后的油门和转向值 + """ + # 限制油门在 0-1 之间 + throttle_clamped = max(0.0, min(CONFIG["max_throttle"], throttle)) + # 限制转向在 -1 到 1 之间 + steer_clamped = max(-CONFIG["max_steer"], min(CONFIG["max_steer"], steer)) + + return throttle_clamped, steer_clamped + + +def run_simulation(): + """运行CARLA仿真主函数""" + # 1. 初始化CARLA环境 + env = init_carla_environment( + host=CONFIG["carla_host"], + port=CONFIG["carla_port"] + ) + if env is None: + logger.error("无法初始化CARLA环境,退出仿真") + return + + # 2. 初始化集成系统 + try: + device = 'cuda' if torch.cuda.is_available() else 'cpu' + system = IntegratedSystem(device=device) + logger.info(f"集成系统初始化完成,使用设备: {device}") + except Exception as e: + logger.error(f"集成系统初始化失败: {e}") + return + + # 3. 运行仿真步骤 + logger.info(f"开始运行{CONFIG['simulation_steps']}步仿真") + for step in range(CONFIG["simulation_steps"]): + try: + # 生成模拟输入数据(实际应用中应从CARLA环境获取真实数据) + image = torch.randn(*CONFIG["image_size"]).unsqueeze(0).to(system.device) + lidar_data = torch.randn(*CONFIG["lidar_size"]).unsqueeze(0).to(system.device) + imu_data = torch.randn(*CONFIG["imu_size"]).to(system.device) + + # 前向传播获取决策 + policy, value = system.forward(image, lidar_data, imu_data) + + # 转换并限制控制信号 + throttle, steer = clamp_control_values( + float(policy[0][0]), + float(policy[0][1]) + ) + + # 应用控制信号到车辆 + control = carla.VehicleControl(throttle=throttle, steer=steer) + env.vehicle.apply_control(control) + + # 日志输出 + if step % 10 == 0: # 每10步输出一次日志 + logger.info( + f"仿真步骤 {step:3d} | 油门: {throttle:.3f} | " + f"转向: {steer:.3f} | 状态价值: {value[0][0]:.3f}" + ) + + # 模拟步骤间延迟 + time.sleep(CONFIG["step_delay"]) + + except Exception as e: + logger.error(f"仿真步骤 {step} 出错: {e}") + continue + + # 4. 清理资源 + try: + # 停止车辆 + env.vehicle.apply_control(carla.VehicleControl(throttle=0.0, brake=1.0)) + time.sleep(1.0) + + # 清理CARLA环境 + if hasattr(env, 'cleanup'): + env.cleanup() + + logger.info("仿真完成,已清理所有资源") + except Exception as e: + logger.error(f"清理资源时出错: {e}") + + +if __name__ == "__main__": + # 设置随机种子以保证可复现性 + torch.manual_seed(42) + + # 运行仿真 + try: + run_simulation() + except KeyboardInterrupt: + logger.info("用户中断了仿真") + except Exception as e: + logger.error(f"仿真运行出错: {e}") \ No newline at end of file From 12476158b57bf588a0d4c0541dae18ca6f9a9a95 Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Fri, 19 Dec 2025 17:12:17 +0800 Subject: [PATCH 3/7] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E9=80=89=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/README.md | 39 +----- src/mmap_drl_nav/main.py | 59 -------- src/mmap_drl_nav/run_simulation.py | 215 ----------------------------- 3 files changed, 1 insertion(+), 312 deletions(-) delete mode 100644 src/mmap_drl_nav/main.py delete mode 100644 src/mmap_drl_nav/run_simulation.py diff --git a/src/mmap_drl_nav/README.md b/src/mmap_drl_nav/README.md index 3ab8967222..d22090f08c 100644 --- a/src/mmap_drl_nav/README.md +++ b/src/mmap_drl_nav/README.md @@ -1,38 +1 @@ -# 机器人导航系统 - 环境配置与运行手册 -## 一、环境设置 -运行本项目代码前,需确保开发环境满足以下依赖版本要求: -- Python 3.7 及以上版本 -- PyTorch 1.7 及以上版本 -- CARLA 模拟器 0.9.11 版本 -- 其余 Python 依赖项详见项目根目录下的 `requirements.txt` 文件 - -## 二、依赖安装步骤 -### 1. 安装Python依赖 -```bash -pip install -r requirements.txt -``` -## 三、代码运行方法 -### 运行系统模拟 -执行以下命令可启动CARLA模拟器,加载完整的感知、注意力与决策模块,生成机器人导航策略: -```bash -python run_simulation.py -``` - -## 四、模型训练与测试 -### 1. 训练模型 -执行以下命令加载模拟数据集,训练感知、跨域注意力和决策模块: -```bash -python main.py --mode train -``` -> 说明:训练参数、超参数等可在 `main.py` 文件中按需配置。 - -### 2. 测试模型 -模型训练完成后,执行以下命令加载测试数据集,评估模型在新数据上的表现并输出测试损失: -```bash -python main.py --mode test -``` - -### 总结 -1. 环境核心要求:Python 3.7+、PyTorch 1.7+、CARLA 0.9.11,需确保CARLA环境变量配置正确; -2. 核心操作命令:模拟运行用 `run_simulation.py`,模型训练/测试用 `main.py --mode [train/test]`; -3. Jetson部署关键步骤:先训练导出ONNX模型,再通过 `deploy.py` 指定模型路径加载推理。 \ No newline at end of file +我的选题是机器人导航系统 diff --git a/src/mmap_drl_nav/main.py b/src/mmap_drl_nav/main.py deleted file mode 100644 index 3756dc661d..0000000000 --- a/src/mmap_drl_nav/main.py +++ /dev/null @@ -1,59 +0,0 @@ -import torch -import torch.nn as nn -from torch.optim import Adam -from utils.dataloader import get_dataloader -from models.perception_module import PerceptionModule -from models.attention_module import CrossDomainAttention -from models.decision_module import DecisionModule -from models.sagm import SelfAssessmentGradientModel - -class IntegratedSystem: - def __init__(self, device='cpu', state_dim=128, action_dim=2): - self.device = device - self.perception = PerceptionModule().to(self.device) - self.attention = CrossDomainAttention(num_blocks=6).to(self.device) - self.decision = DecisionModule().to(self.device) - self.sagm = SelfAssessmentGradientModel(input_dim=state_dim + action_dim).to(self.device) - - def forward(self, image, lidar_data, imu_data, action): - scene_info, segmentation, odometry, obstacles, boundary = self.perception(imu_data, image, lidar_data) - fused_features = self.attention(scene_info, segmentation, odometry, obstacles, boundary) - - policy, value = self.decision(fused_features) - - sagm_q_value = self.sagm(fused_features, action) - return policy, value, sagm_q_value - -def train_model(model, dataloader, optimizer, device, num_epochs=10): - model.train() - for epoch in range(num_epochs): - running_loss = 0.0 - for i, (image, lidar_data, imu_data, target_action) in enumerate(dataloader): - image, lidar_data, imu_data, target_action = image.to(device), lidar_data.to(device), imu_data.to(device), target_action.to(device) - optimizer.zero_grad() - policy_output, value_output, sagm_q_value = model(image, lidar_data, imu_data, target_action) - - loss = (nn.MSELoss()(policy_output, target_action) + - nn.MSELoss()(value_output, target_action.sum(dim=1, keepdim=True)) + - nn.MSELoss()(sagm_q_value, target_action.sum(dim=1, keepdim=True))) - loss.backward() - optimizer.step() - running_loss += loss.item() - if i % 10 == 9: - print(f'Epoch [{epoch+1}/{num_epochs}], Batch [{i+1}/{len(dataloader)}], Loss: {running_loss / 10:.4f}') - running_loss = 0.0 - print('Training complete') - -def test_model(model, dataloader, device): - model.eval() - total_loss = 0.0 - with torch.no_grad(): - for image, lidar_data, imu_data, target_action in dataloader: - image, lidar_data, imu_data, target_action = image.to(device), lidar_data.to(device), imu_data.to(device), target_action.to(device) - policy_output, value_output, sagm_q_value = model(image, lidar_data, imu_data, target_action) - loss = (nn.MSELoss()(policy_output, target_action) + - nn.MSELoss()(value_output, target_action.sum(dim=1, keepdim=True)) + - nn.MSELoss()(sagm_q_value, target_action.sum(dim=1, keepdim=True))) - total_loss += loss.item() - avg_loss = total_loss / len(dataloader) - print(f'Test Average Loss: {avg_loss:.4f}') diff --git a/src/mmap_drl_nav/run_simulation.py b/src/mmap_drl_nav/run_simulation.py deleted file mode 100644 index f5d811617d..0000000000 --- a/src/mmap_drl_nav/run_simulation.py +++ /dev/null @@ -1,215 +0,0 @@ -import torch -import time -import logging -import carla -from typing import Tuple, Optional -from models.perception_module import PerceptionModule -from models.attention_module import CrossDomainAttention -from models.decision_module import DecisionModule -from models.dqn_agent import DQNAgent -from envs.carla_environment import CarlaEnvironment - -# 配置日志 -logging.basicConfig( - level=logging.INFO, - format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', - handlers=[ - logging.StreamHandler() - ] -) -logger = logging.getLogger(__name__) - -# 系统配置 -CONFIG = { - "simulation_steps": 100, - "step_delay": 0.1, - "carla_host": "localhost", - "carla_port": 2000, - "image_size": (3, 256, 256), - "lidar_size": (1, 256, 256), - "imu_size": (1, 6), - "max_throttle": 1.0, - "max_steer": 1.0 -} - - -class IntegratedSystem: - """ - 自动驾驶集成系统,整合感知、注意力和决策模块 - """ - - def __init__(self, device: str = 'cpu'): - self.device = torch.device(device) - self.logger = logging.getLogger(self.__class__.__name__) - - # 初始化各个模块 - try: - self.perception = PerceptionModule().to(self.device) - self.attention = CrossDomainAttention(num_blocks=6).to(self.device) - self.decision = DecisionModule().to(self.device) - self.logger.info(f"成功初始化所有模块,使用设备: {self.device}") - except Exception as e: - self.logger.error(f"模块初始化失败: {e}") - raise - - def forward(self, image: torch.Tensor, lidar_data: torch.Tensor, imu_data: torch.Tensor) -> Tuple[ - torch.Tensor, torch.Tensor]: - """ - 前向传播,处理输入数据并输出策略和价值 - - Args: - image: 图像数据 [B, 3, H, W] - lidar_data: LiDAR数据 [B, 1, H, W] - imu_data: IMU数据 [B, 6] - - Returns: - policy: 决策策略 [B, num_actions] - value: 状态价值 [B, 1] - """ - try: - # 感知模块处理 - scene_info, segmentation, odometry, obstacles, boundary = self.perception(imu_data, image, lidar_data) - - # 跨域注意力融合特征 - fused_features = self.attention(scene_info, segmentation, odometry, obstacles, boundary) - - # 决策模块输出 - policy, value = self.decision(fused_features) - - return policy, value - except Exception as e: - self.logger.error(f"前向传播过程出错: {e}") - raise - - -def init_carla_environment(host: str = "localhost", port: int = 2000) -> Optional[CarlaEnvironment]: - """ - 初始化CARLA环境 - - Args: - host: CARLA服务器地址 - port: CARLA服务器端口 - - Returns: - 初始化后的CarlaEnvironment实例 - """ - try: - env = CarlaEnvironment(host=host, port=port) - # 等待环境加载完成 - time.sleep(2.0) - logger.info(f"成功连接到CARLA服务器 {host}:{port}") - - # 检查车辆是否正确初始化 - if hasattr(env, 'vehicle') and env.vehicle is not None: - logger.info("CARLA车辆已成功初始化") - else: - logger.error("CARLA车辆初始化失败") - return None - - return env - except Exception as e: - logger.error(f"CARLA环境初始化失败: {e}") - return None - - -def clamp_control_values(throttle: float, steer: float) -> Tuple[float, float]: - """ - 限制控制信号在合法范围内 - - Args: - throttle: 油门值 - steer: 转向值 - - Returns: - 限制后的油门和转向值 - """ - # 限制油门在 0-1 之间 - throttle_clamped = max(0.0, min(CONFIG["max_throttle"], throttle)) - # 限制转向在 -1 到 1 之间 - steer_clamped = max(-CONFIG["max_steer"], min(CONFIG["max_steer"], steer)) - - return throttle_clamped, steer_clamped - - -def run_simulation(): - """运行CARLA仿真主函数""" - # 1. 初始化CARLA环境 - env = init_carla_environment( - host=CONFIG["carla_host"], - port=CONFIG["carla_port"] - ) - if env is None: - logger.error("无法初始化CARLA环境,退出仿真") - return - - # 2. 初始化集成系统 - try: - device = 'cuda' if torch.cuda.is_available() else 'cpu' - system = IntegratedSystem(device=device) - logger.info(f"集成系统初始化完成,使用设备: {device}") - except Exception as e: - logger.error(f"集成系统初始化失败: {e}") - return - - # 3. 运行仿真步骤 - logger.info(f"开始运行{CONFIG['simulation_steps']}步仿真") - for step in range(CONFIG["simulation_steps"]): - try: - # 生成模拟输入数据(实际应用中应从CARLA环境获取真实数据) - image = torch.randn(*CONFIG["image_size"]).unsqueeze(0).to(system.device) - lidar_data = torch.randn(*CONFIG["lidar_size"]).unsqueeze(0).to(system.device) - imu_data = torch.randn(*CONFIG["imu_size"]).to(system.device) - - # 前向传播获取决策 - policy, value = system.forward(image, lidar_data, imu_data) - - # 转换并限制控制信号 - throttle, steer = clamp_control_values( - float(policy[0][0]), - float(policy[0][1]) - ) - - # 应用控制信号到车辆 - control = carla.VehicleControl(throttle=throttle, steer=steer) - env.vehicle.apply_control(control) - - # 日志输出 - if step % 10 == 0: # 每10步输出一次日志 - logger.info( - f"仿真步骤 {step:3d} | 油门: {throttle:.3f} | " - f"转向: {steer:.3f} | 状态价值: {value[0][0]:.3f}" - ) - - # 模拟步骤间延迟 - time.sleep(CONFIG["step_delay"]) - - except Exception as e: - logger.error(f"仿真步骤 {step} 出错: {e}") - continue - - # 4. 清理资源 - try: - # 停止车辆 - env.vehicle.apply_control(carla.VehicleControl(throttle=0.0, brake=1.0)) - time.sleep(1.0) - - # 清理CARLA环境 - if hasattr(env, 'cleanup'): - env.cleanup() - - logger.info("仿真完成,已清理所有资源") - except Exception as e: - logger.error(f"清理资源时出错: {e}") - - -if __name__ == "__main__": - # 设置随机种子以保证可复现性 - torch.manual_seed(42) - - # 运行仿真 - try: - run_simulation() - except KeyboardInterrupt: - logger.info("用户中断了仿真") - except Exception as e: - logger.error(f"仿真运行出错: {e}") \ No newline at end of file From 48921ee2cb8151c69f9e289ad0b7d2fa7039f582 Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Sat, 20 Dec 2025 17:18:35 +0800 Subject: [PATCH 4/7] =?UTF-8?q?=E6=9B=B4=E6=96=B0READMA=E6=96=87=E4=BB=B6?= =?UTF-8?q?=EF=BC=8C=E9=85=8D=E7=BD=AE=E7=8E=AF=E5=A2=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/README.md | 43 +++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/src/mmap_drl_nav/README.md b/src/mmap_drl_nav/README.md index d22090f08c..bd8e78c6ad 100644 --- a/src/mmap_drl_nav/README.md +++ b/src/mmap_drl_nav/README.md @@ -1 +1,42 @@ -我的选题是机器人导航系统 +# 多模式机器人导航系统 +## 项目概述 +你要开发的多模式机器人导航系统,核心是融合IMU、摄像头、激光雷达等多传感器数据,通过感知、跨域注意力、决策三大模块协作,最终输出机器人的行动策略,该系统基于CARLA 0.9.11模拟器开发,并采用深度学习技术完成训练与测试。 + +## 环境设置 +### 1. 基础环境要求 +- Python版本:3.7及以上 +- PyTorch版本:1.7及以上(建议匹配CUDA版本以提升训练效率) +- CARLA模拟器版本:0.9.11(需保证客户端与服务端版本一致) + +### 2. 快速配置步骤 +```bash +# 1. 创建并激活虚拟环境 +conda create -n robot_nav python=3.7 -y +conda activate robot_nav + +# 2. 安装PyTorch(以CUDA 11.0为例,可按需调整) +pip install torch==1.7.1+cu110 torchvision==0.8.2+cu110 -f https://download.pytorch.org/whl/torch_stable.html + +# 3. 安装CARLA 0.9.11 +pip install carla==0.9.11 + +# 4. 补充常用依赖 +pip install numpy opencv-python scipy matplotlib +``` + +### 3. 环境验证 +```bash +# 验证Python版本 +python --version + +# 验证PyTorch +python -c "import torch; print(f'PyTorch版本:{torch.__version__},CUDA可用:{torch.cuda.is_available()}')" + +# 验证CARLA(需先启动CARLA 0.9.11服务端) +python -c "import carla; client=carla.Client('localhost',2000); client.set_timeout(5.0); print('CARLA连接成功' if client.get_world() else 'CARLA连接失败')" +``` + +## 总结 +1. 环境核心要求:Python 3.7+、PyTorch 1.7+、CARLA 0.9.11,版本匹配是关键。 +2. 配置流程:先创建虚拟环境,再依次安装PyTorch、CARLA及辅助依赖,最后验证环境可用性。 +3. 系统核心逻辑:通过三大模块融合多传感器数据,基于CARLA模拟器实现机器人导航策略输出。 \ No newline at end of file From 4b7542b0af304a9a55ae8277c17fe41c4bc82f27 Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Sun, 21 Dec 2025 02:46:45 +0800 Subject: [PATCH 5/7] =?UTF-8?q?=E6=8F=90=E4=BA=A4main.py,=E6=9B=B4?= =?UTF-8?q?=E6=96=B0README=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/README.md | 185 +++++++++++++++++++++++++++++-------- src/mmap_drl_nav/main.py | 59 ++++++++++++ 2 files changed, 207 insertions(+), 37 deletions(-) create mode 100644 src/mmap_drl_nav/main.py diff --git a/src/mmap_drl_nav/README.md b/src/mmap_drl_nav/README.md index bd8e78c6ad..6478c655b2 100644 --- a/src/mmap_drl_nav/README.md +++ b/src/mmap_drl_nav/README.md @@ -1,42 +1,153 @@ -# 多模式机器人导航系统 -## 项目概述 -你要开发的多模式机器人导航系统,核心是融合IMU、摄像头、激光雷达等多传感器数据,通过感知、跨域注意力、决策三大模块协作,最终输出机器人的行动策略,该系统基于CARLA 0.9.11模拟器开发,并采用深度学习技术完成训练与测试。 - -## 环境设置 -### 1. 基础环境要求 -- Python版本:3.7及以上 -- PyTorch版本:1.7及以上(建议匹配CUDA版本以提升训练效率) -- CARLA模拟器版本:0.9.11(需保证客户端与服务端版本一致) - -### 2. 快速配置步骤 -```bash -# 1. 创建并激活虚拟环境 -conda create -n robot_nav python=3.7 -y -conda activate robot_nav - -# 2. 安装PyTorch(以CUDA 11.0为例,可按需调整) -pip install torch==1.7.1+cu110 torchvision==0.8.2+cu110 -f https://download.pytorch.org/whl/torch_stable.html - -# 3. 安装CARLA 0.9.11 -pip install carla==0.9.11 - -# 4. 补充常用依赖 -pip install numpy opencv-python scipy matplotlib -``` +# CARLA 智能驾驶导航仿真系统 + +## 项目介绍 +本项目基于 CARLA 模拟器与 PyTorch 框架,实现了一套智能驾驶导航仿真系统。核心功能包括:CARLA 环境连接与车辆生成、多传感器数据(图像/激光雷达/IMU)模拟、跨域注意力特征融合、智能决策输出与车辆控制,可直接运行并直观观察车辆在虚拟场景中的行驶状态。 + +项目解决了新手常见的模块导入、张量维度适配、CARLA 连接配置等问题,形成完整的仿真闭环,可作为智能驾驶算法开发与验证的基础框架。 + +## 核心功能 +- CARLA 环境自动化初始化(连接、车辆生成、资源清理) +- 多源传感器数据模拟与输入适配 +- 跨域注意力模块实现多模态特征融合 +- 决策模块输出车辆控制指令(油门、转向) +- 持续仿真循环,支持直观观察车辆运动状态 + +## 环境依赖 +### 1. 基础环境 +- 操作系统:Windows 10/11(64位) +- Python 版本:3.7.x(推荐 3.7.9) +- 虚拟环境:venv(项目内置,或重新创建) -### 3. 环境验证 -```bash -# 验证Python版本 -python --version +### 2. 核心依赖库 +| 库名称 | 版本要求 | 安装命令 | +|--------------|---------------------------|--------------------------------------------------------------------------| +| PyTorch | 1.10.2+cpu | pip install torch==1.10.2+cpu torchvision==0.11.3+cpu -f https://download.pytorch.org/whl/cpu/torch_stable.html -i https://pypi.tuna.tsinghua.edu.cn/simple | +| CARLA | 0.9.13(与模拟器版本一致) | pip install carla==0.9.13 -i https://pypi.tuna.tsinghua.edu.cn/simple | +| NumPy | 任意兼容版本 | pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple | +| OpenCV-Python| 任意兼容版本 | pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple | -# 验证PyTorch -python -c "import torch; print(f'PyTorch版本:{torch.__version__},CUDA可用:{torch.cuda.is_available()}')" +### 3. CARLA 模拟器 +- 版本:CARLA 0.9.13(Windows 版本) +- 下载地址:[CARLA 0.9.13 官方下载](https://github.com/carla-simulator/carla/releases/tag/0.9.13) +- 存放路径:推荐 D:\carla\WindowsNoEditor(需与后续启动命令适配) -# 验证CARLA(需先启动CARLA 0.9.11服务端) -python -c "import carla; client=carla.Client('localhost',2000); client.set_timeout(5.0); print('CARLA连接成功' if client.get_world() else 'CARLA连接失败')" +## 项目结构 ``` +robot_nav_sys/ +├─ envs/ # 环境模块(CARLA 交互核心) +│ ├─ __init__.py # 模块标识文件(空文件即可) +│ └─ carla_environment.py # CARLA 环境初始化、车辆生成与控制 +├─ models/ # 模型模块(特征融合与决策) +│ ├─ __init__.py # 模块标识文件(空文件即可) +│ ├─ attention_module.py # 跨域注意力模块(多模态特征融合) +│ └─ decision_module.py # 决策模块(输出油门、转向控制指令) +├─ venv/ # 虚拟环境(存放依赖库) +├─ run_simulation.py # 仿真入口(核心运行文件) +└─ README.md # 项目说明文档(本文档) +``` + +## 快速运行步骤 +⚠️ 关键顺序:必须先启动 CARLA 模拟器,再运行项目代码! + +### 步骤 1:启动 CARLA 模拟器(端口 2000) +1. 打开 Windows 命令提示符(CMD),执行以下命令切换到 CARLA 目录: + ```bash + # 切换到 D 盘 + D: + # 进入 CARLA 模拟器目录(根据实际路径调整) + cd carla\WindowsNoEditor + ``` +2. 执行命令启动模拟器(强制指定端口 2000,确保与代码连接匹配): + ```bash + CarlaUE4.exe -carla-port=2000 + ``` +3. 等待 5-10 秒,直到弹出 CARLA 3D 窗口(显示 Town01 城镇场景,无「未响应」标识)。 + +### 步骤 2:启动项目仿真 +1. 新开一个 CMD 窗口(不要关闭模拟器窗口),执行以下命令切换到项目目录: + ```bash + # 切换到 D 盘 + D: + # 进入项目根目录(根据实际路径调整) + cd carla_work\robot_nav_sys + ``` +2. 激活虚拟环境: + ```bash + venv\Scripts\activate.bat + ``` + ✅ 激活成功标志:窗口开头出现 `(venv)` 前缀 +3. 安装依赖库(若未安装): + ```bash + # 执行「环境依赖」章节中的所有 pip 安装命令 + ``` +4. 运行仿真代码: + ```bash + python run_simulation.py + ``` + +### 步骤 3:观察仿真效果 +1. 切换到 CARLA 模拟器窗口,按住鼠标右键拖动调整视角,滚轮缩放,找到白色 Toyota 车辆(生成位置默认:x=100, y=100, z=2)。 +2. 观察到车辆以 0.5 油门持续前进,小幅转向,完成 50 步仿真循环。 +3. 仿真结束后,终端会输出「✅ 仿真结束,CARLA 环境已清理」,车辆自动销毁,资源释放。 + +## 关键功能说明 +### 1. 环境模块(envs/carla_environment.py) +- 初始化:连接 CARLA 模拟器(超时时间 20 秒),获取虚拟世界。 +- 车辆生成:使用 Toyota 车型蓝图,支持 3 次重试机制,避免生成失败;无预设生成点时自动创建手动生成点。 +- 车辆控制:接收油门、转向指令,裁剪到合法范围(油门 0~1,转向 -1~1)。 +- 资源清理:仿真结束后自动销毁车辆,关闭模拟器连接。 + +### 2. 模型模块 +- attention_module.py:跨域注意力模块,统一多模态张量维度(2 维/4 维 → 2 维),通过多块注意力层融合特征。 +- decision_module.py:决策模块,将融合后的 1024 维特征映射到 256 维,最终输出 2 维控制指令(油门、转向)和 1 维价值估计。 + +### 3. 仿真入口(run_simulation.py) +- 集成环境与模型,构建完整仿真闭环。 +- 支持 50 步持续仿真,固定油门 0.5 确保车辆运动,小幅转向避免跑偏。 +- 实时打印仿真状态(每 10 步输出一次油门、转向、价值),方便观察运行情况。 + +## 常见问题解决 +### 1. 连接 CARLA 失败:time-out of 20000ms +- 原因:CARLA 模拟器未启动、端口不匹配、端口被占用。 +- 解决: + 1. 确认 CarlaUE4.exe 已启动,且窗口显示城镇场景。 + 2. 重新执行「步骤 1」,确保用命令 `CarlaUE4.exe -carla-port=2000` 强制指定端口。 + 3. 检查端口 2000 是否被占用,执行命令 `netstat -ano | findstr :2000`,结束占用进程(`taskkill /F /PID 进程号`)。 + +### 2. 虚拟环境激活失败:系统找不到指定的路径 +- 原因:虚拟环境文件夹名错误(非 venv)、路径拼写错误。 +- 解决: + 1. 执行 `dir` 命令查看项目目录下的虚拟环境文件夹名(可能为 env、environment 等)。 + 2. 根据实际文件夹名修改激活命令,例如:`env\Scripts\activate.bat`。 + 3. 若无虚拟环境,执行 `python -m venv venv` 重新创建。 + +### 3. 车辆生成失败 / 找不到车辆 +- 原因:车辆蓝图不兼容、生成点坐标不合理。 +- 解决: + 1. 修改 envs/carla_environment.py 中的车辆蓝图,将 `toyota` 替换为 `model3` 或 `carlacola`。 + 2. 调整手动生成点坐标,例如:`spawn_points = [carla.Transform(carla.Location(x=200, y=200, z=2))]`。 + 3. 在 CARLA 窗口中按住鼠标右键拖动视角,缩放查找车辆。 + +### 4. Lazy modules 警告(非报错) +- 警告信息:`UserWarning: Lazy modules are a new feature under heavy development...` +- 解决:可忽略,不影响运行;若想关闭,在 run_simulation.py 开头添加: + ```python + import warnings + warnings.filterwarnings("ignore", category=UserWarning) + ``` + +## 扩展方向 +- 替换传感器数据:将 run_simulation.py 中的示例数据(image、lidar_data 等)替换为 CARLA 真实传感器采集的数据(需添加传感器配置代码)。 +- 优化决策算法:在 decision_module.py 中集成 DQN、PPO 等强化学习算法,实现自主导航训练。 +- 丰富场景配置:添加障碍物、交通灯、不同城镇地图(修改 CARLA 环境加载逻辑)。 +- 增加可视化:添加传感器数据可视化、车辆轨迹绘制功能。 + +## 注意事项 +- Python 版本必须为 3.7.x,否则可能导致 PyTorch 或 CARLA 库安装失败。 +- CARLA 模拟器与 carla 库版本必须一致(均为 0.9.13),否则会出现兼容性错误。 +- 仿真过程中不要关闭 CARLA 窗口或 CMD 窗口,否则会导致资源泄漏(车辆无法自动销毁)。 +- 若 CARLA 窗口卡顿,可关闭其他占用显卡的程序,或降低模拟器画质(在 CARLA 窗口设置中调整)。 -## 总结 -1. 环境核心要求:Python 3.7+、PyTorch 1.7+、CARLA 0.9.11,版本匹配是关键。 -2. 配置流程:先创建虚拟环境,再依次安装PyTorch、CARLA及辅助依赖,最后验证环境可用性。 -3. 系统核心逻辑:通过三大模块融合多传感器数据,基于CARLA模拟器实现机器人导航策略输出。 \ No newline at end of file +## 致谢 +- CARLA 官方文档:[CARLA 官方文档](https://carla.readthedocs.io/) +- PyTorch 官方文档:[PyTorch 官方文档](https://pytorch.org/docs/stable/index.html) diff --git a/src/mmap_drl_nav/main.py b/src/mmap_drl_nav/main.py new file mode 100644 index 0000000000..3756dc661d --- /dev/null +++ b/src/mmap_drl_nav/main.py @@ -0,0 +1,59 @@ +import torch +import torch.nn as nn +from torch.optim import Adam +from utils.dataloader import get_dataloader +from models.perception_module import PerceptionModule +from models.attention_module import CrossDomainAttention +from models.decision_module import DecisionModule +from models.sagm import SelfAssessmentGradientModel + +class IntegratedSystem: + def __init__(self, device='cpu', state_dim=128, action_dim=2): + self.device = device + self.perception = PerceptionModule().to(self.device) + self.attention = CrossDomainAttention(num_blocks=6).to(self.device) + self.decision = DecisionModule().to(self.device) + self.sagm = SelfAssessmentGradientModel(input_dim=state_dim + action_dim).to(self.device) + + def forward(self, image, lidar_data, imu_data, action): + scene_info, segmentation, odometry, obstacles, boundary = self.perception(imu_data, image, lidar_data) + fused_features = self.attention(scene_info, segmentation, odometry, obstacles, boundary) + + policy, value = self.decision(fused_features) + + sagm_q_value = self.sagm(fused_features, action) + return policy, value, sagm_q_value + +def train_model(model, dataloader, optimizer, device, num_epochs=10): + model.train() + for epoch in range(num_epochs): + running_loss = 0.0 + for i, (image, lidar_data, imu_data, target_action) in enumerate(dataloader): + image, lidar_data, imu_data, target_action = image.to(device), lidar_data.to(device), imu_data.to(device), target_action.to(device) + optimizer.zero_grad() + policy_output, value_output, sagm_q_value = model(image, lidar_data, imu_data, target_action) + + loss = (nn.MSELoss()(policy_output, target_action) + + nn.MSELoss()(value_output, target_action.sum(dim=1, keepdim=True)) + + nn.MSELoss()(sagm_q_value, target_action.sum(dim=1, keepdim=True))) + loss.backward() + optimizer.step() + running_loss += loss.item() + if i % 10 == 9: + print(f'Epoch [{epoch+1}/{num_epochs}], Batch [{i+1}/{len(dataloader)}], Loss: {running_loss / 10:.4f}') + running_loss = 0.0 + print('Training complete') + +def test_model(model, dataloader, device): + model.eval() + total_loss = 0.0 + with torch.no_grad(): + for image, lidar_data, imu_data, target_action in dataloader: + image, lidar_data, imu_data, target_action = image.to(device), lidar_data.to(device), imu_data.to(device), target_action.to(device) + policy_output, value_output, sagm_q_value = model(image, lidar_data, imu_data, target_action) + loss = (nn.MSELoss()(policy_output, target_action) + + nn.MSELoss()(value_output, target_action.sum(dim=1, keepdim=True)) + + nn.MSELoss()(sagm_q_value, target_action.sum(dim=1, keepdim=True))) + total_loss += loss.item() + avg_loss = total_loss / len(dataloader) + print(f'Test Average Loss: {avg_loss:.4f}') From 52585d2389828fb9e0c4ad0638e34475cdb9a89f Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Sun, 21 Dec 2025 13:38:55 +0800 Subject: [PATCH 6/7] =?UTF-8?q?=E4=BB=BF=E7=9C=9F=E5=BE=AA=E7=8E=AF?= =?UTF-8?q?=E5=BB=B6=E9=95=BF=E5=88=B0=20100=20=E6=AD=A5=EF=BC=8C=E6=B2=B9?= =?UTF-8?q?=E9=97=A8=E5=9B=BA=E5=AE=9A=200.6=EF=BC=88=E8=BD=A6=E8=BE=86?= =?UTF-8?q?=E8=A1=8C=E9=A9=B6=E6=98=8E=E6=98=BE=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/run_simulation.py | 105 +++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 src/mmap_drl_nav/run_simulation.py diff --git a/src/mmap_drl_nav/run_simulation.py b/src/mmap_drl_nav/run_simulation.py new file mode 100644 index 0000000000..9786294870 --- /dev/null +++ b/src/mmap_drl_nav/run_simulation.py @@ -0,0 +1,105 @@ +import torch +import time +import numpy as np +from envs.carla_environment import CarlaEnvironment +from models.attention_module import CrossDomainAttention +from models.decision_module import DecisionModule + +# 关闭Lazy modules警告 +import warnings + +warnings.filterwarnings("ignore", category=UserWarning) + + +class IntegratedSystem: + def __init__(self, device='cpu'): + self.device = device + # 初始化注意力模块和决策模块 + self.attention = CrossDomainAttention().to(device) + self.decision = DecisionModule().to(device) + + def forward(self, image, lidar, imu): + """前向传播:融合特征并输出决策""" + # 数据移到指定设备 + image = image.to(self.device) + lidar = lidar.to(self.device) + imu = imu.to(self.device) + + # 特征融合 + fused_feature = self.attention(image, lidar, imu) + # 决策输出 + policy, value = self.decision(fused_feature) + return policy, value + + +def run_simulation(): + # 1. 初始化CARLA环境 + env = None + try: + env = CarlaEnvironment(host='localhost', port=2000) + time.sleep(2) # 等待模拟器加载 + if not env.reset(): + raise RuntimeError("车辆生成失败!") + print("✅ CARLA环境初始化完成,车辆已生成") + except Exception as e: + print(f"❌ CARLA初始化失败:{e}") + if env: + env.close() + return + + # 2. 初始化智能体系统 + try: + system = IntegratedSystem(device='cpu') + print("✅ 智能体系统初始化完成") + except Exception as e: + print(f"❌ 智能体系统初始化失败:{e}") + env.close() + return + + # 3. 持续仿真循环(运行100步,足够看到车辆行驶) + try: + total_steps = 100 # 延长到100步,车辆行驶更久 + print(f"\n🚀 开始仿真({total_steps}步),请查看CARLA窗口!") + + for step in range(total_steps): + # 模拟传感器数据 + image = torch.randn(1, 3, 224, 224) + lidar_data = torch.randn(1, 1, 64, 64) + imu_data = torch.randn(1, 6) + + # 前向计算 + policy, value = system.forward(image, lidar_data, imu_data) + + # 固定油门0.6(车辆明显行驶),小幅转向 + throttle = 0.6 + steer = np.clip(policy.detach().cpu().numpy()[0][1], -0.1, 0.1) + + # 控制车辆 + env.control_vehicle(throttle, steer) + + # 每10步打印状态 + if step % 10 == 0: + print(f"🔹 第{step}步:油门={throttle:.2f},转向={steer:.2f},价值={value.item():.2f}") + + time.sleep(0.1) # 仿真步长 + + print("\n✅ 持续仿真结束!") + except Exception as e: + print(f"❌ 仿真出错:{e}") + finally: + # 4. 清理环境 + env.close() + print("✅ 仿真结束,CARLA环境已清理") + + +if __name__ == "__main__": + # 修复:替换不存在的 torch.version.python,改用 sys 模块获取Python版本 + import sys + + print(f"📌 Python版本:{sys.version.split()[0]}") + print(f"📌 PyTorch版本:{torch.__version__}") + print(f"📌 CUDA可用:{torch.cuda.is_available()}") + print("=" * 50) + + # 运行仿真 + run_simulation() \ No newline at end of file From 64a715a67bc11b6922647b195cf79a17d2e8dc4a Mon Sep 17 00:00:00 2001 From: LELlierle <2958542913@qq.com> Date: Sun, 21 Dec 2025 23:48:31 +0800 Subject: [PATCH 7/7] =?UTF-8?q?=E4=BC=98=E5=8C=96run=5Fsimulation.py?= =?UTF-8?q?=EF=BC=8C=E4=BD=BF=E5=B0=8F=E8=BD=A6=E8=A1=8C=E9=A9=B6=E5=B9=B3?= =?UTF-8?q?=E7=A8=B3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/mmap_drl_nav/run_simulation.py | 48 +++++++++++------------------- 1 file changed, 18 insertions(+), 30 deletions(-) diff --git a/src/mmap_drl_nav/run_simulation.py b/src/mmap_drl_nav/run_simulation.py index 9786294870..5eedaae020 100644 --- a/src/mmap_drl_nav/run_simulation.py +++ b/src/mmap_drl_nav/run_simulation.py @@ -1,11 +1,12 @@ import torch import time import numpy as np +import sys from envs.carla_environment import CarlaEnvironment from models.attention_module import CrossDomainAttention from models.decision_module import DecisionModule -# 关闭Lazy modules警告 +# 关闭警告 import warnings warnings.filterwarnings("ignore", category=UserWarning) @@ -14,40 +15,34 @@ class IntegratedSystem: def __init__(self, device='cpu'): self.device = device - # 初始化注意力模块和决策模块 self.attention = CrossDomainAttention().to(device) self.decision = DecisionModule().to(device) def forward(self, image, lidar, imu): - """前向传播:融合特征并输出决策""" - # 数据移到指定设备 image = image.to(self.device) lidar = lidar.to(self.device) imu = imu.to(self.device) - - # 特征融合 fused_feature = self.attention(image, lidar, imu) - # 决策输出 policy, value = self.decision(fused_feature) return policy, value def run_simulation(): - # 1. 初始化CARLA环境 + # 初始化CARLA环境 env = None try: env = CarlaEnvironment(host='localhost', port=2000) - time.sleep(2) # 等待模拟器加载 + time.sleep(2) if not env.reset(): raise RuntimeError("车辆生成失败!") - print("✅ CARLA环境初始化完成,车辆已生成") + print("✅ CARLA环境初始化完成") except Exception as e: print(f"❌ CARLA初始化失败:{e}") if env: env.close() return - # 2. 初始化智能体系统 + # 初始化智能体系统 try: system = IntegratedSystem(device='cpu') print("✅ 智能体系统初始化完成") @@ -56,10 +51,10 @@ def run_simulation(): env.close() return - # 3. 持续仿真循环(运行100步,足够看到车辆行驶) + # 平稳仿真循环(100步,足够看直线行驶) try: - total_steps = 100 # 延长到100步,车辆行驶更久 - print(f"\n🚀 开始仿真({total_steps}步),请查看CARLA窗口!") + total_steps = 100 + print(f"\n🚀 开始平稳仿真({total_steps}步),车辆沿道路直线行驶!") for step in range(total_steps): # 模拟传感器数据 @@ -67,39 +62,32 @@ def run_simulation(): lidar_data = torch.randn(1, 1, 64, 64) imu_data = torch.randn(1, 6) - # 前向计算 + # 模型决策 policy, value = system.forward(image, lidar_data, imu_data) - # 固定油门0.6(车辆明显行驶),小幅转向 - throttle = 0.6 - steer = np.clip(policy.detach().cpu().numpy()[0][1], -0.1, 0.1) + # 提取转向(仅保留极小值) + raw_steer = policy.detach().cpu().numpy()[0][1] + steer = np.clip(raw_steer, -0.05, 0.05) # 再次限幅 - # 控制车辆 - env.control_vehicle(throttle, steer) + # 控制车辆(油门已在环境中固定为0.5) + env.control_vehicle(0.5, steer) # 每10步打印状态 if step % 10 == 0: - print(f"🔹 第{step}步:油门={throttle:.2f},转向={steer:.2f},价值={value.item():.2f}") + print(f"🔹 第{step}步:转向={steer:.3f},价值={value.item():.2f}") - time.sleep(0.1) # 仿真步长 + time.sleep(0.15) # 稍快的步长,行驶更流畅 - print("\n✅ 持续仿真结束!") + print("\n✅ 仿真结束!车辆全程沿道路直线行驶~") except Exception as e: print(f"❌ 仿真出错:{e}") finally: - # 4. 清理环境 env.close() - print("✅ 仿真结束,CARLA环境已清理") if __name__ == "__main__": - # 修复:替换不存在的 torch.version.python,改用 sys 模块获取Python版本 - import sys - print(f"📌 Python版本:{sys.version.split()[0]}") print(f"📌 PyTorch版本:{torch.__version__}") print(f"📌 CUDA可用:{torch.cuda.is_available()}") print("=" * 50) - - # 运行仿真 run_simulation() \ No newline at end of file