MMDetection全流程实战指南：手把手带你构建目标检测模型

conda create -n mmdetection python=3.8 -y
conda activate mmdetection

# GPU版本
conda install pytorch torchvision -c pytorch 
# CPU版本
conda install pytorch torchvision cpuonly -c pytorch

import torch
torch.cuda.is_available()
exit()

conda uninstall pytorch torchvision -c pytorch

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

pip install -U openmim
mim install mmengine
mim install "mmcv>=2.0.0"

# 更改地址（按自己要求）
cd /mnt/e
# 在Github上下载
git clone https://github.com/open-mmlab/mmdetection.git
# 进入对应的文件夹
cd mmdetection
# 安装配置文件
pip install -v -e .
# "-v" 指详细说明，或更多的输出# "-e" 表示在可编辑模式下安装项目，因此对代码所做的任何本地修改都会生效，从而无需重新安装。

#步骤 1. 我们需要下载配置文件和模型权重文件。
mim download mmdet --config rtmdet_tiny_8xb32-300e_coco --dest .
#下载将需要几秒钟或更长时间，这取决于你的网络环境。完成后，你会在当前文件夹中发现两个文件 rtmdet_tiny_8xb32-300e_coco.py 和 rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth。

#步骤 2. 推理验证。
python demo/image_demo.py demo/demo.jpg rtmdet_tiny_8xb32-300e_coco.py --weights rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --device cuda
#你会在当前文件夹中的 outputs/vis 文件夹中看到一个新的图像 demo.jpg，图像中包含有网络预测的检测框。

import os
import random
from PIL import Image

# 设置基础目录路径
base_dir = "data"
archive_dir = os.path.join(base_dir, "archive")

# 步骤1：重命名文件夹
os.rename(archive_dir, os.path.join(base_dir, "VOC2007"))

# 更新文件夹变量以匹配新路径
voc_dir = os.path.join(base_dir, "VOC2007")
annotations_dir = os.path.join(voc_dir, "annotations")
images_dir = os.path.join(voc_dir, "images")

# 重命名子文件夹
os.rename(annotations_dir, os.path.join(voc_dir, "Annotations"))
os.rename(images_dir, os.path.join(voc_dir, "JPEGImages"))

# 步骤2：转换图片格式
jpegimages_dir = os.path.join(voc_dir, "JPEGImages")
for filename in os.listdir(jpegimages_dir):
    if not filename.lower().endswith(".jpg"):
        original_image_path = os.path.join(jpegimages_dir, filename)
        image = Image.open(original_image_path)
        converted_filename = os.path.splitext(filename)[0] + '.jpg'
        converted_image_path = os.path.join(jpegimages_dir, converted_filename)
        image.convert('RGB').save(converted_image_path, 'JPEG')  # 将图片转换为RGB格式的JPG文件
        os.remove(original_image_path)  # 删除原始文件

# 步骤3：创建文件夹结构
imagesets_dir = os.path.join(voc_dir, "ImageSets")
main_dir = os.path.join(imagesets_dir, "Main")
os.makedirs(main_dir, exist_ok=True)

# 步骤4：分配图片到train.txt和val.txt
image_filenames = [os.path.splitext(f)[0] for f in os.listdir(jpegimages_dir) if f.lower().endswith('.jpg')]
random.shuffle(image_filenames)
split_index = int(0.8 * len(image_filenames))

train_filenames = image_filenames[:split_index]
val_filenames = image_filenames[split_index:]

with open(os.path.join(main_dir, 'train.txt'), 'w') as file:
    file.write("\n".join(train_filenames))

with open(os.path.join(main_dir, 'val.txt'), 'w') as file:
    file.write("\n".join(val_filenames))

print("已完成")

python tools/dataset_converters/pascal_voc.py data --out-dir data/coco/annotations --out-format coco

python tools/train.py configs/yolo/yolov3_mobilenetv2_8xb24-320-300e_coco.py

python tools/train.py work_dirs/yolov3_mobilenetv2_8xb24-320-300e_coco/yolov3_mobilenetv2_8xb24-320-300e_coco.py

python tools/train.py work_dirs/yolov3_mobilenetv2_8xb24-320-300e_coco/yolov3_mobilenetv2_8xb24-320-300e_coco.py

python tools/analysis_tools/analyze_logs.py plot_curve     work_dirs/yolov3_mobilenetv2_8xb24-320-300e_coco/20231108_113125/vis_data/20231108_113125.json     --keys loss --out results.png --legend loss

python demo/image_demo.py demo/1.jfif work_dirs/yolov3_mobilenetv2_8xb24-320-300e_coco/20231108_113125/vis_data/config.py --weights work_dirs/yolov3_mobilenetv2_8xb24-320-300e_coco/epoch_30.pth --show

# Copyright (c) OpenMMLab. All rights reserved.
import argparse
import os.path as osp
import xml.etree.ElementTree as ET
import shutil
import numpy as np
from mmengine.fileio import dump, list_from_file
from mmengine.utils import mkdir_or_exist, track_progress

