YOLOv9/v10 डिटेक्शन

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

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

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

YOLOv9 vs YOLOv10 vs 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-फ्री है — कोई पोस्ट-प्रोसेसिंग नॉन-मैक्सिमम सप्रेशन चरण नहीं। इससे एंड-टू-एंड तैनाती संभव होती है और यह एज़/एम्बेडेड परिदृश्यों तथा TensorRT तैनाती के लिए खासकर लाभकारी है।

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

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

पूर्व-आवश्यकताएँ

GPU किराये के साथ Clore.ai खाता
कस्टम मॉडल प्रशिक्षण के लिए प्रशिक्षण डेटा या COCO प्रीट्रेंड वेट्स का उपयोग
बुनियादी 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 4090 पर TensorRT के साथ 1000+ FPS पर चलता है।

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

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

Docker इमेज:

ultralytics/ultralytics:latest

पोर्ट्स:

22
8000

पर्यावरण चर:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

डिस्क: 20GB न्यूनतम (प्रिट्रेंड वेट्स + आपका डेटासेट)

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

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

# GPU जांचें
nvidia-smi

# Ultralytics इंस्टॉलेशन जांचें
python3 -c "import ultralytics; ultralytics.checks()"

# GPU जानकारी, CUDA संस्करण, और मॉडल उपलब्धता दिखनी चाहिए

चरण 4 — प्रीट्रेंड मॉडलों के साथ त्वरित इनफरेंस

YOLOv10 इनफरेंस (NMS-फ्री)

from ultralytics import YOLO
import cv2

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

# किसी इमेज पर इनफरेंस चलाएँ
results = model("https://ultralytics.com/images/bus.jpg")

# परिणाम दिखाएँ
for result in results:
    boxes = result.boxes
    print(f"Detected {len(boxes)} objects")
    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} at {[int(x) for x in xyxy]}")

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

YOLOv9 इनफरेंस

from ultralytics import YOLO

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

# अधिकतम थ्रूपुट के लिए बैच इनफरेंस
results = model(
    source=[
        "image1.jpg",
        "image2.jpg",
        "image3.jpg",
    ],
    batch=8,        # समानांतर 8 इमेज प्रोसेस करें
    device="cuda",
    conf=0.25,      # कॉन्फिडेंस थ्रेशोल्ड
    iou=0.45,       # NMS IoU थ्रेशोल्ड (v10 के लिए आवश्यक नहीं)
    imgsz=640,
    half=True       # 2x स्पीडअप के लिए FP16
)

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

from ultralytics import YOLO
import cv2

model = YOLO("yolov10s.pt")

# वेबकैम (device=0) या वीडियो फ़ाइल के लिए
cap = cv2.VideoCapture("input_video.mp4")

# वीडियो गुण प्राप्त करें
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"Processed {frame_count} frames")

cap.release()
out.release()
print("Done! Output saved to output_video.mp4")

चरण 5 — एक कस्टम मॉडल ट्रेन करें

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

YOLO एक विशिष्ट निर्देशिका संरचना और लेबल प्रारूप का उपयोग करता है:

dataset/
├── images/
│   ├── train/          # प्रशिक्षण इमेजेज (.jpg/.png)
│   ├── val/            # वैलिडेशन इमेजेज
│   └── test/           # टेस्ट इमेजेज (वैकल्पिक)
└── labels/
    ├── train/          # लेबल फ़ाइलें (.txt)
    ├── val/
    └── test/

प्रत्येक लेबल फ़ाइल (इमेज के समान नाम, .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'
# डेटासेट कॉन्फ़िगरेशन
path: /workspace/dataset
train: images/train
val: images/val
test: images/test

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

# क्लास नाम
names:
  0: person
  1: car
  2: bicycle
EOF

Roboflow से इम्पोर्ट करें (सिफारिश की गई)

# 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")

# डेटासेट अब ./your-project-1/ में है

YOLOv10 ट्रेन करें

from ultralytics import YOLO

# प्रिट्रेंड YOLOv10 मॉडल लोड करें (ट्रांसफर लर्निंग)
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"Training complete! Best 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 बड़ा है, इसलिए कम बैच चाहिए
    device="cuda",
    workers=8,
    project="/workspace/runs",
    name="yolov9_custom",
    amp=True,
    optimizer="SGD",
    momentum=0.937,
    weight_decay=0.0005
)

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

