Bắt đầu

Dataset DOTA với OBB

Dataset DOTA là benchmark quy mô lớn cho phát hiện đối tượng trong ảnh trên không, được phát hành qua ba phiên bản (v1.0, v1.5, v2.0) với tối đa 1,7 triệu chú thích hộp giới hạn xoay (OBB) trên 18 danh mục, thu thập từ nhiều loại cảm biến và nền tảng trên không.

Khám phá các dataset DOTA v1.5 và DOTA v1.0 được lưu trữ chính thức trên Ultralytics Platform để xem trước các chú thích xoay, kiểm tra thống kê và sao chép dataset để huấn luyện.

Các lớp đối tượng trong dataset DOTA dùng cho phát hiện trên không

Tính năng chính#



Xem: Cách huấn luyện Ultralytics YOLO trên dataset DOTA cho bounding box định hướng trong Google Colab
  • Tập hợp dữ liệu từ nhiều loại cảm biến và nền tảng, với kích thước ảnh từ 800 × 800 đến 20.000 × 20.000 pixel.
  • Có hơn 1,7 triệu hộp giới hạn xoay thuộc 18 danh mục.
  • Hỗ trợ phát hiện đối tượng đa tỉ lệ nhờ phạm vi kích thước đối tượng rộng trong mỗi ảnh.
  • Các chuyên gia chú thích đối tượng bằng tứ giác tùy ý (8 bậc tự do), thể hiện đối tượng ở nhiều tỉ lệ, hướng và hình dạng khác nhau.

Các phiên bản dataset#

DOTA-v1.0#

  • Bao gồm 15 danh mục phổ biến.
  • Gồm 2.806 ảnh với 188.282 đối tượng.
  • Tỉ lệ chia tập: 1/2 cho huấn luyện (1.411 ảnh), 1/6 cho xác thực (458 ảnh) và 1/3 cho kiểm thử (937 ảnh).

DOTA-v1.5#

DOTA-v2.0#

  • Tập hợp ảnh từ Google Earth, vệ tinh GF-2 và các ảnh trên không khác.
  • Bao gồm 18 danh mục phổ biến.
  • Bao gồm 11.268 ảnh với 1.793.658 instance.
  • Các danh mục mới được bổ sung: "sân bay" và "bãi đáp trực thăng".
  • Các tập ảnh:
    • Huấn luyện: 1.830 ảnh với 268.627 đối tượng.
    • Xác thực: 593 ảnh với 81.048 đối tượng.
    • Test-dev: 2.792 ảnh với 353.346 đối tượng.
    • Test-challenge: 6.053 ảnh với 1.090.637 đối tượng.

Cấu trúc dataset#

DOTA có cấu trúc dữ liệu phù hợp với các bài toán phát hiện đối tượng OBB:

  • Ảnh: Tập hợp lớn các ảnh hàng không độ phân giải cao, ghi lại nhiều địa hình và công trình khác nhau.
  • Hộp giới hạn định hướng: Các chú giải dưới dạng hình chữ nhật xoay bao quanh đối tượng bất kể hướng của chúng, lý tưởng để ghi nhận các đối tượng như máy bay, tàu thuyền và tòa nhà.

Ứng dụng#

DOTA được dùng làm benchmark để huấn luyện và đánh giá các model phục vụ phân tích ảnh hàng không. Các chú giải hộp giới hạn định hướng biến DOTA thành một bài kiểm tra đầy thách thức đối với các model phát hiện đối tượng trên các đối tượng hàng không bị xoay và nằm dày đặc. Bộ dữ liệu này được sử dụng rộng rãi trong viễn thám, giám sát và quan trắc môi trường.

YAML của dataset#

Tệp YAML của bộ dữ liệu chỉ định các thư mục gốc chứa ảnh/nhãn, tên lớp và siêu dữ liệu quan trọng khác. Ultralytics duy trì các tệp YAML chính thức cho hai bản phát hành được sử dụng phổ biến nhất:

Sử dụng YAML tương ứng với bản phát hành bạn đã tải xuống, hoặc tự tạo YAML nếu bạn đang làm việc với DOTA-v2 hay một biến thể khác. Cả hai bản phát hành sẽ tự động tải xuống (2 GB) từ tài nguyên GitHub của Ultralytics trong lần đầu tiên bạn huấn luyện.

DOTAv1.yaml
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# DOTA 1.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2
# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── DOTAv1 ← downloads here (2 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: DOTAv1 # dataset root dir
train: images/train # train images (relative to 'path') 1411 images
val: images/val # val images (relative to 'path') 458 images
test: images/test # test images (optional) 937 images

# Classes for DOTA 1.0
names:
  0: plane
  1: ship
  2: storage tank
  3: baseball diamond
  4: tennis court
  5: basketball court
  6: ground track field
  7: harbor
  8: bridge
  9: large vehicle
  10: small vehicle
  11: helicopter
  12: roundabout
  13: soccer ball field
  14: swimming pool

# Download script/URL (optional)
download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.zip

Chia ảnh DOTA#

Ảnh gốc thường có kích thước mỗi cạnh vượt quá 10.000 pixel, vì vậy nên chia ảnh thành các ô trước khi đưa dữ liệu vào YOLO. Sử dụng hàm trợ giúp bên dưới để cắt ảnh nguồn thành các crop chồng lấp 1024 × 1024 ở nhiều tỷ lệ, đồng thời giữ cho chú giải luôn đồng bộ.

Chia ảnh
from ultralytics.data.split_dota import split_test, split_trainval

# Chia tập train và val, kèm nhãn.
split_trainval(
    data_root="path/to/DOTAv1.0/",
    save_dir="path/to/DOTAv1.0-split/",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=500,
)
# Chia tập test, không kèm nhãn.
split_test(
    data_root="path/to/DOTAv1.0/",
    save_dir="path/to/DOTAv1.0-split/",
    rates=[0.5, 1.0, 1.5],  # multiscale
    gap=500,
)
Mẹo

Sắp xếp thư mục đầu ra theo cấu trúc YOLO tiêu chuẩn (images/train, labels/train, v.v.) để bạn có thể tham chiếu trực tiếp đến thư mục đó trong YAML của bộ dữ liệu.

Cách sử dụng#

Để huấn luyện model YOLO26n-obb trên bộ dữ liệu DOTA v1, hãy dùng các đoạn code sau. Luôn tham khảo tài liệu của model để xem danh sách đầy đủ các đối số hiện có. Nếu muốn thử nghiệm trước với một tập con nhỏ hơn, hãy cân nhắc dùng bộ dữ liệu DOTA8, chỉ gồm 8 ảnh để kiểm thử nhanh và có thể duyệt trên Ultralytics Platform.

Cấp phép và nguồn gốc bộ dữ liệu

Tất cả hình ảnh và chú thích đi kèm trong bộ dữ liệu DOTAv1 chỉ được phép sử dụng cho mục đích học thuật; nghiêm cấm sử dụng cho mục đích thương mại. Ultralytics hiểu rằng các hạn chế này áp dụng cho bộ dữ liệu nguồn, không áp dụng cho trọng số model đã được pretrained hoặc fine-tune. Hãy xem điều khoản DOTA để xác định mục đích sử dụng dự kiến của bạn.

Ví dụ huấn luyện
from ultralytics import YOLO

# Tải model YOLO26n-OBB đã huấn luyện trước
model = YOLO("yolo26n-obb.pt")

# Huấn luyện model trên dataset DOTAv1
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)

Dữ liệu mẫu và annotation#

Ví dụ bên dưới cho thấy các cảnh và chú giải DOTA điển hình:

Bộ dữ liệu DOTA với chú giải hộp giới hạn định hướng

  • Ví dụ về DOTA: Ảnh chụp này cho thấy mức độ phức tạp của các cảnh hàng không và tầm quan trọng của chú giải hộp giới hạn định hướng, ghi nhận các đối tượng theo hướng tự nhiên của chúng.

Các cảnh này làm nổi bật những thách thức phát hiện đặc thù của ảnh hàng không. DOTA-v2.0 được sử dụng rộng rãi trong các dự án viễn thám và giám sát hàng không nhờ chú giải toàn diện và danh mục đối tượng đa dạng.