from mmdet.evaluation import voc_classes

label_ids = {name: i for i, name in enumerate(voc_classes())}

def parse_xml(args):
    xml_path, img_path = args
    tree = ET.parse(xml_path)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)
    bboxes = []
    labels = []
    bboxes_ignore = []
    labels_ignore = []
    for obj in root.findall('object'):
        name = obj.find('name').text
        label = label_ids[name]
        difficult = obj.find('difficult')
        difficult = 0 if difficult is None else int(difficult.text)  # 设置默认值为0
        bnd_box = obj.find('bndbox')
        bbox = [
            round(float(bnd_box.find('xmin').text)),  # 使用四舍五入取整
            round(float(bnd_box.find('ymin').text)),  # 使用四舍五入取整
            round(float(bnd_box.find('xmax').text)),  # 使用四舍五入取整
            round(float(bnd_box.find('ymax').text))   # 使用四舍五入取整
        ]
        if difficult:
            bboxes_ignore.append(bbox)
            labels_ignore.append(label)
        else:
            bboxes.append(bbox)
            labels.append(label)
    if not bboxes:
        bboxes = np.zeros((0, 4))
        labels = np.zeros((0, ))
    else:
        bboxes = np.array(bboxes, ndmin=2) - 1
        labels = np.array(labels)
    if not bboxes_ignore:
        bboxes_ignore = np.zeros((0, 4))
        labels_ignore = np.zeros((0, ))
    else:
        bboxes_ignore = np.array(bboxes_ignore, ndmin=2) - 1
        labels_ignore = np.array(labels_ignore)
    annotation = {
        'filename': img_path,
        'width': w,
        'height': h,
        'ann': {
            'bboxes': bboxes.astype(np.float32),
            'labels': labels.astype(np.int64),
            'bboxes_ignore': bboxes_ignore.astype(np.float32),
            'labels_ignore': labels_ignore.astype(np.int64)
        }
    }
    return annotation

def cvt_annotations(devkit_path, years, split, out_file):
    if not isinstance(years, list):
        years = [years]
    annotations = []
    for year in years:
        filelist = osp.join(devkit_path,
                            f'VOC{year}/ImageSets/Main/{split}.txt')
        if not osp.isfile(filelist):
            print(f'filelist does not exist: {filelist}, '
                  f'skip voc{year} {split}')
            return
        img_names = list_from_file(filelist)
        xml_paths = [
            osp.join(devkit_path, f'VOC{year}/Annotations/{img_name}.xml')
            for img_name in img_names
        ]
        img_paths = [
            f'VOC{year}/JPEGImages/{img_name}.jpg' for img_name in img_names
        ]
        part_annotations = track_progress(parse_xml,
                                          list(zip(xml_paths, img_paths)))
        annotations.extend(part_annotations)
    if out_file.endswith('json'):
        annotations = cvt_to_coco_json(annotations)
    dump(annotations, out_file)
    return annotations

def cvt_to_coco_json(annotations):
    image_id = 0
    annotation_id = 0
    coco = dict()
    coco['images'] = []
    coco['type'] = 'instance'
    coco['categories'] = []
    coco['annotations'] = []
    image_set = set()

    def addAnnItem(annotation_id, image_id, category_id, bbox, difficult_flag):
        annotation_item = dict()
        annotation_item['segmentation'] = []

        seg = []
        # bbox[] is x1,y1,x2,y2
        # left_top
        seg.append(int(bbox[0]))
        seg.append(int(bbox[1]))
        # left_bottom
        seg.append(int(bbox[0]))
        seg.append(int(bbox[3]))
        # right_bottom
        seg.append(int(bbox[2]))
        seg.append(int(bbox[3]))
        # right_top
        seg.append(int(bbox[2]))
        seg.append(int(bbox[1]))

        annotation_item['segmentation'].append(seg)

        xywh = np.array(
            [bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]])
        annotation_item['area'] = int(xywh[2] * xywh[3])
        if difficult_flag == 1:
            annotation_item['ignore'] = 0
            annotation_item['iscrowd'] = 1
        else:
            annotation_item['ignore'] = 0
            annotation_item['iscrowd'] = 0
        annotation_item['image_id'] = int(image_id)
        annotation_item['bbox'] = xywh.astype(int).tolist()
        annotation_item['category_id'] = int(category_id)
        annotation_item['id'] = int(annotation_id)
        coco['annotations'].append(annotation_item)
        return annotation_id + 1

    for category_id, name in enumerate(voc_classes()):
        category_item = dict()
        category_item['supercategory'] = str('none')
        category_item['id'] = int(category_id)
        category_item['name'] = str(name)
        coco['categories'].append(category_item)

    for ann_dict in annotations:
        file_name = ann_dict['filename']
        ann = ann_dict['ann']
        assert file_name not in image_set
        image_item = dict()
        image_item['id'] = int(image_id)
        image_item['file_name'] = str(file_name)
        image_item['height'] = int(ann_dict['height'])
        image_item['width'] = int(ann_dict['width'])
        coco['images'].append(image_item)
        image_set.add(file_name)

        bboxes = ann['bboxes'][:, :4]
        labels = ann['labels']
        for bbox_id in range(len(bboxes)):
            bbox = bboxes[bbox_id]
            label = labels[bbox_id]
            annotation_id = addAnnItem(
                annotation_id, image_id, label, bbox, difficult_flag=0)

        bboxes_ignore = ann['bboxes_ignore'][:, :4]
        labels_ignore = ann['labels_ignore']
        for bbox_id in range(len(bboxes_ignore)):
            bbox = bboxes_ignore[bbox_id]
            label = labels_ignore[bbox_id]
            annotation_id = addAnnItem(
                annotation_id, image_id, label, bbox, difficult_flag=1)

        image_id += 1

    return coco

