YOLOv9/v10 डिटेक्शन

अत्याधुनिक रीयल-टाइम ऑब्जेक्ट डिटेक्शन — GPU पर नवीनतम YOLO मॉडलों को प्रशिक्षित करें और तैनात करें

YOLO (You Only Look Once) रीयल-टाइम ऑब्जेक्ट डिटेक्शन के लिए स्वर्ण मानक बना हुआ है। YOLOv9 ने Programmable Gradient Information (PGI) और Generalized Efficient Layer Aggregation Network (GELAN) पेश किए, जबकि YOLOv10 ने dual-label assignments के साथ NMS-मुक्त डिटेक्शन लाया। दोनों NVIDIA GPUs पर शीर्ष-स्तरीय सटीकता/गति संतुलन प्रदान करते हैं।

YOLOv9 GitHub: WongKinYiu/yolov9 — 8K+ ⭐
YOLOv10 GitHub: THU-MIG/yolov10 — 10K+ ⭐
Ultralytics (एकीकृत): ultralytics/ultralytics — 32K+ ⭐

YOLOv9 बनाम YOLOv10 बनाम YOLOv8 — त्वरित तुलना

मॉडल

mAP50-95

गति (A100)

पैरामीटर

NMS

YOLOv8x

53.9

14.2ms

68.2M

आवश्यक

YOLOv9e

55.6

16.8ms

57.3M

आवश्यक

YOLOv10x

54.4

10.7ms

29.5M

मुक्त

YOLOv10b

53.0

8.8ms

19.1M

मुक्त

YOLOv10s

46.8

4.2ms

7.2M

मुक्त

YOLOv10 NMS-मुक्त है — कोई post-processing Non-Maximum Suppression चरण नहीं। इससे end-to-end deployment संभव होता है और यह विशेष रूप से edge/embedded परिदृश्यों और TensorRT deployment के लिए लाभकारी है।

उपयोग के मामले

सुरक्षा एवं निगरानी — रीयल-टाइम व्यक्ति/वाहन/ऑब्जेक्ट डिटेक्शन
स्वायत्त वाहन — पैदल यात्री और बाधा डिटेक्शन
विनिर्माण QC — उत्पादन लाइनों पर दोष डिटेक्शन
रिटेल विश्लेषण — ग्राहक प्रवाह और उत्पाद डिटेक्शन
मेडिकल इमेजिंग — X-ray और स्कैन में असामान्यता डिटेक्शन
खेल विश्लेषण — खिलाड़ी और गेंद ट्रैकिंग
कृषि — फसल रोग और कीट डिटेक्शन

पूर्वापेक्षाएँ

GPU किराये के साथ Clore.ai खाता
कस्टम मॉडल प्रशिक्षण के लिए प्रशिक्षण डेटा या COCO pretrained weights का उपयोग करें
Python और कमांड लाइन का बुनियादी ज्ञान

चरण 1 — Clore.ai पर GPU किराए पर लें

पर जाएँ clore.ai → मार्केटप्लेस
अपने कार्य के आधार पर GPU चुनें:
- केवल इन्फ़रेंस: RTX 3080/3090 या RTX 4080 — उत्कृष्ट मूल्य/प्रदर्शन
- छोटे मॉडल प्रशिक्षण: RTX 4090 24GB
- बड़े मॉडल प्रशिक्षण (YOLOv9e/YOLOv10x): A100 40/80GB

रीयल-टाइम इन्फ़रेंस के लिए (वीडियो स्ट्रीम), RTX 3090 या RTX 4090 मॉडल संस्करण के आधार पर 100–500 FPS प्रदान करता है। सबसे छोटा YOLOv10n भी TensorRT के साथ 4090 पर 1000+ FPS पर चलता है।

चरण 2 — Ultralytics कंटेनर तैनात करें

आधिकारिक Ultralytics Docker image एकीकृत API के माध्यम से YOLOv8, YOLOv9, और YOLOv10 का समर्थन करती है:

Docker इमेज:

ultralytics/ultralytics:latest

पोर्ट:

22
8000

Environment Variables:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

डिस्क: कम से कम 20GB (pretrained weights + आपका dataset)

चरण 3 — कनेक्ट करें और सत्यापित करें

ssh root@<server-ip> -p <ssh-port>

# GPU जांचें
nvidia-smi

# Ultralytics स्थापना जांचें
python3 -c "import ultralytics; ultralytics.checks()"

# GPU जानकारी, CUDA version, और model availability दिखना चाहिए