Trích dẫn và lời cảm ơn#

Nếu sử dụng DOTA trong công trình của mình, vui lòng trích dẫn các bài nghiên cứu liên quan:

Trích dẫn
@article{9560031,
  author={Ding, Jian and Xue, Nan and Xia, Gui-Song and Bai, Xiang and Yang, Wen and Yang, Michael and Belongie, Serge and Luo, Jiebo and Datcu, Mihai and Pelillo, Marcello and Zhang, Liangpei},
  journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
  title={Object Detection in Aerial Images: A Large-Scale Benchmark and Challenges},
  year={2022},
  volume={44},
  number={11},
  pages={7778-7796},
  doi={10.1109/TPAMI.2021.3117983}
}

Chúng tôi cảm ơn nhóm phát triển các bộ dữ liệu DOTA đã biên soạn những bộ dữ liệu này. Để xem thông tin đầy đủ về bộ dữ liệu, hãy truy cập trang web DOTA chính thức.

Câu hỏi thường gặp#

  • Bộ dữ liệu DOTA là bộ dữ liệu chuyên biệt tập trung vào phát hiện đối tượng trong ảnh hàng không. Bộ dữ liệu này có hộp giới hạn định hướng (OBB), cung cấp ảnh được chú giải từ nhiều cảnh hàng không khác nhau. Sự đa dạng về hướng, tỷ lệ và hình dạng đối tượng trong 1,7 triệu chú giải và 18 danh mục khiến DOTA trở nên lý tưởng để phát triển và đánh giá các model được thiết kế cho phân tích ảnh hàng không, chẳng hạn như các model dùng trong giám sát, theo dõi môi trường và quản lý thảm họa.

  • DOTA sử dụng Hộp giới hạn định hướng (OBB) để chú giải, được biểu diễn bằng các hình chữ nhật xoay bao quanh đối tượng bất kể hướng của đối tượng. Phương pháp này đảm bảo các đối tượng, dù nhỏ hay nằm ở nhiều góc độ khác nhau, đều được ghi nhận chính xác. Ảnh đa tỷ lệ của bộ dữ liệu, có kích thước từ 800 × 800 đến 20.000 × 20.000 pixel, cũng cho phép phát hiện hiệu quả cả đối tượng nhỏ lẫn lớn. Cách tiếp cận này đặc biệt hữu ích với ảnh hàng không, nơi đối tượng xuất hiện ở nhiều góc độ và tỷ lệ khác nhau.

  • Để huấn luyện model trên bộ dữ liệu DOTA, bạn có thể dùng ví dụ sau với Ultralytics YOLO:

    Ví dụ huấn luyện
    from ultralytics import YOLO
    
    # Tải model YOLO26n-OBB đã huấn luyện trước
    model = YOLO("yolo26n-obb.pt")
    
    # Huấn luyện model trên dataset DOTAv1
    results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)

    Để biết thêm chi tiết về cách chia và tiền xử lý ảnh DOTA, hãy tham khảo phần chia ảnh DOTA.

    • DOTA-v1.0: Bao gồm 15 danh mục phổ biến trong 2.806 ảnh với 188.282 đối tượng. Bộ dữ liệu được chia thành các tập huấn luyện, xác thực và kiểm thử.
    • DOTA-v1.5: Phát triển dựa trên DOTA-v1.0 bằng cách chú giải các đối tượng rất nhỏ (dưới 10 pixel) và bổ sung một danh mục mới, "cần cẩu container", nâng tổng số lên 403.318 đối tượng.
    • DOTA-v2.0: Mở rộng thêm với chú giải từ Google Earth và vệ tinh GF-2, gồm 11.268 ảnh và 1.793.658 đối tượng. Bộ dữ liệu bổ sung các danh mục mới như "sân bay" và "bãi đáp trực thăng".

    Để xem so sánh chi tiết và thông tin cụ thể khác, hãy xem phần phiên bản bộ dữ liệu.

  • Ảnh DOTA có thể rất lớn nên được chia thành các ảnh có độ phân giải nhỏ hơn để thuận tiện cho việc huấn luyện. Dưới đây là đoạn mã Python để chia ảnh:

    Ví dụ
    from ultralytics.data.split_dota import split_test, split_trainval
    
    # chia tập train và val, kèm nhãn.
    split_trainval(
        data_root="path/to/DOTAv1.0/",
        save_dir="path/to/DOTAv1.0-split/",
        rates=[0.5, 1.0, 1.5],  # multiscale
        gap=500,
    )
    # chia tập test, không kèm nhãn.
    split_test(
        data_root="path/to/DOTAv1.0/",
        save_dir="path/to/DOTAv1.0-split/",
        rates=[0.5, 1.0, 1.5],  # multiscale
        gap=500,
    )

    Quy trình này giúp cải thiện hiệu quả huấn luyện và hiệu năng model. Để xem hướng dẫn chi tiết, hãy truy cập phần chia ảnh DOTA.

