之前写了一个基于YOLOv8做旋转目标检测（OBB）的文章，内容写得不够好，内容也有些杂乱无序。现如今YOLO已经更新到11了，数据集也集齐了无人机和卫星的农业大棚，所以这次就写一个基于YOLO11 OBB的农业大棚旋转检测。

1. 下载源码配置环境

        在https://github.com/ultralytics/ultralytics网页下载YOLO11源码，解压缩后创建虚拟环境即可，环境创建不是很难，这里就不细说了。

2. 数据集准备

2.1 数据标注

        这里我使用LabelImg2标注无人机和卫星影像，我是在一整张大幅影像上对影像中的农业大棚进行标注的，最后面使用算法将影像裁剪成合适的尺寸用于训练，后面会详细介绍整个流程。

 卫星影像中的农业大棚

无人机影像中的农业大棚

        在LabelImg2上标注好数据，LabelImg2标注是五点式，即旋转框的中心x，y坐标、旋转框的长度和宽度、旋转角度。如下图所示：

         从图中可以看到影像大小为 7176 X 5080 ，影像为RGB3通道，标注了两个旋转框，旋转框标签为默认的"dog"。

2.2 XML标注文件转DOTA格式标签文件（TXT）

       新建一个名为roxml_to_dota.py的python脚本，复制粘贴下面的代码：

# 文件名称   ：roxml_to_dota.py
# 功能描述   ：把rolabelimg标注的xml文件转换成dota能识别的xml文件，
#             再转换成dota格式的txt文件
#            把旋转框 cx,cy,w,h,angle，或者矩形框cx,cy,w,h,转换成四点坐标x1,y1,x2,y2,x3,y3,x4,y4
import os
import xml.etree.ElementTree as ET
import math
 
cls_list = ['dog']  # 修改为自己的标签
 
 
def edit_xml(xml_file, dotaxml_file):
    """
    修改xml文件
    :param xml_file:xml文件的路径
    :return:
    """
 
    # dxml_file = open(xml_file,encoding='gbk')
    # tree = ET.parse(dxml_file).getroot()
 
    tree = ET.parse(xml_file)
    objs = tree.findall('object')
    for ix, obj in enumerate(objs):
        x0 = ET.Element("x0")  # 创建节点
        y0 = ET.Element("y0")
        x1 = ET.Element("x1")
        y1 = ET.Element("y1")
        x2 = ET.Element("x2")
        y2 = ET.Element("y2")
        x3 = ET.Element("x3")
        y3 = ET.Element("y3")
        # obj_type = obj.find('bndbox')
        # type = obj_type.text
        # print(xml_file)
 
        if (obj.find('robndbox') == None):
            obj_bnd = obj.find('bndbox')
            obj_xmin = obj_bnd.find('xmin')
            obj_ymin = obj_bnd.find('ymin')
            obj_xmax = obj_bnd.find('xmax')
            obj_ymax = obj_bnd.find('ymax')
            # 以防有负值坐标
            xmin = max(float(obj_xmin.text), 0)
            ymin = max(float(obj_ymin.text), 0)
            xmax = max(float(obj_xmax.text), 0)
            ymax = max(float(obj_ymax.text), 0)
            obj_bnd.remove(obj_xmin)  # 删除节点
            obj_bnd.remove(obj_ymin)
            obj_bnd.remove(obj_xmax)
            obj_bnd.remove(obj_ymax)
            x0.text = str(xmin)
            y0.text = str(ymax)
            x1.text = str(xmax)
            y1.text = str(ymax)
            x2.text = str(xmax)
            y2.text = str(ymin)
            x3.text = str(xmin)
            y3.text = str(ymin)
        else:
            obj_bnd = obj.find('robndbox')
            obj_bnd.tag = 'bndbox'  # 修改节点名
            obj_cx = obj_bnd.find('cx')
            obj_cy = obj_bnd.find('cy')
            obj_w = obj_bnd.find('w')
            obj_h = obj_bnd.find('h')
            obj_angle = obj_bnd.find('angle')
            cx = float(obj_cx.text)
            cy = float(obj_cy.text)
            w = float(obj_w.text)
            h = float(obj_h.text)
            angle = float(obj_angle.text)
            obj_bnd.remove(obj_cx)  # 删除节点
            obj_bnd.remove(obj_cy)
            obj_bnd.remove(obj_w)
            obj_bnd.remove(obj_h)
            obj_bnd.remove(obj_angle)
 
            x0.text, y0.text = rotatePoint(cx, cy, cx - w / 2, cy - h / 2, -angle)
            x1.text, y1.text = rotatePoint(cx, cy, cx + w / 2, cy - h / 2, -angle)
            x2.text, y2.text = rotatePoint(cx, cy, cx + w / 2, cy + h / 2, -angle)
            x3.text, y3.text = rotatePoint(cx, cy, cx - w / 2, cy + h / 2, -angle)
 
        # obj.remove(obj_type)  # 删除节点
        obj_bnd.append(x0)  # 新增节点
        obj_bnd.append(y0)
        obj_bnd.append(x1)
        obj_bnd.append(y1)
        obj_bnd.append(x2)
        obj_bnd.append(y2)
        obj_bnd.append(x3)
        obj_bnd.append(y3)
 
        tree.write(dotaxml_file, method='xml', encoding='utf-8')  # 更新xml文件
 
 