बैच साइज: शुरू करें batch=16 RTX 4090 के लिए, batch=32 A100 40GB के लिए
इमेज साइज: imgsz=640 मानक है; उच्च-रिज़ॉल्यूशन कार्यों के लिए 1280 का उपयोग करें
एपोच: फाइन-ट्यूनिंग के लिए 100 एपोच सामान्य है, स्क्रैच से ट्रेनिंग के लिए 300+
AMP (मिक्स्ड प्रिसिशन): हमेशां सक्षम करें amp=True 1.5–2x स्पीडअप के लिए

चरण 6 — अधिकतम गति के लिए TensorRT में एक्सपोर्ट करें

from ultralytics import YOLO

# प्रशिक्षित मॉडल लोड करें
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             # TRT वर्कस्पेस GB में
)
# सहेजा गया रूप: best.engine

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

ONNX में एक्सपोर्ट करें

# तैनाती लचीलापन के लिए ONNX में एक्सपोर्ट करें
model.export(
    format="onnx",
    opset=17,
    half=True,              # FP16 वेट्स
    dynamic=True,           # डायनामिक बैच साइज
    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 Detection API")
model = YOLO("yolov10x.pt")

@app.get("/health")
async def health():
    return {"status": "ok", "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 डेटासेट पर सत्यापन
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"Precision: {metrics.box.mp:.3f}")
print(f"Recall:    {metrics.box.mr:.3f}")

# गति का बेंचमार्क
model.benchmark(
    format="engine",   # कई एक्सपोर्ट फॉर्मैट की तुलना करें
    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 ./

# पूरे प्रशिक्षण रन को डाउनलोड करें
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)

# या ग्रेडिएंट चेकपॉइंटिंग सक्षम करें
model.train(data="data.yaml", batch=8, imgsz=640, cache=False)

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

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

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

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

# सत्यापित करें कि लेबल सही हैं (सामान्यीकृत, 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 यूनिवर्स — 100K+ सार्वजनिक डेटासेट
Ultralytics HUB — क्लाउड प्रशिक्षण प्लेटफ़ॉर्म
COCO डेटासेट — मानक बेंचमार्क डेटासेट

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

Clore.ai GPU सिफारिशें

उपयोग केस

सिफारिश की गई GPU

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

डेवलपमेंट/टेस्टिंग

RTX 3090 (24GB)

~$0.12/gpu/hr

उत्पादन इन्फरेंस

RTX 4090 (24GB)

~$0.70/gpu/hr

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

A100 80GB

~$1.20/gpu/hr

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

PreviousYOLOv8 डिटेक्शन Nextअवलोकन

Last updated 1 day ago

Was this helpful?

hashtagYOLOv9 vs YOLOv10 vs YOLOv8 — त्वरित तुलना

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

hashtagपूर्व-आवश्यकताएँ

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

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

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

hashtagचरण 4 — प्रीट्रेंड मॉडलों के साथ त्वरित इनफरेंस

hashtagYOLOv10 इनफरेंस (NMS-फ्री)

hashtagYOLOv9 इनफरेंस

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

hashtagचरण 5 — एक कस्टम मॉडल ट्रेन करें

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

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

hashtagRoboflow से इम्पोर्ट करें (सिफारिश की गई)

hashtagYOLOv10 ट्रेन करें

hashtagYOLOv9 ट्रेन करें

hashtagचरण 6 — अधिकतम गति के लिए TensorRT में एक्सपोर्ट करें

hashtagONNX में एक्सपोर्ट करें

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

hashtagचरण 8 — अपने मॉडल को वैधता दें और बेंचमार्क करें

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

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

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

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

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

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

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

hashtagClore.ai GPU सिफारिशें

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

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

पूर्व-आवश्यकताएँ

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

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

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

चरण 4 — प्रीट्रेंड मॉडलों के साथ त्वरित इनफरेंस

YOLOv10 इनफरेंस (NMS-फ्री)

YOLOv9 इनफरेंस

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

चरण 5 — एक कस्टम मॉडल ट्रेन करें

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

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

Roboflow से इम्पोर्ट करें (सिफारिश की गई)

YOLOv10 ट्रेन करें

YOLOv9 ट्रेन करें

चरण 6 — अधिकतम गति के लिए TensorRT में एक्सपोर्ट करें

ONNX में एक्सपोर्ट करें

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

चरण 8 — अपने मॉडल को वैधता दें और बेंचमार्क करें

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

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

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

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

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

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

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

Clore.ai GPU सिफारिशें