VisDrone 데이터셋
VisDrone 데이터셋은 대규모 드론 이미지 벤치마크입니다. 탐지 하위 세트(VisDrone2019-DET)는 객체 탐지를 위해 어노테이션된 항공 이미지 8,629장(학습 6,471장, 검증 548장, test-dev 1,610장)을 제공합니다. 이 데이터셋은 중국 톈진대학교의 머신러닝 및 데이터 마이닝 연구실 AISKYEYE 팀이 만들었습니다.
시청: VisDrone 데이터셋으로 Ultralytics YOLO를 학습하는 방법 | 항공 감지 | 전체 튜토리얼 🚀
VisDrone 전체 벤치마크는 중국의 14개 도시에서 드론 장착 카메라로 촬영한 동영상 클립 288개(프레임 261,908개)와 정지 이미지 10,209장으로 구성됩니다. 도시와 농촌 환경, 한산한 장면과 혼잡한 장면, 다양한 날씨와 조명 조건을 아우릅니다. 프레임에는 장면 가시성, 객체 클래스, 가림 여부 등의 추가 속성과 함께 260만 개가 넘는 수동 어노테이션 바운딩 박스가 포함됩니다. Ultralytics VisDrone.yaml 구성은 이 벤치마크의 정지 이미지 하위 세트인 VisDrone2019-DET를 사용합니다.
주요 기능#
- 작고 밀집된 객체: 항공 시점에서는 대상이 작고 밀집되어 있습니다. 검증 이미지 548장에만 레이블이 지정된 박스가 38,759개 포함되어 이미지당 평균 약 70개 객체가 있습니다.
- 장면 다양성: 중국 14개 도시의 이미지로, 도시와 농촌 지역, 주간과 야간, 다양한 날씨 조건을 포함합니다.
- 풍부한 어노테이션: 전체 벤치마크에 260만 개가 넘는 박스가 있으며, 가림 및 가시성 속성이 포함됩니다.
- 사전 정의된 분할: 일관된 평가를 위해 학습/검증/test-dev 분할(이미지 6,471장/548장/1,610장)이 고정되어 있습니다.
데이터셋 구조#
Ultralytics VisDrone 구성은 VisDrone2019-DET 이미지 하위 세트를 포함하며, 다음 세 부분으로 나뉩니다:
| 분할 | 이미지 | 설명 |
|---|---|---|
| 학습 | 6,471 | 검출기 학습에 사용하는 레이블이 지정된 항공 이미지 |
| 검증 | 548 | 개발 중 평가에 사용하는 이미지 |
| Test-dev | 1,610 | 학습된 모델의 최종 평가를 위해 분리해 둔 이미지 |
네 번째 분할인 test-challenge(이미지 1,580장)는 VisDrone 대회를 위해 공개되지 않으며 다운로드되지 않습니다. 따라서 전체 DET 세트는 총 10,209장입니다.
데이터셋에는 보행자, 사람, 자전거, 자동차, 밴, 트럭, 삼륜차, 지붕형 삼륜차, 버스, 오토바이의 10개 객체 클래스가 어노테이션되어 있습니다. VisDrone은 pedestrian(서 있거나 걷는 사람)과 people(그 밖의 자세를 취한 사람)을 구분합니다.
처음 사용할 때 다운로드 스크립트는 원본 VisDrone 어노테이션을 YOLO 형식으로 변환하고, 무시 대상으로 표시된 영역은 건너뜁니다(사용하지 않는 "others" 카테고리도 제외됩니다).
응용 분야#
VisDrone의 조밀한 장면과 작은 표적은 항공 시점의 소형 객체 감지를 위한 표준 벤치마크가 됩니다. 일반적인 드론 컴퓨터 비전 애플리케이션은 다음과 같습니다:
- UAV를 활용한 교통 모니터링 및 차량 계수
- 군중 분석 및 공공 안전 감시
- 인프라 및 건설 현장 점검
- 복잡한 장면에서 작은 객체를 탐지하는 컴퓨터 비전 연구
다른 항공 이미지 벤치마크는 위성 이미지 중심의 xView 데이터셋 또는 방향성 박스를 사용하는 DOTA-v2 데이터셋을 참조하세요.
데이터셋 YAML#
VisDrone.yaml 파일은 데이터셋 경로, 클래스 이름, 자동 다운로드 및 변환 스크립트를 포함한 데이터셋 구성을 정의합니다. 이 파일은 Ultralytics 저장소의 https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml에서 관리됩니다.
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
# Documentation: https://docs.ultralytics.com/datasets/detect/visdrone
# Example usage: yolo train data=VisDrone.yaml
# parent
# ├── ultralytics
# └── datasets
# └── VisDrone ← 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: VisDrone # dataset root dir
train: images/train # train images (relative to 'path') 6471 images
val: images/val # val images (relative to 'path') 548 images
test: images/test # test-dev images (optional) 1610 images
# Classes
names:
0: pedestrian
1: people
2: bicycle
3: car
4: van
5: truck
6: tricycle
7: awning-tricycle
8: bus
9: motor
# Download script/URL (optional) ---------------------------------------------------------------------------------------
download: |
import os
from pathlib import Path
import shutil
from ultralytics.utils.downloads import download
from ultralytics.utils import ASSETS_URL, TQDM
def visdrone2yolo(dir, split, source_name=None):
"""Convert VisDrone annotations to YOLO format with images/{split} and labels/{split} structure."""
from PIL import Image
source_dir = dir / (source_name or f"VisDrone2019-DET-{split}")
images_dir = dir / "images" / split
labels_dir = dir / "labels" / split
labels_dir.mkdir(parents=True, exist_ok=True)
# Move images to new structure
if (source_images_dir := source_dir / "images").exists():
images_dir.mkdir(parents=True, exist_ok=True)
for img in source_images_dir.glob("*.jpg"):
img.rename(images_dir / img.name)
for f in TQDM((source_dir / "annotations").glob("*.txt"), desc=f"Converting {split}"):
img_size = Image.open(images_dir / f.with_suffix(".jpg").name).size
dw, dh = 1.0 / img_size[0], 1.0 / img_size[1]
lines = []
with open(f, encoding="utf-8") as file:
for row in [x.split(",") for x in file.read().strip().splitlines()]:
if row[4] != "0": # Skip ignored regions
x, y, w, h = map(int, row[:4])
cls = int(row[5]) - 1
# Convert to YOLO format
x_center, y_center = (x + w / 2) * dw, (y + h / 2) * dh
w_norm, h_norm = w * dw, h * dh
lines.append(f"{cls} {x_center:.6f} {y_center:.6f} {w_norm:.6f} {h_norm:.6f}\n")
(labels_dir / f.name).write_text("".join(lines), encoding="utf-8")
# Download (ignores test-challenge split)
dir = Path(yaml["path"]) # dataset root dir
urls = [
f"{ASSETS_URL}/VisDrone2019-DET-train.zip",
f"{ASSETS_URL}/VisDrone2019-DET-val.zip",
f"{ASSETS_URL}/VisDrone2019-DET-test-dev.zip",
# f"{ASSETS_URL}/VisDrone2019-DET-test-challenge.zip",
]
download(urls, dir=dir, threads=4)
# Convert
splits = {"VisDrone2019-DET-train": "train", "VisDrone2019-DET-val": "val", "VisDrone2019-DET-test-dev": "test"}
for folder, split in splits.items():
visdrone2yolo(dir, split, folder) # convert VisDrone annotations to YOLO labels
shutil.rmtree(dir / folder) # cleanup original directory사용법#
VisDrone은 처음 학습할 때 자동으로 다운로드됩니다. 세 개의 아카이브를 합한 용량은 약 2GB이며, 압축 해제 및 변환 중에는 디스크 여유 공간이 약 4GB 필요합니다.
다음 코드 조각을 사용하면 이미지 크기 640으로 VisDrone 데이터셋에서 100 에포크 동안 YOLO26n 모델을 학습할 수 있습니다.
from ultralytics import YOLO
# 모델 로드
model = YOLO("yolo26n.pt") # 사전 학습된 모델을 불러옵니다(학습에 권장).
# 모델을 학습합니다 - 데이터셋은 첫 실행 시 자동으로 다운로드됩니다
results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)항공 이미지를 추가로 레이블링하고 브라우저에서 VisDrone 학습 실행을 관리하려면 Ultralytics Platform을 사용하세요.
샘플 데이터 및 어노테이션#
아래 예시는 일반적인 VisDrone 장면을 보여 줍니다. 번화한 도로를 위에서 촬영한 항공 시점 이미지로, 보행자와 차량이 작고 밀집된 대상으로 나타나며 서로에게 가려진 경우가 많습니다.