# 转换成四点坐标
def rotatePoint(xc, yc, xp, yp, theta):
    xoff = xp - xc;
    yoff = yp - yc;
    cosTheta = math.cos(theta)
    sinTheta = math.sin(theta)
    pResx = cosTheta * xoff + sinTheta * yoff
    pResy = - sinTheta * xoff + cosTheta * yoff
    return str(int(xc + pResx)), str(int(yc + pResy))
 
 
def totxt(xml_path, out_path):
    # 想要生成的txt文件保存的路径，这里可以自己修改
 
    files = os.listdir(xml_path)
    i = 0
    for file in files:
 
        tree = ET.parse(xml_path + os.sep + file)
        root = tree.getroot()
 
        name = file.split('.')[0]
 
        output = out_path + '\\' + name + '.txt'
        file = open(output, 'w')
        i = i + 1
        objs = tree.findall('object')
        for obj in objs:
            cls = obj.find('name').text
            box = obj.find('bndbox')
            x0 = int(float(box.find('x0').text))
            y0 = int(float(box.find('y0').text))
            x1 = int(float(box.find('x1').text))
            y1 = int(float(box.find('y1').text))
            x2 = int(float(box.find('x2').text))
            y2 = int(float(box.find('y2').text))
            x3 = int(float(box.find('x3').text))
            y3 = int(float(box.find('y3').text))
            if x0 < 0:
                x0 = 0
            if x1 < 0:
                x1 = 0
            if x2 < 0:
                x2 = 0
            if x3 < 0:
                x3 = 0
            if y0 < 0:
                y0 = 0
            if y1 < 0:
                y1 = 0
            if y2 < 0:
                y2 = 0
            if y3 < 0:
                y3 = 0
            for cls_index, cls_name in enumerate(cls_list):
                if cls == cls_name:
                    file.write("{} {} {} {} {} {} {} {} {} {}\n".format(x0, y0, x1, y1, x2, y2, x3, y3, cls, cls_index))
        file.close()
        # print(output)
        print(i)
 
 
if __name__ == '__main__':
    # -----**** 第一步：把xml文件统一转换成旋转框的xml文件 ****-----
    roxml_path = r'D:\yolo11\data\origin_xml'  # labelimg2标注生成的原始xml文件路径
    dotaxml_path = r'D:\yolo11\data\dota_xml'  # 转换后dota能识别的xml文件路径，路径需存在，不然报错
    out_path = r'D:\yolo11\data\dota_txt'  # 转换后dota格式的txt文件路径，路径需存在，不然报错
    filelist = os.listdir(roxml_path)
    for file in filelist:
        edit_xml(os.path.join(roxml_path, file), os.path.join(dotaxml_path, file))
 
    # -----**** 第二步：把旋转框xml文件转换成txt格式 ****-----
    totxt(dotaxml_path, out_path)

        注意事项：小心修改文件路径，别搞错了，即

if __name__ == '__main__':
    # -----**** 第一步：把xml文件统一转换成旋转框的xml文件 ****-----
    roxml_path = r'D:\data\yolov8_obb\origin_xml'  # labelimg2标注生成的原始xml文件路径
    dotaxml_path = r'D:\data\yolov8_obb\dota_xml'  # 转换后dota能识别的xml文件路径，路径需存在，不然报错
    out_path = r'D:\data\yolov8_obb\dota_txt'  # 转换后dota格式的txt文件路径，路径需存在，不然报错
    filelist = os.listdir(roxml_path)
    for file in filelist:
        edit_xml(os.path.join(roxml_path, file), os.path.join(dotaxml_path, file))
 
    # -----**** 第二步：把旋转框xml文件转换成txt格式 ****-----
    totxt(dotaxml_path, out_path)

         下面是转换后的TXT格式的标签文件（此时的标签还不是YOLO OBB数据集的格式，还需要再转换）

