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