diff --git a/src/driverless_car/README.md b/src/driverless_car/README.md index 2728d19145..0b97ccb5c9 100644 --- a/src/driverless_car/README.md +++ b/src/driverless_car/README.md @@ -1,11 +1,48 @@ - # 无人机深度学习项目集合 -本项目集合包含两个无人机相关的深度学习Demo,均基于代码仿真实现,无需硬件依赖。 +本项目集合包含三个无人机相关的深度学习Demo,均基于代码仿真实现,无需硬件依赖。 + +--- + +## 项目1:无人机航拍图像语义分割(U-Net + 纹理化模拟数据) + +### 项目简介 +这是一个面向新手的无人机航拍图像语义分割项目,无需手动下载外部数据集,通过scikit-image自动生成带草地纹理的模拟航拍道路数据,使用简化版 U-Net 模型实现道路区域的语义分割,全程可在 CPU/GPU 上运行。 + +### 项目亮点 +- 🚀 **数据自动化**:用代码生成带自然纹理的模拟航拍数据,无需手动标注或下载数据集 +- 🧠 **轻量化模型**:简化版 U-Net 结构,降低计算量,新手可在 CPU 上快速训练 +- 📊 **完整流程**:涵盖数据生成、模型训练、结果可视化全闭环,直观展示语义分割效果 + +### 快速运行 +```bash +# 安装依赖 +pip install torch torchvision matplotlib scikit-image pillow numpy opencv-python + +# 运行主程序 +python main_fg.py +``` + +### 核心参数说明 +| 参数名 | 默认值 | 说明 | +|--------|--------|------| +| save_root | ./texture_drone_data | 模拟数据集的保存路径 | +| num_train | 10 | 训练集图片数量 | +| num_test | 1 | 测试集图片数量 | +| img_size | 256 | 图片尺寸(宽 × 高) | +| batch_size | 2 | 批次大小 | +| num_epochs | 5 | 训练轮数 | +| lr | 1e-4 | 学习率 | + +### 结果说明 +运行完成后,会生成包含三幅图的可视化窗口: +- **Original Drone Image (Texture)**:带草地纹理的模拟无人机航拍原图 +- **Ground Truth (Road)**:道路区域的真实掩码 +- **Predicted Road**:模型预测的道路掩码 --- -## 项目1:无人机图像分类深度学习Demo +## 项目2:无人机图像分类深度学习Demo ### 项目简介 该项目实现了**无人机图像分类**的深度学习Demo,使用公开数据集模拟无人机采集的图像数据,搭建轻量化卷积神经网络(CNN)完成分类任务。 @@ -24,7 +61,7 @@ --- -## 项目2:无人机网格路径规划(强化学习 Q-Learning 实现) +## 项目3:无人机网格路径规划(强化学习 Q-Learning 实现) ### 项目简介 基于强化学习(Q-Learning)和网格地图的无人机路径规划项目,实现了无人机在含障碍物的二维网格中自主避障并规划从起点到终点的最优路径。 @@ -50,7 +87,13 @@ 推荐使用国内镜像源加速安装: ```bash -# 基础依赖(推荐) +# 语义分割项目依赖 +pip install torch torchvision matplotlib scikit-image pillow numpy opencv-python + +# 图像分类项目依赖 +pip install torch torchvision matplotlib numpy -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) @@ -66,6 +109,8 @@ pip uninstall gym -y ### 系统要求 - Python 3.7+ - 支持CUDA的GPU(可选,用于加速训练) +- 内存:建议4GB以上 +- 存储空间:至少1GB可用空间 --- @@ -73,25 +118,38 @@ pip uninstall gym -y ``` 无人机深度学习项目/ -├── 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 # 工具函数 +├── README.md # 项目说明文档 +├── 语义分割项目/ # 无人机航拍图像语义分割Demo +│ ├── main_fg.py # 主程序入口 +│ ├── model.py # U-Net模型定义 +│ ├── dataset.py # 数据集处理 +│ ├── utils.py # 工具函数 +│ └── texture_generation.py # 纹理化数据生成 +├── 图像分类项目/ # 无人机图像分类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. 运行主程序:`python main_fg.py` +2. 程序会自动生成纹理化的模拟航拍数据集 +3. 训练简化版 U-Net 模型 +4. 查看分割结果可视化(原图、真实掩码、预测掩码) +5. 结果保存为 `drone_segmentation_texture_result.png` + ### 图像分类项目 1. 运行主程序开始训练和测试 2. 查看数据集样本展示 @@ -106,12 +164,29 @@ pip uninstall gym -y --- +## 扩展方向 + +### 语义分割项目优化方向 +- **数据增强**:在transform中添加随机裁剪、翻转、亮度调整等操作,提升模型泛化能力 +- **模型优化**:在 U-Net 中加入注意力机制(如 SE 模块)或使用 U-Net++ 模型,提升分割精度 +- **真实数据适配**:替换模拟数据生成部分,加载真实的无人机航拍道路数据集 +- **多类别分割**:修改模型输出通道数,实现建筑、植被、水体等多类地物的语义分割 + +### 通用优化建议 +- 使用更高分辨率的输入图像提升分割精度 +- 尝试不同的损失函数(如Dice Loss、Focal Loss) +- 添加数据增强技术提升模型泛化能力 +- 使用预训练模型进行迁移学习 + +--- + ## 注意事项 - 项目完全基于代码仿真,无需真实无人机硬件 - 可在普通PC上运行,建议配置支持CUDA的GPU以加速训练 - 所有可视化界面均已优化,兼容中文显示 - 代码已处理常见的兼容性问题,可直接在PyCharm等IDE中运行 +- 语义分割项目会在指定路径自动创建数据集文件夹,请确保有足够存储空间 --- @@ -123,7 +198,4 @@ pip uninstall gym -y ## 许可证 -本项目采用MIT许可证,详见LICENSE文件。 - ---- - +本项目采用MIT许可证,详见LICENSE文件。 \ No newline at end of file diff --git a/src/driverless_car/aim_data/ph_sort.py b/src/driverless_car/aim_data/ph_sort.py new file mode 100644 index 0000000000..347fd028be --- /dev/null +++ b/src/driverless_car/aim_data/ph_sort.py @@ -0,0 +1,312 @@ +import os +import numpy as np +import matplotlib.pyplot as plt +import seaborn as sns +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import DataLoader, random_split +from torchvision import transforms, models +from torchgeo.datasets import RESISC45 # 无人机/遥感图像数据集 +from sklearn.metrics import confusion_matrix +import warnings +warnings.filterwarnings('ignore') + +# -------------------------- 1. 配置参数 -------------------------- +# 设备配置(优先使用GPU) +DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") +# 图像大小(RESISC45原始大小为256x256,这里统一为224x224) +IMG_SIZE = 224 +# 批次大小 +BATCH_SIZE = 32 +# 训练轮数 +EPOCHS = 10 +# 数据集根目录(自动下载到该路径) +DATA_ROOT = "./datasets/resisc45" +# 训练集占比 +TRAIN_RATIO = 0.8 + +# -------------------------- 2. 数据预处理与加载(适配最新版torchgeo) -------------------------- +# 定义数据变换(直接使用torchvision的变换) +# 训练集:数据增强+归一化 +train_transform = transforms.Compose([ + transforms.Resize((IMG_SIZE, IMG_SIZE)), + transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转 + transforms.RandomVerticalFlip(p=0.5), # 随机垂直翻转 + transforms.RandomRotation(10), # 随机旋转±10度 + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], # ImageNet均值 + std=[0.229, 0.224, 0.225]) # ImageNet标准差 +]) + +# 验证集:仅归一化 +val_transform = transforms.Compose([ + transforms.Resize((IMG_SIZE, IMG_SIZE)), + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) +]) + +# 加载RESISC45数据集(自动下载,最新版torchgeo的参数调整) +# 1. 先加载完整数据集(无split参数,用transforms=None,后续手动拆分并应用变换) +full_dataset = RESISC45( + root=DATA_ROOT, + transforms=None, # 最新版参数是transforms(复数),先设为None,后续拆分后再应用 + download=True # 自动下载数据集 +) + +# 2. 手动拆分训练集和验证集(解决split参数缺失问题) +dataset_size = len(full_dataset) +train_size = int(TRAIN_RATIO * dataset_size) +val_size = dataset_size - train_size +train_subset, val_subset = random_split(full_dataset, [train_size, val_size], generator=torch.Generator().manual_seed(42)) + +# 3. 封装带变换的数据集类(解决不同子集用不同变换的问题) +class DatasetWithTransform: + def __init__(self, subset, transform): + self.subset = subset + self.transform = transform + + def __len__(self): + return len(self.subset) + + def __getitem__(self, idx): + img, label = self.subset[idx] + # 应用变换(img是PIL图像,直接传入transform) + img = self.transform(img) + return img, label + +# 4. 为训练集和验证集应用各自的变换 +train_dataset = DatasetWithTransform(train_subset, train_transform) +val_dataset = DatasetWithTransform(val_subset, val_transform) + +# 创建数据加载器 +train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0) +val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=0) + +# 获取类别名称和数量(45类,如"farmland"(农田)、"road"(道路)、"building"(建筑)等) +class_names = full_dataset.classes +num_classes = len(class_names) +print(f"数据集包含 {num_classes} 个类别,类别列表:{class_names[:10]}...") # 打印前10个类别 + +# -------------------------- 3. 可视化1:数据集样本(无人机图像) -------------------------- +def visualize_dataset_samples(dataset, class_names, num_samples=3): + """可视化每个类别的若干样本图像(随机选几个类别,避免子图过多)""" + # 随机选择8个类别(减少子图数量,更易查看) + selected_classes = np.random.choice(range(num_classes), 8, replace=False) + fig, axes = plt.subplots(nrows=len(selected_classes), ncols=num_samples, figsize=(10, 15)) + fig.suptitle("Drone/Remote Sensing Image Samples (RESISC45)", fontsize=16) + + for row_idx, cls_idx in enumerate(selected_classes): + # 找到该类别的所有样本索引 + cls_samples = [i for i, (img, label) in enumerate(dataset) if label == cls_idx] + # 随机选num_samples个样本(如果样本不足,用replace=True) + selected_samples = np.random.choice(cls_samples, num_samples, replace=len(cls_samples) (H, W, C) + # 反归一化 + mean = np.array([0.485, 0.456, 0.406]) + std = np.array([0.229, 0.224, 0.225]) + img = img * std + mean + img = np.clip(img, 0, 1) + + # 显示图像 + ax = axes[row_idx, col_idx] + ax.imshow(img) + ax.axis("off") + if col_idx == 0: + ax.set_ylabel(class_names[cls_idx], fontsize=10) + plt.tight_layout() + plt.savefig("drone_dataset_samples.png", dpi=300, bbox_inches="tight") + plt.show() + +# 调用样本可视化函数(用train_dataset,也可以用val_dataset) +visualize_dataset_samples(train_dataset, class_names, num_samples=3) + +# -------------------------- 4. 构建迁移学习模型(ResNet18) -------------------------- +def build_model(num_classes): + """构建预训练的ResNet18模型,微调最后一层""" + model = models.resnet18(pretrained=True) + # 冻结特征提取层(数据集足够大时可解冻,这里先冻结加快训练) + for param in model.parameters(): + param.requires_grad = False + # 替换最后一层全连接层,适配数据集类别数 + model.fc = nn.Linear(model.fc.in_features, num_classes) + return model.to(DEVICE) + +model = build_model(num_classes) + +# -------------------------- 5. 模型训练 -------------------------- +# 定义损失函数和优化器 +criterion = nn.CrossEntropyLoss() +optimizer = optim.Adam(model.fc.parameters(), lr=0.001) + +# 记录训练指标 +train_losses = [] +train_accs = [] +val_losses = [] +val_accs = [] + +def train_one_epoch(model, loader, criterion, optimizer, device): + """训练一个epoch""" + model.train() + running_loss = 0.0 + running_corrects = 0 + total_samples = 0 + + for inputs, labels in loader: # 元组(inputs, labels)形式 + inputs = inputs.to(device) + labels = labels.to(device) + + # 前向传播 + outputs = model(inputs) + _, preds = torch.max(outputs, 1) + loss = criterion(outputs, labels) + + # 反向传播+优化 + optimizer.zero_grad() + loss.backward() + optimizer.step() + + # 统计 + running_loss += loss.item() * inputs.size(0) + running_corrects += torch.sum(preds == labels.data) + total_samples += inputs.size(0) + + epoch_loss = running_loss / total_samples + epoch_acc = running_corrects.double() / total_samples + return epoch_loss, epoch_acc + +def validate(model, loader, criterion, device): + """验证模型""" + model.eval() + running_loss = 0.0 + running_corrects = 0 + total_samples = 0 + all_preds = [] + all_labels = [] + + with torch.no_grad(): + for inputs, labels in loader: + inputs = inputs.to(device) + labels = labels.to(device) + + outputs = model(inputs) + _, preds = torch.max(outputs, 1) + loss = criterion(outputs, labels) + + # 统计 + running_loss += loss.item() * inputs.size(0) + running_corrects += torch.sum(preds == labels.data) + total_samples += inputs.size(0) + all_preds.extend(preds.cpu().numpy()) + all_labels.extend(labels.cpu().numpy()) + + epoch_loss = running_loss / total_samples + epoch_acc = running_corrects.double() / total_samples + return epoch_loss, epoch_acc, np.array(all_preds), np.array(all_labels) + +# 开始训练 +print(f"\n开始训练(设备:{DEVICE})...") +for epoch in range(EPOCHS): + train_loss, train_acc = train_one_epoch(model, train_loader, criterion, optimizer, DEVICE) + val_loss, val_acc, _, _ = validate(model, val_loader, criterion, DEVICE) + + # 记录指标 + train_losses.append(train_loss) + train_accs.append(train_acc.item()) + val_losses.append(val_loss) + val_accs.append(val_acc.item()) + + print(f"Epoch {epoch+1}/{EPOCHS} | Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f} | Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.4f}") + +# -------------------------- 6. 可视化2:训练过程(损失/准确率曲线) -------------------------- +def visualize_training(train_losses, val_losses, train_accs, val_accs): + """可视化训练曲线""" + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) + fig.suptitle("Training Process (Drone Image Classification)", fontsize=16) + + # 损失曲线 + ax1.plot(range(1, EPOCHS+1), train_losses, label="Train Loss", marker="o", color="blue") + ax1.plot(range(1, EPOCHS+1), val_losses, label="Val Loss", marker="s", color="red") + ax1.set_xlabel("Epoch") + ax1.set_ylabel("Loss") + ax1.set_title("Loss Curve") + ax1.legend() + ax1.grid(alpha=0.3) + + # 准确率曲线 + ax2.plot(range(1, EPOCHS+1), train_accs, label="Train Acc", marker="o", color="blue") + ax2.plot(range(1, EPOCHS+1), val_accs, label="Val Acc", marker="s", color="red") + ax2.set_xlabel("Epoch") + ax2.set_ylabel("Accuracy") + ax2.set_title("Accuracy Curve") + ax2.legend() + ax2.grid(alpha=0.3) + + plt.tight_layout() + plt.savefig("drone_training_curve.png", dpi=300, bbox_inches="tight") + plt.show() + +visualize_training(train_losses, val_losses, train_accs, val_accs) + +# -------------------------- 7. 可视化3:混淆矩阵(选前10类,避免过于密集) -------------------------- +def visualize_confusion_matrix(model, loader, class_names, device, top_n=10): + """可视化混淆矩阵(仅显示前top_n类)""" + # 获取预测和标签 + _, _, all_preds, all_labels = validate(model, loader, criterion, device) + # 选择前top_n类的索引 + top_classes = range(min(top_n, num_classes)) + # 筛选出前top_n类的样本 + mask = np.isin(all_labels, top_classes) + all_preds_filtered = all_preds[mask] + all_labels_filtered = all_labels[mask] + # 计算混淆矩阵 + cm = confusion_matrix(all_labels_filtered, all_preds_filtered) + # 获取前top_n类的名称 + top_class_names = [class_names[i] for i in top_classes] + + # 绘制混淆矩阵 + plt.figure(figsize=(10, 8)) + sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=top_class_names, yticklabels=top_class_names) + plt.xlabel("Predicted Label") + plt.ylabel("True Label") + plt.title(f"Confusion Matrix (Top {top_n} Classes)") + plt.tight_layout() + plt.savefig("drone_confusion_matrix.png", dpi=300, bbox_inches="tight") + plt.show() + +visualize_confusion_matrix(model, val_loader, class_names, DEVICE, top_n=10) + +# -------------------------- 8. 可视化4:单张图像预测 -------------------------- +def predict_single_image(model, img_path, class_names, transform, device): + """预测单张无人机图像并可视化""" + from PIL import Image + # 加载图像 + img = Image.open(img_path).convert("RGB") + img_original = img.copy() + # 预处理 + img_tensor = transform(img).unsqueeze(0).to(device) # 添加batch维度 + + # 预测 + model.eval() + with torch.no_grad(): + outputs = model(img_tensor) + _, pred = torch.max(outputs, 1) + pred_label = class_names[pred.item()] + + # 可视化 + plt.figure(figsize=(8, 6)) + plt.imshow(img_original) + plt.axis("off") + plt.title(f"Predicted: {pred_label}", fontsize=14) + plt.tight_layout() + plt.savefig("drone_single_prediction.png", dpi=300, bbox_inches="tight") + plt.show() + +# 示例:使用数据集内的一张图像进行预测(获取数据集图像路径) +# 注意:full_dataset的files属性存储了图像路径(最新版torchgeo仍保留该属性) +sample_img_path = full_dataset.files[0] # 取数据集第一张图像 +predict_single_image(model, sample_img_path, class_names, val_transform, DEVICE) \ No newline at end of file diff --git a/src/driverless_car/main.py b/src/driverless_car/main.py index 6bcaa3a58f..e1cda0ad11 100644 --- a/src/driverless_car/main.py +++ b/src/driverless_car/main.py @@ -1,153 +1,203 @@ -import torch -import torch.nn as nn -import torch.optim as optim -from torch.utils.data import DataLoader -from torchvision import datasets, transforms -import matplotlib.pyplot as plt -import numpy as np -import os -from PIL import Image -import random +# 导入必要的库 +import torch # PyTorch核心库,用于张量计算和模型构建 +import torch.nn as nn # 神经网络模块,包含各种层和损失函数 +import torch.optim as optim # 优化器模块,用于模型参数更新 +from torch.utils.data import DataLoader # 数据加载器,用于批量加载数据集 +from torchvision import datasets, transforms # 内置数据集和图像变换工具 +import matplotlib.pyplot as plt # 可视化库,用于绘制训练曲线和图像 +import numpy as np # 数值计算库(本代码中暂未直接使用,保留备用) +import os # 操作系统库,用于文件和文件夹操作 +from PIL import Image # 图像处理库,用于读取和处理图像 +import random # 随机数库(本代码中暂未直接使用,保留备用) # -------------------------- # 1. 基础配置(解决可视化和字体问题) # -------------------------- import matplotlib -matplotlib.use('TkAgg') # 更换后端,兼容PyCharm的可视化 +# 更换Matplotlib后端为TkAgg,兼容PyCharm等IDE的可视化显示(避免图像无法弹出) +matplotlib.use('TkAgg') -# 类别名称(对应CIFAR-10的10类) +# 类别名称(对应CIFAR-10数据集的10个类别,可替换为无人机图像的自定义类别) +# 注:若用于真实无人机图像分类,需将此处改为无人机场景类别(如农田、道路、建筑等) classes = ('Airplane', 'Car', 'Bird', 'Cat', 'Deer', 'Dog', 'Frog', 'Horse', 'Ship', 'Truck') # -------------------------- # 2. 数据预处理(简化,减少计算量) # -------------------------- -# 简化变换:移除数据增强(加快训练,牺牲一点泛化能力) +# 定义图像预处理流水线:将图像统一尺寸、转换为张量、归一化 +# 简化变换:移除数据增强(如随机翻转、旋转),加快训练速度,牺牲少量泛化能力 basic_transform = transforms.Compose([ - transforms.Resize((32, 32)), - transforms.ToTensor(), - transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + transforms.Resize((32, 32)), # 将图像缩放到32x32(CIFAR-10原始尺寸就是32x32,此处为统一处理) + transforms.ToTensor(), # 将PIL图像转换为PyTorch张量,形状为(C, H, W),数值范围0-1 + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 归一化:将数值范围调整为-1到1,参数为RGB三通道的均值和标准差 ]) -# 加载CIFAR-10数据集(使用简化变换) +# 加载CIFAR-10数据集(若用于无人机图像分类,可替换为自定义数据集) +# root:数据集保存路径;train=True表示加载训练集;download=True表示若本地无数据集则自动下载 train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=basic_transform) test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=basic_transform) -# 增大批次大小,加快训练(根据内存调整,默认128) + +# 创建数据加载器,批量加载数据 +# batch_size=128:每次加载128个样本,增大批次可加快训练(需根据内存调整) +# shuffle=True:训练集打乱顺序,提升模型泛化能力;测试集无需打乱 train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False) # -------------------------- -# 3. 搭建轻量化CNN模型(原模型,参数少,速度快) +# 3. 搭建轻量化CNN模型(参数少,速度快,适配无人机端的低算力场景) # -------------------------- class DroneCNN(nn.Module): + """ + 轻量化卷积神经网络模型,适用于无人机图像分类(低算力设备) + 结构:3层卷积 + 3层池化 + 2层全连接 + """ def __init__(self): - super(DroneCNN, self).__init__() + super(DroneCNN, self).__init__() # 继承父类nn.Module的初始化 + # 卷积层1:输入通道3(RGB),输出通道32,卷积核3x3,填充1(保持尺寸不变) self.conv1 = nn.Conv2d(3, 32, 3, padding=1) + # 卷积层2:输入通道32,输出通道64,卷积核3x3,填充1 self.conv2 = nn.Conv2d(32, 64, 3, padding=1) + # 卷积层3:输入通道64,输出通道128,卷积核3x3,填充1 self.conv3 = nn.Conv2d(64, 128, 3, padding=1) + # 最大池化层:核2x2,步长2(将图像尺寸缩小一半) self.pool = nn.MaxPool2d(2, 2) + # 全连接层1:输入维度128*4*4(卷积池化后的数据维度),输出维度512 + # 计算过程:32x32 → 池化后16x16 → 池化后8x8 → 池化后4x4,故128*4*4 self.fc1 = nn.Linear(128 * 4 * 4, 512) + # 全连接层2:输入维度512,输出维度10(对应CIFAR-10的10个类别) self.fc2 = nn.Linear(512, 10) - self.relu = nn.ReLU() - self.dropout = nn.Dropout(0.3) # 降低dropout比例,加快计算 + self.relu = nn.ReLU() # 激活函数,引入非线性 + self.dropout = nn.Dropout(0.3) # Dropout层:随机丢弃30%的神经元,防止过拟合(降低比例加快计算) def forward(self, x): + """ + 前向传播函数:定义数据在模型中的流动路径 + :param x: 输入张量,形状为(batch_size, 3, 32, 32) + :return: 输出张量,形状为(batch_size, 10)(每个样本的类别得分) + """ + # 卷积1 → ReLU → 池化:32x32 → 16x16 x = self.pool(self.relu(self.conv1(x))) + # 卷积2 → ReLU → 池化:16x16 → 8x8 x = self.pool(self.relu(self.conv2(x))) + # 卷积3 → ReLU → 池化:8x8 → 4x4 x = self.pool(self.relu(self.conv3(x))) - x = x.view(-1, 128 * 4 * 4) + # 展平:将4维张量(batch_size, 128, 4, 4)转换为2维张量(batch_size, 128*4*4) + x = x.view(-1, 128 * 4 * 4) # -1表示自动计算batch_size + # 全连接1 → ReLU x = self.relu(self.fc1(x)) - x = self.dropout(x) - x = self.fc2(x) + x = self.dropout(x) # 应用Dropout + x = self.fc2(x) # 全连接2,输出类别得分 return x -# 初始化模型、损失函数、优化器 +# 设备配置:优先使用GPU(CUDA),无GPU则使用CPU(适配无人机的CPU场景) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") +# 初始化模型并移至指定设备 model = DroneCNN().to(device) +# 损失函数:交叉熵损失(适用于多分类任务,包含Softmax操作) criterion = nn.CrossEntropyLoss() -# 使用SGD优化器(比Adam稍快,或保留Adam,影响不大) +# 优化器:Adam优化器(自适应学习率,收敛速度快),学习率0.001 optimizer = optim.Adam(model.parameters(), lr=0.001) # -------------------------- -# 4. 训练函数(大幅优化速度) +# 4. 训练函数(大幅优化速度,适配实时训练需求) # -------------------------- -# 全局开启交互模式,用于实时绘图 +# 全局开启Matplotlib交互模式,用于实时绘制训练曲线(无需等待绘图完成) plt.ion() +# 创建1行2列的子图,用于显示损失曲线和准确率曲线,设置窗口大小 fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) # 训练曲线窗口 def plot_training_curve(train_losses, train_accs, test_accs): - """更新训练曲线窗口,减少绘图开销""" - ax1.clear() - ax2.clear() - # 损失曲线 + """ + 更新训练曲线窗口,减少绘图开销(只清空重绘,不重建窗口) + :param train_losses: 训练损失列表 + :param train_accs: 训练准确率列表 + :param test_accs: 测试准确率列表 + """ + ax1.clear() # 清空第一个子图 + ax2.clear() # 清空第二个子图 + # 绘制训练损失曲线 ax1.plot(train_losses, label='Training Loss', color='blue') - ax1.set_xlabel('Iteration (Batch)') - ax1.set_ylabel('Loss') - ax1.set_title('Training Loss Change') - ax1.legend() - ax1.grid(True) - # 准确率曲线 + ax1.set_xlabel('Iteration (Batch)') # x轴:批次迭代次数 + ax1.set_ylabel('Loss') # y轴:损失值 + ax1.set_title('Training Loss Change') # 标题 + ax1.legend() # 显示图例 + ax1.grid(True) # 显示网格 + # 绘制训练/测试准确率曲线 ax2.plot(train_accs, label='Training Accuracy', color='green') ax2.plot(test_accs, label='Test Accuracy', color='red') - ax2.set_xlabel('Iteration (Batch)') - ax2.set_ylabel('Accuracy (%)') - ax2.set_title('Training/Test Accuracy Change') - ax2.legend() - ax2.grid(True) - plt.draw() - plt.pause(0.01) # 减少暂停时间,加快绘图 + ax2.set_xlabel('Iteration (Batch)') # x轴:批次迭代次数 + ax2.set_ylabel('Accuracy (%)') # y轴:准确率(百分比) + ax2.set_title('Training/Test Accuracy Change') # 标题 + ax2.legend() # 显示图例 + ax2.grid(True) # 显示网格 + plt.draw() # 重绘图像 + plt.pause(0.01) # 暂停极短时间,让图像更新(减少暂停时间加快绘图) def calculate_test_acc_fast(test_loader, sample_batches=5): - """快速计算测试集准确率:只抽取少量批次,不遍历整个测试集""" - test_correct = 0 - test_total = 0 - model.eval() - with torch.no_grad(): - # 只取前sample_batches个批次,大幅减少耗时 + """ + 快速计算测试集准确率:只抽取少量批次,不遍历整个测试集(大幅减少耗时) + :param test_loader: 测试集数据加载器 + :param sample_batches: 抽取的批次数量,默认5 + :return: 测试集准确率(百分比) + """ + test_correct = 0 # 正确预测的样本数 + test_total = 0 # 总样本数 + model.eval() # 将模型设置为评估模式(关闭Dropout、BatchNorm等层的训练行为) + with torch.no_grad(): # 关闭梯度计算(节省内存,加快计算) + # 只遍历前sample_batches个批次 for i, (test_inputs, test_labels) in enumerate(test_loader): if i >= sample_batches: - break + break # 达到指定批次后停止 + # 将数据移至指定设备 test_inputs, test_labels = test_inputs.to(device), test_labels.to(device) - test_outputs = model(test_inputs) + test_outputs = model(test_inputs) # 模型预测 + # 获取预测结果:取类别得分最大的索引 _, test_predicted = torch.max(test_outputs.data, 1) - test_total += test_labels.size(0) - test_correct += (test_predicted == test_labels).sum().item() - model.train() + test_total += test_labels.size(0) # 累计样本数 + test_correct += (test_predicted == test_labels).sum().item() # 累计正确数 + model.train() # 将模型恢复为训练模式 if test_total == 0: return 0.0 - return 100 * test_correct / test_total - -def train_model(epochs=1): # 减少训练轮数,默认1轮 - train_losses = [] - train_accs = [] - test_accs = [] - model.train() - - for epoch in range(epochs): - running_loss = 0.0 - correct = 0 - total = 0 - # 每200个批次更新一次曲线(原100,减少更新频率) + return 100 * test_correct / test_total # 计算准确率(百分比) + +def train_model(epochs=1): # 训练轮数默认1轮(减少轮数加快训练,可根据需求调整) + """ + 模型训练函数,优化训练速度,实时绘制训练曲线 + :param epochs: 训练轮数,默认1 + """ + train_losses = [] # 存储训练损失 + train_accs = [] # 存储训练准确率 + test_accs = [] # 存储测试准确率 + model.train() # 将模型设置为训练模式 + + for epoch in range(epochs): # 遍历训练轮数 + running_loss = 0.0 # 累计批次损失 + correct = 0 # 累计正确预测数 + total = 0 # 累计样本数 + # 每200个批次更新一次曲线(原100,减少更新频率,降低绘图开销) update_interval = 200 + # 遍历训练集数据加载器 for i, (inputs, labels) in enumerate(train_loader): + # 将数据移至指定设备 inputs, labels = inputs.to(device), labels.to(device) # 前向传播+反向传播+优化 - optimizer.zero_grad() - outputs = model(inputs) - loss = criterion(outputs, labels) - loss.backward() - optimizer.step() + optimizer.zero_grad() # 清空梯度(避免梯度累积) + outputs = model(inputs) # 模型前向传播,得到类别得分 + loss = criterion(outputs, labels) # 计算损失 + loss.backward() # 反向传播,计算梯度 + optimizer.step() # 优化器更新模型参数 # 统计指标 - running_loss += loss.item() - _, predicted = torch.max(outputs.data, 1) - total += labels.size(0) - correct += (predicted == labels).sum().item() + running_loss += loss.item() # 累计损失值(item()将张量转换为标量) + _, predicted = torch.max(outputs.data, 1) # 获取预测类别 + total += labels.size(0) # 累计样本数 + correct += (predicted == labels).sum().item() # 累计正确数 - # 降低更新频率,减少计算和绘图开销 + # 达到更新间隔时,计算并记录指标,更新曲线 if i % update_interval == update_interval - 1: - train_loss = running_loss / update_interval - train_acc = 100 * correct / total + train_loss = running_loss / update_interval # 计算平均损失 + train_acc = 100 * correct / total # 计算训练准确率 train_losses.append(train_loss) train_accs.append(train_acc) @@ -155,108 +205,133 @@ def train_model(epochs=1): # 减少训练轮数,默认1轮 test_acc = calculate_test_acc_fast(test_loader, sample_batches=5) test_accs.append(test_acc) + # 打印训练信息 print(f'Epoch {epoch+1}, Batch {i+1} | Loss: {train_loss:.3f} | Train Acc: {train_acc:.2f}% | Test Acc: {test_acc:.2f}%') + # 重置统计变量 running_loss = 0.0 correct = 0 total = 0 + # 更新训练曲线 plot_training_curve(train_losses, train_accs, test_accs) - # 保存模型 + # 训练完成后保存模型参数(后续可加载模型进行推理) torch.save(model.state_dict(), 'drone_model.pth') print('模型已保存为drone_model.pth') - model.eval() + model.eval() # 模型设置为评估模式 plt.ioff() # 关闭交互模式 - plt.show(block=False) + plt.show(block=False) # 显示曲线窗口,不阻塞程序 # -------------------------- -# 5. 模拟无人机实时图像输入(优化推理速度) +# 5. 模拟无人机实时图像输入(优化推理速度,适配无人机实时流处理) # -------------------------- def load_drone_images(folder_path): - """读取本地文件夹中的图像,模拟无人机采集的图像流""" + """ + 读取本地文件夹中的图像,模拟无人机采集的图像流 + :param folder_path: 图像文件夹路径 + :return: 图像路径列表 + """ + # 支持的图像扩展名 img_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.gif'] img_paths = [] + # 遍历文件夹中的文件 for file in os.listdir(folder_path): + # 判断文件扩展名是否在支持的列表中 if os.path.splitext(file)[1].lower() in img_extensions: - img_paths.append(os.path.join(folder_path, file)) + img_paths.append(os.path.join(folder_path, file)) # 拼接完整路径 if not img_paths: raise ValueError(f'文件夹{folder_path}中未找到任何图像文件!') return img_paths def preprocess_image(img_path): - """预处理单张图像,简化操作""" - # 读取图像(RGB模式) + """ + 预处理单张图像,适配模型输入要求 + :param img_path: 图像路径 + :return: 原始图像(用于显示),预处理后的张量(用于模型推理) + """ + # 读取图像(RGB模式,避免灰度图问题) img = Image.open(img_path).convert('RGB') - original_img = img.copy() - # 预处理 + original_img = img.copy() # 保存原始图像,用于可视化显示 + # 应用预处理流水线 img = basic_transform(img) - # 添加batch维度 + # 添加batch维度(模型输入要求batch_size在前,形状为(1, 3, 32, 32)) img = torch.unsqueeze(img, 0) return original_img, img.to(device) -def drone_real_time_inference(folder_path, delay=0.1): # 降低延迟,默认0.1秒 - """模拟无人机实时图像输入,优化推理速度""" +def drone_real_time_inference(folder_path, delay=0.1): + """ + 模拟无人机实时图像输入,优化推理速度,实时显示预测结果 + :param folder_path: 无人机图像文件夹路径 + :param delay: 每张图像的显示延迟(秒),默认0.1秒(低延迟,快速播放) + """ print(f'\n开始模拟无人机实时图像流(读取文件夹:{folder_path}),每{delay}秒处理一张图像...') img_paths = load_drone_images(folder_path) - # 创建单个显示窗口,减少窗口创建开销 + # 创建单个显示窗口,减少窗口创建开销(优化可视化速度) fig, ax = plt.subplots(figsize=(6, 4)) # 缩小窗口,加快绘图 - plt.ion() + plt.ion() # 开启交互模式 + # 遍历图像路径,模拟实时图像流 for img_path in img_paths: try: # 预处理图像 original_img, input_tensor = preprocess_image(img_path) - # 模型预测(简化,减少计算) + # 模型预测(推理阶段,关闭梯度计算) with torch.no_grad(): - outputs = model(input_tensor) - probabilities = torch.softmax(outputs, dim=1) - pred_idx = torch.argmax(probabilities, dim=1).item() - pred_class = classes[pred_idx] - pred_conf = probabilities[0][pred_idx].item() * 100 + outputs = model(input_tensor) # 模型前向传播,得到类别得分 + probabilities = torch.softmax(outputs, dim=1) # 将得分转换为概率(0-1) + pred_idx = torch.argmax(probabilities, dim=1).item() # 获取概率最大的类别索引 + pred_class = classes[pred_idx] # 获取类别名称 + pred_conf = probabilities[0][pred_idx].item() * 100 # 计算预测置信度(百分比) # 可视化优化:只更新图像和文本,不重建窗口 - ax.clear() - ax.imshow(original_img) - ax.axis('off') - # 简化文本显示,减少渲染开销 + ax.clear() # 清空窗口 + ax.imshow(original_img) # 显示原始图像 + ax.axis('off') # 关闭坐标轴,美观显示 + # 显示预测结果和置信度,添加白色背景框增强可读性 text = f'{pred_class} ({pred_conf:.1f}%)' ax.text(5, 5, text, fontsize=10, color='red', bbox=dict(facecolor='white', alpha=0.7, edgecolor='none')) - ax.set_title('Drone Real-Time View', fontsize=12) - plt.draw() - plt.pause(delay) + ax.set_title('Drone Real-Time View', fontsize=12) # 窗口标题 + plt.draw() # 重绘图像 + plt.pause(delay) # 暂停指定时间,模拟实时流 - # 简化控制台输出 + # 简化控制台输出,只显示关键信息 print(f'图像:{os.path.basename(img_path)} → {pred_class} ({pred_conf:.1f}%)') except Exception as e: + # 捕获异常,避免单张图像处理失败导致程序终止 print(f'处理图像{img_path}时出错:{e}') continue - # 结束后保持窗口 - plt.ioff() + # 推理完成后,保持窗口显示 + plt.ioff() # 关闭交互模式 + # 在窗口中显示完成提示 ax.text(0.5, 0.5, 'Done!', fontsize=14, ha='center', va='center', transform=ax.transAxes, bbox=dict(facecolor='red', alpha=0.8)) plt.draw() - plt.show(block=True) + plt.show(block=True) # 阻塞程序,保持窗口 # -------------------------- -# 主程序运行 +# 主程序运行入口 # -------------------------- if __name__ == '__main__': - # 第一步:训练模型(优化后速度大幅提升) - train_model(epochs=1) # 可改为2轮,仍比原来快很多 + # 第一步:训练模型(优化后速度大幅提升,默认1轮) + # 可根据需求改为2轮,仍比原始版本快很多 + train_model(epochs=1) - # 第二步:加载模型(可选) + # 第二步:加载模型(可选,若已训练过模型,可直接加载无需重新训练) # model.load_state_dict(torch.load('drone_model.pth', map_location=device)) # model.eval() # print('模型已加载') # 第三步:模拟无人机实时图像输入 + # 无人机图像文件夹路径(相对路径,可替换为绝对路径) drone_image_folder = r".\driverless_car\data\potoh" + # 若文件夹不存在,则创建并提示用户放入图片 if not os.path.exists(drone_image_folder): os.makedirs(drone_image_folder) print(f'已创建文件夹:{drone_image_folder},请放入测试图片后重新运行!') else: - drone_real_time_inference(drone_image_folder, delay=0.1) # 低延迟,快速播放 \ No newline at end of file + # 执行实时推理 + drone_real_time_inference(drone_image_folder, delay=0.1) \ No newline at end of file diff --git a/src/driverless_car/main_height.py b/src/driverless_car/main_height.py index e801592db1..4a4ead4792 100644 --- a/src/driverless_car/main_height.py +++ b/src/driverless_car/main_height.py @@ -1,4 +1,4 @@ -#无人机高度保持 +# 导入必要的库 import tkinter as tk from tkinter import ttk, messagebox import numpy as np @@ -111,68 +111,79 @@ def _init_controller(self): class SimpleController: def __init__(self): - # 模拟一个经过训练的控制器(实际使用时加载PyTorch模型) - self.kp = 0.05 # 比例系数(模拟模型学到的参数) - self.kd = 0.02 # 微分系数 + # 模拟一个经过训练的控制器(实际使用时加载PyTorch/TensorFlow模型) + # 无人机高度保持:控制器的核心参数,模拟模型学到的比例和微分系数 + self.kp = 0.05 # 比例系数(对应高度误差的响应强度) + self.kd = 0.02 # 微分系数(对应误差变化率的响应强度,抑制震荡) def predict(self, error, error_rate, current_h): """ - 输入:误差e、误差变化率de、当前高度h - 输出:油门控制量(0~1) + 无人机高度保持:控制器的核心预测逻辑,输入状态输出油门控制量 + 输入:误差e(目标高度-当前高度)、误差变化率de、当前高度h + 输出:油门控制量(0~1,0为最小油门,1为最大油门) """ - # 模拟深度学习模型的输出(实际中是model(inputs)) + # 模拟深度学习模型的输出(实际中是model(inputs)的前向传播) + # 基础油门0.5为悬停基准,叠加比例和微分控制项实现高度保持 throttle = 0.5 + self.kp * error + self.kd * error_rate - # 限制油门范围 + # 限制油门范围在0~1之间,避免超出无人机的物理控制范围 return np.clip(throttle, 0.0, 1.0) return SimpleController() def _update_data(self): - """更新无人机数据(模拟或真实数据)""" + """更新无人机数据(模拟无人机的高度动力学和控制逻辑)""" # 获取当前时间 t = self.time_data[-1] + self.dt if self.time_data else 0.0 self.time_data.append(t) - # 更新目标高度(从输入框读取) + # 更新目标高度(从输入框读取,支持实时修改目标高度,测试高度保持的动态响应) + # 无人机高度保持:实时更新目标高度,模拟用户手动调整无人机的期望高度 try: new_target = float(self.target_entry.get()) self.target_h = new_target except ValueError: - pass # 忽略无效输入 + pass # 忽略无效输入,保持原有目标高度 self.target_height.append(self.target_h) - # 计算当前高度(基于物理模型模拟) + # 计算当前高度(基于简化的物理模型模拟无人机的高度变化) + # 无人机高度保持:核心的高度动力学模拟,反映油门对高度的影响 if not self.current_height: - # 初始高度 - current_h = 0.0 # 从地面开始 + # 初始高度:从地面(0米)开始,模拟无人机起飞阶段 + current_h = 0.0 else: - # 基于上一时刻高度和油门计算当前高度(简化物理模型) + # 基于上一时刻高度和油门计算当前高度(简化的无人机高度物理模型) last_h = self.current_height[-1] last_throttle = self.throttle_data[-1] if self.throttle_data else 0.5 - # 高度变化 = 油门贡献 - 重力衰减 - h_change = (last_throttle - 0.45) * 0.8 # 简化模型:油门>0.45时上升 + # 高度变化 = 油门贡献 - 重力衰减(简化模型:油门>0.45时上升,<0.45时下降) + # 无人机高度保持:油门是控制高度的核心变量,0.45为悬停临界油门 + h_change = (last_throttle - 0.45) * 0.8 # 0.8为高度变化的增益系数 - # 加入噪声(模拟气流) + # 加入噪声(模拟气流扰动,贴近真实的无人机飞行环境) + # 无人机高度保持:气流噪声是影响高度稳定的主要干扰因素 if self.simulate_noise: - h_change += random.gauss(0, 0.15) # 高斯噪声 + h_change += random.gauss(0, 0.15) # 加入高斯噪声,均值0,标准差0.15 + # 计算当前高度:上一高度 + 高度变化 * 采样时间间隔 current_h = last_h + h_change * self.dt self.current_height.append(current_h) - # 计算误差 + # 计算高度误差(目标高度 - 当前高度,是高度保持控制的核心输入) + # 无人机高度保持:误差是控制器的关键输入,误差为正表示需要上升,为负表示需要下降 error = self.target_h - current_h self.error_data.append(error) - # 计算误差变化率 + # 计算误差变化率(反映误差的变化趋势,抑制高度震荡) + # 无人机高度保持:误差变化率用于阻尼控制,避免无人机高度频繁震荡 error_rate = (error - self.error_data[-2]) / self.dt if len(self.error_data) > 1 else 0.0 - # 深度学习控制器计算油门 + # 深度学习控制器计算油门(核心的高度保持控制逻辑) + # 无人机高度保持:控制器根据误差和误差变化率输出油门,实现高度的闭环控制 throttle = self.controller.predict(error, error_rate, current_h) self.throttle_data.append(throttle) - # 限制数据长度 + # 限制数据长度,只保留最近的max_points个数据点,保证绘图的流畅性 if len(self.time_data) > self.max_points: self.time_data.pop(0) self.current_height.pop(0) @@ -181,21 +192,24 @@ def _update_data(self): self.throttle_data.pop(0) def _update_plot(self, frame): - """更新绘图""" + """更新绘图,可视化无人机高度保持的各项数据""" if self.running: self._update_data() + # 实时显示无人机的高度状态,便于监控高度保持的效果 self.status_var.set( f"运行中 | 当前高度: {self.current_height[-1]:.2f}米 | 误差: {self.error_data[-1]:.2f}米") - # 更新高度曲线 + # 更新高度曲线(可视化当前高度和目标高度的偏差,直观反映高度保持效果) + # 无人机高度保持:核心可视化项,观察当前高度是否跟踪目标高度 self.line_current.set_data(self.time_data, self.current_height) self.line_target.set_data(self.time_data, self.target_height) - # 更新误差和油门曲线 + # 更新误差和油门曲线(分析高度误差的变化和油门的控制响应) + # 无人机高度保持:误差曲线反映控制精度,油门曲线反映控制器的输出特性 self.line_error.set_data(self.time_data, self.error_data) self.line_throttle.set_data(self.time_data, self.throttle_data) - # 自动调整坐标轴范围 + # 自动调整坐标轴范围,保证数据始终在视图内 for ax in [self.ax1, self.ax2, self.ax2_twin]: ax.relim() ax.autoscale_view() @@ -203,21 +217,21 @@ def _update_plot(self, frame): return self.line_current, self.line_target, self.line_error, self.line_throttle def start(self): - """开始运行""" + """开始运行,启动无人机高度保持的模拟过程""" self.running = True self.start_btn.config(state=tk.DISABLED) self.pause_btn.config(state=tk.NORMAL) self.status_var.set("启动中...") def pause(self): - """暂停运行""" + """暂停运行,暂停无人机高度保持的模拟过程""" self.running = False self.start_btn.config(state=tk.NORMAL) self.pause_btn.config(state=tk.DISABLED) self.status_var.set("已暂停") def reset(self): - """重置数据""" + """重置数据,清空所有历史数据,恢复初始状态""" self.pause() self.time_data = [] self.current_height = [] @@ -230,7 +244,7 @@ def reset(self): self.canvas.draw() def run(self): - """启动动画""" + """启动动画,开始无人机高度保持的可视化循环""" self.ani = FuncAnimation( self.fig, self._update_plot, interval=int(self.dt * 1000), blit=True, cache_frame_data=False @@ -239,6 +253,7 @@ def run(self): if __name__ == "__main__": + # 无人机高度保持:程序入口,创建主窗口和可视化应用实例 root = tk.Tk() app = DroneHeightVisualizer(root) app.run() \ No newline at end of file diff --git a/src/driverless_car/main_mock.py b/src/driverless_car/main_mock.py index eab7d4c279..a91e7a3e86 100644 --- a/src/driverless_car/main_mock.py +++ b/src/driverless_car/main_mock.py @@ -1,165 +1,244 @@ -#目标跟踪 -import cv2 -import numpy as np -from ultralytics import YOLO -from filterpy.kalman import KalmanFilter -import random - +# 导入必要的库 +import cv2 # OpenCV库,用于图像/视频处理、绘图和显示 +import numpy as np # 数值计算库,用于数组操作和矩阵运算 +from ultralytics import YOLO # 导入YOLOv8模型(来自ultralytics库) +from filterpy.kalman import KalmanFilter # 导入卡尔曼滤波器(来自filterpy库) +import random # 随机数库,用于生成虚拟目标的初始参数和随机运动 + +# -------------------------- +# 虚拟环境类:生成随机移动的目标,模拟无人机拍摄的场景 +# -------------------------- class VirtualEnv: - """虚拟环境:生成随机移动的目标""" + """ + 虚拟环境类:生成指定数量的随机移动目标,模拟无人机的视觉场景 + 功能:初始化目标、更新目标位置(含边界反弹和不规则运动)、渲染场景画面 + """ def __init__(self, width=800, height=600, num_objects=3): - self.width = width - self.height = height - self.objects = [] # 存储目标信息:(x, y, w, h, velocity_x, velocity_y, color) - self._init_objects(num_objects) + """ + 初始化虚拟环境 + :param width: 场景画面宽度(像素),默认800 + :param height: 场景画面高度(像素),默认600 + :param num_objects: 虚拟目标数量,默认3 + """ + self.width = width # 画面宽度 + self.height = height # 画面高度 + self.objects = [] # 存储目标信息:每个元素为[x, y, w, h, velocity_x, velocity_y, color] + # x/y:目标左上角坐标;w/h:目标宽高;velocity_x/y:x/y方向速度;color:目标颜色 + self._init_objects(num_objects) # 初始化虚拟目标 def _init_objects(self, num_objects): - """初始化随机移动的目标""" + """ + 初始化随机移动的目标(内部方法,外部无需调用) + :param num_objects: 目标数量 + """ for _ in range(num_objects): - # 随机初始位置(确保在画面内) + # 随机初始位置(确保目标完全在画面内,避免超出边界) x = random.randint(50, self.width - 50) y = random.randint(50, self.height - 50) + # 随机目标尺寸(宽高在30-60像素之间) w, h = random.randint(30, 60), random.randint(30, 60) - # 随机速度(像素/帧) + # 随机速度(x/y方向,范围-2到2像素/帧,支持正负方向) vx = random.uniform(-2, 2) vy = random.uniform(-2, 2) - # 随机颜色 + # 随机目标颜色(RGB格式,0-255) color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)) + # 将目标信息添加到列表 self.objects.append([x, y, w, h, vx, vy, color]) def update(self): - """更新目标位置(模拟随机移动)""" + """更新目标位置(模拟随机移动和环境约束)""" for obj in self.objects: + # 解包目标信息 x, y, w, h, vx, vy, color = obj - # 更新位置 + # 1. 更新位置(根据速度移动) x += vx y += vy - # 边界反弹(模拟环境约束) + # 2. 边界反弹(当目标碰到画面边界时,反向并随机调整速度) if x <= 0 or x >= self.width - w: - vx = -vx * random.uniform(0.8, 1.2) # 随机调整速度 + vx = -vx * random.uniform(0.8, 1.2) # 反向速度,同时0.8-1.2倍随机调整(模拟非弹性碰撞) if y <= 0 or y >= self.height - h: vy = -vy * random.uniform(0.8, 1.2) - # 随机小幅度改变速度(模拟不规则运动) + # 3. 随机小幅度改变速度(模拟目标的不规则运动,更贴近真实场景) vx += random.uniform(-0.3, 0.3) vy += random.uniform(-0.3, 0.3) - # 更新目标信息 + # 4. 更新目标信息(覆盖原列表) obj[:] = [x, y, w, h, vx, vy, color] def render(self): - """渲染环境画面""" + """ + 渲染环境画面(生成包含目标的图像) + :return: 渲染后的画面(numpy数组,形状为(height, width, 3)) + """ + # 创建黑色背景(全0数组,uint8类型) frame = np.zeros((self.height, self.width, 3), dtype=np.uint8) + # 遍历目标,绘制矩形框 for obj in self.objects: x, y, w, h, _, _, color = obj + # 绘制矩形:参数为画面、左上角坐标、右下角坐标、颜色、线宽 cv2.rectangle(frame, (int(x), int(y)), (int(x + w), int(y + h)), color, 2) return frame - +# -------------------------- +# 目标跟踪器类:结合YOLOv8检测和卡尔曼滤波预测,实现目标跟踪 +# -------------------------- class Tracker: - """目标跟踪器:结合YOLO检测和卡尔曼滤波预测""" + """ + 目标跟踪器类:结合YOLOv8目标检测和卡尔曼滤波预测 + 功能:加载YOLO模型、初始化卡尔曼滤波器、匹配检测结果与跟踪器、更新跟踪状态 + """ def __init__(self, model_path="yolov8n.pt"): - self.detector = YOLO(model_path) # 加载YOLOv8模型 - self.trackers = {} # 跟踪器字典:{id: 卡尔曼滤波器} - self.next_id = 0 # 下一个目标ID + """ + 初始化跟踪器 + :param model_path: YOLOv8模型路径,默认使用轻量化的yolov8n.pt(nano版本) + """ + self.detector = YOLO(model_path) # 加载YOLOv8预训练模型 + self.trackers = {} # 跟踪器字典:{track_id: 卡尔曼滤波器实例},存储每个目标的跟踪器 + self.next_id = 0 # 下一个分配的目标ID(从0开始递增,用于区分不同目标) def _init_kalman(self, bbox): - """初始化卡尔曼滤波器(针对边界框[x, y, w, h])""" + """ + 初始化卡尔曼滤波器(针对边界框[x, y, w, h],8维状态,4维测量) + :param bbox: 初始边界框,格式为[x, y, w, h](x/y:左上角坐标,w/h:宽高) + :return: 初始化后的卡尔曼滤波器实例 + """ + # 初始化卡尔曼滤波器:dim_x=8(状态维度:x, y, w, h, vx, vy, vw, vh),dim_z=4(测量维度:x, y, w, h) + # 状态说明:x/y/w/h为边界框参数,vx/vy/vw/vh为对应参数的速度(假设匀速运动) kf = KalmanFilter(dim_x=8, dim_z=4) - # 状态转移矩阵(假设匀速运动模型) + + # 1. 状态转移矩阵F(定义状态的变化规律,这里采用匀速运动模型) + # 例如:x(t+1) = x(t) + vx(t)*1;vx(t+1) = vx(t) kf.F = np.array([ - [1, 0, 0, 0, 1, 0, 0, 0], - [0, 1, 0, 0, 0, 1, 0, 0], - [0, 0, 1, 0, 0, 0, 1, 0], - [0, 0, 0, 1, 0, 0, 0, 1], - [0, 0, 0, 0, 1, 0, 0, 0], - [0, 0, 0, 0, 0, 1, 0, 0], - [0, 0, 0, 0, 0, 0, 1, 0], - [0, 0, 0, 0, 0, 0, 0, 1] + [1, 0, 0, 0, 1, 0, 0, 0], # x = x + vx + [0, 1, 0, 0, 0, 1, 0, 0], # y = y + vy + [0, 0, 1, 0, 0, 0, 1, 0], # w = w + vw + [0, 0, 0, 1, 0, 0, 0, 1], # h = h + vh + [0, 0, 0, 0, 1, 0, 0, 0], # vx = vx + [0, 0, 0, 0, 0, 1, 0, 0], # vy = vy + [0, 0, 0, 0, 0, 0, 1, 0], # vw = vw + [0, 0, 0, 0, 0, 0, 0, 1] # vh = vh ]) - # 测量矩阵 + + # 2. 测量矩阵H(定义测量值如何映射到状态,只测量x, y, w, h) kf.H = np.array([ - [1, 0, 0, 0, 0, 0, 0, 0], - [0, 1, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 0, 0, 0, 0] + [1, 0, 0, 0, 0, 0, 0, 0], # 测量x + [0, 1, 0, 0, 0, 0, 0, 0], # 测量y + [0, 0, 1, 0, 0, 0, 0, 0], # 测量w + [0, 0, 0, 1, 0, 0, 0, 0] # 测量h ]) - # 噪声协方差矩阵 - kf.R *= 10.0 # 测量噪声 - kf.P *= 1000.0 # 初始状态协方差 - kf.Q[-4:, -4:] *= 0.5 # 过程噪声(速度部分) - # 初始化状态 - kf.x[:4] = np.array(bbox).reshape(4, 1) + + # 3. 噪声协方差矩阵(调整滤波的稳定性和响应速度) + kf.R *= 10.0 # 测量噪声协方差(增大表示信任检测结果的程度降低,默认值*10) + kf.P *= 1000.0 # 初始状态协方差(增大表示初始状态的不确定性高,默认值*1000) + kf.Q[-4:, -4:] *= 0.5 # 过程噪声协方差(速度部分,减小表示信任运动模型的程度高,默认值*0.5) + + # 4. 初始化卡尔曼滤波器的状态(前4维为初始边界框,后4维速度初始化为0) + kf.x[:4] = np.array(bbox).reshape(4, 1) # 转换为列向量赋值 + return kf def update(self, frame): - """更新跟踪:检测目标 -> 匹配跟踪器 -> 预测位置""" - # 1. YOLO目标检测(这里简化为检测所有目标,实际可指定类别) - results = self.detector(frame, classes=[0]) # 假设跟踪"人"(类别0),虚拟目标可适配 - detections = [] + """ + 更新跟踪状态:检测目标 -> 匹配跟踪器 -> 预测位置 -> 返回跟踪结果 + :param frame: 输入画面(numpy数组,来自虚拟环境或无人机摄像头) + :return: 跟踪结果列表,每个元素为(track_id, x1, y1, x2, y2)(x2/y2为右下角坐标) + """ + # -------------------------- + # 1. YOLOv8目标检测(简化版:检测类别0(人),虚拟目标可适配) + # -------------------------- + # 调用YOLO模型检测,classes=[0]表示只检测COCO数据集中的"人"类别(虚拟目标会被识别为其他类别,可根据需求调整) + results = self.detector(frame, classes=[0]) + detections = [] # 存储检测到的边界框,格式为[x, y, w, h] for result in results: for box in result.boxes: - x1, y1, x2, y2 = box.xyxy[0].cpu().numpy() # 边界框坐标 + # 提取边界框的xyxy格式(x1, y1为左上角,x2, y2为右下角) + x1, y1, x2, y2 = box.xyxy[0].cpu().numpy() + # 转换为[x, y, w, h]格式(与卡尔曼滤波器的状态匹配) w, h = x2 - x1, y2 - y1 - detections.append([x1, y1, w, h]) # 存储[x, y, w, h] + detections.append([x1, y1, w, h]) - # 2. 卡尔曼滤波预测与匹配(简化版:距离最近匹配) - new_trackers = {} + # -------------------------- + # 2. 卡尔曼滤波预测与匹配(简化版:欧氏距离最近匹配) + # -------------------------- + new_trackers = {} # 存储更新后的跟踪器(避免修改原字典时的迭代问题) for det in detections: + # 初始化最小距离和最佳匹配ID min_dist = float('inf') best_id = None - # 与现有跟踪器匹配 + # 遍历现有跟踪器,寻找最匹配的目标 for track_id, kf in self.trackers.items(): - # 预测当前位置 + # 卡尔曼滤波器预测当前状态(根据运动模型推测目标位置) kf.predict() - pred = kf.x[:4].flatten() # 预测的[x, y, w, h] - # 计算检测与预测的距离(欧氏距离) + # 获取预测的边界框(前4维,展平为1维数组) + pred = kf.x[:4].flatten() + # 计算检测框与预测框的欧氏距离(距离越小,匹配度越高) dist = np.linalg.norm(np.array(det) - pred) - if dist < min_dist and dist < 50: # 阈值控制匹配 + # 筛选距离小于50(阈值)的最近匹配(阈值可根据场景调整) + if dist < min_dist and dist < 50: min_dist = dist best_id = track_id - # 匹配成功:更新跟踪器 + # 情况1:匹配成功(找到最佳ID),更新对应的卡尔曼滤波器 if best_id is not None: + # 用检测到的边界框更新卡尔曼滤波器(校正预测结果) self.trackers[best_id].update(np.array(det).reshape(4, 1)) + # 将更新后的跟踪器加入新字典 new_trackers[best_id] = self.trackers[best_id] - # 新目标:初始化跟踪器 + # 情况2:无匹配(新目标),初始化新的卡尔曼滤波器 else: + # 为新目标初始化卡尔曼滤波器 new_trackers[self.next_id] = self._init_kalman(det) + # 下一个目标ID递增 self.next_id += 1 + # 更新跟踪器字典为新的跟踪器(移除未匹配的旧跟踪器) self.trackers = new_trackers - # 3. 返回跟踪结果(ID + 预测边界框) + # -------------------------- + # 3. 整理跟踪结果并返回 + # -------------------------- tracks = [] for track_id, kf in self.trackers.items(): + # 获取卡尔曼滤波器的状态(预测的边界框) x, y, w, h = kf.x[:4].flatten() + # 转换为xyxy格式(用于绘图) tracks.append((track_id, int(x), int(y), int(x + w), int(y + h))) return tracks - +# -------------------------- +# 主函数:运行虚拟环境和目标跟踪 +# -------------------------- def main(): - # 初始化虚拟环境和跟踪器 + """主程序:初始化环境和跟踪器,实时运行目标跟踪并显示结果""" + # 1. 初始化虚拟环境(宽度1024,高度768,4个虚拟目标) env = VirtualEnv(width=1024, height=768, num_objects=4) + # 2. 初始化目标跟踪器(使用默认的yolov8n.pt模型) tracker = Tracker() + # 3. 实时循环:更新环境 -> 跟踪目标 -> 绘制结果 -> 显示画面 while True: # 更新虚拟环境(目标移动) env.update() + # 渲染环境画面 frame = env.render() - # 无人机视角跟踪(调用跟踪器) + # 无人机视角跟踪:调用跟踪器更新,获取跟踪结果 tracks = tracker.update(frame) - # 绘制跟踪结果 + # 绘制跟踪结果(绿色矩形框+目标ID) for track_id, x1, y1, x2, y2 in tracks: + # 绘制跟踪框(绿色,线宽2) cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2) + # 绘制目标ID(在框的左上角,字体大小0.5,绿色,线宽2) cv2.putText(frame, f"ID: {track_id}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) - # 显示画面 + # 显示画面(窗口标题为"Drone Tracking (Virtual Objects)") cv2.imshow("Drone Tracking (Virtual Objects)", frame) + # 按键退出:按下q键(30ms延迟,控制帧率) if cv2.waitKey(30) & 0xFF == ord('q'): break + # 释放窗口资源 cv2.destroyAllWindows() - +# 程序入口 if __name__ == "__main__": main() \ No newline at end of file