2.3 标签更改

        我在标注的过程中使用的是LabelImg2软件中默认的标签名，即"dog"。在这里我使用代码将其中的标签修改为自己的标签，即"dp"。

        新建一个名为change_label.py的python文件，复制粘贴下面的代码：

import os
 
 
def replace_text_in_files(folder_path, old_text, new_text):
    # 遍历指定文件夹
    for filename in os.listdir(folder_path):
        # 检查文件是否是.txt文件
        if filename.endswith(".txt"):
            file_path = os.path.join(folder_path, filename)
            # 读取文件内容
            with open(file_path, 'r', encoding='utf-8') as file:
                file_data = file.read()
 
            # 替换文本
            updated_data = file_data.replace(old_text, new_text)
 
            # 写入更改后的内容
            with open(file_path, 'w', encoding='utf-8') as file:
                file.write(updated_data)
 
 
# 调用函数，将'dog'替换为'dp'
replace_text_in_files(r'D:\yolo11\greenhouse\roxml_to_dota\xml_to_txt', 'dog', 'dp')

        下面是更改标签后的txtTXT文件内容：

2.4 DOTA格式标签文件转换为YOLO OBB训练所需的格式

（1）TIF格式影像（下载的卫星影像是tif格式）转换为PNG格式

        创建一个名为tif_to_png.py的python文件，复制粘贴下面的代码：

import os
import tifffile
from PIL import Image
import numpy as np
 
def tif2png_high_quality(tif_folder, png_folder):
    """
    将tif文件夹中的所有tif图像转换为png图像，并尽可能保持图像质量。
    Args:
        tif_folder: 包含tif图像的文件夹路径。
        png_folder: 保存png图像的文件夹路径。
    """
 
    if not os.path.exists(png_folder):
        os.makedirs(png_folder)
 
    for filename in os.listdir(tif_folder):
        if filename.endswith(".tif") or filename.endswith(".tiff"):
            tif_filepath = os.path.join(tif_folder, filename)
            png_filepath = os.path.join(png_folder, filename.replace(".tif", ".png").replace(".tiff", ".png"))
 
            try:
                # 使用tifffile库读取tif图像，可以更好地处理各种tif格式和元数据
                tif_image = tifffile.imread(tif_filepath)
 
                #  如果tif图像是多通道的，需要进行一些处理，例如转换为RGB图像或者分别保存每个通道
                if tif_image.ndim == 3 and tif_image.shape[2] > 3: #处理多波段图像，例如大于3个波段的遥感图像
                    # 可以选择需要的波段合成RGB图像，或者保存所有波段为单独的png文件
                    # 这里以合成RGB图像为例，假设前三个波段是RGB波段
                    tif_image = tif_image[:,:,:3] # 取前三个波段
                    tif_image = np.clip(tif_image, 0, 255).astype(np.uint8) # 裁剪像素值到0-255，并转换为uint8类型
                    img = Image.fromarray(tif_image)
 
 
                elif tif_image.dtype == np.uint16: #16位图像处理，转换为8位
                    img = Image.fromarray((tif_image / 256).astype(np.uint8))
                else: # 其他情况直接转换
                    img = Image.fromarray(tif_image)
 
                # 使用 Pillow 库保存 png 图像, 可以指定更高的压缩质量
                img.save(png_filepath, "PNG", compress_level=1) # compress_level 1 表示最小压缩，质量最高
                print(f"已将 {tif_filepath} 转换为 {png_filepath}")
 
            except Exception as e:
                print(f"转换 {tif_filepath} 时出错: {e}")
 
 
 
# 示例用法：
tif_folder = "tif_images"  # 替换为你的tif图像文件夹路径
png_folder = "png_images"  # 替换为你想保存png图像的文件夹路径
tif2png_high_quality(tif_folder, png_folder)

        设置好图像文件夹路径，将TIF图像转换为PNG格式的图像 

 （2）在项目代码目录下面创建下面的文件夹结构，然后将划分好的图像和标签文件放到相应的文件夹中 （这里我直接使用v8教程里面的图）