Bình luận17

Đặt câu hỏi, chia sẻ kết quả hoặc giúp đỡ người khác.

  1. XWP-PPPGitHub

    May I ask how you converted the inference results from YOLOV8 OBB into inference results that can be uploaded to DOTA's Task 1 server? I saved the final inference results of the model in the form of xyxyxy and uploaded them via email. However, the mAP results provided on YOLO's official website differ significantly. I would like to know the reason for this. Can you provide me with a conversion code to convert the test image set into a result that can be uploaded to DOTA's Task 1 server? Thank you very much for your help!

    1
    1. Paula DerrengerUltralytics(đã chỉnh sửa)

      @XWP-PPP hi there!

      DOTA's Task 1 server expects a zip of one text file per class (Task1_plane.txt, Task1_storage-tank.txt, ...), where each line is imgname score x1 y1 x2 y2 x3 y3 x4 y4, with the image name given without extension. OBB results are stored in result.obb, not result.boxes. Here is a snippet that builds those files:

      import shutil
      from collections import defaultdict
      from pathlib import Path
      
      from ultralytics import YOLO
      
      # Load your trained YOLO26-OBB model
      model = YOLO("path/to/your/yolo26n-obb.pt")
      
      # Collect one DOTA Task1 line per detection: imgname score x1 y1 x2 y2 x3 y3 x4 y4 (pixels)
      category_results = defaultdict(list)
      for r in model.predict(source="path/to/test/images", stream=True):
          img_name = Path(r.path).stem
          for cls, conf, pts in zip(r.obb.cls.int().tolist(), r.obb.conf.tolist(), r.obb.xyxyxyxy.flatten(1).tolist()):
              coords = " ".join(f"{p:.1f}" for p in pts)
              category_results[f"Task1_{model.names[cls].replace(' ', '-')}.txt"].append(f"{img_name} {conf:.6f} {coords}\n")
      
      # Save one file per category and zip the submission folder
      output_dir = Path("submission")
      output_dir.mkdir(exist_ok=True)
      for category_file, lines in category_results.items():
          (output_dir / category_file).write_text("".join(lines))
      shutil.make_archive("submission", "zip", output_dir)

      Upload submission.zip to the DOTA Task 1 server. If your mAP differs from your local validation, check that image names match the test set and that the coordinates are in pixels of the original (unsplit) images. For more details, see the DOTA Dataset Documentation. Happy coding! 😊

  2. Taufiq-Ahmed-prantoGitHub

    Hi, I want to use the DOTA dataset only for YOLOv11 Nano. I don't want to use the model with oriented bounding boxes (OBB). What is the procedure?

  3. Jie Liu

    I have download dotav1 form https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.zip and use script split dataset.

    from ultralytics.data.split_dota import split_test, split_trainval
    
    # split train and val set, with labels.
    split_trainval(
        data_root="/dataset/coco/DOTAv1",
        save_dir="/dataset/coco/DOTAv1.0-split/",
        rates=[0.5, 1.0, 1.5],  # multiscale
        gap=500,
    )
    # split test set, without labels.
    split_test(
        data_root="/dataset/coco/DOTAv1/",
        save_dir="/dataset/coco/DOTAv1.0-split/",
        rates=[0.5, 1.0, 1.5],  # multiscale
        gap=500,
    )

    how to reproduce yolov11 obb result, please show me the command like

    yolo train model=ultralytics-8.3.13/ultralytics/cfg/models/11/yolo11n-obb.yaml data=DOTAv1/DOTAv1.yaml epochs=500 batch=32*4 imgsz=640 device=4,5,6,7 cache=disk amp=True
    1. Glenn JocherUltralytics(đã chỉnh sửa)

      @keeper-jie for training YOLO26-OBB on DOTAv1 after splitting, use this command with your 4 GPUs:
      yolo obb train data=DOTAv1.yaml model=yolo26n-obb.pt epochs=500 imgsz=1024 batch=128 device=4,5,6,7

      Key parameters from our DOTA documentation:

      • imgsz=1024 (matches dataset's multiscale split)
      • Use official model name yolo26n-obb.pt rather than YAML path
      • Batch size 128 (32*4 GPUs) via batch=128

      Ensure your dataset YAML paths point to the split images directory.

  4. huynhkhoa44GitHub

    I have labeled data in YOLOv8 object detection format, our label data format is already rotated rectangles to the correct angle of the object, however since it is in YOLOv8 object detection format, the "angle" parameter is missing. I no longer keep the label folder on CVAT so I cannot export to a different label format. Is there a way to add the angle value from the 4 pre-existing <x_center> <y_center> values?

    1. Glenn JocherUltralytics

      To add the angle value from your existing YOLOv8 labels, you'll need to calculate it based on the coordinates. Unfortunately, without the original CVAT labels, this requires manual computation or using a tool that supports angle annotations. For guidance on datasets with oriented bounding boxes, you can refer to the DOTA dataset documentation at https://docs.ultralytics.com/datasets/obb/dota-v2/.

  5. jack-readyGitHub

    Recently, I've been using YOLOv8 to train the DOTAv1 dataset and encountered some issues. I was wondering if I could seek advice. 1.To train the DOTA dataset, we split the original DOTA images with high-resolution into images with 1024x1024. I noticed that the provided segmentation code provides three sizes, rates=[0.5, 1.0, 1.5]. In order to obtain 1024×1024 images, it seems that we should choose rates=1, but I noticed that some images in the segmentation results of the validation set are smaller than 1024×1024, such as 1024×1023, 824*1024, etc. What is the reason for this?Will it affect the experiment? 2.Another issue arises during the training process. I noticed that the training process conducts validation after each epoch. I attempted to disable validation by setting val=False, but it seems to have no effect. What could be the reason for this? The training code snippet is as follows: results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=640, batch=10, workers=0, val=False). Additionally, during validation, it seems that the images are not being resized to 640. Printing the results in the code yields torch.Size([10, 3, 672, 672]), whereas during the training process, images are correctly resized to 640. Could someone help me understand this?

    1. Glenn JocherUltralytics(đã chỉnh sửa)

      @jack-ready hi there!

      Thank you for reaching out with your questions regarding training the DOTA dataset with YOLOv8. Let's address each of your concerns:

      1. Image Splitting and Sizes: When splitting high-resolution DOTA images into 1024x1024 segments using rates=[0.5, 1.0, 1.5], you might notice some resulting images are slightly smaller than 1024x1024 (e.g., 1024x1023 or 824x1024). This occurs due to the way the splitting algorithm handles the edges of the original images. If the original image dimensions are not perfectly divisible by 1024, the last segment in each row or column might be smaller. This should not significantly affect your experiment as long as the majority of your data maintains the expected size. However, you can ensure consistency by padding these smaller images to 1024x1024 if necessary.

      2. Disabling Validation: The val=False argument should indeed disable validation during training. If it doesn't seem to work, please ensure you are using the latest version of the Ultralytics package. You can update it using:

        pip install --upgrade ultralytics

        If the issue persists, providing a minimum reproducible example would be very helpful for us to diagnose the problem. You can find guidance on creating one here: Minimum Reproducible Example.

      3. Image Resizing During Validation: The discrepancy in image sizes during validation (e.g., torch.Size([10, 3, 672, 672]) instead of 640) might be due to the model's internal resizing logic. Ensure that the imgsz parameter is correctly set for both training and validation. Validation uses the same imgsz as training, so set it explicitly in your training script:

        results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=640, batch=10, workers=0, val=True)

      I hope this helps! If you have any further questions or need additional assistance, feel free to ask. Happy training! 🚀

    2. jack-readyGitHub

      Thank you very much for your help. I have another question regarding the YOLOV8 training on the DOTA v1.0 dataset. I would like to know how to set the training parameters, such as learning rate, optimizer, and loss function. When I try to reproduce the results, my mAP50 is about 74%, but it does not reach 78%. I would greatly appreciate any assistance you can provide.Below is my training code. from ultralytics import YOLO model = YOLO("yolov8n-obb.yaml") model.load("yolov8n-obb.pt") model = YOLO("yolov8n-obb.yaml").load("yolov8n.pt") results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=640, batch=48, workers=0,project="runs/DOTAV1.0",val=True,resume=True)

    3. Glenn JocherUltralytics(đã chỉnh sửa)

      Hi there! Glad to help with your training setup. To fine-tune your training parameters for better mAP50 results, you can adjust the learning rate, optimizer, and loss function. For instance, you might try a lower learning rate or switch to a different optimizer like Adam. Here's a quick example:

      from ultralytics import YOLO
      
      model = YOLO("yolo26n-obb.yaml").load("yolo26n-obb.pt")
      results = model.train(
          data="DOTAv1.yaml", 
          epochs=100, 
          imgsz=640, 
          batch=48, 
          workers=0, 
          project="runs/DOTAV1.0", 
          val=True, 
          lr0=0.001,  # Adjust learning rate
          optimizer='Adam'  # Change optimizer
      )

      Ensure you're using the latest version of the Ultralytics package to avoid any bugs. If you still face issues, feel free to share more details. Happy training! 🚀

  6. Tintin26100GitHub

    How can I find the number of instances per class in DOTA v1.5 ? I've been searching for this information for a moment and I can't find any answers

    1. Paula DerrengerUltralytics

      @Tintin26100 hello!

      The number of instances per class in DOTA v1.5 isn't directly listed in the dataset's summary. However, you can obtain this information by analyzing the annotation files provided with the dataset. Each object instance in these files is labeled with a class, and you can count the number of times each class appears.

      If you need further guidance on how to process these annotation files or any other assistance with the DOTA dataset, feel free to ask!

      Happy coding! 😊

    2. Tintin26100GitHub

      Hi, thanks for your quick answer, I will gladly accept your help because I don't really know what to do to extract those informations, where do you find the annotation files ? Is it on the github ? If it is what's it's path ? Thanks for the time you spend helping

    3. Paula DerrengerUltralytics

      @Tintin26100 hello!

      The annotation files for the DOTA dataset are typically included within the dataset download itself. These files contain the details for each instance, including class labels and oriented bounding box coordinates.

      For the DOTA v1.5 dataset, you can find these files in the dataset directory after you download it from the official DOTA dataset page or the provided download link in the dataset's YAML configuration file. The path to the annotations will usually be structured under the labels or annotations directory within the main dataset folder.

      If you've already downloaded the dataset, you should look for .txt or .json files corresponding to each image in the dataset, which contain the annotations. If you need further assistance navigating these files or extracting specific data, feel free to ask!

      Thank you for reaching out, and happy analyzing! 😊

    1. Glenn JocherUltralytics(đã chỉnh sửa)

      Hey there! 😊 Testing the DOTA dataset online using YOLO26-obb is quite straightforward. If you've already prepared your dataset according to the Ultralytics guidelines and split the images, here's a simple example to get you started with training:

      # Train a YOLO26n-OBB model on the DOTA v1 dataset
      yolo obb train data=DOTAv1.yaml model=yolo26n-obb.pt epochs=100 imgsz=640

      This command uses DOTA v1 and the corresponding .yaml file (DOTAv1.yaml) describing your dataset paths and classes. Adjust epochs and imgsz based on your needs.

      Just make sure to check out the DOTA dataset page on Ultralytics docs for more info on dataset preparation and additional configurations! Happy detecting! 🚀