चरण 4 — pretrained models के साथ त्वरित इन्फ़रेंस

YOLOv10 इन्फ़रेंस (NMS-मुक्त)

from ultralytics import YOLO
import cv2

# YOLOv10 model लोड करें (यदि मौजूद नहीं है तो स्वतः डाउनलोड होता है)
model = YOLO("yolov10x.pt")  # विकल्प: n, s, m, b, l, x

# किसी image पर inference चलाएँ
results = model("https://ultralytics.com/images/bus.jpg")

# परिणाम प्रदर्शित करें
for result in results:
    boxes = result.boxes
    print(f"{len(boxes)} ऑब्जेक्ट्स का पता चला")
    for box in boxes:
        cls = int(box.cls[0])
        conf = float(box.conf[0])
        xyxy = box.xyxy[0].tolist()
        print(f"  {model.names[cls]}: {conf:.2f} पर {[int(x) for x in xyxy]}")

# एनोटेटेड image सहेजें
results[0].save("output.jpg")

YOLOv9 इन्फ़रेंस

from ultralytics import YOLO

# YOLOv9 model लोड करें
model = YOLO("yolov9e.pt")  # विकल्प: t, s, m, c, e

# अधिकतम throughput के लिए batch inference
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # समानांतर में 8 images संसाधित करें
    device="cuda",
    conf=0.25,      # विश्वास सीमा
    iou=0.45,       # NMS IoU threshold (v10 के लिए आवश्यक नहीं)
    imgsz=640,
    half=True       # 2x speedup के लिए FP16
)

रीयल-टाइम वीडियो स्ट्रीम इन्फ़रेंस

from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# webcam (device=0) या video file के लिए
cap = cv2.VideoCapture("input_video.mp4")

# वीडियो properties प्राप्त करें
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# आउटपुट लिखने वाला
out = cv2.VideoWriter(
    "output_video.mp4",
    cv2.VideoWriter_fourcc(*"mp4v"),
    fps,
    (width, height)
)

frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame, conf=0.25, verbose=False)
    annotated = results[0].plot()
    out.write(annotated)
    frame_count += 1
    
    if frame_count % 100 == 0:
        print(f"{frame_count} फ़्रेम प्रोसेस किए गए")

cap.release()
out.release()
print("हो गया! आउटपुट output_video.mp4 में सहेजा गया")

चरण 5 — कस्टम मॉडल को प्रशिक्षित करें

अपना डेटासेट तैयार करें

YOLO एक विशिष्ट directory structure और label format का उपयोग करता है:

dataset/
├── images/
│   ├── train/          # प्रशिक्षण images (.jpg/.png)
│   ├── val/            # validation images
│   └── test/           # test images (optional)
└── labels/
    ├── train/          # label files (.txt)
    ├── val/
    └── test/

प्रत्येक label file (छवि के समान नाम वाली, .txt विस्तार) में शामिल होता है:

# class_id center_x center_y width height (सभी 0-1 के बीच सामान्यीकृत)
0 0.512 0.334 0.256 0.412
1 0.123 0.654 0.089 0.123

डेटासेट कॉन्फ़िगरेशन बनाएं

cat > /workspace/custom_dataset.yaml << 'EOF'
# dataset configuration
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

# classes की संख्या
nc: 3

# class names
names:
  0: person
  1: car
  2: bicycle
EOF

Roboflow से import करें (अनुशंसित)

# Roboflow इंस्टॉल करें
pip install roboflow

from roboflow import Roboflow
rf = Roboflow(api_key="YOUR_API_KEY")
project = rf.workspace("your-workspace").project("your-project")
version = project.version(1)
dataset = version.download("yolov9")

# Dataset अब ./your-project-1/ पर है

YOLOv10 को प्रशिक्षित करें

from ultralytics import YOLO

# pretrained YOLOv10 model लोड करें (transfer learning)
model = YOLO("yolov10m.pt")  # मध्यम संस्करण — अच्छा संतुलन

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=16,               # अपने GPU VRAM के अनुसार समायोजित करें
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov10_custom",
    patience=50,            # प्रारंभिक रोक
    save=True,
    save_period=10,         # हर 10 एपॉक्स पर चेकपॉइंट सहेजें
    plots=True,
    val=True,
    augment=True,           # डेटा ऑग्मेंटेशन
    degrees=10.0,
    flipud=0.0,
    fliplr=0.5,
    mosaic=1.0,
    mixup=0.1,
    copy_paste=0.1,
    lr0=0.01,
    lrf=0.01,
    momentum=0.937,
    weight_decay=0.0005,
    warmup_epochs=3.0,
    amp=True                # स्वचालित मिश्रित परिशुद्धता (FP16)
)

