GroundingDINO

Detecta cualquier objeto usando descripciones de texto con GroundingDINO

Detecta cualquier objeto usando descripciones de texto con GroundingDINO.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Todos los ejemplos en esta guía se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace mercado.

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

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

¿Qué es GroundingDINO?

GroundingDINO de IDEA-Research permite:

• Detección de objetos zero-shot con indicaciones de texto

• Detectar cualquier objeto sin entrenamiento

• Localización de cuadros delimitadores de alta precisión

• Combinar con SAM para segmentación automática

Recursos

• GitHub: IDEA-Research/GroundingDINO

• Artículo: Documento de GroundingDINO

• HuggingFace: IDEA-Research/grounding-dino

• Demostración: Espacio de HuggingFace

Hardware recomendado

Componente	Mínimo	Recomendado	Óptimo
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	6GB	12GB	16GB
CPU	4 núcleos	8 núcleos	16 núcleos
RAM	16GB	32GB	64GB
Almacenamiento	SSD de 20 GB	50GB NVMe	100GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen Docker:

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

Puertos:

22/tcp
7860/http

Comando:

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

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

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

# Descargar pesos
mkdir weights
cd weights
wget https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth

Lo que puedes crear

Etiquetado automatizado

• Auto-anotar conjuntos de datos para entrenamiento de ML

• Generar cuadros delimitadores a partir de descripciones

• Acelerar las canalizaciones de etiquetado de datos

Búsqueda visual

• Encontrar objetos específicos en bases de imágenes

• Sistemas de moderación de contenido

• Reconocimiento de productos en retail

Robótica y automatización

• Localización de objetos para brazos robóticos

• Sistemas de gestión de inventario

• Inspección de control de calidad

Aplicaciones creativas

• Recortar automáticamente sujetos de fotos

• Generar máscaras de objetos con SAM

• Edición de imágenes consciente del contenido

Analítica

• Contar objetos en imágenes

• Rastrear inventario desde fotos

• Monitoreo de vida silvestre

Uso básico

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

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

# Cargar imagen
image_source, image = load_image("input.jpg")

# Detectar objetos
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
)

# Anotar imagen
annotated_frame = annotate(
    image_source=image_source,
    boxes=boxes,
    logits=logits,
    phrases=phrases
)

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

GroundingDINO + SAM (Grounded-SAM)

Combinar detección con segmentación:

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

# Cargar GroundingDINO
dino_model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

# Cargar SAM
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")
sam_predictor = SamPredictor(sam)

# Cargar imagen
image_source, image = load_image("input.jpg")

# Detectar con GroundingDINO
boxes, logits, phrases = predict(
    model=dino_model,
    image=image,
    caption="person . car",
    box_threshold=0.35,
    text_threshold=0.25
)

# Segmentar con SAM
sam_predictor.set_image(image_source)

# Convertir cajas al formato de 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)

Procesamiento por lotes

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

Canalización de detección personalizada

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
    )

    # Convertir a coordenadas absolutas
    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

# Detectar autos y personas
results = detect_and_export(
    "street.jpg",
    "car . person . bicycle . traffic light",
    "detections.json"
)

Interfaz 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):
    # Guardar imagen temporal
    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="Imagen de entrada"),
        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 - Detección de objetos de conjunto abierto",
    description="Detecta cualquier objeto describiéndolo en texto. Ejecutándose en servidores GPU de CLORE.AI."
)

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

Rendimiento

Tarea	Resolución	GPU	Velocidad
Imagen única	800x600	RTX 3090	120ms
Imagen única	800x600	RTX 4090	80ms
Imagen única	1920x1080	RTX 4090	150ms
Lote (10 imágenes)	800x600	RTX 4090	600ms

Problemas comunes y soluciones

Baja precisión de detección

Problema: Objetos que no se detectan

Soluciones:

• Reduce box_threshold a 0.2-0.3

• Reduce text_threshold a 0.15-0.2

• Usar descripciones de objetos más específicas

• Separar objetos con " . " no con comas

# Buen formato de indicación
TEXT_PROMPT = "red car . person wearing hat . wooden chair"

# Mal formato de indicación
TEXT_PROMPT = "red car, person wearing hat, wooden chair"

Memoria insuficiente

Problema: CUDA OOM en imágenes grandes

Soluciones:

# Redimensionar imágenes grandes antes de la detección
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)

Inferencia lenta

Problema: La detección toma demasiado tiempo

Soluciones:

• Usar imágenes de entrada más pequeñas

• Procesar múltiples imágenes por lotes

• Usar inferencia en FP16

• Alquilar GPU más rápida (RTX 4090, A100)

Falsos positivos

Problema: Detectando objetos incorrectos

Soluciones:

• Aumente box_threshold a 0.4-0.5

• Ser más específico en las indicaciones

• Usar indicaciones negativas (filtrar resultados después de la detección)

# Filtrar detecciones de baja confianza
filtered = [(b, l, p) for b, l, p in zip(boxes, logits, phrases) if l > 0.5]

Solución de problemas

Objetos no detectados

• Usar descripciones de texto más específicas

• Probar diferentes redacciones

• Bajar el umbral de confianza

Cuadros delimitadores incorrectos

• Ser más específico en la indicación de texto

• Usar "." para separar múltiples objetos

• Comprobar la calidad de las imágenes

Fuera de memoria

• Reducir la resolución de la imagen

• Procesar imágenes una a la vez

• Usar una variante de modelo más pequeña

Inferencia lenta

• Usar TensorRT para aceleración

• Agrupar imágenes de tamaño similar por lotes

• Habilitar inferencia FP16

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores

Próximos pasos

• SAM2 - Segmentar objetos detectados

• Florence-2 - Más tareas de visión

• YOLO - Detección más rápida para clases conocidas