目标检测 Grounding DINO 用语言指定要检测的目标

https://github.com/IDEA-Research/GroundingDINO

 

 

 

 

 

 

 

级联方案（推荐）

def optimized_drone_pipeline(image):
    # 第一段：YOLO快速初筛
    fast_detections = yolo_model(image)
    
    # 第二段：对感兴趣区域用Grounding DINO精细识别
    for roi in fast_detections:
        if is_potential_landmark(roi):
            specific_prompt = get_landmark_prompt(roi)
            detailed_detection = grounding_dino(roi, specific_prompt)
    
    return combined_results

　　

 

 

 

 

 

 

 

 

 

 https://github.com/loki-keroro/SAMbase_segmentation

基于SAM-DINO-CLIP组合模型实现全景图场景下的地物分类和实例分割

 

自定义提示

模型会根据不同的提示文本，生成不同的掩码，可修改main.py中的category_cfg变量，自定义提示文本。

• landcover_prompts为地物分类的提示，在全景图场景下一般用于分割区域连续或较大的类别
• cityobject_prompts为实例分割的提示，在全景图场景下一般用于图像内区域不连续的对象类别
• landcover_prompts_cn和cityobject_prompts_cn为每个类别的中文含义

category_cfg = {
    "landcover_prompts": ['building', 'low vegetation', 'tree', 'river', 'shed', 'road', 'lake', 'bare soil'],
    "landcover_prompts_cn": ['建筑', '低矮植被', '树木', '河流', '棚屋', '道路', '湖泊', '裸土'],
    "cityobject_prompts": ['car', 'truck', 'bus', 'train', 'ship', 'boat'],
    "cityobject_prompts_cn": ['轿车', '卡车', '巴士', '列车', '船(舰)', '船(舶)']
}

　　

 

安装

 

git clone https://github.com/IDEA-Research/GroundingDINO.git

cd GroundingDINO/

pip install -e .如果报错

# # 创建名为 sam2 的 Python 3.10 环境

# conda create -n sam2 python=3.10 -y

# # Linux/Mac

# conda activate sam2

# win10

# activate sam2

# 安装 PyTorch (CUDA 11.8 版本)​

# conda install pytorch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 pytorch-cuda=11.8 -c pytorch -c nvidia -y

pip install torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 --index-url https://download.pytorch.org/whl/cu118

 

# 先安装依赖

pip install -r requirements.txt

# 然后尝试非 editable 安装

pip install .

 

下载权重

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

　　

 

 

 

 

 

 

# 效果其次 600mb
PYTHONWARNINGS="ignore" python demo/inference_on_a_image.py \
-c groundingdino/config/GroundingDINO_SwinT_OGC.py \
-p weights/groundingdino_swint_ogc.pth \
-i demo/npu2pm.JPG \
-o "demo/" \
-t "house"


# 效果更好 900mb
PYTHONWARNINGS="ignore" python demo/inference_on_a_image.py \
-c groundingdino/config/GroundingDINO_SwinB_cfg.py \
-p weights/groundingdino_swinb_cogcoor.pth \
-i demo/npu2pm.JPG \
-o "demo/" \
-t "house"

　　

 

 

 

 

 代码

import argparse
import os
import sys

import numpy as np
import torch
from PIL import Image, ImageDraw, ImageFont


import warnings
warnings.filterwarnings("ignore")  # 忽略所有警告
# 或针对特定警告：
warnings.filterwarnings("ignore", category=FutureWarning)  # 仅忽略 FutureWarning
warnings.filterwarnings("ignore", category=UserWarning)    # 仅忽略 UserWarning

import time

import groundingdino.datasets.transforms as T
from groundingdino.models import build_model
from groundingdino.util import box_ops
from groundingdino.util.slconfig import SLConfig
from groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
from groundingdino.util.vl_utils import create_positive_map_from_span


def plot_boxes_to_image(image_pil, tgt):
    H, W = tgt["size"]
    boxes = tgt["boxes"]
    labels = tgt["labels"]
    assert len(boxes) == len(labels), "boxes and labels must have same length"

    draw = ImageDraw.Draw(image_pil)
    mask = Image.new("L", image_pil.size, 0)
    mask_draw = ImageDraw.Draw(mask)

    # draw boxes and masks
    for box, label in zip(boxes, labels):
        # from 0..1 to 0..W, 0..H
        box = box * torch.Tensor([W, H, W, H])
        # from xywh to xyxy
        box[:2] -= box[2:] / 2
        box[2:] += box[:2]
        # random color
        color = tuple(np.random.randint(0, 255, size=3).tolist())
        # draw
        x0, y0, x1, y1 = box
        x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1)

        draw.rectangle([x0, y0, x1, y1], outline=color, width=6)
        # draw.text((x0, y0), str(label), fill=color)

        font = ImageFont.load_default()
        if hasattr(font, "getbbox"):
            bbox = draw.textbbox((x0, y0), str(label), font)
        else:
            w, h = draw.textsize(str(label), font)
            bbox = (x0, y0, w + x0, y0 + h)
        # bbox = draw.textbbox((x0, y0), str(label))
        draw.rectangle(bbox, fill=color)
        draw.text((x0, y0), str(label), fill="white")

        mask_draw.rectangle([x0, y0, x1, y1], fill=255, width=6)

    return image_pil, mask