print(f"प्रशिक्षण पूरा! सर्वश्रेष्ठ mAP: {results.results_dict['metrics/mAP50-95(B)']:.3f}")

YOLOv9 को प्रशिक्षित करें

from ultralytics import YOLO

model = YOLO("yolov9e.pt")

results = model.train(
    data="/workspace/custom_dataset.yaml",
    epochs=100,
    imgsz=640,
    batch=8,               # v9e बड़ा है, कम batch की आवश्यकता है
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)

प्रशिक्षण सुझाव:

बैच आकार: से शुरू करें batch=16 for RTX 4090, batch=32 for A100 40GB
छवि आकार: imgsz=640 मानक है; उच्च-रिज़ॉल्यूशन कार्यों के लिए 1280 उपयोग करें
एपॉक्स: 100 epochs fine-tuning के लिए सामान्य हैं, scratch से training के लिए 300+
AMP (मिक्स्ड प्रिसिजन): हमेशा सक्षम करें amp=True 1.5–2x speedup के लिए

चरण 6 — अधिकतम गति के लिए TensorRT में निर्यात करें

from ultralytics import YOLO

# प्रशिक्षित model लोड करें
model = YOLO("/workspace/runs/yolov10_custom/weights/best.pt")

# सर्वोत्तम गति/सटीकता संतुलन के लिए TensorRT में निर्यात करें (FP16)
model.export(
    format="engine",        # TensorRT इंजन
    device="cuda",
    half=True,              # FP16
    dynamic=False,          # अधिकतम TRT अनुकूलन के लिए स्थिर आकृतियाँ
    batch=1,                # बैच आकार 1 (रीयल-टाइम) के लिए अनुकूलित करें
    imgsz=640,
    workspace=4             # GB में TRT वर्कस्पेस
)
# इस रूप में सहेजा गया: best.engine

# TRT engine लोड करें और चलाएँ
trt_model = YOLO("best.engine")
results = trt_model("image.jpg")

ONNX में निर्यात करें

# डिप्लॉयमेंट लचीलापन के लिए ONNX में निर्यात करें
model.export(
    format="onnx",
    opset=17,
    half=True,              # FP16 weights
    dynamic=True,           # गतिशील batch size
    simplify=True
)

चरण 7 — REST API के रूप में सर्व करें

pip install fastapi uvicorn python-multipart

cat > /workspace/yolo_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse, FileResponse
from ultralytics import YOLO
from PIL import Image
import io
import uuid
import os

app = FastAPI(title="YOLOv10 डिटेक्शन API")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ठीक", "model": "yolov10x", "device": "cuda"}

@app.post("/detect")
async def detect(
    file: UploadFile = File(...),
    conf: float = 0.25,
    iou: float = 0.45,
    return_image: bool = False
):
    # अपलोड की गई छवि पढ़ें
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    
    # डिटेक्शन चलाएँ
    results = model(img, conf=conf, iou=iou, verbose=False)
    result = results[0]
    
    # प्रतिक्रिया बनाएं
    detections = []
    for box in result.boxes:
        detections.append({
            "class": model.names[int(box.cls[0])],
            "confidence": round(float(box.conf[0]), 4),
            "bbox": [round(x, 2) for x in box.xyxy[0].tolist()],
            "class_id": int(box.cls[0])
        })
    
    response = {
        "count": len(detections),
        "detections": detections,
        "image_size": list(result.orig_shape)
    }
    
    if return_image:
        output_path = f"/tmp/{uuid.uuid4()}.jpg"
        result.save(filename=output_path)
        return FileResponse(output_path, media_type="image/jpeg")
    
    return JSONResponse(response)