인용 및 감사의 글#
연구 또는 개발 작업에 VisDrone 데이터셋을 사용하는 경우, 다음 논문을 인용해 주세요:
@ARTICLE{9573394,
author={Zhu, Pengfei and Wen, Longyin and Du, Dawei and Bian, Xiao and Fan, Heng and Hu, Qinghua and Ling, Haibin},
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
title={Detection and Tracking Meet Drones Challenge},
year={2022},
volume={44},
number={11},
pages={7380-7399},
doi={10.1109/TPAMI.2021.3119563}}VisDrone 데이터셋을 만들고 유지 관리한 중국 톈진대학교 머신러닝 및 데이터 마이닝 연구실의 AISKYEYE 팀에 감사드립니다. 자세한 내용은 VisDrone 데이터셋 GitHub 저장소를 방문해 주세요.
자주 묻는 질문#
VisDrone은 객체가 작고 밀집되어 있으며 위에서 촬영된 드론 이미지로 검출기를 학습하고 벤치마크하는 데 사용됩니다. 항공 시점, 혼잡한 장면, 다양한 조건이 결합되어 UAV 기반 교통 모니터링, 군중 분석, 소형 객체 탐지 연구의 표준 테스트베드로 활용됩니다.
Ultralytics VisDrone 구성에는 이미지 8,629장이 포함됩니다. 학습용 6,471장, 검증용 548장, 테스트용(test-dev) 1,610장입니다. 모든 분할에는 보행자, 사람, 자전거, 자동차, 밴, 트럭, 삼륜차, 지붕형 삼륜차, 버스, 오토바이의 동일한 10개 클래스가 포함됩니다. 전체 구성은 데이터셋 구조를 참조하세요.
data="VisDrone.yaml"로 처음 학습할 때 VisDrone이 자동으로 다운로드되므로 별도의 수동 작업은 필요하지 않습니다. 스크립트는 Ultralytics GitHub 릴리스 에셋에서 아카이브 3개(약 2GB)를 가져와 어노테이션을 YOLO 형식으로 변환합니다. 대회용 비공개 test-challenge 분할은 포함되지 않습니다.VisDrone의 객체는 프레임에 비해 매우 작아 수십 픽셀에 불과한 경우가 많고, 심하게 가려진 객체가 밀집된 그룹으로 나타나므로 지상 촬영 사진에 맞춰 조정된 감지기에 부담을 줍니다. 더 높은 해상도(예: 배치 크기를 줄인
imgsz=1280)로 학습하고 예측하면 작은 대상을 포착할 수 있으며, 고해상도 타일링은 대용량 이미지를 분할해 작은 객체가 각 추론 윈도우에서 더 많은 영역을 차지하도록 합니다.전체 VisDrone 벤치마크는 이미지 객체 탐지, 동영상 객체 탐지, 단일 객체 추적, 다중 객체 추적, 군중 계수의 5개 작업으로 구성되며, 동영상 클립 288개와 정지 이미지 10,209장을 포함합니다. Ultralytics
VisDrone.yaml구성은 이미지 탐지 작업(VisDrone2019-DET)만 다루며, 학습 이미지 6,471장, 검증 이미지 548장, test-dev 이미지 1,610장을 다운로드합니다."Detection and Tracking Meet Drones Challenge" 논문(IEEE TPAMI, vol. 44, no. 11, 2022, DOI 10.1109/TPAMI.2021.3119563)을 인용하세요. 전체 BibTeX 항목은 위의 인용 및 감사의 말 섹션에 있습니다.
댓글24
질문을 하거나 결과를 공유하거나 다른 사람을 도와주세요.
arpithavkhanapur1226-collab
Thank you for the suggestions. I’ve tried the recommended changes and checked the dataset, including removing the degenerate bounding box, but I’m still facing the NaN issue around epoch 30. The best mAP I’m getting is only around 33.2%, which is far below the expected performance. I’ve tried several approaches already, but I’m not able to figure out what is causing the instability. Could you please help me identify what might be going wrong or suggest what I should specifically check next? ,I have attached my code and result below ,I would really appreciate your guidance.
visdrone2.ipynb
Paula DerrengerUltralyticsPlease rerun a clean baseline with the official
VisDrone.yaml, pretrained weights, and defaults; after correcting annotations, delete all*.cachefiles in the dataset’slabelsdirectories, and restart the notebook kernel if Ultralytics was upgraded. If NaNs persist, share the complete text training log/traceback, exactmodel.train(...)arguments, Ultralytics version, and output fromyolo checks; also try a smaller learning rate and higherimgszsuch as1280, since VisDrone contains many tiny objects.
arpithavkhanapur1226-collab
I’m training YOLOv12 on the VisDrone dataset, but I faced NaN losses after around epoch 29. I found a degenerate bounding box with zero height and removed it, but the NaN issue still occurred. I then tried DDPNet on VisDrone, but the validation performance started plateauing around epoch 14. Training is also very slow on a T4 (~4 hours for 12 epochs). Could you suggest what I should check or change to improve the training performance?
Paula DerrengerUltralyticsAfter correcting every invalid/non-finite label and ensuring normalized boxes have positive width/height, delete all
*.cachefiles inside thelabelsdirectories before retraining. Establish a baseline with a pretrained Ultralytics model atimgsz=640; then inspectresults.png, per-class AP, and the confusion matrix before changing augmentation or resolution. VisDrone contains many tiny, dense objects, so higher resolution may improve accuracy but will substantially slow a T4; use ann/smodel and the largest stable batch first. If NaNs persist, please share the exact training command, complete text logs around the first NaN, Ultralytics version, andyolo checksoutput; see the VisDrone training guide and fine-tuning troubleshooting.
mslabdelhak29
Hello can you offre a pretrained model i need it and i dont have source to entrain for 100 epochs
Glenn JocherUltralytics(수정됨)Hi, we don’t currently provide an official YOLO model pretrained specifically on VisDrone, so the usual workflow is to start from a generic checkpoint like
yolo26n.ptand fine‑tune it on VisDrone; you can safely reduceepochs(e.g. 10–20) or train on a subset of the data in Colab to keep compute low, and the YOLO train mode docs show how to adjust these arguments.
ysharvit
I am looking for drone photos in desert area ( in order to develop rescue detection system (I volunteer in SAR unit)) Can I filter only desert BG pictures in your dataset?
Glenn JocherUltralytics(수정됨)VisDrone doesn’t include scene/terrain metadata like “desert” (it’s largely urban/traffic), so there’s no built‑in way to filter for desert backgrounds; for SAR you’ll want to gather desert drone imagery and fine‑tune a COCO‑pretrained YOLO26 using the dataset setup in the Datasets Overview or manage it end‑to‑end with Ultralytics Platform datasets.
fardinabbasi
It would be very useful if someone could provide a list of pretrained YOLO models for the VisDrone dataset that are compatible with Ultralytics.
Glenn JocherUltralytics(수정됨)Ultralytics doesn’t currently maintain an official list of VisDrone‑trained checkpoints; the recommended path is to fine‑tune a COCO‑pretrained YOLO26 variant (e.g.,
yolo26s.pt)—see the available base weights on the YOLO26 models page.
lawyeh
Hello, the example and the yaml file pull from the object detection in images dataset (task 1). How can I train the model for object detection in video (task )?
Glenn JocherUltralyticsFor video object detection (Task 2) with VisDrone, you'll use the same YOLO training process but process video frames as individual images. Ensure your dataset paths in VisDrone.yaml point to the video task's frame sequences (organized as images), then train normally. Video inference can be done with
model.predict(source='video.mp4')after training. For video-specific annotations, verify they're converted to YOLO format per frame.1
SudhanshuBlaze
I trained yolov10x on VisDrone dataset with the below parameters, but I got the final
box_lossof1.97. I feel that model performed very poorly, do you know what might be the issue? Or what hyperparameters should I use?from ultralytics import YOLO # Load a model model = YOLO("yolov10x.pt") # load a pretrained model (recommended for training) # Train the model results = model.train(data="VisDrone.yaml", epochs=1000, imgsz=640, patience=250, project='visdrone', name='train', batch=-1)
Glenn JocherUltralytics@SudhanshuBlaze it sounds like your model might be struggling with the complexity of the VisDrone dataset. First, ensure you're using the latest version of the Ultralytics package. You might also want to experiment with different learning rates, batch sizes, and augmentation techniques. Sometimes, reducing the learning rate or increasing the batch size can help stabilize training. Additionally, consider using early stopping to prevent overfitting. If the issue persists, reviewing the dataset for any inconsistencies or mislabeled data could also be beneficial. For more detailed guidance, you can refer to the VisDrone documentation.
mariem158
quelles sont les étapes pour télécharger roboflow100 sur google colab. je veux utiliser ce dataset pour faire la détection précise des véhicules filmés par des caméras ?
Paula DerrengerUltralytics(수정됨)@mariem158 bonjour!
Pour télécharger et utiliser le dataset Roboflow100 sur Google Colab pour la détection précise des véhicules, vous pouvez suivre les étapes ci-dessous. Cependant, il semble que vous ayez mentionné le dataset VisDrone dans votre commentaire, donc je vais également inclure des informations sur ce dataset.
Étapes pour télécharger Roboflow100 sur Google Colab
-
Installer les dépendances nécessaires:
!pip install roboflow -
Importer et configurer Roboflow:
from roboflow import Roboflow rf = Roboflow(api_key="YOUR_API_KEY") project = rf.workspace().project("roboflow100") dataset = project.version("1").download("yolov8") -
Configurer le dataset pour l'entraînement:
from ultralytics import YOLO # Charger un modèle pré-entraîné model = YOLO("yolo26n.pt") # Entraîner le modèle results = model.train(data=dataset.location + "/data.yaml", epochs=100, imgsz=640)
Utilisation du dataset VisDrone
Le dataset VisDrone est une excellente ressource pour la détection d'objets, le suivi d'objets et le comptage de foules dans des images et vidéos capturées par des drones. Voici comment vous pouvez l'utiliser avec YOLO26:
-
Télécharger et configurer le dataset VisDrone:
from ultralytics import YOLO # Charger un modèle pré-entraîné model = YOLO("yolo26n.pt") # Entraîner le modèle results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640) -
YAML de configuration pour VisDrone:
# Ultralytics YOLO 🚀, AGPL-3.0 license # VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University path: ../datasets/VisDrone train: VisDrone2019-DET-train/images val: VisDrone2019-DET-val/images test: VisDrone2019-DET-test-dev/images names: 0: pedestrian 1: people 2: bicycle 3: car 4: van 5: truck 6: tricycle 7: awning-tricycle 8: bus 9: motor
Pour plus de détails sur l'utilisation du dataset VisDrone, vous pouvez consulter la documentation complète ici : VisDrone Dataset Documentation.
N'hésitez pas à revenir vers nous si vous avez d'autres questions! 😊
Cordialement, L'équipe Ultralytics
-
mariem158
comment intégrer visdataset sur google colab et l'intégrer dans mon code qui détecte seulement des véhicules par des drones situé verticalement au dessus de la route.
Paula DerrengerUltralytics(수정됨)Bonjour,
Merci pour votre question ! Pour intégrer le dataset VisDrone dans Google Colab et l'utiliser pour détecter uniquement des véhicules capturés par des drones, voici les étapes à suivre :
-
Configurer Google Colab:
- Assurez-vous d'avoir accès à un GPU pour accélérer l'entraînement. Allez dans
Runtime>Change runtime typeet sélectionnezGPU.
- Assurez-vous d'avoir accès à un GPU pour accélérer l'entraînement. Allez dans
-
Installer les dépendances:
- Installez les bibliothèques nécessaires, notamment
ultralyticspour YOLO26.
- Installez les bibliothèques nécessaires, notamment
-
Télécharger et préparer le dataset VisDrone:
- Utilisez le script de téléchargement et de conversion fourni dans le fichier
VisDrone.yaml.
- Utilisez le script de téléchargement et de conversion fourni dans le fichier
-
Entraîner le modèle:
- Chargez un modèle pré-entraîné YOLO26 et entraînez-le sur le dataset VisDrone en filtrant uniquement les classes de véhicules.
Voici un exemple de code pour chaque étape :
# Installer les dépendances !pip install ultralytics # Importer les bibliothèques nécessaires from ultralytics import YOLO import os from pathlib import Path # Télécharger et préparer le dataset VisDrone def download_visdrone(): from ultralytics.utils.downloads import download def visdrone2yolo(dir): from PIL import Image from tqdm import tqdm def convert_box(size, box): dw = 1. / size[0] dh = 1. / size[1] return (box[0] + box[2] / 2) * dw, (box[1] + box[3] / 2) * dh, box[2] * dw, box[3] * dh (dir / 'labels').mkdir(parents=True, exist_ok=True) pbar = tqdm((dir / 'annotations').glob('*.txt'), desc=f'Converting {dir}') for f in pbar: img_size = Image.open((dir / 'images' / f.name).with_suffix('.jpg')).size lines = [] with open(f, 'r') as file: for row in [x.split(',') for x in file.read().strip().splitlines()]: if row[4] == '0': continue cls = int(row[5]) - 1 box = convert_box(img_size, tuple(map(int, row[:4]))) lines.append(f"{cls} {' '.join(f'{x:.6f}' for x in box)}\n") with open(str(f).replace(f'{os.sep}annotations{os.sep}', f'{os.sep}labels{os.sep}'), 'w') as fl: fl.writelines(lines) dir = Path('../datasets/VisDrone') urls = [ 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-train.zip', 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-val.zip', 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-dev.zip', 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-challenge.zip' ] download(urls, dir=dir, curl=True, threads=4) for d in ['VisDrone2019-DET-train', 'VisDrone2019-DET-val', 'VisDrone2019-DET-test-dev']: visdrone2yolo(dir / d) download_visdrone() # Entraîner le modèle YOLO26 sur le dataset VisDrone model = YOLO("yolo26n.pt") # Charger un modèle pré-entraîné results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)Pour plus de détails sur la configuration du dataset et les options d'entraînement, vous pouvez consulter la documentation complète ici.
N'hésitez pas à revenir vers nous si vous avez d'autres questions. Bonne chance avec votre projet ! 🚀
Cordialement, L'équipe Ultralytics
-
mariem158
comment je peux utiliser les modèles de visdrone et faire l'appel à ce dataset dans mon code pour faire la détection des véhicules par mon drone?
Paula DerrengerUltralytics(수정됨)Bonjour,
Merci pour votre question ! Pour utiliser le dataset VisDrone et détecter uniquement les véhicules capturés par des drones, voici comment procéder sur Google Colab :
-
Configurer Google Colab:
- Assurez-vous d'avoir accès à un GPU pour accélérer l'entraînement. Allez dans
Runtime>Change runtime typeet sélectionnezGPU.
- Assurez-vous d'avoir accès à un GPU pour accélérer l'entraînement. Allez dans
-
Installer les dépendances:
- Installez les bibliothèques nécessaires, notamment
ultralyticspour YOLO26.
- Installez les bibliothèques nécessaires, notamment
-
Télécharger et préparer le dataset VisDrone:
- Utilisez le script de téléchargement et de conversion fourni dans le fichier
VisDrone.yaml.
- Utilisez le script de téléchargement et de conversion fourni dans le fichier
-
Entraîner le modèle:
- Chargez un modèle pré-entraîné YOLO26 et entraînez-le sur le dataset VisDrone en filtrant uniquement les classes de véhicules.
Voici un exemple de code pour chaque étape :
# Installer les dépendances !pip install ultralytics # Importer les bibliothèques nécessaires from ultralytics import YOLO import os from pathlib import Path # Télécharger et préparer le dataset VisDrone def download_visdrone(): from ultralytics.utils.downloads import download def visdrone2yolo(dir): from PIL import Image from tqdm import tqdm def convert_box(size, box): dw = 1. / size[0] dh = 1. / size[1] return (box[0] + box[2] / 2) * dw, (box[1] + box[3] / 2) * dh, box[2] * dw, box[3] * dh (dir / 'labels').mkdir(parents=True, exist_ok=True) pbar = tqdm((dir / 'annotations').glob('*.txt'), desc=f'Converting {dir}') for f in pbar: img_size = Image.open((dir / 'images' / f.name).with_suffix('.jpg')).size lines = [] with open(f, 'r') as file: for row in [x.split(',') for x in file.read().strip().splitlines()]: if row[4] == '0': continue cls = int(row[5]) - 1 box = convert_box(img_size, tuple(map(int, row[:4]))) lines.append(f"{cls} {' '.join(f'{x:.6f}' for x in box)}\n") with open(str(f).replace(f'{os.sep}annotations{os.sep}', f'{os.sep}labels{os.sep}'), 'w') as fl: fl.writelines(lines) dir = Path('../datasets/VisDrone') urls = [ 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-train.zip', 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-val.zip', 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-dev.zip', 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-challenge.zip' ] download(urls, dir=dir, curl=True, threads=4) for d in ['VisDrone2019-DET-train', 'VisDrone2019-DET-val', 'VisDrone2019-DET-test-dev']: visdrone2yolo(dir / d) download_visdrone() # Entraîner le modèle YOLO26 sur le dataset VisDrone model = YOLO("yolo26n.pt") # Charger un modèle pré-entraîné results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)Pour plus de détails sur la configuration du dataset et les options d'entraînement, vous pouvez consulter la documentation complète ici.
N'hésitez pas à revenir vers nous si vous avez d'autres questions. Bonne chance avec votre projet ! 🚀
Cordialement, L'équipe Ultralytics
-
Elvis-Kiilu2
This is nice, but what's next after the detection? How do we send/retrieve the data to a given database? What further insights can we draw from the detected data? What other technologies can we intergrate to this to draw meaningful inferences??
Paula DerrengerUltralytics(수정됨)After detection, you have a few options to extend the functionality:
-
Data Storage: To send and store detections on a database:
import sqlite3 from datetime import datetime from ultralytics import YOLO # Connect to SQLite database connection = sqlite3.connect('my_detections.db') cursor = connection.cursor() # Create table cursor.execute('''CREATE TABLE IF NOT EXISTS detections (timestamp DATETIME, class TEXT, confidence REAL, x REAL, y REAL, width REAL, height REAL)''') # Example insertion from detection results = YOLO("yolo26n.pt")("image.jpg")[0] names = results.names timestamp = datetime.now().isoformat() for det in results.boxes: cursor.execute('''INSERT INTO detections (timestamp, class, confidence, x, y, width, height) VALUES (?, ?, ?, ?, ?, ?, ?)''', (timestamp, names[int(det.cls)], float(det.conf), *det.xywh[0].tolist())) connection.commit() connection.close() -
Further Analysis: Analyze the time series of detections to observe trends, detect anomalies, or aggregate counts over time.
-
Integration with Other Technologies: Integrate with IoT platforms for real-time alerts or incorporate AI-based services for enhanced image analysis and decision-making processes.
These steps help bridge the gap between raw detection outputs and actionable insights or responses in real-world applications.
-
Elvis-Kiilu2
Thanks @pderrenger for the reply. I wanted to implement this for my next project. Your insights are a good starting point. My aim is to extract/read data from the detected class/boxes. Then compare and match the read data with with those in a database that in a cloud data warehouse, Bigquery to be specific.
Paula DerrengerUltralyticsHey there! It's great to hear you're planning to use YOLOv8 for your project. To extract and compare data from detected objects with your BigQuery database, you can follow these steps:
-
Extract Data: After detection, extract the necessary details from each detection (like class, confidence, and bounding box coordinates).
-
Format Data: Convert this data into a suitable format (like JSON or CSV) that can be easily ingested into BigQuery.
-
Upload to BigQuery: Use the BigQuery API to upload your formatted data. Here’s a small Python snippet using
google-cloud-bigquery:from google.cloud import bigquery # Construct a BigQuery client object. client = bigquery.Client() # Define your table ID (dataset.table) table_id = "your-project.your_dataset.your_table" # Define the data to be inserted rows_to_insert = [ {u"class": detected_class, u"confidence": confidence, u"x_min": x_min, u"y_min": y_min, u"width": width, u"height": height} ] # Insert data into BigQuery errors = client.insert_rows_json(table_id, rows_to_insert) if errors == []: print("New rows have been added.") -
Query and Analyze: Once your data is in BigQuery, you can use SQL queries to compare, analyze, and draw insights based on your specific needs.
This workflow will help you leverage the power of cloud computing to analyze large datasets efficiently. If you need further assistance or have more specific requirements, feel free to ask! 🚀
-