def parse_args():
    parser = argparse.ArgumentParser(
        description='Convert PASCAL VOC annotations to mmdetection format')
    parser.add_argument('devkit_path', help='pascal voc devkit path')
    parser.add_argument('-o', '--out-dir', help='output path')
    parser.add_argument(
        '--out-format',
        default='coco',
        choices=('pkl', 'coco'),
        help='output format, "coco" indicates coco annotation format')
    args = parser.parse_args()
    return args

def copy_images_to_folders(devkit_path, out_dir):
    jpeg_images_dir = osp.join(devkit_path, 'JPEGImages')
    image_sets_main_dir = osp.join(devkit_path, 'ImageSets', 'Main')

    splits_and_dirs = {
        'train': 'train2017',
        'test': 'test2017',
        'val': 'val2017'
    }

    for split, new_dir_name in splits_and_dirs.items():
        txt_file = osp.join(image_sets_main_dir, f'{split}.txt')
        new_folder = osp.join(out_dir, new_dir_name)
        mkdir_or_exist(new_folder)  # Ensure the directory exists

        with open(txt_file, 'r') as f:
            img_names = [line.strip() for line in f.readlines()]

        for img_name in img_names:
            src_img_path = osp.join(jpeg_images_dir, f'{img_name}.jpg')
            dest_img_path = osp.join(new_folder, f'{img_name}.jpg')
            shutil.copy(src_img_path, dest_img_path)

import os.path as osp
import shutil

def copy_images_to_dest(src_dir, dest_dir, img_list_file):
    """复制图片到目标文件夹"""
    with open(img_list_file, 'r') as f:
        lines = f.readlines()
        img_names = [line.strip() + '.jpg' for line in lines]
        print(f"Copying {len(img_names)} images from {src_dir} to {dest_dir} ...")
        for img_name in img_names:
            src_path = osp.join(src_dir, img_name)
            dest_path = osp.join(dest_dir, img_name)
            if not osp.exists(src_path):
                print(f"Image {src_path} does not exist!")
                continue
            shutil.copy(src_path, dest_path)
            print(f"Copied {img_name} to {dest_dir}")

def main():
    args = parse_args()
    devkit_path = args.devkit_path
    out_dir = args.out_dir if args.out_dir else devkit_path
    mkdir_or_exist(out_dir)

    years = []
    if osp.isdir(osp.join(devkit_path, 'VOC2007')):
        years.append('2007')
    if osp.isdir(osp.join(devkit_path, 'VOC2012')):
        years.append('2012')
    if '2007' in years and '2012' in years:
        years.append(['2007', '2012'])

    if not years:
        raise IOError(f'The devkit path {devkit_path} contains neither '
                      '"VOC2007" nor "VOC2012" subfolder')

    out_fmt = f'.{args.out_format}'
    if args.out_format == 'coco':
        out_fmt = '.json'

    for year in years:
        if isinstance(year, list):
            multi_year = year
        else:
            multi_year = [year]

        for y in multi_year:
            for split in ['train', 'val']:
                if split == 'train':
                    dataset_name = 'instances_train2017'
                    sub_folder = 'train2017'
                elif split == 'val':
                    dataset_name = 'instances_val2017'
                    sub_folder = 'val2017'
                else:
                    continue

                print(f'processing {dataset_name} for VOC{y} ...')
                cvt_annotations(devkit_path, y, split,
                                osp.join(out_dir, dataset_name + out_fmt))

                # 创建并复制图片到对应的文件夹
                img_out_dir = osp.join(out_dir, "..", sub_folder, f'VOC{y}', 'JPEGImages')
                mkdir_or_exist(img_out_dir)
                img_list_file = osp.join(devkit_path, f'VOC{y}', 'ImageSets', 'Main', f'{split}.txt')
                src_img_dir = osp.join(devkit_path, f'VOC{y}', 'JPEGImages')
                copy_images_to_dest(src_img_dir, img_out_dir, img_list_file)

    print('Done!')

if __name__ == '__main__':
    main()