无人机视角垃圾检测，26700余张无人机图像，超过4万标注信息，共3.6GB数据量，可用于环卫快速检查，垃圾快速定位等应用。

好的，无人机视角垃圾检测是一个非常实用的应用，可以显著提高环卫工作的效率。以下是一个基于PyTorch的完整代码示例，涵盖了数据加载、模型构建、训练、验证和评估等关键步骤。我们将使用YOLOv5作为目标检测模型，因为它在实时检测任务中表现出色。

1. 环境准备

首先，确保你已经安装了必要的库和工具。你可以使用以下命令安装所需的库：

pip install torch torchvision opencv-python pandas
pip install -U albumentations
pip install -U pyyaml
pip install -U yolov5

2. 数据准备

假设你的数据集目录结构如下：

dataset/
├── images/
│   ├── train/
│   └── val/
└── labels/
    ├── train/
    └── val/

其中，images文件夹包含训练和验证的图像，labels文件夹包含相应的标签文件（YOLO格式的txt文件）。

3. 数据加载

import os
import cv2
import pandas as pd
from torch.utils.data import Dataset, DataLoader
from albumentations import Compose, Resize, Normalize, HorizontalFlip, VerticalFlip, RandomRotate90
from albumentations.pytorch import ToTensorV2

class GarbageDetectionDataset(Dataset):
    def __init__(self, image_dir, label_dir, transform=None):
        self.image_dir = image_dir
        self.label_dir = label_dir
        self.transform = transform
        self.image_files = os.listdir(image_dir)

    def __len__(self):
        return len(self.image_files)

    def __getitem__(self, idx):
        img_path = os.path.join(self.image_dir, self.image_files[idx])
        label_path = os.path.join(self.label_dir, os.path.splitext(self.image_files[idx])[0] + '.txt')

        image = cv2.imread(img_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        labels = []
        if os.path.exists(label_path):
            with open(label_path, 'r') as f:
                lines = f.readlines()
                for line in lines:
                    class_id, x_center, y_center, width, height = map(float, line.strip().split())
                    labels.append([class_id, x_center, y_center, width, height])

        if self.transform:
            transformed = self.transform(image=image, bboxes=labels, class_labels=[label[0] for label in labels])
            image = transformed['image']
            labels = transformed['bboxes']

        return image, labels

# 数据增强
transform = Compose([
    Resize(640, 640),
    Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    HorizontalFlip(p=0.5),
    VerticalFlip(p=0.5),
    RandomRotate90(p=0.5),
    ToTensorV2()
])

# 创建数据集
train_dataset = GarbageDetectionDataset(image_dir='dataset/images/train', label_dir='dataset/labels/train', transform=transform)
val_dataset = GarbageDetectionDataset(image_dir='dataset/images/val', label_dir='dataset/labels/val', transform=transform)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False, num_workers=4)

4. 模型构建

import torch
import yolov5

# 加载预训练的YOLOv5模型
model = yolov5.models.yolov5s(pretrained=True)

# 修改模型的类别数
model.model[-1].nc = 1  # 假设只有一个类别：垃圾
model.model[-1].export = False

# 将模型移到GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

5. 训练和验证

import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
from tqdm import tqdm

# 定义损失函数和优化器
criterion = yolov5.loss.Computeloss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)

# 训练函数
def train(model, dataloader, criterion, optimizer, device):
    model.train()
    running_loss = 0.0
    for images, targets in tqdm(dataloader, desc='Training'):
        images = images.to(device)
        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    return running_loss / len(dataloader)

# 验证函数
def validate(model, dataloader, criterion, device):
    model.eval()
    running_loss = 0.0
    with torch.no_grad():
        for images, targets in tqdm(dataloader, desc='Validating'):
            images = images.to(device)
            targets = [{k: v.to(device) for k, v in t.items()} for t in targets]

            outputs = model(images)
            loss = criterion(outputs, targets)

            running_loss += loss.item()

    return running_loss / len(dataloader)

# 训练和验证
num_epochs = 10
for epoch in range(num_epochs):
    train_loss = train(model, train_loader, criterion, optimizer, device)
    val_loss = validate(model, val_loader, criterion, device)
    scheduler.step()

    print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}')

6. 评估和可视化

import matplotlib.pyplot as plt

# 可视化预测结果
def visualize_predictions(model, dataloader, device, num_images=5):
    model.eval()
    fig, axes = plt.subplots(1, num_images, figsize=(20, 5))

    with torch.no_grad():
        for i, (images, targets) in enumerate(dataloader):
            if i >= num_images:
                break

            images = images.to(device)
            targets = [{k: v.to(device) for k, v in t.items()} for t in targets]

            outputs = model(images)
            predictions = yolov5.utils.general.non_max_suppression(outputs)[0]

            image = images[0].cpu().numpy().transpose(1, 2, 0)
            image = (image * [0.229, 0.224, 0.225] + [0.485, 0.456, 0.406]) * 255
            image = image.astype(np.uint8)

            for pred in predictions:
                x1, y1, x2, y2, conf, cls = pred
                x1, y1, x2, y2 = map(int, [x1, y1, x2, y2])
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, f'{conf:.2f}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

            axes[i].imshow(image)
            axes[i].axis('off')

    plt.show()

visualize_predictions(model, val_loader, device)

7. 总结

以上代码提供了一个完整的框架，用于实现基于YOLOv5的无人机视角垃圾检测。代码包括数据加载、模型构建、训练、验证和结果可视化等多个步骤