@app.post("/detect/batch")
async def detect_batch(files: list[UploadFile] = File(...)):
    results = []
    for file in files:
        data = await file.read()
        img = Image.open(io.BytesIO(data)).convert("RGB")
        res = model(img, verbose=False)[0]
        results.append({
            "filename": file.filename,
            "count": len(res.boxes),
            "detections": [
                {"class": model.names[int(b.cls[0])], "conf": float(b.conf[0])}
                for b in res.boxes
            ]
        })
    return JSONResponse({"results": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
EOF

python3 /workspace/yolo_api.py &

# API का परीक्षण करें
curl -X POST "http://localhost:8000/detect" \\
    -F "file=@test_image.jpg" | python3 -m json.tool

चरण 8 — अपने मॉडल का सत्यापन और बेंचमार्क करें

from ultralytics import YOLO

model = YOLO("yolov10x.pt")

# COCO dataset पर मान्य करें
metrics = model.val(
    data="coco.yaml",
    imgsz=640,
    batch=32,
    device="cuda",
    half=True
)

print(f"mAP50:    {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")
print(f"परिशुद्धता: {metrics.box.mp:.3f}")
print(f"रिकॉल:    {metrics.box.mr:.3f}")

# गति बेंचमार्क करें
model.benchmark(
    format="engine",   # कई export formats की तुलना करें
    imgsz=640,
    half=True,
    device="cuda"
)

परिणाम डाउनलोड करें

# अपनी स्थानीय मशीन से:
scp -P <ssh-port> root@<server-ip>:/workspace/runs/yolov10_custom/weights/best.pt ./
scp -P <ssh-port> root@<server-ip>:/workspace/output_video.mp4 ./

# पूरे training run को डाउनलोड करें
rsync -avz -e "ssh -p <ssh-port>" \\
    root@<server-ip>:/workspace/runs/ \\
    ./yolo_training_runs/

समस्या निवारण

प्रशिक्षण के दौरान CUDA Out of Memory

# बैच आकार कम करें
model.train(data="data.yaml", batch=4, imgsz=640)

# या gradient checkpointing सक्षम करें
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)

धीमी प्रशिक्षण गति

# caching सक्षम करें (dataset को RAM/GPU में लोड करता है)
model.train(data="data.yaml", cache=True)  # RAM में cache करें
model.train(data="data.yaml", cache="disk")  # डिस्क में cache करें

# workers बढ़ाएँ (सावधानी: बहुत अधिक होने पर धीमा हो सकता है)
model.train(data="data.yaml", workers=8)

कम mAP / खराब डिटेक्शन

# सुनिश्चित करें कि labels सही हैं (सामान्यीकृत, 0-1 के भीतर)
python3 -c \"
from ultralytics.data.utils import check_det_dataset
check_det_dataset('custom_dataset.yaml')
"

# प्रशिक्षण नमूनों को विज़ुअलाइज़ करें
python3 -c \"
from ultralytics import YOLO
model = YOLO('yolov10m.pt')
model.train(data='data.yaml', epochs=1, batch=4, plots=True)
# /workspace/runs/train/exp/train_batch*.jpg जांचें
"

प्रदर्शन संदर्भ (Clore.ai GPUs)

मॉडल

GPU

बैच

FPS (इन्फ़रेंस)

mAP50-95

YOLOv10n

RTX 3090

1,200

38.5

YOLOv10s

RTX 3090

780

46.8

YOLOv10m

RTX 4090

950

51.3

YOLOv10x

RTX 4090

380

54.4

YOLOv9e

A100 40G

720

55.6

YOLOv10x TRT

RTX 4090

920

54.2

अतिरिक्त संसाधन

Ultralytics दस्तावेज़ीकरण
YOLOv9 पेपर
YOLOv10 पेपर
Roboflow Universe — 100K+ सार्वजनिक डेटासेट
Ultralytics HUB — क्लाउड प्रशिक्षण प्लेटफ़ॉर्म
COCO डेटासेट — मानक बेंचमार्क डेटासेट

Clore.ai GPU रेंटल्स पर YOLOv9 और YOLOv10, कस्टम ऑब्जेक्ट डिटेक्शन मॉडल को प्रशिक्षित करने और रीयल-टाइम इन्फ़ेरेंस पाइपलाइनों को तैनात करने का एक किफायती तरीका प्रदान करते हैं — AWS SageMaker या Google Vertex AI की अतिरिक्त जटिलता के बिना।

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण

अनुशंसित GPU

Clore.ai पर अनुमानित लागत

विकास/परीक्षण

RTX 3090 (24GB)

$0.07–0.21/gpu/hr

प्रोडक्शन इनफ़रेंस

RTX 4090 (24GB)

$0.14–0.42/gpu/hr

बड़े-बैच प्रशिक्षण

A100 80GB

bare metal

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.

पिछलाYOLOv8 डिटेक्शन

अगलाअवलोकन

अंतिम अपडेट 1 माह पहले

क्या यह उपयोगी था?