（3）编写转换标注格式的代码

        创建一个名为convert_dota_to_yolo_obb.py的python文件，复制粘贴下面的代码：

import sys
# yolo11源码文件夹
sys.path.append('D:\yolo11')
 
from ultralytics.data.converter import convert_dota_to_yolo_obb
# 上一步骤中设置的文件夹结构根目录
convert_dota_to_yolo_obb('D:\yolo11\greenhouse\data')

        由于官方源码转换代码用的是VOC数据集，所以这里我们需要修改ultralytics/data/

converter.py中的类别名，改成自己的数据集类别名。修改ultralytics/data/converter.py中的代码：先注释掉原有的class_mapping代码，然后按照原有格式写入自己的类别，我的即为：

class_mapping = {
    "dp": 0,
}

        转换后的YOLO OBB数据集格式的标签会保存在labels\train和labels\val中（训练需要使用的就是这两个文件夹，train_original和val_original用不到）

        转换后的OBB数据集格式的标签文件中的内容

2.5 png格式影像裁剪

       在项目代码目录下面创建下面的文件夹结构，然后将OBB格式的标签文件和对应的图像放到相应的文件夹中 （labels里面的train_original和val_original文件夹不需要，不用创建这两个文件夹，截图里面多余了）

        创建一个名为split_images.py的python文件，复制粘贴下面的代码：

from ultralytics.data.split_dota import split_test, split_trainval
 
# 分割训练集和验证集，同时包含标签。标签需要是YOLO格式的，
# 即：0 0.332813 0.164062 0.403125 0.15 0.45 0.373437 0.379688 0.389062
#
# @param data_root str，数据根目录的路径。
# @param save_dir str，保存分割后数据集的目录路径。
# @param rates list，用于设定不同尺度分割比例的列表，例如[0.5, 1.0, 1.5]表示三个尺度。
# @param gap int，设定在数据集中间隔多少个像素进行一次分割。
split_trainval(
    data_root=r"D:\yolo11\datasets",
    save_dir=r"D:\yolo11\DOTAv1.0-split",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=100,
)
 
