GroundingDINO

GroundingDINO के साथ टेक्स्ट विवरणों द्वारा किसी भी वस्तु का पता लगाएँ

GroundingDINO के साथ पाठ विवरणों का उपयोग करके किसी भी वस्तु का पता लगाएँ।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

इस मार्गदर्शिका के सभी उदाहरणों को GPU सर्वरों पर चलाया जा सकता है जिन्हें के माध्यम से किराए पर लिया जाता है CLORE.AI मार्केटप्लेस मार्केटप्लेस।

CLORE.AI पर किराये पर लेना

1. पर जाएँ CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (निश्चित दर) या स्पॉट (बिड प्राइस)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTC, या USDT/USDC

6. ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

अपने सर्वर तक पहुँचें

• कनेक्शन विवरण में खोजें मेरे ऑर्डर

• वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

GroundingDINO क्या है?

IDEA-Research द्वारा GroundingDINO सक्षम करता है:

• पाठ प्रॉम्प्ट के साथ शून्य-शॉट वस्तु पहचान

• प्रशिक्षण के बिना किसी भी वस्तु का पता लगाएँ

• उच्च-सटीकता बाउंडिंग बॉक्स लोकलाइज़ेशन

• स्वचालित सेगमेंटेशन के लिए SAM के साथ संयोजन

संसाधन

• GitHub: IDEA-Research/GroundingDINO

• पेपर: GroundingDINO पेपर

• HuggingFace: IDEA-Research/grounding-dino

• डेमो: HuggingFace Space

अनुशंसित हार्डवेयर

घटक	न्यूनतम	अनुशंसित	सर्वोत्तम
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	6GB	12GB	16GB
CPU	4 कोर	8 कोर	16 कोर
RAM	16GB	32GB	64GB
स्टोरेज	20GB SSD	50GB NVMe	100GB NVMe
इंटरनेट	100 Mbps	500 Mbps	1 Gbps

CLORE.AI पर त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

पोर्ट:

22/tcp
7860/http

कमांड:

cd /workspace && \
git clone https://github.com/IDEA-Research/GroundingDINO.git && \
cd GroundingDINO && \
pip install -e . && \
python demo/gradio_demo.py

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें http_pub URL में मेरे ऑर्डर:

1. जाएँ मेरे ऑर्डर पृष्ठ

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए उदाहरणों में।

इंस्टॉलेशन

git clone https://github.com/IDEA-Research/GroundingDINO.git
cd GroundingDINO
pip install -e .

# वेट्स डाउनलोड करें
mkdir weights
cd weights
wget https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth

आप क्या बना सकते हैं

स्वचालित लेबलिंग

• एमएल प्रशिक्षण के लिए डेटासेट स्वचालित रूप से एनोटेट करें

• विवरणों से बाउंडिंग बॉक्स उत्पन्न करें

• डेटा लेबलिंग पाइपलाइनों को तेज करें

विज़ुअल सर्च

• इमेज डेटाबेस में विशिष्ट वस्तुओं को खोजें

• कंटेंट मॉडरेशन सिस्टम

• रिटेल में उत्पाद की पहचान

रोबोटिक्स और ऑटोमेशन

• रोबोट आर्म के लिए वस्तु स्थानिकरण

• इन्वेंटरी प्रबंधन प्रणाली

• गुणवत्ता नियंत्रण निरीक्षण

रचनात्मक अनुप्रयोग

• फोटोज़ से विषयों को ऑटो-कॉर्प करें

• SAM के साथ वस्तु मास्क जेनरेट करें

• कंटेंट-अवेयर इमेज संपादन

विश्लेषण

• छवियों में वस्तुओं की गणना करें

• फोटो से इन्वेंटरी ट्रैक करें

• वन्यजीव निगरानी

मूल उपयोग

from groundingdino.util.inference import load_model, load_image, predict, annotate
import cv2

# मॉडल लोड करें
model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

# छवि लोड करें
image_source, image = load_image("input.jpg")

# वस्तुओं का पता लगाएँ
TEXT_PROMPT = "cat . dog . person"
BOX_THRESHOLD = 0.35
TEXT_THRESHOLD = 0.25

boxes, logits, phrases = predict(
    model=model,
    image=image,
    caption=TEXT_PROMPT,
    box_threshold=BOX_THRESHOLD,
    text_threshold=TEXT_THRESHOLD
)