def load_image(image_path):
    # load image
    image_pil = Image.open(image_path).convert("RGB")  # load image

    transform = T.Compose(
        [
            T.RandomResize([800], max_size=1333),
            T.ToTensor(),
            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ]
    )
    image, _ = transform(image_pil, None)  # 3, h, w
    return image_pil, image


def load_model(model_config_path, model_checkpoint_path, cpu_only=False):
    args = SLConfig.fromfile(model_config_path)
    args.device = "cuda" if not cpu_only else "cpu"
    model = build_model(args)
    checkpoint = torch.load(model_checkpoint_path, map_location="cpu")
    load_res = model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False)
    print(load_res)
    _ = model.eval()
    return model


def get_grounding_output(model, image, caption, box_threshold, text_threshold=None, with_logits=True, cpu_only=False, token_spans=None):
    assert text_threshold is not None or token_spans is not None, "text_threshould and token_spans should not be None at the same time!"
    caption = caption.lower()
    caption = caption.strip()
    if not caption.endswith("."):
        caption = caption + "."
    device = "cuda" if not cpu_only else "cpu"
    model = model.to(device)
    image = image.to(device)
    with torch.no_grad():
        outputs = model(image[None], captions=[caption])
    logits = outputs["pred_logits"].sigmoid()[0]  # (nq, 256)
    boxes = outputs["pred_boxes"][0]  # (nq, 4)

    # filter output
    if token_spans is None:
        logits_filt = logits.cpu().clone()
        boxes_filt = boxes.cpu().clone()
        filt_mask = logits_filt.max(dim=1)[0] > box_threshold
        logits_filt = logits_filt[filt_mask]  # num_filt, 256
        boxes_filt = boxes_filt[filt_mask]  # num_filt, 4

        # get phrase
        tokenlizer = model.tokenizer
        tokenized = tokenlizer(caption)
        # build pred
        pred_phrases = []
        for logit, box in zip(logits_filt, boxes_filt):
            pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer)
            if with_logits:
                pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
            else:
                pred_phrases.append(pred_phrase)
    else:
        # given-phrase mode
        positive_maps = create_positive_map_from_span(
            model.tokenizer(text_prompt),
            token_span=token_spans
        ).to(image.device) # n_phrase, 256

        logits_for_phrases = positive_maps @ logits.T # n_phrase, nq
        all_logits = []
        all_phrases = []
        all_boxes = []
        for (token_span, logit_phr) in zip(token_spans, logits_for_phrases):
            # get phrase
            phrase = ' '.join([caption[_s:_e] for (_s, _e) in token_span])
            # get mask
            filt_mask = logit_phr > box_threshold
            # filt box
            all_boxes.append(boxes[filt_mask])
            # filt logits
            all_logits.append(logit_phr[filt_mask])
            if with_logits:
                logit_phr_num = logit_phr[filt_mask]
                all_phrases.extend([phrase + f"({str(logit.item())[:4]})" for logit in logit_phr_num])
            else:
                all_phrases.extend([phrase for _ in range(len(filt_mask))])
        boxes_filt = torch.cat(all_boxes, dim=0).cpu()
        pred_phrases = all_phrases


    return boxes_filt, pred_phrases