# 分割测试集，不包含标签。
#
# @param data_root str，数据根目录的路径。
# @param save_dir str，保存分割后数据集的目录路径。
# @param rates list，用于设定不同尺度分割比例的列表，例如[0.5, 1.0, 1.5]表示三个尺度。
# @param gap int，设定在数据集中间隔多少个像素进行一次分割。
split_test(
    data_root=r"D:\yolo11\datasets",
    save_dir=r"D:\yolo11\DOTAv1.0-split",
    rates=[0.5，1.0, 1.5],  # multiscale
    gap=100,

        裁剪的图像尺寸可以在split_dota里面修改，可以修改成自己需要的，比如说1280,1024,

960,768,640等等。如果设置裁剪大小为640 x 640，那么rates中的0.5代表图像大小为320 X 320，1.5代表图像大小为960 X 960。建议设置合适的多尺度图像大小用于训练和验证，这样泛化性能可能会好一些。rates可以设置为[0.3, 1.0, 1.3]。

        运行代码之后裁剪的图像和对应的标注文件会在DOTAv1.0-split文件夹中。要查看裁剪得到了多少张图像，可以直接看DOTAv1.0-split\labels里面对应的文件夹，看DOTAv1.0-split\images是难以知道的，因为images里面包含了有标签的图像和没有标签的图像。

        这里我其实有点疑惑，我原本是想把所有图像裁剪了再划分数据集，但是这里按照ultralytics里面的代码意思，似乎是先将所有的大幅影像先划分为训练影像、验证影像和测试影像，裁剪之后即是对应的数据集，但是先将所有的大幅影像先划分为训练影像、验证影像和测试影像的做法似乎不太科学，因为这样的话每个数据集中的图像差异可能比较大，这样训练得到的结果可能泛化性并不好。我觉得可能不如统一裁剪之后随机划分数据集的做法，个人目前比较粗浅的看法。。。

2.6 挑选有标签的图像

        上一步骤中裁剪得到的图像数量和标签数量是不匹配的，因为有些没有标签的图像没有舍弃掉。所有这里需要写个算法将有标签的图像挑选出来，与标签一一对应。

        创建一个名为pick_images.py的python文件，复制粘贴下面的代码：

import os
import shutil
 
# 裁剪得到的标签的文件夹
labels_dir = r'D:\yolo11\DOTAv1.0-split\labels\train'
# 裁剪得到图像的文件夹
images_dir = r'D:\yolo11\DOTAv1.0-split\images\train'
# 存放挑选出来的图像的文件夹
pick_dir = r'D:\yolo11\DOTAv1.0-split\images\pick'
 
# 确保 pick_dir 存在
os.makedirs(pick_dir, exist_ok=True)
 
# 获取 labels_dir 下的所有 .txt 文件
label_files = [f for f in os.listdir(labels_dir) if f.endswith('.txt')]
 
for label_file in label_files:
    # 提取文件名（不包括扩展名）
    base_name = os.path.splitext(label_file)[0]
    
    # 构建对应的图像文件路径
    image_jpg_path = os.path.join(images_dir, base_name + '.jpg')
    image_png_path = os.path.join(images_dir, base_name + '.png')
    
    # 检查是否存在对应的图像文件
    if os.path.exists(image_jpg_path):
        # 复制图像文件到 pick_dir
        shutil.copy(image_jpg_path, pick_dir)
        print(f"已复制 {image_jpg_path} 到 {pick_dir}")
    elif os.path.exists(image_png_path):
        # 复制图像文件到 pick_dir
        shutil.copy(image_png_path, pick_dir)
        print(f"已复制 {image_png_path} 到 {pick_dir}")
    else:
        print(f"未找到与 {label_file} 对应的图像文件")
 
 
 

2.7 数据集划分

        先构建好文件夹结构，文件夹结构如下（用的YOLOv8中的图，所有图像放在img文件夹下，所有txt放在dotatxt文件夹下），至于文件夹为什么是这样的结构我现在还不懂。。。

        使用下面的代码划分数据集

import os
import random
import shutil
 
random.seed(42)
 
"""
该脚本用于将给定的数据集分割成训练集和测试集。
数据集应包含图像和对应的标注文件。
脚本会按照90%训练集和10%测试集的比例进行分割，并将图像和标注文件分别复制到相应的文件夹中。
"""
 
# 设置数据集文件夹路径和输出文件夹路径
data_folder = 'data_mouse_ro'
img_folder = 'data_mouse_ro/dataset/images'
label_folder = 'data_mouse_ro/dataset/labels'
 
# 计算每个子集的大小
# 总文件数乘以0.9得到训练集大小，其余为测试集大小
total_files = len(os.listdir(os.path.join(data_folder, 'img')))
train_size = int(total_files * 0.9)
test_size = int(total_files - train_size)
 
# 获取所有图像文件的文件名列表，并进行随机打乱
image_files = os.listdir(os.path.join(data_folder, 'img'))
random.shuffle(image_files)
 
# 复制图像和标注文件到相应的子集文件夹中
# 枚举每个图像文件，根据索引决定复制到训练集还是测试集文件夹
for i, image_file in enumerate(image_files):
    base_file_name = os.path.splitext(image_file)[0]  # 获取文件名（不包括扩展名）
    image_path = os.path.join(data_folder, 'img', image_file)
    label_path = os.path.join(data_folder, 'dotatxt', base_file_name + '.txt')
 
    # 根据索引判断文件应复制到训练集还是测试集
    if i < train_size:
        shutil.copy(image_path, os.path.join(img_folder, 'train'))  # 复制图像到训练集
        shutil.copy(label_path, os.path.join(label_folder, 'train_original'))  # 复制标注到训练集
    else:
        shutil.copy(image_path, os.path.join(img_folder, 'val'))  # 复制图像到测试集
        shutil.copy(label_path, os.path.join(label_folder, 'val_original'))  # 复制标注到测试集

3. 模型配置

（1）新建模型配置文件my-data-obb.yaml

        在yolo11\ultralytics\cfg\datasets路径下，新建my-data-obb.yaml文件（复制粘贴其中某一个yaml文件改个名字），写入如下代码，其中参数根据自己的情况设置

# Ultralytics YOLO ?, AGPL-3.0 license
# COCO 2017 dataset https://cocodataset.org by Microsoft
# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
# Example usage: yolo train data=coco.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco  ← downloads here (20.1 GB)
 
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: datasets # dataset root dir
train: images/train # train images (relative to 'path') 118287 images
val: images/val # val images (relative to 'path') 5000 images
test: images/val # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
 
# Classes----我的数据集类别只有一个，即dp----
names:
  0: dp

（2）修改模型配置文件yolo11-obb.yaml

        在yolo11\ultralytics\cfg\models\11路径下，修改yolo11-obb.yaml文件，将nc参数修改为自己的数据集类别数。我听别的博主说这里不改没有关系，会根据前面设置的my-data-obb.yaml文件修改。

4. 训练

（1）根据自己的实际情况修改yolo11\ultralytics\cfg\default.yaml文件中的训练参数

        训练参数设置

        下面是其他的参数设置

        验证、测试参数设置

        推理参数设置

       可视化参数设置

        导出参数设置

        超参数设置

（2）运行下面的代码即可开始训练（路径和参数根据自己的情况设置）

        不使用权重进行训练

from ultralytics import YOLO
 
# Load a model
model = YOLO("/home/jun/object_detect/yolo11/ultralytics/cfg/models/11/yolo11-obb.yaml")
 
# Train the model
train_results = model.train(
    data="/home/jun/object_detect/yolo11/ultralytics/cfg/datasets/my-data-obb.yaml",  # path to dataset YAML
    epochs=1400,  # number of training epochs
    batch=4,
    workers=0,
    amp=False,
    imgsz=640,  # training image size
    device="0",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
    pretrained=False,
    verbose=True,
    optimizer="AdamW",
)
 
# Evaluate model performance on the validation set
metrics = model.val()
 

        使用权重进行训练（这里就不需要模型配置文件yolo11-obb.yaml了，除非你修改了模型结构）

from ultralytics import YOLO
 
# Load a model-----这里直接加载权重文件
model = YOLO("yolo11n-obb.pt")
 
# Train the model
train_results = model.train(
    data="/home/jun/object_detect/yolo11/ultralytics/cfg/datasets/my-data-obb.yaml",  # path to dataset YAML
    epochs=1400,  # number of training epochs
    batch=4,
    workers=0,
    amp=False,
    imgsz=640,  # training image size
    device="0",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
    pretrained=False,
    verbose=True,
    optimizer="AdamW",
)
 
# Evaluate model performance on the validation set
metrics = model.val()

5. 验证

        在yolo11目录下创建一个名为val.py的脚本，复制粘贴下面的代码，其中的参数根据自己的情况设置

from ultralytics import YOLO
 
# Load a model----加载自己训练好的权重
model = YOLO("yolo11n-obb.pt")
 
# Customize validation settings
validation_results = model.val(data="my-data-obb.yaml", imgsz=640, batch=16, conf=0.25, iou=0.6, device="0")
 
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # a list contains map50-95 of each category

6. 推理

        在yolo11目录下创建一个名为predict.py的脚本，复制粘贴下面的代码，其中的参数根据自己的情况设置

from ultralytics import YOLO
 
# Load a model
model = YOLO("yolo11n-obb.pt")  # pretrained YOLO11n model
 
# Run batched inference on a list of images
results = model(["image1.jpg", "image2.jpg"])  # return a list of Results objects
# results = model("path/to/your/images")  # 这里可以直接放文件夹路径，会推理完里面的全部图像
 
# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    # result.save(filename="result.jpg")  # save to disk

        模型配置、训练、验证、推理的更多细节可以阅读ultralytics的官方文档，里面会有详细的说明。

        农业大棚无人机图像234张，卫星图像999张，两者数量不均衡，总体数量也不用够多，下次会解决这些问题。

        这只是一个篇分享经验的文章，难免有错误或者遗漏的地方，欢迎交流指正。

PS：

这里插播一下RT-DETR模型的训练代码：

from ultralytics import RTDETR
 
# Load a COCO-pretrained RT-DETR-l model
model = RTDETR("/home/jun/yolo11/ultralytics/cfg/models/rt-detr/rtdetr-resnet50.yaml")
 
# Display model information (optional)
model.info()
 
# Train the model
train_results = model.train(
    data="/home/jun/yolo11/ultralytics/cfg/datasets/my-data.yaml",  # path to dataset YAML
    epochs=1400,  # number of training epochs
    batch=4,
    amp=False,
    workers=0,
    imgsz=640,  # training image size
    device="0",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
    pretrained=False,
    verbose=True,
    optimizer="AdamW",
)
 
# Evaluate model performance on the validation set
metrics = model.val()