# छवि एनोटेट करें
annotated_frame = annotate(
    image_source=image_source,
    boxes=boxes,
    logits=logits,
    phrases=phrases
)

cv2.imwrite("output.jpg", annotated_frame)

GroundingDINO + SAM (Grounded-SAM)

डिटेक्शन को सेगमेंटेशन के साथ जोड़ें:

import torch
import numpy as np
from groundingdino.util.inference import load_model, load_image, predict
from segment_anything import sam_model_registry, SamPredictor

# GroundingDINO लोड करें
dino_model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

# SAM लोड करें
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")
sam_predictor = SamPredictor(sam)

# छवि लोड करें
image_source, image = load_image("input.jpg")

# GroundingDINO के साथ डिटेक्ट करें
boxes, logits, phrases = predict(
    model=dino_model,
    image=image,
    caption="person . car",
    box_threshold=0.35,
    text_threshold=0.25
)

# SAM के साथ सेगमेंट करें
sam_predictor.set_image(image_source)

# बॉक्स को SAM फॉर्मेट में कन्वर्ट करें
H, W = image_source.shape[:2]
boxes_xyxy = boxes * torch.tensor([W, H, W, H])

masks = []
for box in boxes_xyxy:
    mask, _, _ = sam_predictor.predict(
        box=box.numpy(),
        multimask_output=False
    )
    masks.append(mask)

बैच प्रोसेसिंग

import os
from groundingdino.util.inference import load_model, load_image, predict, annotate
import cv2

model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

input_dir = "./images"
output_dir = "./detected"
os.makedirs(output_dir, exist_ok=True)

TEXT_PROMPT = "product . price tag . barcode"

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image_path = os.path.join(input_dir, filename)
    image_source, image = load_image(image_path)

    boxes, logits, phrases = predict(
        model=model,
        image=image,
        caption=TEXT_PROMPT,
        box_threshold=0.3,
        text_threshold=0.25
    )

    annotated = annotate(image_source, boxes, logits, phrases)
    cv2.imwrite(os.path.join(output_dir, filename), annotated)

    print(f"{filename}: Found {len(boxes)} objects")

कस्टम डिटेक्शन पाइपलाइन

from groundingdino.util.inference import load_model, load_image, predict
import json

model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

def detect_and_export(image_path, prompt, output_json):
    image_source, image = load_image(image_path)
    H, W = image_source.shape[:2]

    boxes, logits, phrases = predict(
        model=model,
        image=image,
        caption=prompt,
        box_threshold=0.35,
        text_threshold=0.25
    )

    # निरपेक्ष निर्देशाँक में कन्वर्ट करें
    detections = []
    for box, logit, phrase in zip(boxes, logits, phrases):
        x1, y1, x2, y2 = box * torch.tensor([W, H, W, H])
        detections.append({
            "label": phrase,
            "confidence": float(logit),
            "bbox": {
                "x1": int(x1),
                "y1": int(y1),
                "x2": int(x2),
                "y2": int(y2)
            }
        })

    with open(output_json, "w") as f:
        json.dump(detections, f, indent=2)

    return detections

# कारों और लोगों का पता लगाएँ
results = detect_and_export(
    "street.jpg",
    "car . person . bicycle . traffic light",
    "detections.json"
)

Gradio इंटरफ़ेस

import gradio as gr
import cv2
from groundingdino.util.inference import load_model, load_image, predict, annotate
import tempfile
import numpy as np

model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

def detect_objects(image, text_prompt, box_threshold, text_threshold):
    # अस्थायी छवि सहेजें
    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as f:
        cv2.imwrite(f.name, cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR))
        image_source, img = load_image(f.name)

    boxes, logits, phrases = predict(
        model=model,
        image=img,
        caption=text_prompt,
        box_threshold=box_threshold,
        text_threshold=text_threshold
    )

    annotated = annotate(image_source, boxes, logits, phrases)
    annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)

    return annotated_rgb, f"Found {len(boxes)} objects: {', '.join(phrases)}"