if __name__ == "__main__":

    # parser = argparse.ArgumentParser("Grounding DINO example", add_help=True)
    # parser.add_argument("--config_file", "-c", type=str, required=True, help="path to config file")
    # parser.add_argument(
    #     "--checkpoint_path", "-p", type=str, required=True, help="path to checkpoint file"
    # )
    # parser.add_argument("--image_path", "-i", type=str, required=True, help="path to image file")
    # parser.add_argument("--text_prompt", "-t", type=str, required=True, help="text prompt")
    # parser.add_argument(
    #     "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory"
    # )

    # parser.add_argument("--box_threshold", type=float, default=0.3, help="box threshold")
    # parser.add_argument("--text_threshold", type=float, default=0.25, help="text threshold")
    # parser.add_argument("--token_spans", type=str, default=None, help=
    #                     "The positions of start and end positions of phrases of interest. \
    #                     For example, a caption is 'a cat and a dog', \
    #                     if you would like to detect 'cat', the token_spans should be '[[[2, 5]], ]', since 'a cat and a dog'[2:5] is 'cat'. \
    #                     if you would like to detect 'a cat', the token_spans should be '[[[0, 1], [2, 5]], ]', since 'a cat and a dog'[0:1] is 'a', and 'a cat and a dog'[2:5] is 'cat'. \
    #                     ")

    # parser.add_argument("--cpu-only", action="store_true", help="running on cpu only!, default=False")
    # args = parser.parse_args()

    # # cfg
    # config_file = args.config_file  # change the path of the model config file
    # checkpoint_path = args.checkpoint_path  # change the path of the model
    # image_path = args.image_path
    # text_prompt = args.text_prompt
    # output_dir = args.output_dir
    # box_threshold = args.box_threshold
    # text_threshold = args.text_threshold
    # token_spans = args.token_spans


    config_file = "../groundingdino/config/GroundingDINO_SwinT_OGC.py"
    checkpoint_path = "../weights/groundingdino_swint_ogc.pth"
    image_path = "npu2pm.JPG"
    text_prompt = "house" #structure
    output_dir = "outputs"
    box_threshold = 0.24
    text_threshold = 0.3
    token_spans = None
    cpu_only = False

    #--token_spans "[[[9, 10], [11, 14]], [[19, 20], [21, 24]]]"

    # make dir
    os.makedirs(output_dir, exist_ok=True)
    # load image
    image_pil, image = load_image(image_path)
    # load model
    model = load_model(config_file, checkpoint_path, cpu_only=cpu_only)

    # visualize raw image
    #image_pil.save(os.path.join(output_dir, "raw_image.jpg"))

    # set the text_threshold to None if token_spans is set.
    if token_spans is not None:
        text_threshold = None
        print("Using token_spans. Set the text_threshold to None.")


    # run model
    start_time = time.time()
    boxes_filt, pred_phrases = get_grounding_output(
        model, image, text_prompt, box_threshold, text_threshold, cpu_only=cpu_only, token_spans=eval(f"{token_spans}")
    )

    elapsed_time = time.time() - start_time
    print(f"执行耗时: {elapsed_time:.4f} 秒")  # 保留4位小数

    # visualize pred
    size = image_pil.size
    pred_dict = {
        "boxes": boxes_filt,
        "size": [size[1], size[0]],  # H,W
        "labels": pred_phrases,
    }
    # import ipdb; ipdb.set_trace()
    image_with_box = plot_boxes_to_image(image_pil, pred_dict)[0]
    image_with_box.save(os.path.join(output_dir, "pred.jpg"))

　　

代码2 

import warnings
warnings.filterwarnings("ignore")  # 忽略所有警告
# 或针对特定警告：
warnings.filterwarnings("ignore", category=FutureWarning)  # 仅忽略 FutureWarning
warnings.filterwarnings("ignore", category=UserWarning)    # 仅忽略 UserWarning



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

config_path="../groundingdino/config/GroundingDINO_SwinT_OGC.py"
weights_path="../weights/groundingdino_swint_ogc.pth"



'''
以下是"房子"的英文近义词，按语义分类：
🏠 ​​Direct Synonyms​​
​​House​​ - 最常用
​​Building​​ - 建筑物（更广义）
​​Home​​ - 带有情感色彩的家
​​Residence​​ - 正式用语，住所
​​Dwelling​​ - 居住场所
🏡 ​​Specific Types of Houses​​
​​Villa​​ - 别墅
​​Apartment​​ - 公寓
​​Cottage​​ - 小屋，村舍
​​Bungalow​​ - 平房
​​Mansion​​ - 豪宅
​​Duplex​​ - 双拼别墅
​​Townhouse​​ - 联排别墅
🏘️ ​​Architectural Terms​​
​​Structure​​ - 结构物
​​Edifice​​ - 大型建筑（正式）
​​Construction​​ - 建筑物
​​Property​​ - 房产
📝 ​​Literary/Formal Terms​​
​​Abode​​ - 住所（文学性）
​​Habitation​​ - 居住地
​​Domicile​​ - 法定住所
​​Residency​​ - 居所

# "building road vehicle park residential commercial industrial" 

'''
model = load_model(config_path, weights_path)
IMAGE_PATH = "npu2pm.JPG"
TEXT_PROMPT = "building house structure construction" 
BOX_TRESHOLD = 0.3   #0.35
TEXT_TRESHOLD = 0.3  # 0.25
Save_path=TEXT_PROMPT+IMAGE_PATH

image_source, image = load_image(IMAGE_PATH)

boxes, logits, phrases = predict(
    model=model,
    image=image,
    caption=TEXT_PROMPT,
    box_threshold=BOX_TRESHOLD,
    text_threshold=TEXT_TRESHOLD
)

annotated_frame = annotate(image_source=image_source, boxes=boxes, logits=logits, phrases=phrases)
cv2.imwrite(Save_path, annotated_frame)