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 Marketplace de CLORE.AI.

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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

• Detecta cualquier objeto sin entrenamiento

• Localización precisa de cajas delimitadoras de alta exactitud

• Combínalo con SAM para segmentación automática

Recursos

• GitHub: IDEA-Research/GroundingDINO

• Artículo: Documento técnico de GroundingDINO

• HuggingFace: IDEA-Research/grounding-dino

• Demo: Espacio de Hugging Face

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 de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

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

• Anota automáticamente conjuntos de datos para entrenamiento de ML

• Genera cajas delimitadoras a partir de descripciones

• Acelera los flujos de etiquetado de datos

Búsqueda visual

• Encuentra objetos específicos en bases de datos de imágenes

• Sistemas de moderación de contenido

• Reconocimiento de productos en el comercio minorista

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

• Recorta automáticamente los sujetos de las fotos

• Genera máscaras de objetos con SAM

• Edición de imágenes consciente del contenido

Analítica

• Cuenta objetos en imágenes

• Rastrea el inventario a partir de fotos

• Monitoreo de fauna 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 = "gato . perro . persona"
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)

Combina la detección con la 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="persona . coche",
    box_threshold=0.35,
    text_threshold=0.25
)

# Segmentar con SAM
sam_predictor.set_image(image_source)

# Convertir las 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 = "producto . etiqueta de precio . código de barras"

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}: Se encontraron {len(boxes)} objetos")

Flujo de detección personalizado

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 coches y personas
results = detect_and_export(
    "street.jpg",
    "coche . persona . bicicleta . semáforo",
    "detections.json"
)

Interfaz de 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"Se encontraron {len(boxes)} objetos: {', '.join(phrases)}"

demo = gr.Interface(
    fn=detect_objects,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Textbox(label="Objetos a detectar", value="persona . coche . perro", placeholder="objeto1 . objeto2 . objeto3"),
        gr.Slider(0.1, 0.9, value=0.35, label="Umbral de caja"),
        gr.Slider(0.1, 0.9, value=0.25, label="Umbral de texto")
    ],
    outputs=[
        gr.Image(label="Resultado de la detección"),
        gr.Textbox(label="Resumen")
    ],
    title="GroundingDINO - Detección de objetos de conjunto abierto",
    description="Detecta cualquier objeto describiéndolo en texto. Ejecutándose en los 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	120 ms
Imagen única	800x600	RTX 4090	80ms
Imagen única	1920x1080	RTX 4090	150 ms
Lote (10 imágenes)	800x600	RTX 4090	600ms

Problemas comunes y soluciones

Baja precisión de detección

Problema: Los objetos no se detectan

Soluciones:

• Reduce box_threshold a 0.2-0.3

• Reduce text_threshold a 0.15-0.2

• Usa descripciones de objetos más específicas

• Separa los objetos con " . " y no con comas

# Buen formato de indicación
TEXT_PROMPT = "coche rojo . persona con sombrero . silla de madera"

# Mal formato de indicación
TEXT_PROMPT = "coche rojo, persona con sombrero, silla de madera"

Sin memoria

Problema: Error de memoria CUDA OOM en imágenes grandes

Soluciones:

# Redimensiona las 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 tarda demasiado

Soluciones:

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

• Procesa varias imágenes por lotes

• Usa inferencia FP16

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

Falsos positivos

Problema: Detectando objetos incorrectos

Soluciones:

• Aumenta box_threshold a 0.4-0.5

• Sé más específico en las indicaciones

• Usa indicaciones negativas (filtra los resultados después de la detección)

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

Solución de problemas

Los objetos no se detectan

• Usa descripciones de texto más específicas

• Prueba distintas formulaciones

• Reduce el umbral de confianza

Cajas delimitadoras incorrectas

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

• Usa "." para separar varios objetos

• Comprueba la calidad de las imágenes

Sin memoria

• Reduce la resolución de la imagen

• Procesa las imágenes de una en una

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

Inferencia lenta

• Usa TensorRT para acelerar

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

• Habilita la inferencia FP16

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• SAM2 - Segmentar objetos detectados

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

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