demo = gr.Interface(
    fn=detect_objects,
    inputs=[
        gr.Image(type="pil", label="इनपुट इमेज"),
        gr.Textbox(label="Objects to Detect", value="person . car . dog", placeholder="object1 . object2 . object3"),
        gr.Slider(0.1, 0.9, value=0.35, label="Box Threshold"),
        gr.Slider(0.1, 0.9, value=0.25, label="Text Threshold")
    ],
    outputs=[
        gr.Image(label="Detection Result"),
        gr.Textbox(label="Summary")
    ],
    title="GroundingDINO - Open-Set Object Detection",
    description="पाठ में वर्णन करके किसी भी वस्तु का पता लगाएँ। CLORE.AI GPU सर्वरों पर चल रहा है."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

प्रदर्शन

कार्य	रिज़ॉल्यूशन	GPU	स्पीड
एकल छवि	800x600	RTX 3090	120ms
एकल छवि	800x600	RTX 4090	80ms
एकल छवि	1920x1080	RTX 4090	150ms
बैच (10 छवियाँ)	800x600	RTX 4090	600ms

सामान्य समस्याएँ और समाधान

कम डिटेक्शन सटीकता

समस्या: वस्तुएँ पता नहीं लग रही हैं

समाधान:

• कम करें box_threshold 0.2-0.3 पर

• कम करें text_threshold 0.15-0.2 पर

• और अधिक विशिष्ट वस्तु विवरणों का उपयोग करें

• वस्तुओं को अल्पविराम के बजाय " . " से अलग करें

# अच्छा प्रॉम्प्ट फॉर्मेट
TEXT_PROMPT = "red car . person wearing hat . wooden chair"

# बुरा प्रॉम्प्ट फॉर्मेट
TEXT_PROMPT = "red car, person wearing hat, wooden chair"

आउट ऑफ़ मेमोरी

समस्या: बड़ी छवियों पर CUDA OOM

समाधान:

# डिटेक्शन से पहले बड़ी छवियों का आकार बदलें
from PIL import Image

def resize_if_needed(image_path, max_size=1280):
    img = Image.open(image_path)
    if max(img.size) > max_size:
        ratio = max_size / max(img.size)
        new_size = (int(img.width * ratio), int(img.height * ratio))
        img = img.resize(new_size, Image.LANCZOS)
        img.save(image_path)

धिमा इनफ़रेंस

समस्या: डिटेक्शन बहुत समय ले रहा है

समाधान:

• छोटे इनपुट छवियों का उपयोग करें

• कई छवियों को बैच में प्रोसेस करें

• FP16 इन्फरेंस का उपयोग करें

• तेज़ GPU किराये पर लें (RTX 4090, A100)

गलत सकारात्मक (False Positives)

समस्या: गलत वस्तुओं का पता लगना

समाधान:

• बढ़ाएँ box_threshold 0.4-0.5 पर

• प्रॉम्प्ट में अधिक विशिष्ट रहें

• नकारात्मक प्रॉम्प्ट का उपयोग करें (डिटेक्शन के बाद परिणाम फ़िल्टर करें)

# कम-विश्वास डिटेक्शनों को फ़िल्टर करें
filtered = [(b, l, p) for b, l, p in zip(boxes, logits, phrases) if l > 0.5]

समस्याओं का निवारण

ऑब्जेक्ट्स डिटेक्ट नहीं हो रहे हैं

• अधिक विशिष्ट पाठ विवरणों का उपयोग करें

• विभिन्न वाक्य-विन्यास आज़माएँ

• कॉन्फिडेंस थ्रेशोल्ड कम करें

बाउंडिंग बॉक्स गलत हैं

• पाठ प्रॉम्प्ट में अधिक विशिष्ट रहें

• कई वस्तुओं को अलग करने के लिए "." का उपयोग करें

• छवि गुणवत्ता जांचें

मेमोरी खत्म

• छवि रिज़ॉल्यूशन कम करें

• छवियों को एक-एक करके प्रोसेस करें

• छोटे मॉडल वेरिएंट का उपयोग करें

धीमी निष्पादन गति

• गति के लिए TensorRT का उपयोग करें

• समान आकार की छवियों को बैच में प्रोसेस करें

• FP16 इन्फरेंस सक्षम करें

लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

GPU	घंटात्मक दर	दैनिक दर	4-घंटे सत्र
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

कीमतें प्रदाता और मांग के अनुसार बदलती हैं। जाँच करें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

• भुगतान करें CLORE टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• SAM2 - डिटेक्ट किए गए ऑब्जेक्ट्स का सेगमेंट

• Florence-2 - और अधिक विज़न कार्य

• YOLO - ज्ञात वर्गों के लिए तेज़ डिटेक्शन