From bd3533c93010e528ca91d457029252b6d78fda15 Mon Sep 17 00:00:00 2001 From: MKHQ07 Date: Thu, 18 Dec 2025 18:10:32 +0800 Subject: [PATCH 1/4] =?UTF-8?q?=E4=BD=8D=E5=A7=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/driverless_car/README.md | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/src/driverless_car/README.md b/src/driverless_car/README.md index 930234d00c..3f471f9983 100644 --- a/src/driverless_car/README.md +++ b/src/driverless_car/README.md @@ -11,4 +11,30 @@ ### 1. 依赖库安装 项目基于Python和PyTorch实现,需安装以下依赖库: ```bash -pip install torch torchvision matplotlib numpy \ No newline at end of file +pip install torch torchvision matplotlib numpy +无人机网格路径规划(强化学习 Q-Learning 实现) +这是一个基于强化学习(Q-Learning)和网格地图的无人机路径规划项目,实现了无人机在含障碍物的二维网格中自主避障并规划从起点到终点的最优路径,全程通过代码模拟(无需硬件),并提供了美观的可视化界面展示训练过程和路径结果。 +项目介绍 +核心功能 +自定义 gymnasium 网格环境,包含起点、终点、随机障碍物 +基于 Q-Learning 算法训练智能体,学习上下左右移动的最优策略 +实时可视化无人机的移动路径、网格环境和训练奖励变化 +优化的可视化界面,支持坐标标注、路径方向箭头、移动平均奖励曲线 +技术栈 +环境搭建:gymnasium(gym 的维护版)自定义网格环境 +强化学习算法:Q-Learning(ε- 贪心策略平衡探索与利用) +可视化:matplotlib(绘制网格、路径、奖励曲线) +数值计算:numpy +安装依赖 +1. 卸载旧版 gym(可选) +bash +运行 +pip uninstall gym -y +2. 安装依赖库(使用国内镜像源加速) +bash +运行 +# 基础依赖(推荐) +pip install gymnasium numpy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple + +# 若需要gymnasium完整版(包含额外环境,如Atari) +pip install gymnasium[all] -i https://pypi.tuna.tsinghua.edu.cn/simple \ No newline at end of file From 9df5107d9a47af64b10ea3ab8929b4d66f8cb76b Mon Sep 17 00:00:00 2001 From: MKHQ07 Date: Thu, 18 Dec 2025 19:21:59 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E4=BD=8D=E5=A7=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/driverless_car/README.md | 155 +++++++++++++++++++++++++++-------- 1 file changed, 122 insertions(+), 33 deletions(-) diff --git a/src/driverless_car/README.md b/src/driverless_car/README.md index 3f471f9983..2728d19145 100644 --- a/src/driverless_car/README.md +++ b/src/driverless_car/README.md @@ -1,40 +1,129 @@ -# 无人机图像分类深度学习Demo(无硬件/仿真依赖) -该项目实现了**无人机图像分类**的深度学习简单方向demo,无需无人机硬件和仿真软件,通过公开数据集模拟无人机采集的图像数据,搭建轻量化卷积神经网络(CNN)完成分类任务,并提供数据显示和可视化界面,帮助新手理解无人机深度学习的基本流程。 -## 项目特点 -- 🚀 **无硬件依赖**:使用CIFAR-10公开数据集模拟无人机航拍图像,无需无人机硬件和仿真软件。 -- 🧠 **轻量化模型**:搭建适用于无人机端的轻量化CNN,兼顾性能与算力消耗。 -- 📊 **可视化界面**:包含数据集样本展示、训练过程实时可视化、预测结果展示三大可视化模块。 -- 🐞 **兼容性修复**:解决Matplotlib中文字体缺失、PyCharm后端兼容等问题,可直接运行。 +# 无人机深度学习项目集合 + +本项目集合包含两个无人机相关的深度学习Demo,均基于代码仿真实现,无需硬件依赖。 + +--- + +## 项目1:无人机图像分类深度学习Demo + +### 项目简介 +该项目实现了**无人机图像分类**的深度学习Demo,使用公开数据集模拟无人机采集的图像数据,搭建轻量化卷积神经网络(CNN)完成分类任务。 + +### 主要特点 +- 🚀 **无硬件依赖**:使用CIFAR-10公开数据集模拟无人机航拍图像 +- 🧠 **轻量化模型**:搭建适用于无人机端的轻量化CNN,兼顾性能与算力消耗 +- 📊 **可视化界面**:包含数据集样本展示、训练过程实时可视化、预测结果展示 +- 🐞 **兼容性修复**:解决Matplotlib中文字体缺失、PyCharm后端兼容等问题 + +### 技术栈 +- Python + PyTorch +- torchvision (数据集处理) +- matplotlib (可视化) +- numpy (数值计算) + +--- + +## 项目2:无人机网格路径规划(强化学习 Q-Learning 实现) + +### 项目简介 +基于强化学习(Q-Learning)和网格地图的无人机路径规划项目,实现了无人机在含障碍物的二维网格中自主避障并规划从起点到终点的最优路径。 + +### 核心功能 +- 自定义 gymnasium 网格环境,包含起点、终点、随机障碍物 +- 基于 Q-Learning 算法训练智能体,学习上下左右移动的最优策略 +- 实时可视化无人机的移动路径、网格环境和训练奖励变化 +- 优化的可视化界面,支持坐标标注、路径方向箭头、移动平均奖励曲线 + +### 技术栈 +- **环境搭建**:gymnasium(gym 的维护版)自定义网格环境 +- **强化学习算法**:Q-Learning(ε-贪心策略平衡探索与利用) +- **可视化**:matplotlib(绘制网格、路径、奖励曲线) +- **数值计算**:numpy + +--- ## 环境配置 -### 1. 依赖库安装 -项目基于Python和PyTorch实现,需安装以下依赖库: + +### 基础依赖安装 + +推荐使用国内镜像源加速安装: + ```bash -pip install torch torchvision matplotlib numpy -无人机网格路径规划(强化学习 Q-Learning 实现) -这是一个基于强化学习(Q-Learning)和网格地图的无人机路径规划项目,实现了无人机在含障碍物的二维网格中自主避障并规划从起点到终点的最优路径,全程通过代码模拟(无需硬件),并提供了美观的可视化界面展示训练过程和路径结果。 -项目介绍 -核心功能 -自定义 gymnasium 网格环境,包含起点、终点、随机障碍物 -基于 Q-Learning 算法训练智能体,学习上下左右移动的最优策略 -实时可视化无人机的移动路径、网格环境和训练奖励变化 -优化的可视化界面,支持坐标标注、路径方向箭头、移动平均奖励曲线 -技术栈 -环境搭建:gymnasium(gym 的维护版)自定义网格环境 -强化学习算法:Q-Learning(ε- 贪心策略平衡探索与利用) -可视化:matplotlib(绘制网格、路径、奖励曲线) -数值计算:numpy -安装依赖 -1. 卸载旧版 gym(可选) -bash -运行 -pip uninstall gym -y -2. 安装依赖库(使用国内镜像源加速) -bash -运行 # 基础依赖(推荐) -pip install gymnasium numpy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple +pip install torch torchvision matplotlib numpy gymnasium -i https://pypi.tuna.tsinghua.edu.cn/simple # 若需要gymnasium完整版(包含额外环境,如Atari) -pip install gymnasium[all] -i https://pypi.tuna.tsinghua.edu.cn/simple \ No newline at end of file +pip install gymnasium[all] -i https://pypi.tuna.tsinghua.edu.cn/simple +``` + +### 卸载旧版依赖(可选) +```bash +# 卸载旧版 gym(如果存在冲突) +pip uninstall gym -y +``` + +### 系统要求 +- Python 3.7+ +- 支持CUDA的GPU(可选,用于加速训练) + +--- + +## 项目结构 + +``` +无人机深度学习项目/ +├── README.md # 项目说明文档 +├── 图像分类项目/ # 无人机图像分类Demo +│ ├── main.py # 主程序入口 +│ ├── model.py # CNN模型定义 +│ ├── train.py # 训练脚本 +│ ├── visualize.py # 可视化工具 +│ └── utils.py # 工具函数 +└── 路径规划项目/ # 无人机路径规划Demo + ├── main.py # 主程序入口 + ├── environment.py # 网格环境定义 + ├── q_learning.py # Q-Learning算法实现 + ├── visualization.py # 可视化工具 + └── utils.py # 工具函数 +``` + +--- + +## 使用说明 + +### 图像分类项目 +1. 运行主程序开始训练和测试 +2. 查看数据集样本展示 +3. 观察训练过程可视化 +4. 测试模型预测效果 + +### 路径规划项目 +1. 启动网格环境 +2. 运行Q-Learning训练过程 +3. 观察路径规划结果 +4. 查看训练奖励变化曲线 + +--- + +## 注意事项 + +- 项目完全基于代码仿真,无需真实无人机硬件 +- 可在普通PC上运行,建议配置支持CUDA的GPU以加速训练 +- 所有可视化界面均已优化,兼容中文显示 +- 代码已处理常见的兼容性问题,可直接在PyCharm等IDE中运行 + +--- + +## 贡献指南 + +欢迎提交Issue和Pull Request来改进项目! + +--- + +## 许可证 + +本项目采用MIT许可证,详见LICENSE文件。 + +--- + From 65767bfed742a6dc8b3d80cb596b4a882bfe508a Mon Sep 17 00:00:00 2001 From: MKHQ07 Date: Thu, 18 Dec 2025 19:50:25 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E4=BD=8D=E5=A7=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/driverless_car/main_run.py | 494 +++++++++++---------------------- 1 file changed, 165 insertions(+), 329 deletions(-) diff --git a/src/driverless_car/main_run.py b/src/driverless_car/main_run.py index 92d72c914f..de60642468 100644 --- a/src/driverless_car/main_run.py +++ b/src/driverless_car/main_run.py @@ -1,349 +1,185 @@ -import tkinter as tk -from tkinter import ttk, messagebox import numpy as np -import matplotlib.pyplot as plt -from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader -import time +import matplotlib.pyplot as plt import random - -# 设置中文显 示 -plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"] -plt.rcParams["axes.unicode_minus"] = False - - - -# 1. 数据生成与预处理(模拟无人机飞行数据) -class DroneSpeedDataset(Dataset): - """无人机速度控制数据集(模拟数据)""" - - def __init__(self, num_samples=10000, dt=0.1): - self.dt = dt # 采样时间间隔(秒) - self.data = self._generate_data(num_samples) - - def _generate_data(self, num_samples): - """生成模拟数据:输入为速度误差、误差变化率,输出为最优控制量""" - data = [] - # 模拟不同目标速度(-5~5 m/s,无人机水平速度范围) - target_speeds = np.random.uniform(-5, 5, num_samples) - # 初始速度 - current_speeds = np.random.uniform(-3, 3, num_samples) - - for v_target, v_current in zip(target_speeds, current_speeds): - # 计算误差 - error = v_target - v_current - # 误差变化率(简化:假设上一时刻误差为当前误差的0.8倍) - error_dot = (error - 0.8 * error) / self.dt - # 用PID公式生成"最优"控制量(作为标签) - # 控制量范围:0~1(归一化的电机输出) - kp, ki, kd = 0.1, 0.01, 0.05 - control = 0.5 + kp * error + kd * error_dot - control = np.clip(control, 0.0, 1.0) # 限制范围 - - # 加入噪声(模拟真实环境) - error += np.random.normal(0, 0.1) - error_dot += np.random.normal(0, 0.05) - - data.append((error, error_dot, control)) - return np.array(data, dtype=np.float32) +import os + +# -------------------------- 修复Matplotlib后端问题(核心新增代码) -------------------------- +# 方案一:强制设置Matplotlib后端,避开PyCharm的兼容问题 +plt.switch_backend('TkAgg') # 优先用TkAgg后端(需安装tkinter,大部分环境已预装) +# 如果TkAgg报错,可替换为以下后端: +# plt.switch_backend('Agg') # 无界面后端,需配合保存图片使用 +# plt.switch_backend('Qt5Agg') # 需安装PyQt5 + +# -------------------------- 1. 配置参数 -------------------------- +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") +img_size = (64, 64) +batch_size = 32 +epochs = 30 +lr = 1e-3 +threshold = 0.02 + +# -------------------------- 2. 代码生成模拟无人机巡检数据 -------------------------- +def generate_normal_sample(): + """生成单张正常的无人机巡检图像(3通道,64x64)""" + img = np.ones((img_size[0], img_size[1], 3), dtype=np.float32) * 0.5 + # 绘制网格纹理 + for i in range(0, img_size[0], 4): + img[i, :, :] = 0.1 + for j in range(0, img_size[1], 4): + img[:, j, :] = 0.1 + # 添加噪声 + noise = np.random.normal(0, 0.02, img.shape).astype(np.float32) + img = np.clip(img + noise, 0, 1) + return img + +def generate_abnormal_sample(): + """生成单张异常的无人机巡检图像(3通道,64x64)""" + img = generate_normal_sample() + # 制造异常区域 + x1 = random.randint(10, 30) + y1 = random.randint(10, 30) + x2 = random.randint(30, 50) + y2 = random.randint(30, 50) + img[x1:x2, y1:y2, :] = np.random.uniform(0.7, 1.0, (x2-x1, y2-y1, 3)) + return img + +# 自定义数据集 +class DroneInspectionDataset(Dataset): + def __init__(self, is_normal, sample_num=1000): + self.sample_num = sample_num + self.is_normal = is_normal def __len__(self): - return len(self.data) + return self.sample_num def __getitem__(self, idx): - x = self.data[idx, :2] # 输入:误差、误差变化率 - y = self.data[idx, 2:] # 输出:控制量 - return torch.tensor(x), torch.tensor(y) - - -# 2. 深度学习控制器模型 -class SpeedController(nn.Module): - """基于MLP的速度控制器""" - - def __init__(self, input_dim=2, hidden_dim=64, output_dim=1): - super(SpeedController, self).__init__() - self.network = nn.Sequential( - nn.Linear(input_dim, hidden_dim), - nn.ReLU(), - nn.Linear(hidden_dim, hidden_dim // 2), - nn.ReLU(), - nn.Linear(hidden_dim // 2, output_dim), - nn.Sigmoid() # 输出控制量(0~1) + if self.is_normal: + img = generate_normal_sample() + else: + img = generate_abnormal_sample() + # 转换为张量:(H, W, C) → (C, H, W) + img_tensor = torch.from_numpy(img).permute(2, 0, 1) + img_tensor = (img_tensor - 0.5) / 0.5 # 归一化到[-1,1] + return img_tensor + +# -------------------------- 3. 定义轻量化自编码器模型 -------------------------- +class LightweightAutoencoder(nn.Module): + def __init__(self): + super(LightweightAutoencoder, self).__init__() + # 编码器:3通道输入 + self.encoder = nn.Sequential( + nn.Conv2d(3, 16, 3, stride=2, padding=1), # 3→16,64→32 + nn.ReLU(True), + nn.Conv2d(16, 32, 3, stride=2, padding=1), # 16→32,32→16 + nn.ReLU(True), + nn.Conv2d(32, 64, 3, stride=2, padding=1), # 32→64,16→8 + nn.ReLU(True) + ) + # 解码器:3通道输出 + self.decoder = nn.Sequential( + nn.ConvTranspose2d(64, 32, 3, stride=2, padding=1, output_padding=1), # 8→16 + nn.ReLU(True), + nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1), # 16→32 + nn.ReLU(True), + nn.ConvTranspose2d(16, 3, 3, stride=2, padding=1, output_padding=1), # 32→64,输出3通道 + nn.Tanh() ) def forward(self, x): - return self.network(x) - - -# 3. 模型训练函数 -def train_controller(num_epochs=50, batch_size=64): - # 生成数据集 - dataset = DroneSpeedDataset(num_samples=20000) - train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True) - - # 初始化模型、损失函数和优化器 - model = SpeedController() + # 自动处理维度:3维→4维(添加batch维度) + if len(x.shape) == 3: + x = x.unsqueeze(0) # (C,H,W) → (1,C,H,W) + encoded = self.encoder(x) + decoded = self.decoder(encoded) + return decoded + +# -------------------------- 4. 训练自编码器 -------------------------- +def train_model(): + train_dataset = DroneInspectionDataset(is_normal=True, sample_num=1000) + train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) + + model = LightweightAutoencoder().to(device) criterion = nn.MSELoss() - optimizer = optim.Adam(model.parameters(), lr=0.001) + optimizer = optim.Adam(model.parameters(), lr=lr) - # 训练过程 - loss_history = [] - for epoch in range(num_epochs): - model.train() + # 训练 + model.train() + for epoch in range(epochs): total_loss = 0.0 - for x, y in train_loader: + for data in train_loader: + img = data.to(device) + output = model(img) + loss = criterion(output, img) + # 反向传播 optimizer.zero_grad() - outputs = model(x) - loss = criterion(outputs, y) loss.backward() optimizer.step() - total_loss += loss.item() * x.size(0) - - avg_loss = total_loss / len(dataset) - loss_history.append(avg_loss) - if (epoch + 1) % 10 == 0: - print(f"Epoch [{epoch + 1}/{num_epochs}], 平均损失: {avg_loss:.6f}") - - # 保存模型 - torch.save(model.state_dict(), "speed_controller.pth") - return model, loss_history - - -# 4. 无人机速度控制仿真 -class DroneSimulator: - """无人机速度控制仿真器(简化物理模型)""" - - def __init__(self, dt=0.1): - self.dt = dt # 采样时间 - self.current_speed = 0.0 # 当前速度(m/s) - self.mass = 1.5 # 无人机质量(kg) - self.drag_coef = 0.2 # 阻力系数 - self.max_thrust = 5.0 # 最大推力(N) - - def update(self, control): - """根据控制量更新速度""" - # 控制量(0~1)映射到推力 - thrust = control * self.max_thrust - # 合力 = 推力 - 阻力(阻力与速度平方成正比) - drag = self.drag_coef * self.current_speed ** 2 * np.sign(self.current_speed) - force = thrust - drag - # 加速度 = 合力 / 质量 - acceleration = force / self.mass - # 更新速度(加入噪声模拟风干扰) - self.current_speed += acceleration * self.dt + np.random.normal(0, 0.05) - # 限制最大速度(-8~8 m/s) - self.current_speed = np.clip(self.current_speed, -8, 8) - return self.current_speed - - -# 5. 可视化控制界面 -class SpeedControlVisualizer: - def __init__(self, root): - self.root = root - self.root.title("无人机速度控制可视化系统") - self.root.geometry("1000x700") - - # 控制参数 - self.dt = 0.1 # 控制频率(10Hz) - self.target_speed = 2.0 # 初始目标速度(m/s) - self.running = False - self.data = { - "time": [], - "current_speed": [], - "target_speed": [], - "error": [], - "control": [] - } - self.max_points = 200 # 最大显示数据点 - - # 初始化组件 - self._init_ui() - self._init_plots() - - # 初始化模型和仿真器 - self.model = None - self.simulator = DroneSimulator(dt=self.dt) - - def _init_ui(self): - """创建UI控件""" - # 控制面板 - control_frame = ttk.LabelFrame(self.root, text="控制参数") - control_frame.pack(side=tk.TOP, fill=tk.X, padx=10, pady=5) - - # 目标速度设置 - ttk.Label(control_frame, text="目标速度 (m/s):").grid(row=0, column=0, padx=5, pady=5) - self.target_entry = ttk.Entry(control_frame, width=10) - self.target_entry.insert(0, str(self.target_speed)) - self.target_entry.grid(row=0, column=1, padx=5, pady=5) - - # 模型控制按钮 - self.train_btn = ttk.Button(control_frame, text="训练模型", command=self.train_model) - self.train_btn.grid(row=0, column=2, padx=5, pady=5) - - self.start_btn = ttk.Button(control_frame, text="开始控制", command=self.start_control, state=tk.DISABLED) - self.start_btn.grid(row=0, column=3, padx=5, pady=5) - - self.pause_btn = ttk.Button(control_frame, text="暂停", command=self.pause_control, state=tk.DISABLED) - self.pause_btn.grid(row=0, column=4, padx=5, pady=5) - - # 状态显示 - self.status_var = tk.StringVar(value="就绪 | 模型状态: 未训练") - ttk.Label(control_frame, textvariable=self.status_var).grid(row=0, column=5, padx=20, pady=5) - - def _init_plots(self): - """初始化绘图区域""" - self.fig, (self.ax1, self.ax2) = plt.subplots(2, 1, figsize=(9, 6), sharex=True) - self.canvas = FigureCanvasTkAgg(self.fig, master=self.root) - self.canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True, padx=10, pady=5) - - # 速度曲线(上半部分) - self.line_current, = self.ax1.plot([], [], label="当前速度", color='blue', linewidth=2) - self.line_target, = self.ax1.plot([], [], label="目标速度", color='red', linestyle='--', linewidth=1.5) - self.ax1.set_ylabel("速度 (m/s)") - self.ax1.set_title("无人机速度跟踪曲线") - self.ax1.grid(True) - self.ax1.legend() - self.ax1.set_ylim(-6, 6) # 速度范围 - - # 误差和控制量曲线(下半部分) - self.line_error, = self.ax2.plot([], [], label="速度误差", color='green', linewidth=2) - self.ax2_twin = self.ax2.twinx() # 双Y轴 - self.line_control, = self.ax2_twin.plot([], [], label="控制量", color='orange', linewidth=2, alpha=0.7) - self.ax2.set_xlabel("时间 (秒)") - self.ax2.set_ylabel("误差 (m/s)") - self.ax2_twin.set_ylabel("控制量 (0~1)") - self.ax2.set_title("速度误差与控制量变化") - self.ax2.grid(True) - self.ax2.set_ylim(-4, 4) # 误差范围 - self.ax2_twin.set_ylim(0, 1) # 控制量范围 - # 合并图例 - lines = [self.line_error, self.line_control] - self.ax2.legend(lines, [l.get_label() for l in lines], loc='upper left') - - self.fig.tight_layout() - - def train_model(self): - """训练深度学习控制器""" - self.status_var.set("开始训练模型...") - self.root.update() - - try: - # 训练模型 - self.model, loss_history = train_controller(num_epochs=50) - self.status_var.set("模型训练完成") - self.start_btn.config(state=tk.NORMAL) - - # 显示训练损失曲线 - self._plot_loss_curve(loss_history) - except Exception as e: - messagebox.showerror("训练失败", str(e)) - self.status_var.set(f"训练失败: {str(e)}") - - def _plot_loss_curve(self, loss_history): - """显示训练损失曲线""" - # 创建新窗口显示损失曲线 - loss_window = tk.Toplevel(self.root) - loss_window.title("训练损失曲线") - loss_window.geometry("600x400") - - fig, ax = plt.subplots(figsize=(6, 4)) - ax.plot(range(1, len(loss_history) + 1), loss_history, color='purple') - ax.set_title("模型训练损失") - ax.set_xlabel("Epoch") - ax.set_ylabel("MSE损失") - ax.grid(True) - - canvas = FigureCanvasTkAgg(fig, master=loss_window) - canvas.draw() - canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True) - - def start_control(self): - """开始速度控制""" - # 更新目标速度 - try: - self.target_speed = float(self.target_entry.get()) - except ValueError: - messagebox.showerror("输入错误", "目标速度必须是数字") - return - - self.running = True - self.start_btn.config(state=tk.DISABLED) - self.pause_btn.config(state=tk.NORMAL) - self.status_var.set(f"控制中 | 目标速度: {self.target_speed} m/s") - - # 重置仿真器 - self.simulator = DroneSimulator(dt=self.dt) - # 启动控制循环 - self._control_loop() - - def pause_control(self): - """暂停控制""" - self.running = False - self.start_btn.config(state=tk.NORMAL) - self.pause_btn.config(state=tk.DISABLED) - self.status_var.set(f"已暂停 | 当前速度: {self.data['current_speed'][-1]:.2f} m/s") - - def _control_loop(self): - """控制循环(实时更新速度和控制量)""" - if not self.running: - return - - # 获取当前时间 - t = self.data["time"][-1] + self.dt if self.data["time"] else 0.0 - - # 1. 计算当前状态 - current_speed = self.simulator.current_speed - error = self.target_speed - current_speed - # 计算误差变化率 - error_dot = (error - self.data["error"][-1]) / self.dt if self.data["error"] else 0.0 - - # 2. 深度学习模型计算控制量 - model_input = torch.tensor([[error, error_dot]], dtype=torch.float32) - with torch.no_grad(): - control = self.model(model_input).item() # 输出0~1 - - # 3. 更新无人机速度 - new_speed = self.simulator.update(control) - - # 4. 保存数据 - self.data["time"].append(t) - self.data["current_speed"].append(new_speed) - self.data["target_speed"].append(self.target_speed) - self.data["error"].append(error) - self.data["control"].append(control) - - # 限制数据长度 - if len(self.data["time"]) > self.max_points: - for key in self.data: - self.data[key].pop(0) - - # 5. 更新绘图 - self._update_plots() - - # 6. 循环调用(模拟实时控制) - self.root.after(int(self.dt * 1000), self._control_loop) - - def _update_plots(self): - """更新图表""" - # 更新速度曲线 - self.line_current.set_data(self.data["time"], self.data["current_speed"]) - self.line_target.set_data(self.data["time"], self.data["target_speed"]) - - # 更新误差和控制量曲线 - self.line_error.set_data(self.data["time"], self.data["error"]) - self.line_control.set_data(self.data["time"], self.data["control"]) - - # 自动调整X轴范围 - for ax in [self.ax1, self.ax2, self.ax2_twin]: - ax.set_xlim(max(0, self.data["time"][-1] - 20), self.data["time"][-1] + 1) # 显示最近20秒数据 - - self.canvas.draw() - - + total_loss += loss.item() * data.size(0) + avg_loss = total_loss / len(train_loader.dataset) + print(f"Epoch [{epoch+1}/{epochs}], Average Loss: {avg_loss:.6f}") + print("训练完成!") + return model + +# -------------------------- 5. 异常检测测试 -------------------------- +def test_anomaly_detection(model): + model.eval() + # 生成测试样本:5正常+5异常 + test_normal = DroneInspectionDataset(is_normal=True, sample_num=5) + test_abnormal = DroneInspectionDataset(is_normal=False, sample_num=5) + # 拼接测试样本:(10,3,64,64) + test_samples = torch.stack([test_normal[i] for i in range(5)] + [test_abnormal[i] for i in range(5)]) + test_labels = [0]*5 + [1]*5 # 0=正常,1=异常 + + # 计算重构误差 + errors = [] + with torch.no_grad(): + for img in test_samples: + img = img.to(device) + output = model(img) + # 还原到[0,1]计算误差 + img_01 = (img + 1) / 2 # (3,64,64) + output_01 = (output.squeeze(0) + 1) / 2 # 去掉batch维度 + error = nn.MSELoss()(output_01, img_01).item() + errors.append(error) + + # 可视化结果(修复后) + plt.figure(figsize=(15, 8)) + for i in range(len(test_samples)): + # 处理图像用于显示:(C,H,W) → (H,W,C) + img = (test_samples[i].permute(1, 2, 0).cpu().numpy() + 1) / 2 + error = errors[i] + is_anomaly = error > threshold + # 绘制 + plt.subplot(2, 5, i+1) + plt.imshow(img) + plt.title(f"Label: {'Normal' if test_labels[i]==0 else 'Abnormal'}\nError: {error:.4f}\nDetect: {'Anomaly' if is_anomaly else 'Normal'}") + plt.axis('off') + plt.tight_layout() + + # -------------------------- 修复可视化的核心修改 -------------------------- + try: + # 尝试显示图像 + plt.show() + except Exception as e: + # 如果显示失败,保存图像到本地(方案二兜底) + print(f"显示图像失败:{e},将保存图像到本地") + # 创建保存目录(如果不存在) + if not os.path.exists("drone_anomaly_results"): + os.makedirs("drone_anomaly_results") + # 保存图像 + plt.savefig("drone_anomaly_results/anomaly_detection_result.png", dpi=300, bbox_inches='tight') + print("图像已保存到:drone_anomaly_results/anomaly_detection_result.png") + finally: + # 关闭画布,释放资源 + plt.close() + +# -------------------------- 主函数 -------------------------- if __name__ == "__main__": - root = tk.Tk() - app = SpeedControlVisualizer(root) - root.mainloop() \ No newline at end of file + # 训练模型 + model = train_model() + # 测试异常检测 + test_anomaly_detection(model) \ No newline at end of file From 35a79dbe6ed4ef4f4da7097214e7df680b546c2d Mon Sep 17 00:00:00 2001 From: MKHQ07 Date: Thu, 18 Dec 2025 20:31:32 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E4=BD=8D=E5=A7=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/driverless_car/fg_station/main_fg.py | 316 +++++++++++++++++++++++ 1 file changed, 316 insertions(+) create mode 100644 src/driverless_car/fg_station/main_fg.py diff --git a/src/driverless_car/fg_station/main_fg.py b/src/driverless_car/fg_station/main_fg.py new file mode 100644 index 0000000000..642613b940 --- /dev/null +++ b/src/driverless_car/fg_station/main_fg.py @@ -0,0 +1,316 @@ +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import Dataset, DataLoader +from torchvision import transforms +from PIL import Image +import os +import matplotlib.pyplot as plt +import numpy as np +# scikit-image相关库(生成纹理数据) +from skimage import data, util +from skimage.transform import resize + +# ====================== 1. 自动生成带纹理的模拟航拍数据集(修复维度问题) ====================== +def generate_synthetic_drone_data(save_root, num_train=10, num_test=1, img_size=256): + """ + 用scikit-image生成带纹理的模拟无人机航拍道路数据(修复维度不匹配问题) + :param save_root: 数据集保存根路径 + :param num_train: 训练集图片数量 + :param num_test: 测试集图片数量 + :param img_size: 图片尺寸(默认256x256) + """ + # 创建文件夹结构 + train_img_dir = os.path.join(save_root, "train", "images") + train_mask_dir = os.path.join(save_root, "train", "masks") + test_img_dir = os.path.join(save_root, "test", "images") + test_mask_dir = os.path.join(save_root, "test", "masks") + for dir_path in [train_img_dir, train_mask_dir, test_img_dir, test_mask_dir]: + os.makedirs(dir_path, exist_ok=True) + + # 生成训练数据 + for i in range(num_train): + # 1. 生成自然纹理背景:用skimage的草地图片(二维灰度图)转换为三维RGB图 + grass = data.grass() # 获取skimage内置的草地纹理图(二维灰度图:img_size×img_size) + grass = resize(grass, (img_size, img_size), anti_aliasing=True) # 缩放至256x256 + grass = util.img_as_ubyte(grass) # 转为uint8格式(0-255) + # 关键修复:将二维灰度图转为三维RGB图(复制三个通道) + grass = np.stack([grass, grass, grass], axis=-1) # 变为:img_size×img_size×3 + + # 2. 生成道路纹理:灰色混凝土纹理(三维RGB格式,和背景一致) + road = np.random.rand(img_size, img_size, 3) * 50 + 100 # 灰色噪声纹理(100-150亮度) + road = road.astype(np.uint8) + + # 3. 随机生成道路区域(矩形),合并背景和道路(处理坐标顺序问题,避免空切片) + img = grass.copy() + # 随机确定道路的左上角和右下角坐标,确保y1 < y2,x1 < x2(避免切片为空) + road_x1 = np.random.randint(0, img_size // 2) + road_x2 = np.random.randint(img_size // 2, img_size) + road_y1 = np.random.randint(0, img_size) + road_y2 = np.random.randint(road_y1, img_size) # 确保y2 >= y1 + # 将道路区域替换到背景图中(现在维度匹配,不会报错) + img[road_y1:road_y2, road_x1:road_x2, :] = road[road_y1:road_y2, road_x1:road_x2, :] + + # 4. 生成对应的掩码图:道路区域为白色(255),背景为黑色(0)(二维) + mask = np.zeros((img_size, img_size), dtype=np.uint8) + mask[road_y1:road_y2, road_x1:road_x2] = 255 # 白色道路掩码 + + # 5. 保存图片(JPG格式存图像,PNG格式存掩码) + img_pil = Image.fromarray(img) + mask_pil = Image.fromarray(mask) + img_pil.save(os.path.join(train_img_dir, f"{i+1}.jpg")) + mask_pil.save(os.path.join(train_mask_dir, f"{i+1}.png")) + + # 生成测试数据(逻辑和训练数据一致) + for i in range(num_test): + grass = data.grass() + grass = resize(grass, (img_size, img_size), anti_aliasing=True) + grass = util.img_as_ubyte(grass) + grass = np.stack([grass, grass, grass], axis=-1) # 转为三维RGB图 + + road = np.random.rand(img_size, img_size, 3) * 50 + 100 + road = road.astype(np.uint8) + + img = grass.copy() + road_x1 = np.random.randint(0, img_size // 2) + road_x2 = np.random.randint(img_size // 2, img_size) + road_y1 = np.random.randint(0, img_size) + road_y2 = np.random.randint(road_y1, img_size) # 确保y2 >= y1 + img[road_y1:road_y2, road_x1:road_x2, :] = road[road_y1:road_y2, road_x1:road_x2, :] + + mask = np.zeros((img_size, img_size), dtype=np.uint8) + mask[road_y1:road_y2, road_x1:road_x2] = 255 + + img_pil = Image.fromarray(img) + mask_pil = Image.fromarray(mask) + img_pil.save(os.path.join(test_img_dir, f"{i+1}.jpg")) + mask_pil.save(os.path.join(test_mask_dir, f"{i+1}.png")) + + print(f"✅ 带纹理的模拟数据集生成完成!保存路径:{save_root}") + return train_img_dir, train_mask_dir, os.path.join(test_img_dir, "1.jpg"), os.path.join(test_mask_dir, "1.png") + +# ====================== 2. 定义简化版U-Net模型 ====================== +class DoubleConv(nn.Module): + """双卷积层(U-Net的基础模块,提取特征)""" + def __init__(self, in_channels, out_channels): + super().__init__() + self.conv = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), + nn.ReLU(inplace=True), + nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), + nn.ReLU(inplace=True) + ) + + def forward(self, x): + return self.conv(x) + +class Down(nn.Module): + """下采样(最大池化+双卷积)""" + def __init__(self, in_channels, out_channels): + super().__init__() + self.pool_conv = nn.Sequential( + nn.MaxPool2d(2), + DoubleConv(in_channels, out_channels) + ) + + def forward(self, x): + return self.pool_conv(x) + +class Up(nn.Module): + """上采样(转置卷积+拼接+双卷积)""" + def __init__(self, in_channels, out_channels): + super().__init__() + self.up = nn.ConvTranspose2d(in_channels, in_channels//2, kernel_size=2, stride=2) + self.conv = DoubleConv(in_channels, out_channels) + + def forward(self, x1, x2): + x1 = self.up(x1) # 上采样后的特征图 + # 拼接:将上采样的特征图和对应下采样的特征图拼接(U-Net的核心跳连) + x = torch.cat([x2, x1], dim=1) + return self.conv(x) + +class OutConv(nn.Module): + """输出层(1x1卷积,调整通道数到类别数)""" + def __init__(self, in_channels, out_channels): + super().__init__() + self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1) + + def forward(self, x): + return self.conv(x) + +class SimpleUNet(nn.Module): + """简化版U-Net(减少了一层下采样,适合新手快速训练)""" + def __init__(self, n_channels=3, n_classes=1): + super().__init__() + self.n_channels = n_channels # 输入通道:3(RGB图像) + self.n_classes = n_classes # 输出通道:1(二分类:道路/背景) + + self.inc = DoubleConv(n_channels, 64) # 输入层:3→64 + self.down1 = Down(64, 128) # 下采样1:64→128 + self.down2 = Down(128, 256) # 下采样2:128→256 + self.up1 = Up(256, 128) # 上采样1:256→128 + self.up2 = Up(128, 64) # 上采样2:128→64 + self.outc = OutConv(64, n_classes) # 输出层:64→1 + + def forward(self, x): + # 下采样(编码) + x1 = self.inc(x) # [batch, 64, H, W] + x2 = self.down1(x1)# [batch, 128, H/2, W/2] + x3 = self.down2(x2)# [batch, 256, H/4, W/4] + # 上采样(解码) + x = self.up1(x3, x2)# [batch, 128, H/2, W/2] + x = self.up2(x, x1) # [batch, 64, H, W] + logits = self.outc(x)# [batch, 1, H, W] + return logits + +# ====================== 3. 定义数据集类(适配生成的数据集) ====================== +class RoadDataset(Dataset): + def __init__(self, img_dir, mask_dir, transform=None): + self.img_dir = img_dir + self.mask_dir = mask_dir + self.transform = transform + # 只取jpg格式的图片(避免其他文件干扰) + self.img_names = [f for f in os.listdir(img_dir) if f.endswith('.jpg')] + # 容错:如果没有jpg文件,给出提示 + if len(self.img_names) == 0: + raise ValueError(f"路径 {img_dir} 下没有找到.jpg格式的图片!") + + def __len__(self): + # 数据集长度 + return len(self.img_names) + + def __getitem__(self, idx): + # 读取单张图像和对应的掩码 + img_name = self.img_names[idx] + img_path = os.path.join(self.img_dir, img_name) + # 掩码文件是png格式,替换后缀 + mask_path = os.path.join(self.mask_dir, img_name.replace('.jpg', '.png')) + + # 容错:检查掩码文件是否存在 + if not os.path.exists(mask_path): + raise FileNotFoundError(f"掩码文件 {mask_path} 不存在,请检查数据集是否完整!") + + # 打开图像(RGB)和掩码(灰度图) + image = Image.open(img_path).convert('RGB') + mask = Image.open(mask_path).convert('L') + + # 数据预处理(resize、转tensor) + if self.transform: + image = self.transform(image) + mask = self.transform(mask) + + # 掩码二值化:大于0.5的为1(道路),否则为0(背景) + mask = (mask > 0.5).float() + return image, mask + +# ====================== 4. 主训练和测试流程 ====================== +def main(): + # -------------------------- 第一步:自动生成带纹理的模拟数据集 -------------------------- + # 数据集保存路径(可自定义,比如D:\texture_drone_data) + save_root = r"D:\texture_drone_data" + # 生成10张训练图,1张测试图(数量可调整) + train_img_dir, train_mask_dir, test_img_path, test_mask_path = generate_synthetic_drone_data( + save_root, num_train=10, num_test=1 + ) + + # -------------------------- 配置参数 -------------------------- + batch_size = 2 # 批次大小(CPU建议设为1/2,GPU可设更大) + num_epochs = 5 # 训练轮数(纹理数据简单,5轮足够收敛) + lr = 1e-4 # 学习率 + + # -------------------------- 数据预处理 -------------------------- + transform = transforms.Compose([ + transforms.Resize((256, 256)), # 统一尺寸为256x256(和生成的图片一致) + transforms.ToTensor(), # 转为tensor,且像素值归一化到[0,1] + ]) + + # -------------------------- 加载数据集 -------------------------- + try: + train_dataset = RoadDataset(train_img_dir, train_mask_dir, transform=transform) + train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) + print(f"✅ 数据集加载成功!共 {len(train_dataset)} 张训练图片") + except ValueError as e: + print(f"❌ 数据集加载失败:{e}") + return + except FileNotFoundError as e: + print(f"❌ 数据集加载失败:{e}") + return + + # -------------------------- 初始化模型 -------------------------- + # 自动选择CPU/GPU(有GPU会自动使用,训练更快) + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + model = SimpleUNet(n_channels=3, n_classes=1).to(device) + # 损失函数:二分类用BCEWithLogitsLoss(自带sigmoid,数值更稳定) + criterion = nn.BCEWithLogitsLoss() + # 优化器:Adam(常用的优化器,收敛速度快) + optimizer = optim.Adam(model.parameters(), lr=lr) + + # -------------------------- 训练模型 -------------------------- + model.train() # 切换到训练模式 + print(f"\n开始训练(使用 {device})...") + for epoch in range(num_epochs): + running_loss = 0.0 + for batch_idx, (images, masks) in enumerate(train_loader): + # 数据移到设备上(CPU/GPU) + images = images.to(device) + masks = masks.to(device) + + # 前向传播:输入图片,得到模型输出 + outputs = model(images) + # 计算损失 + loss = criterion(outputs, masks) + + # 反向传播+优化:更新模型参数 + optimizer.zero_grad() # 清空梯度(避免梯度累积) + loss.backward() # 反向传播计算梯度 + optimizer.step() # 更新模型参数 + + running_loss += loss.item() * images.size(0) + + # 每5个批次打印一次损失(便于观察训练进度) + if (batch_idx + 1) % 5 == 0: + print(f"Batch [{batch_idx+1}/{len(train_loader)}], Loss: {loss.item():.4f}") + + # 打印每轮的平均损失 + epoch_loss = running_loss / len(train_dataset) + print(f'Epoch [{epoch+1}/{num_epochs}], Average Loss: {epoch_loss:.4f}\n') + + # -------------------------- 测试单张图片 -------------------------- + model.eval() # 切换到评估模式(禁用Dropout等层) + # 读取并预处理测试图片 + test_image = Image.open(test_img_path).convert('RGB') + test_mask = Image.open(test_mask_path).convert('L') + # 增加batch维度(模型输入需要batch维度,用unsqueeze(0)添加) + test_image_tensor = transform(test_image).unsqueeze(0).to(device) + + # 预测(禁用梯度计算,加快速度并节省内存) + with torch.no_grad(): + pred_output = model(test_image_tensor) + # 用sigmoid转为概率,再二值化得到分割掩码(大于0.5为道路) + pred_mask = torch.sigmoid(pred_output) > 0.5 + + # -------------------------- 可视化结果 -------------------------- + plt.figure(figsize=(15, 5)) + # 原图 + plt.subplot(1, 3, 1) + plt.imshow(test_image) + plt.title('Original Drone Image (Texture)') + plt.axis('off') + # 真实掩码 + plt.subplot(1, 3, 2) + plt.imshow(test_mask, cmap='gray') + plt.title('Ground Truth (Road)') + plt.axis('off') + # 预测掩码 + plt.subplot(1, 3, 3) + plt.imshow(pred_mask.cpu().squeeze().numpy(), cmap='gray') + plt.title('Predicted Road') + plt.axis('off') + + # 保存结果图片到当前目录 + plt.savefig("drone_segmentation_texture_result.png") + plt.show() + print("✅ 纹理数据分割结果已保存为 drone_segmentation_texture_result.png") + +if __name__ == '__main__': + main() \ No newline at end of file