Add files using upload-large-folder tool

external/Grounded-Segment-Anything/.gitignore

@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# checkpoint
+*.pth
+outputs/
+
+.idea/

external/Grounded-Segment-Anything/automatic_label_demo.py

@@ -0,0 +1,323 @@
+import argparse
+import os
+import copy
+
+import numpy as np
+import json
+import torch
+import torchvision
+from PIL import Image, ImageDraw, ImageFont
+import nltk
+import litellm
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util import box_ops
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam, SamPredictor 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+# BLIP
+from transformers import BlipProcessor, BlipForConditionalGeneration
+
+# ChatGPT
+import openai
+
+
+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 generate_caption(raw_image, device):
+    # unconditional image captioning
+    if device == "cuda":
+        inputs = processor(raw_image, return_tensors="pt").to("cuda", torch.float16)
+    else:
+        inputs = processor(raw_image, return_tensors="pt")
+    out = blip_model.generate(**inputs)
+    caption = processor.decode(out[0], skip_special_tokens=True)
+    return caption
+
+
+def generate_tags(caption, split=',', max_tokens=100, model="gpt-3.5-turbo"):
+    lemma = nltk.wordnet.WordNetLemmatizer()
+    if openai_key:
+        prompt = [
+            {
+                'role': 'system',
+                'content': 'Extract the unique nouns in the caption. Remove all the adjectives. ' + \
+                           f'List the nouns in singular form. Split them by "{split} ". ' + \
+                           f'Caption: {caption}.'
+            }
+        ]
+        response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+        reply = response['choices'][0]['message']['content']
+        # sometimes return with "noun: xxx, xxx, xxx"
+        tags = reply.split(':')[-1].strip()
+    else:
+        nltk.download(['punkt', 'averaged_perceptron_tagger', 'wordnet'])
+        tags_list = [word for (word, pos) in nltk.pos_tag(nltk.word_tokenize(caption)) if pos[0] == 'N']
+        tags_lemma = [lemma.lemmatize(w) for w in tags_list]
+        tags = ', '.join(map(str, tags_lemma))
+    return tags
+
+
+def check_caption(caption, pred_phrases, max_tokens=100, model="gpt-3.5-turbo"):
+    object_list = [obj.split('(')[0] for obj in pred_phrases]
+    object_num = []
+    for obj in set(object_list):
+        object_num.append(f'{object_list.count(obj)} {obj}')
+    object_num = ', '.join(object_num)
+    print(f"Correct object number: {object_num}")
+
+    if openai_key:
+        prompt = [
+            {
+                'role': 'system',
+                'content': 'Revise the number in the caption if it is wrong. ' + \
+                           f'Caption: {caption}. ' + \
+                           f'True object number: {object_num}. ' + \
+                           'Only give the revised caption: '
+            }
+        ]
+        response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+        reply = response['choices'][0]['message']['content']
+        # sometimes return with "Caption: xxx, xxx, xxx"
+        caption = reply.split(':')[-1].strip()
+    return caption
+
+
+def load_model(model_config_path, model_checkpoint_path, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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,device="cpu"):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+    model = model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # get phrase
+    tokenlizer = model.tokenizer
+    tokenized = tokenlizer(caption)
+    # build pred
+    pred_phrases = []
+    scores = []
+    for logit, box in zip(logits_filt, boxes_filt):
+        pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer)
+        pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
+        scores.append(logit.max().item())
+
+    return boxes_filt, torch.Tensor(scores), pred_phrases
+
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+    ax.text(x0, y0, label)
+
+
+def save_mask_data(output_dir, caption, mask_list, box_list, label_list):
+    value = 0  # 0 for background
+
+    mask_img = torch.zeros(mask_list.shape[-2:])
+    for idx, mask in enumerate(mask_list):
+        mask_img[mask.cpu().numpy()[0] == True] = value + idx + 1
+    plt.figure(figsize=(10, 10))
+    plt.imshow(mask_img.numpy())
+    plt.axis('off')
+    plt.savefig(os.path.join(output_dir, 'mask.jpg'), bbox_inches="tight", dpi=300, pad_inches=0.0)
+
+    json_data = {
+        'caption': caption,
+        'mask':[{
+            'value': value,
+            'label': 'background'
+        }]
+    }
+    for label, box in zip(label_list, box_list):
+        value += 1
+        name, logit = label.split('(')
+        logit = logit[:-1] # the last is ')'
+        json_data['mask'].append({
+            'value': value,
+            'label': name,
+            'logit': float(logit),
+            'box': box.numpy().tolist(),
+        })
+    with open(os.path.join(output_dir, 'label.json'), 'w') as f:
+        json.dump(json_data, f)
+    
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument(
+        "--grounded_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument("--input_image", type=str, required=True, help="path to image file")
+    parser.add_argument("--split", default=",", type=str, help="split for text prompt")
+    parser.add_argument("--openai_key", type=str, help="key for chatgpt")
+    parser.add_argument("--openai_proxy", default=None, type=str, help="proxy for chatgpt")
+    parser.add_argument(
+        "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory"
+    )
+
+    parser.add_argument("--box_threshold", type=float, default=0.25, help="box threshold")
+    parser.add_argument("--text_threshold", type=float, default=0.2, help="text threshold")
+    parser.add_argument("--iou_threshold", type=float, default=0.5, help="iou threshold")
+
+    parser.add_argument("--device", type=str, default="cpu", help="running on cpu only!, default=False")
+    args = parser.parse_args()
+
+    # cfg
+    config_file = args.config  # change the path of the model config file
+    grounded_checkpoint = args.grounded_checkpoint  # change the path of the model
+    sam_checkpoint = args.sam_checkpoint
+    image_path = args.input_image
+    split = args.split
+    openai_key = args.openai_key
+    openai_proxy = args.openai_proxy
+    output_dir = args.output_dir
+    box_threshold = args.box_threshold
+    text_threshold = args.text_threshold
+    iou_threshold = args.iou_threshold
+    device = args.device
+
+    openai.api_key = openai_key
+    if openai_proxy:
+        openai.proxy = {"http": openai_proxy, "https": openai_proxy}
+
+    # 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, grounded_checkpoint, device=device)
+
+    # visualize raw image
+    image_pil.save(os.path.join(output_dir, "raw_image.jpg"))
+
+    # generate caption and tags
+    # use Tag2Text can generate better captions
+    # https://huggingface.co/spaces/xinyu1205/Tag2Text
+    # but there are some bugs...
+    processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-large")
+    if device == "cuda":
+        blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-large", torch_dtype=torch.float16).to("cuda")
+    else:
+        blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-large")
+    caption = generate_caption(image_pil, device=device)
+    # Currently ", " is better for detecting single tags
+    # while ". " is a little worse in some case
+    text_prompt = generate_tags(caption, split=split)
+    print(f"Caption: {caption}")
+    print(f"Tags: {text_prompt}")
+
+    # run grounding dino model
+    boxes_filt, scores, pred_phrases = get_grounding_output(
+        model, image, text_prompt, box_threshold, text_threshold, device=device
+    )
+
+    # initialize SAM
+    predictor = SamPredictor(build_sam(checkpoint=sam_checkpoint).to(device))
+    image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    boxes_filt = boxes_filt.cpu()
+    # use NMS to handle overlapped boxes
+    print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+    nms_idx = torchvision.ops.nms(boxes_filt, scores, iou_threshold).numpy().tolist()
+    boxes_filt = boxes_filt[nms_idx]
+    pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+    print(f"After NMS: {boxes_filt.shape[0]} boxes")
+    caption = check_caption(caption, pred_phrases)
+    print(f"Revise caption with number: {caption}")
+
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+    masks, _, _ = predictor.predict_torch(
+        point_coords = None,
+        point_labels = None,
+        boxes = transformed_boxes.to(device),
+        multimask_output = False,
+    )
+    
+    # draw output image
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    for mask in masks:
+        show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    for box, label in zip(boxes_filt, pred_phrases):
+        show_box(box.numpy(), plt.gca(), label)
+
+    plt.title(caption)
+    plt.axis('off')
+    plt.savefig(
+        os.path.join(output_dir, "automatic_label_output.jpg"), 
+        bbox_inches="tight", dpi=300, pad_inches=0.0
+    )
+
+    save_mask_data(output_dir, caption, masks, boxes_filt, pred_phrases)

external/Grounded-Segment-Anything/automatic_label_ram_demo.py

@@ -0,0 +1,324 @@
+import argparse
+import os
+
+import numpy as np
+import json
+import torch
+import torchvision
+from PIL import Image
+import litellm
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import (
+    build_sam,
+    build_sam_hq,
+    SamPredictor
+) 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Recognize Anything Model & Tag2Text
+from ram.models import ram
+from ram import inference_ram
+import torchvision.transforms as TS
+
+# ChatGPT or nltk is required when using tags_chineses
+# import openai
+# import nltk
+
+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 check_tags_chinese(tags_chinese, pred_phrases, max_tokens=100, model="gpt-3.5-turbo"):
+    object_list = [obj.split('(')[0] for obj in pred_phrases]
+    object_num = []
+    for obj in set(object_list):
+        object_num.append(f'{object_list.count(obj)} {obj}')
+    object_num = ', '.join(object_num)
+    print(f"Correct object number: {object_num}")
+
+    if openai_key:
+        prompt = [
+            {
+                'role': 'system',
+                'content': 'Revise the number in the tags_chinese if it is wrong. ' + \
+                           f'tags_chinese: {tags_chinese}. ' + \
+                           f'True object number: {object_num}. ' + \
+                           'Only give the revised tags_chinese: '
+            }
+        ]
+        response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+        reply = response['choices'][0]['message']['content']
+        # sometimes return with "tags_chinese: xxx, xxx, xxx"
+        tags_chinese = reply.split(':')[-1].strip()
+    return tags_chinese
+
+
+def load_model(model_config_path, model_checkpoint_path, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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,device="cpu"):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+    model = model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # get phrase
+    tokenlizer = model.tokenizer
+    tokenized = tokenlizer(caption)
+    # build pred
+    pred_phrases = []
+    scores = []
+    for logit, box in zip(logits_filt, boxes_filt):
+        pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer)
+        pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
+        scores.append(logit.max().item())
+
+    return boxes_filt, torch.Tensor(scores), pred_phrases
+
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+    ax.text(x0, y0, label)
+
+
+def save_mask_data(output_dir, tags_chinese, mask_list, box_list, label_list):
+    value = 0  # 0 for background
+
+    mask_img = torch.zeros(mask_list.shape[-2:])
+    for idx, mask in enumerate(mask_list):
+        mask_img[mask.cpu().numpy()[0] == True] = value + idx + 1
+    plt.figure(figsize=(10, 10))
+    plt.imshow(mask_img.numpy())
+    plt.axis('off')
+    plt.savefig(os.path.join(output_dir, 'mask.jpg'), bbox_inches="tight", dpi=300, pad_inches=0.0)
+
+    json_data = {
+        'tags_chinese': tags_chinese,
+        'mask':[{
+            'value': value,
+            'label': 'background'
+        }]
+    }
+    for label, box in zip(label_list, box_list):
+        value += 1
+        name, logit = label.split('(')
+        logit = logit[:-1] # the last is ')'
+        json_data['mask'].append({
+            'value': value,
+            'label': name,
+            'logit': float(logit),
+            'box': box.numpy().tolist(),
+        })
+    with open(os.path.join(output_dir, 'label.json'), 'w') as f:
+        json.dump(json_data, f)
+    
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument(
+        "--ram_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--grounded_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_hq_checkpoint", type=str, default=None, help="path to sam-hq checkpoint file"
+    )
+    parser.add_argument(
+        "--use_sam_hq", action="store_true", help="using sam-hq for prediction"
+    )
+    parser.add_argument("--input_image", type=str, required=True, help="path to image file")
+    parser.add_argument("--split", default=",", type=str, help="split for text prompt")
+    parser.add_argument("--openai_key", type=str, help="key for chatgpt")
+    parser.add_argument("--openai_proxy", default=None, type=str, help="proxy for chatgpt")
+    parser.add_argument(
+        "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory"
+    )
+
+    parser.add_argument("--box_threshold", type=float, default=0.25, help="box threshold")
+    parser.add_argument("--text_threshold", type=float, default=0.2, help="text threshold")
+    parser.add_argument("--iou_threshold", type=float, default=0.5, help="iou threshold")
+
+    parser.add_argument("--device", type=str, default="cpu", help="running on cpu only!, default=False")
+    args = parser.parse_args()
+
+    # cfg
+    config_file = args.config  # change the path of the model config file
+    ram_checkpoint = args.ram_checkpoint  # change the path of the model
+    grounded_checkpoint = args.grounded_checkpoint  # change the path of the model
+    sam_checkpoint = args.sam_checkpoint
+    sam_hq_checkpoint = args.sam_hq_checkpoint
+    use_sam_hq = args.use_sam_hq
+    image_path = args.input_image
+    split = args.split
+    openai_key = args.openai_key
+    openai_proxy = args.openai_proxy
+    output_dir = args.output_dir
+    box_threshold = args.box_threshold
+    text_threshold = args.text_threshold
+    iou_threshold = args.iou_threshold
+    device = args.device
+    
+    # ChatGPT or nltk is required when using tags_chineses
+    # openai.api_key = openai_key
+    # if openai_proxy:
+        # openai.proxy = {"http": openai_proxy, "https": openai_proxy}
+
+    # 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, grounded_checkpoint, device=device)
+
+    # visualize raw image
+    image_pil.save(os.path.join(output_dir, "raw_image.jpg"))
+
+    # initialize Recognize Anything Model
+    normalize = TS.Normalize(mean=[0.485, 0.456, 0.406],
+                                     std=[0.229, 0.224, 0.225])
+    transform = TS.Compose([
+                    TS.Resize((384, 384)),
+                    TS.ToTensor(), normalize
+                ])
+    
+    # load model
+    ram_model = ram(pretrained=ram_checkpoint,
+                                        image_size=384,
+                                        vit='swin_l')
+    # threshold for tagging
+    # we reduce the threshold to obtain more tags
+    ram_model.eval()
+
+    ram_model = ram_model.to(device)
+    raw_image = image_pil.resize(
+                    (384, 384))
+    raw_image  = transform(raw_image).unsqueeze(0).to(device)
+
+    res = inference_ram(raw_image , ram_model)
+
+    # Currently ", " is better for detecting single tags
+    # while ". " is a little worse in some case
+    tags=res[0].replace(' |', ',')
+    tags_chinese=res[1].replace(' |', ',')
+
+    print("Image Tags: ", res[0])
+    print("图像标签: ", res[1])
+
+    # run grounding dino model
+    boxes_filt, scores, pred_phrases = get_grounding_output(
+        model, image, tags, box_threshold, text_threshold, device=device
+    )
+
+    # initialize SAM
+    if use_sam_hq:
+        print("Initialize SAM-HQ Predictor")
+        predictor = SamPredictor(build_sam_hq(checkpoint=sam_hq_checkpoint).to(device))
+    else:
+        predictor = SamPredictor(build_sam(checkpoint=sam_checkpoint).to(device))
+    image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    boxes_filt = boxes_filt.cpu()
+    # use NMS to handle overlapped boxes
+    print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+    nms_idx = torchvision.ops.nms(boxes_filt, scores, iou_threshold).numpy().tolist()
+    boxes_filt = boxes_filt[nms_idx]
+    pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+    print(f"After NMS: {boxes_filt.shape[0]} boxes")
+    tags_chinese = check_tags_chinese(tags_chinese, pred_phrases)
+    print(f"Revise tags_chinese with number: {tags_chinese}")
+
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+    masks, _, _ = predictor.predict_torch(
+        point_coords = None,
+        point_labels = None,
+        boxes = transformed_boxes.to(device),
+        multimask_output = False,
+    )
+    
+    # draw output image
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    for mask in masks:
+        show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    for box, label in zip(boxes_filt, pred_phrases):
+        show_box(box.numpy(), plt.gca(), label)
+
+    # plt.title('RAM-tags' + tags + '\n' + 'RAM-tags_chineseing: ' + tags_chinese + '\n')
+    plt.axis('off')
+    plt.savefig(
+        os.path.join(output_dir, "automatic_label_output.jpg"), 
+        bbox_inches="tight", dpi=300, pad_inches=0.0
+    )
+
+    save_mask_data(output_dir, tags_chinese, masks, boxes_filt, pred_phrases)

external/Grounded-Segment-Anything/automatic_label_tag2text_demo.py

@@ -0,0 +1,352 @@
+import argparse
+import os
+import copy
+
+import numpy as np
+import json
+import torch
+import torchvision
+from PIL import Image, ImageDraw, ImageFont
+import litellm
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util import box_ops
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam, SamPredictor 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Tag2Text
+from ram.models import tag2text
+from ram import inference_tag2text
+import torchvision.transforms as TS
+
+# ChatGPT or nltk is required when using captions
+# import openai
+# import nltk
+
+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 generate_caption(raw_image, device):
+    # unconditional image captioning
+    if device == "cuda":
+        inputs = processor(raw_image, return_tensors="pt").to("cuda", torch.float16)
+    else:
+        inputs = processor(raw_image, return_tensors="pt")
+    out = blip_model.generate(**inputs)
+    caption = processor.decode(out[0], skip_special_tokens=True)
+    return caption
+
+
+def generate_tags(caption, split=',', max_tokens=100, model="gpt-3.5-turbo"):
+    lemma = nltk.wordnet.WordNetLemmatizer()
+    if openai_key:
+        prompt = [
+            {
+                'role': 'system',
+                'content': 'Extract the unique nouns in the caption. Remove all the adjectives. ' + \
+                           f'List the nouns in singular form. Split them by "{split} ". ' + \
+                           f'Caption: {caption}.'
+            }
+        ]
+        response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+        reply = response['choices'][0]['message']['content']
+        # sometimes return with "noun: xxx, xxx, xxx"
+        tags = reply.split(':')[-1].strip()
+    else:
+        nltk.download(['punkt', 'averaged_perceptron_tagger', 'wordnet'])
+        tags_list = [word for (word, pos) in nltk.pos_tag(nltk.word_tokenize(caption)) if pos[0] == 'N']
+        tags_lemma = [lemma.lemmatize(w) for w in tags_list]
+        tags = ', '.join(map(str, tags_lemma))
+    return tags
+
+
+def check_caption(caption, pred_phrases, max_tokens=100, model="gpt-3.5-turbo"):
+    object_list = [obj.split('(')[0] for obj in pred_phrases]
+    object_num = []
+    for obj in set(object_list):
+        object_num.append(f'{object_list.count(obj)} {obj}')
+    object_num = ', '.join(object_num)
+    print(f"Correct object number: {object_num}")
+
+    if openai_key:
+        prompt = [
+            {
+                'role': 'system',
+                'content': 'Revise the number in the caption if it is wrong. ' + \
+                           f'Caption: {caption}. ' + \
+                           f'True object number: {object_num}. ' + \
+                           'Only give the revised caption: '
+            }
+        ]
+        response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+        reply = response['choices'][0]['message']['content']
+        # sometimes return with "Caption: xxx, xxx, xxx"
+        caption = reply.split(':')[-1].strip()
+    return caption
+
+
+def load_model(model_config_path, model_checkpoint_path, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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,device="cpu"):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+    model = model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # get phrase
+    tokenlizer = model.tokenizer
+    tokenized = tokenlizer(caption)
+    # build pred
+    pred_phrases = []
+    scores = []
+    for logit, box in zip(logits_filt, boxes_filt):
+        pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer)
+        pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
+        scores.append(logit.max().item())
+
+    return boxes_filt, torch.Tensor(scores), pred_phrases
+
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+    ax.text(x0, y0, label)
+
+
+def save_mask_data(output_dir, caption, mask_list, box_list, label_list):
+    value = 0  # 0 for background
+
+    mask_img = torch.zeros(mask_list.shape[-2:])
+    for idx, mask in enumerate(mask_list):
+        mask_img[mask.cpu().numpy()[0] == True] = value + idx + 1
+    plt.figure(figsize=(10, 10))
+    plt.imshow(mask_img.numpy())
+    plt.axis('off')
+    plt.savefig(os.path.join(output_dir, 'mask.jpg'), bbox_inches="tight", dpi=300, pad_inches=0.0)
+
+    json_data = {
+        'caption': caption,
+        'mask':[{
+            'value': value,
+            'label': 'background'
+        }]
+    }
+    for label, box in zip(label_list, box_list):
+        value += 1
+        name, logit = label.split('(')
+        logit = logit[:-1] # the last is ')'
+        json_data['mask'].append({
+            'value': value,
+            'label': name,
+            'logit': float(logit),
+            'box': box.numpy().tolist(),
+        })
+    with open(os.path.join(output_dir, 'label.json'), 'w') as f:
+        json.dump(json_data, f)
+    
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument(
+        "--tag2text_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--grounded_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument("--input_image", type=str, required=True, help="path to image file")
+    parser.add_argument("--split", default=",", type=str, help="split for text prompt")
+    parser.add_argument("--openai_key", type=str, help="key for chatgpt")
+    parser.add_argument("--openai_proxy", default=None, type=str, help="proxy for chatgpt")
+    parser.add_argument(
+        "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory"
+    )
+
+    parser.add_argument("--box_threshold", type=float, default=0.25, help="box threshold")
+    parser.add_argument("--text_threshold", type=float, default=0.2, help="text threshold")
+    parser.add_argument("--iou_threshold", type=float, default=0.5, help="iou threshold")
+
+    parser.add_argument("--device", type=str, default="cpu", help="running on cpu only!, default=False")
+    args = parser.parse_args()
+
+    # cfg
+    config_file = args.config  # change the path of the model config file
+    tag2text_checkpoint = args.tag2text_checkpoint  # change the path of the model
+    grounded_checkpoint = args.grounded_checkpoint  # change the path of the model
+    sam_checkpoint = args.sam_checkpoint
+    image_path = args.input_image
+    split = args.split
+    openai_key = args.openai_key
+    openai_proxy = args.openai_proxy
+    output_dir = args.output_dir
+    box_threshold = args.box_threshold
+    text_threshold = args.text_threshold
+    iou_threshold = args.iou_threshold
+    device = args.device
+    
+    # ChatGPT or nltk is required when using captions
+    # openai.api_key = openai_key
+    # if openai_proxy:
+        # openai.proxy = {"http": openai_proxy, "https": openai_proxy}
+
+    # 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, grounded_checkpoint, device=device)
+
+    # visualize raw image
+    image_pil.save(os.path.join(output_dir, "raw_image.jpg"))
+
+    # initialize Tag2Text
+    normalize = TS.Normalize(mean=[0.485, 0.456, 0.406],
+                                     std=[0.229, 0.224, 0.225])
+    transform = TS.Compose([
+                    TS.Resize((384, 384)),
+                    TS.ToTensor(), normalize
+                ])
+    
+    # filter out attributes and action categories which are difficult to grounding
+    delete_tag_index = []
+    for i in range(3012, 3429):
+        delete_tag_index.append(i)
+
+    specified_tags='None'
+    # load model
+    tag2text_model = tag2text(pretrained=tag2text_checkpoint,
+                                        image_size=384,
+                                        vit='swin_b',
+                                        delete_tag_index=delete_tag_index)
+    # threshold for tagging
+    # we reduce the threshold to obtain more tags
+    tag2text_model.threshold = 0.64 
+    tag2text_model.eval()
+
+    tag2text_model = tag2text_model.to(device)
+    raw_image = image_pil.resize(
+                    (384, 384))
+    raw_image  = transform(raw_image).unsqueeze(0).to(device)
+
+    res = inference_tag2text(raw_image , tag2text_model, specified_tags)
+
+    # Currently ", " is better for detecting single tags
+    # while ". " is a little worse in some case
+    text_prompt=res[0].replace(' |', ',')
+    caption=res[2]
+
+    print(f"Caption: {caption}")
+    print(f"Tags: {text_prompt}")
+
+    # run grounding dino model
+    boxes_filt, scores, pred_phrases = get_grounding_output(
+        model, image, text_prompt, box_threshold, text_threshold, device=device
+    )
+
+    # initialize SAM
+    predictor = SamPredictor(build_sam(checkpoint=sam_checkpoint).to(device))
+    image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    boxes_filt = boxes_filt.cpu()
+    # use NMS to handle overlapped boxes
+    print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+    nms_idx = torchvision.ops.nms(boxes_filt, scores, iou_threshold).numpy().tolist()
+    boxes_filt = boxes_filt[nms_idx]
+    pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+    print(f"After NMS: {boxes_filt.shape[0]} boxes")
+    caption = check_caption(caption, pred_phrases)
+    print(f"Revise caption with number: {caption}")
+
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+    masks, _, _ = predictor.predict_torch(
+        point_coords = None,
+        point_labels = None,
+        boxes = transformed_boxes.to(device),
+        multimask_output = False,
+    )
+    
+    # draw output image
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    for mask in masks:
+        show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    for box, label in zip(boxes_filt, pred_phrases):
+        show_box(box.numpy(), plt.gca(), label)
+
+    plt.title('Tag2Text-Captioning: ' + caption + '\n' + 'Tag2Text-Tagging' + text_prompt + '\n')
+    plt.axis('off')
+    plt.savefig(
+        os.path.join(output_dir, "automatic_label_output.jpg"), 
+        bbox_inches="tight", dpi=300, pad_inches=0.0
+    )
+
+    save_mask_data(output_dir, caption, masks, boxes_filt, pred_phrases)

external/Grounded-Segment-Anything/chatbot.py

@@ -0,0 +1,1460 @@
+# coding: utf-8
+import os
+import gradio as gr
+import random
+import torch
+import cv2
+import re
+import uuid
+from PIL import Image, ImageDraw, ImageOps
+import math
+import numpy as np
+import argparse
+import inspect
+
+import shutil
+import torchvision
+import whisper
+import matplotlib.pyplot as plt
+from automatic_label_demo import load_model, load_image, get_grounding_output, show_box, show_mask, generate_tags, check_caption
+from grounding_dino_demo import plot_boxes_to_image
+from segment_anything import build_sam, SamAutomaticMaskGenerator, SamPredictor
+from segment_anything.utils.amg import remove_small_regions 
+
+from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation
+from transformers import pipeline, BlipProcessor, BlipForConditionalGeneration, BlipForQuestionAnswering
+from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
+
+from diffusers import StableDiffusionPipeline, StableDiffusionInpaintPipeline, StableDiffusionInstructPix2PixPipeline
+from diffusers import EulerAncestralDiscreteScheduler
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, UniPCMultistepScheduler
+from controlnet_aux import OpenposeDetector, MLSDdetector, HEDdetector
+
+from langchain.agents.initialize import initialize_agent
+from langchain.agents.tools import Tool
+from langchain.chains.conversation.memory import ConversationBufferMemory
+from langchain.llms.openai import OpenAI
+
+VISUAL_CHATGPT_PREFIX = """Visual ChatGPT is designed to be able to assist with a wide range of text and visual related tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. Visual ChatGPT is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
+
+Visual ChatGPT is able to process and understand large amounts of text and images. As a language model, Visual ChatGPT can not directly read images, but it has a list of tools to finish different visual tasks. Each image will have a file name formed as "image/xxx.png", and Visual ChatGPT can invoke different tools to indirectly understand pictures. When talking about images, Visual ChatGPT is very strict to the file name and will never fabricate nonexistent files. When using tools to generate new image files, Visual ChatGPT is also known that the image may not be the same as the user's demand, and will use other visual question answering tools or description tools to observe the real image. Visual ChatGPT is able to use tools in a sequence, and is loyal to the tool observation outputs rather than faking the image content and image file name. It will remember to provide the file name from the last tool observation, if a new image is generated.
+
+Human may provide new figures to Visual ChatGPT with a description. The description helps Visual ChatGPT to understand this image, but Visual ChatGPT should use tools to finish following tasks, rather than directly imagine from the description.
+
+Overall, Visual ChatGPT is a powerful visual dialogue assistant tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. 
+
+
+TOOLS:
+------
+
+Visual ChatGPT  has access to the following tools:"""
+
+VISUAL_CHATGPT_FORMAT_INSTRUCTIONS = """To use a tool, please use the following format:
+
+```
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+```
+
+When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
+
+```
+Thought: Do I need to use a tool? No
+{ai_prefix}: [your response here]
+```
+"""
+
+VISUAL_CHATGPT_SUFFIX = """You are very strict to the filename correctness and will never fake a file name if it does not exist.
+You will remember to provide the image file name loyally if it's provided in the last tool observation.
+
+Begin!
+
+Previous conversation history:
+{chat_history}
+
+New input: {input}
+Since Visual ChatGPT is a text language model, Visual ChatGPT must use tools to observe images rather than imagination.
+The thoughts and observations are only visible for Visual ChatGPT, Visual ChatGPT should remember to repeat important information in the final response for Human. 
+Thought: Do I need to use a tool? {agent_scratchpad} Let's think step by step.
+"""
+
+VISUAL_CHATGPT_PREFIX_CN = """Visual ChatGPT 旨在能够协助完成范围广泛的文本和视觉相关任务，从回答简单的问题到提供对广泛主题的深入解释和讨论。 Visual ChatGPT 能够根据收到的输入生成类似人类的文本，使其能够进行听起来自然的对话，并提供连贯且与手头主题相关的响应。
+
+Visual ChatGPT 能够处理和理解大量文本和图像。作为一种语言模型，Visual ChatGPT 不能直接读取图像，但它有一系列工具来完成不同的视觉任务。每张图片都会有一个文件名，格式为“image/xxx.png”，Visual ChatGPT可以调用不同的工具来间接理解图片。在谈论图片时，Visual ChatGPT 对文件名的要求非常严格，绝不会伪造不存在的文件。在使用工具生成新的图像文件时，Visual ChatGPT也知道图像可能与用户需求不一样，会使用其他视觉问答工具或描述工具来观察真实图像。 Visual ChatGPT 能够按顺序使用工具，并且忠于工具观察输出，而不是伪造图像内容和图像文件名。如果生成新图像，它将记得提供上次工具观察的文件名。
+
+Human 可能会向 Visual ChatGPT 提供带有描述的新图形。描述帮助 Visual ChatGPT 理解这个图像，但 Visual ChatGPT 应该使用工具来完成以下任务，而不是直接从描述中想象。有些工具将会返回英文描述，但你对用户的聊天应当采用中文。
+
+总的来说，Visual ChatGPT 是一个强大的可视化对话辅助工具，可以帮助处理范围广泛的任务，并提供关于范围广泛的主题的有价值的见解和信息。
+
+工具列表:
+------
+
+Visual ChatGPT 可以使用这些工具:"""
+
+VISUAL_CHATGPT_FORMAT_INSTRUCTIONS_CN = """用户使用中文和你进行聊天，但是工具的参数应当使用英文。如果要调用工具，你必须遵循如下格式:
+
+```
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+```
+
+当你不再需要继续调用工具，而是对观察结果进行总结回复时，你必须使用如下格式：
+
+
+```
+Thought: Do I need to use a tool? No
+{ai_prefix}: [your response here]
+```
+"""
+
+VISUAL_CHATGPT_SUFFIX_CN = """你对文件名的正确性非常严格，而且永远不会伪造不存在的文件。
+
+开始!
+
+因为Visual ChatGPT是一个文本语言模型，必须使用工具去观察图片而不是依靠想象。
+推理想法和观察结果只对Visual ChatGPT可见，需要记得在最终回复时把重要的信息重复给用户，你只能给用户返回中文句子。我们一步一步思考。在你使用工具时，工具的参数只能是英文。
+
+聊天历史:
+{chat_history}
+
+新输入: {input}
+Thought: Do I need to use a tool? {agent_scratchpad}
+"""
+
+os.makedirs('image', exist_ok=True)
+
+
+def seed_everything(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    return seed
+
+
+def prompts(name, description):
+    def decorator(func):
+        func.name = name
+        func.description = description
+        return func
+
+    return decorator
+
+
+def blend_gt2pt(old_image, new_image, sigma=0.15, steps=100):
+    new_size = new_image.size
+    old_size = old_image.size
+    easy_img = np.array(new_image)
+    gt_img_array = np.array(old_image)
+    pos_w = (new_size[0] - old_size[0]) // 2
+    pos_h = (new_size[1] - old_size[1]) // 2
+
+    kernel_h = cv2.getGaussianKernel(old_size[1], old_size[1] * sigma)
+    kernel_w = cv2.getGaussianKernel(old_size[0], old_size[0] * sigma)
+    kernel = np.multiply(kernel_h, np.transpose(kernel_w))
+
+    kernel[steps:-steps, steps:-steps] = 1
+    kernel[:steps, :steps] = kernel[:steps, :steps] / kernel[steps - 1, steps - 1]
+    kernel[:steps, -steps:] = kernel[:steps, -steps:] / kernel[steps - 1, -(steps)]
+    kernel[-steps:, :steps] = kernel[-steps:, :steps] / kernel[-steps, steps - 1]
+    kernel[-steps:, -steps:] = kernel[-steps:, -steps:] / kernel[-steps, -steps]
+    kernel = np.expand_dims(kernel, 2)
+    kernel = np.repeat(kernel, 3, 2)
+
+    weight = np.linspace(0, 1, steps)
+    top = np.expand_dims(weight, 1)
+    top = np.repeat(top, old_size[0] - 2 * steps, 1)
+    top = np.expand_dims(top, 2)
+    top = np.repeat(top, 3, 2)
+
+    weight = np.linspace(1, 0, steps)
+    down = np.expand_dims(weight, 1)
+    down = np.repeat(down, old_size[0] - 2 * steps, 1)
+    down = np.expand_dims(down, 2)
+    down = np.repeat(down, 3, 2)
+
+    weight = np.linspace(0, 1, steps)
+    left = np.expand_dims(weight, 0)
+    left = np.repeat(left, old_size[1] - 2 * steps, 0)
+    left = np.expand_dims(left, 2)
+    left = np.repeat(left, 3, 2)
+
+    weight = np.linspace(1, 0, steps)
+    right = np.expand_dims(weight, 0)
+    right = np.repeat(right, old_size[1] - 2 * steps, 0)
+    right = np.expand_dims(right, 2)
+    right = np.repeat(right, 3, 2)
+
+    kernel[:steps, steps:-steps] = top
+    kernel[-steps:, steps:-steps] = down
+    kernel[steps:-steps, :steps] = left
+    kernel[steps:-steps, -steps:] = right
+
+    pt_gt_img = easy_img[pos_h:pos_h + old_size[1], pos_w:pos_w + old_size[0]]
+    gaussian_gt_img = kernel * gt_img_array + (1 - kernel) * pt_gt_img  # gt img with blur img
+    gaussian_gt_img = gaussian_gt_img.astype(np.int64)
+    easy_img[pos_h:pos_h + old_size[1], pos_w:pos_w + old_size[0]] = gaussian_gt_img
+    gaussian_img = Image.fromarray(easy_img)
+    return gaussian_img
+
+
+def cut_dialogue_history(history_memory, keep_last_n_words=500):
+    if history_memory is None or len(history_memory) == 0:
+        return history_memory
+    tokens = history_memory.split()
+    n_tokens = len(tokens)
+    print(f"history_memory:{history_memory}, n_tokens: {n_tokens}")
+    if n_tokens < keep_last_n_words:
+        return history_memory
+    paragraphs = history_memory.split('\n')
+    last_n_tokens = n_tokens
+    while last_n_tokens >= keep_last_n_words:
+        last_n_tokens -= len(paragraphs[0].split(' '))
+        paragraphs = paragraphs[1:]
+    return '\n' + '\n'.join(paragraphs)
+
+
+def get_new_image_name(org_img_name, func_name="update"):
+    head_tail = os.path.split(org_img_name)
+    head = head_tail[0]
+    tail = head_tail[1]
+    name_split = tail.split('.')[0].split('_')
+    this_new_uuid = str(uuid.uuid4())[:4]
+    if len(name_split) == 1:
+        most_org_file_name = name_split[0]
+    else:
+        assert len(name_split) == 4
+        most_org_file_name = name_split[3]
+    recent_prev_file_name = name_split[0]
+    new_file_name = f'{this_new_uuid}_{func_name}_{recent_prev_file_name}_{most_org_file_name}.png'
+    return os.path.join(head, new_file_name)
+
+
+
+class MaskFormer:
+    def __init__(self, device):
+        print(f"Initializing MaskFormer to {device}")
+        self.device = device
+        self.processor = CLIPSegProcessor.from_pretrained("CIDAS/clipseg-rd64-refined")
+        self.model = CLIPSegForImageSegmentation.from_pretrained("CIDAS/clipseg-rd64-refined").to(device)
+
+    def inference(self, image_path, text):
+        threshold = 0.5
+        min_area = 0.02
+        padding = 20
+        original_image = Image.open(image_path)
+        image = original_image.resize((512, 512))
+        inputs = self.processor(text=text, images=image, padding="max_length", return_tensors="pt").to(self.device)
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        mask = torch.sigmoid(outputs[0]).squeeze().cpu().numpy() > threshold
+        area_ratio = len(np.argwhere(mask)) / (mask.shape[0] * mask.shape[1])
+        if area_ratio < min_area:
+            return None
+        true_indices = np.argwhere(mask)
+        mask_array = np.zeros_like(mask, dtype=bool)
+        for idx in true_indices:
+            padded_slice = tuple(slice(max(0, i - padding), i + padding + 1) for i in idx)
+            mask_array[padded_slice] = True
+        visual_mask = (mask_array * 255).astype(np.uint8)
+        image_mask = Image.fromarray(visual_mask)
+        return image_mask.resize(original_image.size)
+
+
+class ImageEditing:
+    def __init__(self, device):
+        print(f"Initializing ImageEditing to {device}")
+        self.device = device
+        self.mask_former = MaskFormer(device=self.device)
+        self.revision = 'fp16' if 'cuda' in device else None
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.inpaint = StableDiffusionInpaintPipeline.from_pretrained(
+            "runwayml/stable-diffusion-inpainting", revision=self.revision, torch_dtype=self.torch_dtype).to(device)
+
+    @prompts(name="Replace Something From The Photo",
+             description="useful when you want to replace an object from the object description or "
+                         "location with another object from its description. "
+                         "The input to this tool should be a comma separated string of three, "
+                         "representing the image_path, the object to be replaced, the object to be replaced with ")
+    def inference_replace(self, inputs):
+        image_path, to_be_replaced_txt, replace_with_txt = inputs.split(",")
+        original_image = Image.open(image_path)
+        original_size = original_image.size
+        mask_image = self.mask_former.inference(image_path, to_be_replaced_txt)
+        updated_image = self.inpaint(prompt=replace_with_txt, image=original_image.resize((512, 512)),
+                                     mask_image=mask_image.resize((512, 512))).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="replace-something")
+        updated_image = updated_image.resize(original_size)
+        updated_image.save(updated_image_path)
+        print(
+            f"\nProcessed ImageEditing, Input Image: {image_path}, Replace {to_be_replaced_txt} to {replace_with_txt}, "
+            f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class InstructPix2Pix:
+    def __init__(self, device):
+        print(f"Initializing InstructPix2Pix to {device}")
+        self.device = device
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.pipe = StableDiffusionInstructPix2PixPipeline.from_pretrained("timbrooks/instruct-pix2pix",
+                                                                           safety_checker=None,
+                                                                           torch_dtype=self.torch_dtype).to(device)
+        self.pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(self.pipe.scheduler.config)
+
+    @prompts(name="Instruct Image Using Text",
+             description="useful when you want to the style of the image to be like the text. "
+                         "like: make it look like a painting. or make it like a robot. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the text. ")
+    def inference(self, inputs):
+        """Change style of image."""
+        print("===>Starting InstructPix2Pix Inference")
+        image_path, text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        original_image = Image.open(image_path)
+        image = self.pipe(text, image=original_image, num_inference_steps=40, image_guidance_scale=1.2).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="pix2pix")
+        image.save(updated_image_path)
+        print(f"\nProcessed InstructPix2Pix, Input Image: {image_path}, Instruct Text: {text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class Text2Image:
+    def __init__(self, device):
+        print(f"Initializing Text2Image to {device}")
+        self.device = device
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5",
+                                                            torch_dtype=self.torch_dtype)
+        self.pipe.to(device)
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
+                        'fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image From User Input Text",
+             description="useful when you want to generate an image from a user input text and save it to a file. "
+                         "like: generate an image of an object or something, or generate an image that includes some objects. "
+                         "The input to this tool should be a string, representing the text used to generate image. ")
+    def inference(self, text):
+        image_filename = os.path.join('image', f"{str(uuid.uuid4())[:8]}.png")
+        prompt = text + ', ' + self.a_prompt
+        image = self.pipe(prompt, negative_prompt=self.n_prompt).images[0]
+        image.save(image_filename)
+        print(
+            f"\nProcessed Text2Image, Input Text: {text}, Output Image: {image_filename}")
+        return image_filename
+
+
+class ImageCaptioning:
+    def __init__(self, device):
+        print(f"Initializing ImageCaptioning to {device}")
+        self.device = device
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+        self.model = BlipForConditionalGeneration.from_pretrained(
+            "Salesforce/blip-image-captioning-base", torch_dtype=self.torch_dtype).to(self.device)
+
+    @prompts(name="Get Photo Description",
+             description="useful when you want to know what is inside the photo. receives image_path as input. "
+                         "The input to this tool should be a string, representing the image_path. ")
+    def inference(self, image_path):
+        inputs = self.processor(Image.open(image_path), return_tensors="pt").to(self.device, self.torch_dtype)
+        out = self.model.generate(**inputs)
+        captions = self.processor.decode(out[0], skip_special_tokens=True)
+        print(f"\nProcessed ImageCaptioning, Input Image: {image_path}, Output Text: {captions}")
+        return captions
+
+
+class Image2Canny:
+    def __init__(self, device):
+        print("Initializing Image2Canny")
+        self.low_threshold = 100
+        self.high_threshold = 200
+
+    @prompts(name="Edge Detection On Image",
+             description="useful when you want to detect the edge of the image. "
+                         "like: detect the edges of this image, or canny detection on image, "
+                         "or perform edge detection on this image, or detect the canny image of this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        image = np.array(image)
+        canny = cv2.Canny(image, self.low_threshold, self.high_threshold)
+        canny = canny[:, :, None]
+        canny = np.concatenate([canny, canny, canny], axis=2)
+        canny = Image.fromarray(canny)
+        updated_image_path = get_new_image_name(inputs, func_name="edge")
+        canny.save(updated_image_path)
+        print(f"\nProcessed Image2Canny, Input Image: {inputs}, Output Text: {updated_image_path}")
+        return updated_image_path
+
+
+class CannyText2Image:
+    def __init__(self, device):
+        print(f"Initializing CannyText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained("fusing/stable-diffusion-v1-5-controlnet-canny",
+                                                          torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype)
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
+                            'fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Canny Image",
+             description="useful when you want to generate a new real image from both the user description and a canny image."
+                         " like: generate a real image of a object or something from this canny image,"
+                         " or generate a new real image of a object or something from this edge image. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description. ")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="canny2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed CannyText2Image, Input Canny: {image_path}, Input Text: {instruct_text}, "
+              f"Output Text: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Line:
+    def __init__(self, device):
+        print("Initializing Image2Line")
+        self.detector = MLSDdetector.from_pretrained('lllyasviel/ControlNet')
+
+    @prompts(name="Line Detection On Image",
+             description="useful when you want to detect the straight line of the image. "
+                         "like: detect the straight lines of this image, or straight line detection on image, "
+                         "or perform straight line detection on this image, or detect the straight line image of this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        mlsd = self.detector(image)
+        updated_image_path = get_new_image_name(inputs, func_name="line-of")
+        mlsd.save(updated_image_path)
+        print(f"\nProcessed Image2Line, Input Image: {inputs}, Output Line: {updated_image_path}")
+        return updated_image_path
+
+
+class LineText2Image:
+    def __init__(self, device):
+        print(f"Initializing LineText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained("fusing/stable-diffusion-v1-5-controlnet-mlsd",
+                                                          torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype
+        )
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
+                            'fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Line Image",
+             description="useful when you want to generate a new real image from both the user description "
+                         "and a straight line image. "
+                         "like: generate a real image of a object or something from this straight line image, "
+                         "or generate a new real image of a object or something from this straight lines. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description. ")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="line2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed LineText2Image, Input Line: {image_path}, Input Text: {instruct_text}, "
+              f"Output Text: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Hed:
+    def __init__(self, device):
+        print("Initializing Image2Hed")
+        self.detector = HEDdetector.from_pretrained('lllyasviel/ControlNet')
+
+    @prompts(name="Hed Detection On Image",
+             description="useful when you want to detect the soft hed boundary of the image. "
+                         "like: detect the soft hed boundary of this image, or hed boundary detection on image, "
+                         "or perform hed boundary detection on this image, or detect soft hed boundary image of this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        hed = self.detector(image)
+        updated_image_path = get_new_image_name(inputs, func_name="hed-boundary")
+        hed.save(updated_image_path)
+        print(f"\nProcessed Image2Hed, Input Image: {inputs}, Output Hed: {updated_image_path}")
+        return updated_image_path
+
+
+class HedText2Image:
+    def __init__(self, device):
+        print(f"Initializing HedText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained("fusing/stable-diffusion-v1-5-controlnet-hed",
+                                                          torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype
+        )
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
+                            'fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Soft Hed Boundary Image",
+             description="useful when you want to generate a new real image from both the user description "
+                         "and a soft hed boundary image. "
+                         "like: generate a real image of a object or something from this soft hed boundary image, "
+                         "or generate a new real image of a object or something from this hed boundary. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="hed2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed HedText2Image, Input Hed: {image_path}, Input Text: {instruct_text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Scribble:
+    def __init__(self, device):
+        print("Initializing Image2Scribble")
+        self.detector = HEDdetector.from_pretrained('lllyasviel/ControlNet')
+
+    @prompts(name="Sketch Detection On Image",
+             description="useful when you want to generate a scribble of the image. "
+                         "like: generate a scribble of this image, or generate a sketch from this image, "
+                         "detect the sketch from this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        scribble = self.detector(image, scribble=True)
+        updated_image_path = get_new_image_name(inputs, func_name="scribble")
+        scribble.save(updated_image_path)
+        print(f"\nProcessed Image2Scribble, Input Image: {inputs}, Output Scribble: {updated_image_path}")
+        return updated_image_path
+
+
+class ScribbleText2Image:
+    def __init__(self, device):
+        print(f"Initializing ScribbleText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained("fusing/stable-diffusion-v1-5-controlnet-scribble",
+                                                          torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype
+        )
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
+                            'fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Sketch Image",
+             description="useful when you want to generate a new real image from both the user description and "
+                         "a scribble image or a sketch image. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="scribble2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed ScribbleText2Image, Input Scribble: {image_path}, Input Text: {instruct_text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Pose:
+    def __init__(self, device):
+        print("Initializing Image2Pose")
+        self.detector = OpenposeDetector.from_pretrained('lllyasviel/ControlNet')
+
+    @prompts(name="Pose Detection On Image",
+             description="useful when you want to detect the human pose of the image. "
+                         "like: generate human poses of this image, or generate a pose image from this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        pose = self.detector(image)
+        updated_image_path = get_new_image_name(inputs, func_name="human-pose")
+        pose.save(updated_image_path)
+        print(f"\nProcessed Image2Pose, Input Image: {inputs}, Output Pose: {updated_image_path}")
+        return updated_image_path
+
+
+class PoseText2Image:
+    def __init__(self, device):
+        print(f"Initializing PoseText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained("fusing/stable-diffusion-v1-5-controlnet-openpose",
+                                                          torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype)
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.num_inference_steps = 20
+        self.seed = -1
+        self.unconditional_guidance_scale = 9.0
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
+                            ' fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Pose Image",
+             description="useful when you want to generate a new real image from both the user description "
+                         "and a human pose image. "
+                         "like: generate a real image of a human from this human pose image, "
+                         "or generate a new real image of a human from this pose. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="pose2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed PoseText2Image, Input Pose: {image_path}, Input Text: {instruct_text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Seg:
+    def __init__(self, device):
+        print("Initializing Image2Seg")
+        self.image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-small")
+        self.image_segmentor = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-small")
+        self.ade_palette = [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
+                            [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
+                            [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
+                            [150, 5, 61], [120, 120, 70], [8, 255, 51], [255, 6, 82],
+                            [143, 255, 140], [204, 255, 4], [255, 51, 7], [204, 70, 3],
+                            [0, 102, 200], [61, 230, 250], [255, 6, 51], [11, 102, 255],
+                            [255, 7, 71], [255, 9, 224], [9, 7, 230], [220, 220, 220],
+                            [255, 9, 92], [112, 9, 255], [8, 255, 214], [7, 255, 224],
+                            [255, 184, 6], [10, 255, 71], [255, 41, 10], [7, 255, 255],
+                            [224, 255, 8], [102, 8, 255], [255, 61, 6], [255, 194, 7],
+                            [255, 122, 8], [0, 255, 20], [255, 8, 41], [255, 5, 153],
+                            [6, 51, 255], [235, 12, 255], [160, 150, 20], [0, 163, 255],
+                            [140, 140, 140], [250, 10, 15], [20, 255, 0], [31, 255, 0],
+                            [255, 31, 0], [255, 224, 0], [153, 255, 0], [0, 0, 255],
+                            [255, 71, 0], [0, 235, 255], [0, 173, 255], [31, 0, 255],
+                            [11, 200, 200], [255, 82, 0], [0, 255, 245], [0, 61, 255],
+                            [0, 255, 112], [0, 255, 133], [255, 0, 0], [255, 163, 0],
+                            [255, 102, 0], [194, 255, 0], [0, 143, 255], [51, 255, 0],
+                            [0, 82, 255], [0, 255, 41], [0, 255, 173], [10, 0, 255],
+                            [173, 255, 0], [0, 255, 153], [255, 92, 0], [255, 0, 255],
+                            [255, 0, 245], [255, 0, 102], [255, 173, 0], [255, 0, 20],
+                            [255, 184, 184], [0, 31, 255], [0, 255, 61], [0, 71, 255],
+                            [255, 0, 204], [0, 255, 194], [0, 255, 82], [0, 10, 255],
+                            [0, 112, 255], [51, 0, 255], [0, 194, 255], [0, 122, 255],
+                            [0, 255, 163], [255, 153, 0], [0, 255, 10], [255, 112, 0],
+                            [143, 255, 0], [82, 0, 255], [163, 255, 0], [255, 235, 0],
+                            [8, 184, 170], [133, 0, 255], [0, 255, 92], [184, 0, 255],
+                            [255, 0, 31], [0, 184, 255], [0, 214, 255], [255, 0, 112],
+                            [92, 255, 0], [0, 224, 255], [112, 224, 255], [70, 184, 160],
+                            [163, 0, 255], [153, 0, 255], [71, 255, 0], [255, 0, 163],
+                            [255, 204, 0], [255, 0, 143], [0, 255, 235], [133, 255, 0],
+                            [255, 0, 235], [245, 0, 255], [255, 0, 122], [255, 245, 0],
+                            [10, 190, 212], [214, 255, 0], [0, 204, 255], [20, 0, 255],
+                            [255, 255, 0], [0, 153, 255], [0, 41, 255], [0, 255, 204],
+                            [41, 0, 255], [41, 255, 0], [173, 0, 255], [0, 245, 255],
+                            [71, 0, 255], [122, 0, 255], [0, 255, 184], [0, 92, 255],
+                            [184, 255, 0], [0, 133, 255], [255, 214, 0], [25, 194, 194],
+                            [102, 255, 0], [92, 0, 255]]
+
+    @prompts(name="Segmentation On Image",
+             description="useful when you want to detect segmentations of the image. "
+                         "like: segment this image, or generate segmentations on this image, "
+                         "or perform segmentation on this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        pixel_values = self.image_processor(image, return_tensors="pt").pixel_values
+        with torch.no_grad():
+            outputs = self.image_segmentor(pixel_values)
+        seg = self.image_processor.post_process_semantic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]
+        color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)  # height, width, 3
+        palette = np.array(self.ade_palette)
+        for label, color in enumerate(palette):
+            color_seg[seg == label, :] = color
+        color_seg = color_seg.astype(np.uint8)
+        segmentation = Image.fromarray(color_seg)
+        updated_image_path = get_new_image_name(inputs, func_name="segmentation")
+        segmentation.save(updated_image_path)
+        print(f"\nProcessed Image2Seg, Input Image: {inputs}, Output Pose: {updated_image_path}")
+        return updated_image_path
+
+
+class SegText2Image:
+    def __init__(self, device):
+        print(f"Initializing SegText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained("fusing/stable-diffusion-v1-5-controlnet-seg",
+                                                          torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype)
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
+                            ' fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Segmentations",
+             description="useful when you want to generate a new real image from both the user description and segmentations. "
+                         "like: generate a real image of a object or something from this segmentation image, "
+                         "or generate a new real image of a object or something from these segmentations. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="segment2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed SegText2Image, Input Seg: {image_path}, Input Text: {instruct_text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Depth:
+    def __init__(self, device):
+        print("Initializing Image2Depth")
+        self.depth_estimator = pipeline('depth-estimation')
+
+    @prompts(name="Predict Depth On Image",
+             description="useful when you want to detect depth of the image. like: generate the depth from this image, "
+                         "or detect the depth map on this image, or predict the depth for this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        depth = self.depth_estimator(image)['depth']
+        depth = np.array(depth)
+        depth = depth[:, :, None]
+        depth = np.concatenate([depth, depth, depth], axis=2)
+        depth = Image.fromarray(depth)
+        updated_image_path = get_new_image_name(inputs, func_name="depth")
+        depth.save(updated_image_path)
+        print(f"\nProcessed Image2Depth, Input Image: {inputs}, Output Depth: {updated_image_path}")
+        return updated_image_path
+
+
+class DepthText2Image:
+    def __init__(self, device):
+        print(f"Initializing DepthText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained(
+            "fusing/stable-diffusion-v1-5-controlnet-depth", torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype)
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
+                            ' fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Depth",
+             description="useful when you want to generate a new real image from both the user description and depth image. "
+                         "like: generate a real image of a object or something from this depth image, "
+                         "or generate a new real image of a object or something from the depth map. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="depth2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed DepthText2Image, Input Depth: {image_path}, Input Text: {instruct_text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class Image2Normal:
+    def __init__(self, device):
+        print("Initializing Image2Normal")
+        self.depth_estimator = pipeline("depth-estimation", model="Intel/dpt-hybrid-midas")
+        self.bg_threhold = 0.4
+
+    @prompts(name="Predict Normal Map On Image",
+             description="useful when you want to detect norm map of the image. "
+                         "like: generate normal map from this image, or predict normal map of this image. "
+                         "The input to this tool should be a string, representing the image_path")
+    def inference(self, inputs):
+        image = Image.open(inputs)
+        original_size = image.size
+        image = self.depth_estimator(image)['predicted_depth'][0]
+        image = image.numpy()
+        image_depth = image.copy()
+        image_depth -= np.min(image_depth)
+        image_depth /= np.max(image_depth)
+        x = cv2.Sobel(image, cv2.CV_32F, 1, 0, ksize=3)
+        x[image_depth < self.bg_threhold] = 0
+        y = cv2.Sobel(image, cv2.CV_32F, 0, 1, ksize=3)
+        y[image_depth < self.bg_threhold] = 0
+        z = np.ones_like(x) * np.pi * 2.0
+        image = np.stack([x, y, z], axis=2)
+        image /= np.sum(image ** 2.0, axis=2, keepdims=True) ** 0.5
+        image = (image * 127.5 + 127.5).clip(0, 255).astype(np.uint8)
+        image = Image.fromarray(image)
+        image = image.resize(original_size)
+        updated_image_path = get_new_image_name(inputs, func_name="normal-map")
+        image.save(updated_image_path)
+        print(f"\nProcessed Image2Normal, Input Image: {inputs}, Output Depth: {updated_image_path}")
+        return updated_image_path
+
+
+class NormalText2Image:
+    def __init__(self, device):
+        print(f"Initializing NormalText2Image to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.controlnet = ControlNetModel.from_pretrained(
+            "fusing/stable-diffusion-v1-5-controlnet-normal", torch_dtype=self.torch_dtype)
+        self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5", controlnet=self.controlnet, safety_checker=None,
+            torch_dtype=self.torch_dtype)
+        self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
+        self.pipe.to(device)
+        self.seed = -1
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,' \
+                            ' fewer digits, cropped, worst quality, low quality'
+
+    @prompts(name="Generate Image Condition On Normal Map",
+             description="useful when you want to generate a new real image from both the user description and normal map. "
+                         "like: generate a real image of a object or something from this normal map, "
+                         "or generate a new real image of a object or something from the normal map. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the user description")
+    def inference(self, inputs):
+        image_path, instruct_text = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        image = Image.open(image_path)
+        self.seed = random.randint(0, 65535)
+        seed_everything(self.seed)
+        prompt = f'{instruct_text}, {self.a_prompt}'
+        image = self.pipe(prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt,
+                          guidance_scale=9.0).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name="normal2image")
+        image.save(updated_image_path)
+        print(f"\nProcessed NormalText2Image, Input Normal: {image_path}, Input Text: {instruct_text}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+
+class VisualQuestionAnswering:
+    def __init__(self, device):
+        print(f"Initializing VisualQuestionAnswering to {device}")
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.device = device
+        self.processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
+        self.model = BlipForQuestionAnswering.from_pretrained(
+            "Salesforce/blip-vqa-base", torch_dtype=self.torch_dtype).to(self.device)
+
+    @prompts(name="Answer Question About The Image",
+             description="useful when you need an answer for a question based on an image. "
+                         "like: what is the background color of the last image, how many cats in this figure, what is in this figure. "
+                         "The input to this tool should be a comma separated string of two, representing the image_path and the question")
+    def inference(self, inputs):
+        image_path, question = inputs.split(",")[0], ','.join(inputs.split(',')[1:])
+        raw_image = Image.open(image_path).convert('RGB')
+        inputs = self.processor(raw_image, question, return_tensors="pt").to(self.device, self.torch_dtype)
+        out = self.model.generate(**inputs)
+        answer = self.processor.decode(out[0], skip_special_tokens=True)
+        print(f"\nProcessed VisualQuestionAnswering, Input Image: {image_path}, Input Question: {question}, "
+              f"Output Answer: {answer}")
+        return answer
+
+
+class InfinityOutPainting:
+    template_model = True # Add this line to show this is a template model.
+    def __init__(self, ImageCaptioning, ImageEditing, VisualQuestionAnswering):
+        self.llm = OpenAI(temperature=0)
+        self.ImageCaption = ImageCaptioning
+        self.ImageEditing = ImageEditing
+        self.ImageVQA = VisualQuestionAnswering
+        self.a_prompt = 'best quality, extremely detailed'
+        self.n_prompt = 'longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, ' \
+                        'fewer digits, cropped, worst quality, low quality'
+
+    def get_BLIP_vqa(self, image, question):
+        inputs = self.ImageVQA.processor(image, question, return_tensors="pt").to(self.ImageVQA.device,
+                                                                                  self.ImageVQA.torch_dtype)
+        out = self.ImageVQA.model.generate(**inputs)
+        answer = self.ImageVQA.processor.decode(out[0], skip_special_tokens=True)
+        print(f"\nProcessed VisualQuestionAnswering, Input Question: {question}, Output Answer: {answer}")
+        return answer
+
+    def get_BLIP_caption(self, image):
+        inputs = self.ImageCaption.processor(image, return_tensors="pt").to(self.ImageCaption.device,
+                                                                                self.ImageCaption.torch_dtype)
+        out = self.ImageCaption.model.generate(**inputs)
+        BLIP_caption = self.ImageCaption.processor.decode(out[0], skip_special_tokens=True)
+        return BLIP_caption
+
+    def check_prompt(self, prompt):
+        check = f"Here is a paragraph with adjectives. " \
+                f"{prompt} " \
+                f"Please change all plural forms in the adjectives to singular forms. "
+        return self.llm(check)
+
+    def get_imagine_caption(self, image, imagine):
+        BLIP_caption = self.get_BLIP_caption(image)
+        background_color = self.get_BLIP_vqa(image, 'what is the background color of this image')
+        style = self.get_BLIP_vqa(image, 'what is the style of this image')
+        imagine_prompt = f"let's pretend you are an excellent painter and now " \
+                         f"there is an incomplete painting with {BLIP_caption} in the center, " \
+                         f"please imagine the complete painting and describe it" \
+                         f"you should consider the background color is {background_color}, the style is {style}" \
+                         f"You should make the painting as vivid and realistic as possible" \
+                         f"You can not use words like painting or picture" \
+                         f"and you should use no more than 50 words to describe it"
+        caption = self.llm(imagine_prompt) if imagine else BLIP_caption
+        caption = self.check_prompt(caption)
+        print(f'BLIP observation: {BLIP_caption}, ChatGPT imagine to {caption}') if imagine else print(
+            f'Prompt: {caption}')
+        return caption
+
+    def resize_image(self, image, max_size=1000000, multiple=8):
+        aspect_ratio = image.size[0] / image.size[1]
+        new_width = int(math.sqrt(max_size * aspect_ratio))
+        new_height = int(new_width / aspect_ratio)
+        new_width, new_height = new_width - (new_width % multiple), new_height - (new_height % multiple)
+        return image.resize((new_width, new_height))
+
+    def dowhile(self, original_img, tosize, expand_ratio, imagine, usr_prompt):
+        old_img = original_img
+        while (old_img.size != tosize):
+            prompt = self.check_prompt(usr_prompt) if usr_prompt else self.get_imagine_caption(old_img, imagine)
+            crop_w = 15 if old_img.size[0] != tosize[0] else 0
+            crop_h = 15 if old_img.size[1] != tosize[1] else 0
+            old_img = ImageOps.crop(old_img, (crop_w, crop_h, crop_w, crop_h))
+            temp_canvas_size = (expand_ratio * old_img.width if expand_ratio * old_img.width < tosize[0] else tosize[0],
+                                expand_ratio * old_img.height if expand_ratio * old_img.height < tosize[1] else tosize[
+                                    1])
+            temp_canvas, temp_mask = Image.new("RGB", temp_canvas_size, color="white"), Image.new("L", temp_canvas_size,
+                                                                                                  color="white")
+            x, y = (temp_canvas.width - old_img.width) // 2, (temp_canvas.height - old_img.height) // 2
+            temp_canvas.paste(old_img, (x, y))
+            temp_mask.paste(0, (x, y, x + old_img.width, y + old_img.height))
+            resized_temp_canvas, resized_temp_mask = self.resize_image(temp_canvas), self.resize_image(temp_mask)
+            image = self.ImageEditing.inpaint(prompt=prompt, image=resized_temp_canvas, mask_image=resized_temp_mask,
+                                              height=resized_temp_canvas.height, width=resized_temp_canvas.width,
+                                              num_inference_steps=50).images[0].resize(
+                (temp_canvas.width, temp_canvas.height), Image.ANTIALIAS)
+            image = blend_gt2pt(old_img, image)
+            old_img = image
+        return old_img
+
+    @prompts(name="Extend An Image",
+             description="useful when you need to extend an image into a larger image."
+                         "like: extend the image into a resolution of 2048x1024, extend the image into 2048x1024. "
+                         "The input to this tool should be a comma separated string of two, representing the image_path and the resolution of widthxheight")
+    def inference(self, inputs):
+        image_path, resolution = inputs.split(',')
+        width, height = resolution.split('x')
+        tosize = (int(width), int(height))
+        image = Image.open(image_path)
+        image = ImageOps.crop(image, (10, 10, 10, 10))
+        out_painted_image = self.dowhile(image, tosize, 4, True, False)
+        updated_image_path = get_new_image_name(image_path, func_name="outpainting")
+        out_painted_image.save(updated_image_path)
+        print(f"\nProcessed InfinityOutPainting, Input Image: {image_path}, Input Resolution: {resolution}, "
+              f"Output Image: {updated_image_path}")
+        return updated_image_path
+
+#############################################New Tool#############################################
+class Grounded_dino_sam_inpainting:
+    def __init__(self, device):
+        print(f"Initializing BLIP")
+        self.device = device
+        self.torch_dtype = torch.float16 if 'cuda' in device else torch.float32
+        self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-large")
+        self.blip_model = BlipForConditionalGeneration.from_pretrained(
+            "Salesforce/blip-image-captioning-large", torch_dtype=self.torch_dtype
+        ).to(self.device)
+        print(f"Initializing GroundingDINO")
+        self.dino_model = load_model(
+            model_config_path="GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py", 
+            model_checkpoint_path="groundingdino_swint_ogc.pth", 
+            device=self.device
+        )
+        print(f"Initializing Segment Anthing")
+        self.sam_model = build_sam(checkpoint="sam_vit_h_4b8939.pth").to(self.device)
+        print(f"Initializing Stable Diffusion")
+        self.sd_pipe = StableDiffusionInpaintPipeline.from_pretrained(
+            "runwayml/stable-diffusion-inpainting", torch_dtype=self.torch_dtype
+        ).to(self.device)
+
+    @prompts(name="Get Photo Description",
+             description="useful when you want to know what is inside the photo. receives image_path as input. "
+                         "The input to this tool should be a string, representing the image_path. ")
+    def inference_caption(self, image_path):
+        inputs = self.blip_processor(Image.open(image_path), return_tensors="pt").to(self.device, self.torch_dtype)
+        out = self.blip_model.generate(**inputs)
+        captions = self.blip_processor.decode(out[0], skip_special_tokens=True)
+        print(f"\nProcessed ImageCaptioning, Input Image: {image_path}, Output Text: {captions}")
+        return captions
+    
+    def _detect_object(self, image_path, text_prompt, func_name):
+        image_pil, image = load_image(image_path)
+        boxes_filt, scores, pred_phrases = get_grounding_output(
+            self.dino_model, image, text_prompt, 0.3, 0.25, device=self.device
+        )
+        # use NMS to handle overlapped boxes
+        print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+        nms_idx = torchvision.ops.nms(boxes_filt, scores, 0.5).numpy().tolist()
+        boxes_filt = boxes_filt[nms_idx]
+        pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+        print(f"After NMS: {boxes_filt.shape[0]} boxes")
+        size = image_pil.size
+        pred_dict = {
+            "boxes": boxes_filt,
+            "size": [size[1], size[0]],  # H,W
+            "labels": pred_phrases,
+        }
+        image_with_box = plot_boxes_to_image(image_pil, pred_dict)[0]
+        updated_image_path = get_new_image_name(image_path, func_name)
+        image_with_box.save(updated_image_path)
+        return updated_image_path
+
+    @prompts(name="Detect One Object In Image",
+             description="useful when you want to detect the specific object in the image. "
+                         "like: detect the black dog in the image. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the description of specific object.")
+    def inference_detect_one_object(self, inputs):
+        image_path, text_prompt = inputs.split(',')
+        print(f"\nInput Text Prompt: {text_prompt}")
+        updated_image_path = self._detect_object(image_path, text_prompt, func_name="det-object")
+        print(f"Processed DetectOneObject, Input Image: {image_path}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+    @prompts(name="Detect Multiple Objects In Image",
+             description="useful when you want to detect two or more specific objects in the image. "
+                         "like: detect the black dog and white cat in the image. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the description of multiple specific objects. "
+                         "Different description should be separated by symbol '&', "
+                         "like 'black dog & white cat'. ")
+    def inference_detect_multi_object(self, inputs):
+        image_path, text_prompt = inputs.split(',')
+        processed_text_prompt = text_prompt.replace(' &', ',')
+        print(f"\nOriginal Text Prompt: {text_prompt}, Input Text Prompt: {processed_text_prompt}")
+        updated_image_path = self._detect_object(image_path, text_prompt, func_name="det-objects")
+        print(f"Processed DetectMultiObject, Input Image: {image_path}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+    # modified from https://github.com/Cheems-Seminar/segment-anything-and-name-it/blob/58408f1e4e340f565c5ef6b0c71920cdcd30b213/chatbot.py#L1046
+    @prompts(name="Segment Anything in Image",
+             description="useful when you want to segment anything in the image. "
+                         "like: segment anything in the image. "
+                         "The input to this tool should be a string, representing the image_path. ")
+    def inference_segment_anything(self, image_path):
+        image = cv2.imread(image_path)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        mask_generator = SamAutomaticMaskGenerator(self.sam_model)
+        anns = mask_generator.generate(image)
+        plt.figure(figsize=(10, 10))
+        plt.imshow(image)
+        sorted_anns = sorted(anns, key=(lambda x: x['area']), reverse=True)
+        ax = plt.gca()
+        ax.set_autoscale_on(False)
+        for ann in sorted_anns:
+            m = ann['segmentation']
+            img = np.ones((m.shape[0], m.shape[1], 3))
+            color_mask = np.random.random((1, 3)).tolist()[0]
+            for i in range(3):
+                img[:,:,i] = color_mask[i]
+            ax.imshow(np.dstack((img, m*0.35)))
+        plt.axis('off')
+        updated_image_path = get_new_image_name(image_path, func_name="seg-any")
+        plt.savefig(updated_image_path, bbox_inches='tight', dpi=300, pad_inches=0.0)
+        print(f"\nProcessed SegmentAnything, Input Image: {image_path}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+    def _segment_object(self, image_path, text_prompt, func_name):
+        image_pil, image = load_image(image_path)
+        # run grounding dino model
+        boxes_filt, scores, pred_phrases = get_grounding_output(
+            self.dino_model, image, text_prompt, 0.25, 0.2, device=self.device
+        )
+        # initialize SAM
+        predictor = SamPredictor(self.sam_model)
+        image = cv2.imread(image_path)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        predictor.set_image(image)
+        size = image_pil.size
+        H, W = size[1], size[0]
+        for i in range(boxes_filt.size(0)):
+            boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+            boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+            boxes_filt[i][2:] += boxes_filt[i][:2]
+        boxes_filt = boxes_filt.cpu()
+        # use NMS to handle overlapped boxes
+        print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+        nms_idx = torchvision.ops.nms(boxes_filt, scores, 0.5).numpy().tolist()
+        boxes_filt = boxes_filt[nms_idx]
+        pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+        print(f"After NMS: {boxes_filt.shape[0]} boxes")
+        # generate mask
+        transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2])
+        masks, _, _ = predictor.predict_torch(
+            point_coords = None,
+            point_labels = None,
+            boxes = transformed_boxes.to(self.device),
+            multimask_output = False,
+        )
+        # remove the mask when area < area_thresh (in pixels)
+        new_masks = []
+        for mask in masks:
+            # reshape to be used in remove_small_regions()
+            mask = mask.cpu().numpy().squeeze()
+            mask, _ = remove_small_regions(mask, 100, mode="holes")
+            mask, _ = remove_small_regions(mask, 100, mode="islands")
+            new_masks.append(torch.as_tensor(mask).unsqueeze(0))
+        masks = torch.stack(new_masks, dim=0)
+        # add box and mask in the image
+        plt.figure(figsize=(10, 10))
+        plt.imshow(image)
+        for mask in masks:
+            show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+        for box, label in zip(boxes_filt, pred_phrases):
+            show_box(box.numpy(), plt.gca(), label)
+        plt.axis('off')
+        updated_image_path = get_new_image_name(image_path, func_name)
+        plt.savefig(updated_image_path, bbox_inches='tight', dpi=300, pad_inches=0.0)
+        return updated_image_path, pred_phrases
+
+    @prompts(name="Segment One Object In Image",
+             description="useful when you want to segment the specific object in the image. "
+                         "like: segment the black dog in the image, or mask the black dog in the image. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the description of specific object.")
+    def inference_segment_one_object(self, inputs):
+        image_path, text_prompt = inputs.split(',')
+        print(f"\nInput Text Prompt: {text_prompt}")
+        updated_image_path, _ = self._segment_object(image_path, text_prompt, func_name="seg-object")
+        print(f"Processed SegmentOneObject, Input Image: {image_path}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+    @prompts(name="Segment Multiple Object In Image",
+             description="useful when you want to segment two or more specific objects in the image. "
+                         "like: segment the black dog and white cat in the image. "
+                         "The input to this tool should be a comma separated string of two, "
+                         "representing the image_path and the description of multiple specific objects. "
+                         "Different description should be separated by symbol '&', "
+                         "like 'black dog & white cat'. ")
+    def inference_segment_multi_object(self, inputs):
+        image_path, text_prompt = inputs.split(',')
+        processed_text_prompt = text_prompt.replace(' &', ',')
+        print("\nOriginal Text Prompt: {text_prompt}, Input Text Prompt: {processed_text_prompt}, ")
+        updated_image_path, _ = self._segment_object(image_path, text_prompt, func_name="seg-objects")
+        print(f"Processed SegmentMultiObject, Input Image: {image_path}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+    @prompts(name="Auto Label the Image",
+             description="useful when you want to label the image automatically. "
+                         "like: help me label the image. "
+                         "The input to this tool should be a string, representing the image_path. ")
+    def inference_auto_segment_object(self, image_path):
+        inputs = self.blip_processor(Image.open(image_path), return_tensors="pt").to(self.device, self.torch_dtype)
+        out = self.blip_model.generate(**inputs)
+        caption = self.blip_processor.decode(out[0], skip_special_tokens=True)
+        text_prompt = generate_tags(caption, split=",")
+        print(f"\nCaption: {caption}")
+        print(f"Tags: {text_prompt}")
+        updated_image_path, pred_phrases = self._segment_object(image_path, text_prompt, func_name="auto-label")
+        caption = check_caption(caption, pred_phrases)
+        print(f"Revise caption with number: {caption}")
+        print(f"Processed SegmentMultiObject, Input Image: {image_path}, Caption: {caption}, "
+              f"Text Prompt: {text_prompt}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+    def _inpainting(self, image_path, to_be_replaced_txt, replace_with_txt, func_name):
+        image_pil, image = load_image(image_path)
+        # run grounding dino model
+        boxes_filt, scores, pred_phrases = get_grounding_output(
+            self.dino_model, image, to_be_replaced_txt, 0.3, 0.25, device=self.device
+        )
+        # initialize SAM
+        predictor = SamPredictor(self.sam_model)
+        image = cv2.imread(image_path)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        predictor.set_image(image)
+        size = image_pil.size
+        H, W = size[1], size[0]
+        for i in range(boxes_filt.size(0)):
+            boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+            boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+            boxes_filt[i][2:] += boxes_filt[i][:2]
+        boxes_filt = boxes_filt.cpu()
+        # generate mask
+        transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2])
+        masks, _, _ = predictor.predict_torch(
+            point_coords = None,
+            point_labels = None,
+            boxes = transformed_boxes.to(self.device),
+            multimask_output = False,
+        )
+        # inpainting pipeline
+        mask = masks[0][0].cpu().numpy() # simply choose the first mask, which will be refine in the future release
+        mask_pil = Image.fromarray(mask).resize((512, 512))
+        image_pil = Image.fromarray(image).resize((512, 512))
+        image = self.sd_pipe(prompt=replace_with_txt, image=image_pil, mask_image=mask_pil).images[0]
+        updated_image_path = get_new_image_name(image_path, func_name)
+        image.save(updated_image_path)
+        return updated_image_path
+
+    @prompts(name="Replace Something From The Photo",
+             description="useful when you want to replace an object from the object description or "
+                         "location with another object from its description. "
+                         "The input to this tool should be a comma separated string of three, "
+                         "representing the image_path, the object to be replaced, the object to be replaced with ")
+    def inference_replace(self, inputs):
+        image_path, to_be_replaced_txt, replace_with_txt = inputs.split(",")
+        print(f"\nReplace {to_be_replaced_txt} to {replace_with_txt}")
+        updated_image_path = self._inpainting(image_path, to_be_replaced_txt, replace_with_txt, 'replace-something')
+        print(f"Processed ImageEditing, Input Image: {image_path}, Output Image: {updated_image_path}")
+        return updated_image_path
+
+#############################################New Tool#############################################
+
+
+class ConversationBot:
+    def __init__(self, load_dict):
+        # load_dict = {'VisualQuestionAnswering':'cuda:0', 'ImageCaptioning':'cuda:1',...}
+        print(f"Initializing VisualChatGPT, load_dict={load_dict}")
+        if 'ImageCaptioning' not in load_dict and 'Grounded_dino_sam_inpainting' not in load_dict:
+            raise ValueError("You have to load ImageCaptioning or Grounded_dino_sam_inpainting as a basic function for VisualChatGPT")
+
+        self.models = {}
+        # Load Basic Foundation Models
+        for class_name, device in load_dict.items():
+            self.models[class_name] = globals()[class_name](device=device)
+
+        # Load Template Foundation Models
+        for class_name, module in globals().items():
+            if getattr(module, 'template_model', False):
+                template_required_names = {k for k in inspect.signature(module.__init__).parameters.keys() if k!='self'}
+                loaded_names = set([type(e).__name__ for e in self.models.values()])
+                if template_required_names.issubset(loaded_names):
+                    self.models[class_name] = globals()[class_name](
+                        **{name: self.models[name] for name in template_required_names})
+        self.tools = []
+        for instance in self.models.values():
+            for e in dir(instance):
+                if e.startswith('inference'):
+                    func = getattr(instance, e)
+                    self.tools.append(Tool(name=func.name, description=func.description, func=func))
+        self.llm = OpenAI(temperature=0)
+        self.memory = ConversationBufferMemory(memory_key="chat_history", output_key='output')
+
+    def run_text(self, text, state):
+        self.agent.memory.buffer = cut_dialogue_history(self.agent.memory.buffer, keep_last_n_words=500)
+        res = self.agent({"input": text.strip()})
+        res['output'] = res['output'].replace("\\", "/")
+        response = re.sub('(image/[-\w]*.png)', lambda m: f'![](/file={m.group(0)})*{m.group(0)}*', res['output'])
+        state = state + [(text, response)]
+        print(f"\nProcessed run_text, Input text: {text}\nCurrent state: {state}\n"
+              f"Current Memory: {self.agent.memory.buffer}")
+        return state, state
+
+    def run_image(self, image, state, txt, lang):
+        # image_filename = os.path.join('image', f"{str(uuid.uuid4())[:8]}.png")
+        # print("======>Auto Resize Image...")
+        # img = Image.open(image.name)
+        # width, height = img.size
+        # ratio = min(512 / width, 512 / height)
+        # width_new, height_new = (round(width * ratio), round(height * ratio))
+        # width_new = int(np.round(width_new / 64.0)) * 64
+        # height_new = int(np.round(height_new / 64.0)) * 64
+        # img = img.resize((width_new, height_new))
+        # img = img.convert('RGB')
+        # img.save(image_filename)
+        # img.save(image_filename, "PNG")
+        # print(f"Resize image form {width}x{height} to {width_new}x{height_new}")
+        ## Directly use original image for better results
+        suffix = image.name.split('.')[-1] 
+        image_filename = os.path.join('image', f"{str(uuid.uuid4())[:8]}.{suffix}")
+        shutil.copy(image.name, image_filename)
+        if 'Grounded_dino_sam_inpainting' in self.models:
+            description = self.models['Grounded_dino_sam_inpainting'].inference_caption(image_filename)
+        else:
+            description = self.models['ImageCaptioning'].inference(image_filename)
+        if lang == 'Chinese':
+            Human_prompt = f'\nHuman: 提供一张名为 {image_filename}的图片。它的描述是: {description}。 这些信息帮助你理解这个图像，但是你应该使用工具来完成下面的任务，而不是直接从我的描述中想象。 如果你明白了, 说 \"收到\". \n'
+            AI_prompt = "收到。  "
+        else:
+            Human_prompt = f'\nHuman: provide a figure named {image_filename}. The description is: {description}. This information helps you to understand this image, but you should use tools to finish following tasks, rather than directly imagine from my description. If you understand, say \"Received\". \n'
+            AI_prompt = "Received.  "
+        self.agent.memory.buffer = self.agent.memory.buffer + Human_prompt + 'AI: ' + AI_prompt
+        state = state + [(f"![](/file={image_filename})*{image_filename}*", AI_prompt)]
+        print(f"\nProcessed run_image, Input image: {image_filename}\nCurrent state: {state}\n"
+              f"Current Memory: {self.agent.memory.buffer}")
+        return state, state, f'{txt} {image_filename} '
+
+    def init_agent(self, openai_api_key, lang):
+        self.memory.clear() #clear previous history
+        if lang=='English':
+            PREFIX, FORMAT_INSTRUCTIONS, SUFFIX = VISUAL_CHATGPT_PREFIX, VISUAL_CHATGPT_FORMAT_INSTRUCTIONS, VISUAL_CHATGPT_SUFFIX
+            place = "Enter text and press enter, or upload an image"
+            label_clear = "Clear"
+        else:
+            PREFIX, FORMAT_INSTRUCTIONS, SUFFIX = VISUAL_CHATGPT_PREFIX_CN, VISUAL_CHATGPT_FORMAT_INSTRUCTIONS_CN, VISUAL_CHATGPT_SUFFIX_CN
+            place = "输入文字并回车，或者上传图片"
+            label_clear = "清除"
+        self.llm = OpenAI(temperature=0, openai_api_key=openai_api_key)
+        self.agent = initialize_agent(
+            self.tools,
+            self.llm,
+            agent="conversational-react-description",
+            verbose=True,
+            memory=self.memory,
+            return_intermediate_steps=True,
+            agent_kwargs={'prefix': PREFIX, 'format_instructions': FORMAT_INSTRUCTIONS, 'suffix': SUFFIX}, )
+        return gr.update(visible = True), gr.update(visible = True)
+
+
+whisper_model = whisper.load_model("base").to('cuda:0')
+def speech_recognition(speech_file):
+    # whisper
+    # load audio and pad/trim it to fit 30 seconds
+    audio = whisper.load_audio(speech_file)
+    audio = whisper.pad_or_trim(audio)
+
+    # make log-Mel spectrogram and move to the same device as the model
+    mel = whisper.log_mel_spectrogram(audio).to(whisper_model.device)
+
+    # detect the spoken language
+    _, probs = whisper_model.detect_language(mel)
+    speech_language = max(probs, key=probs.get)
+    print(f'\nDetect Language: {speech_language}')
+
+    # decode the audio
+    options = whisper.DecodingOptions(fp16 = False)
+    result = whisper.decode(whisper_model, mel, options)
+    print(result.text)
+
+    return result.text
+
+
+if __name__ == '__main__':
+    load_dict = {'Grounded_dino_sam_inpainting': 'cuda:0'}
+    # load_dict = {'ImageCaptioning': 'cuda:0'}
+    
+    bot = ConversationBot(load_dict)
+
+    with gr.Blocks(css="#chatbot {overflow:auto; height:500px;}") as demo:
+        gr.Markdown("<h3><center>ChatBot</center></h3>")
+        gr.Markdown(
+            """This is a demo to the work [Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything).<br>
+            """
+        )
+
+        with gr.Row():
+            lang = gr.Radio(choices=['Chinese', 'English'], value='English', label='Language')
+            openai_api_key_textbox = gr.Textbox(
+                placeholder="Paste your OpenAI API key here to start ChatBot(sk-...) and press Enter ↵️",
+                show_label=False,
+                lines=1,
+                type="password",
+            )
+
+        chatbot = gr.Chatbot(elem_id="chatbot", label="ChatBot")
+        state = gr.State([])
+
+        with gr.Row(visible=False) as input_raws:
+            with gr.Column(scale=0.7):
+                txt = gr.Textbox(show_label=False, placeholder="Enter text and press enter, or upload an image").style(container=False)
+            with gr.Column(scale=0.10, min_width=0):
+                run = gr.Button("🏃‍♂️Run")
+            with gr.Column(scale=0.10, min_width=0):
+                clear = gr.Button("🔄Clear️")
+            with gr.Column(scale=0.10, min_width=0):
+                btn = gr.UploadButton("🖼️Upload", file_types=["image"])
+        with gr.Row(visible=False, equal_height=True) as audio_raw:
+            with gr.Column(scale=0.85):
+                audio = gr.Audio(source="microphone", type="filepath", label="Just say it!")
+            with gr.Column(scale=0.15):
+                transcribe = gr.Button("Transcribe")
+
+        gr.Examples(
+            examples=[
+                    "Describe this image",
+                    "Detect the dog",
+                    "Detect the dog and the cat",
+                    "Segment anything",
+                    "Segment the dog",
+                    "Help me label the image",
+                    "Replace the dog with a cat",
+                    ],
+            inputs=txt
+        )
+
+        openai_api_key_textbox.submit(bot.init_agent, [openai_api_key_textbox, lang], [input_raws, audio_raw])
+        transcribe.click(speech_recognition, inputs=[audio], outputs=[txt])
+        txt.submit(bot.run_text, [txt, state], [chatbot, state])
+        txt.submit(lambda: "", None, txt)
+        run.click(bot.run_text, [txt, state], [chatbot, state])
+        run.click(lambda: "", None, txt)
+        btn.upload(bot.run_image, [btn, state, txt, lang], [chatbot, state, txt])
+        clear.click(bot.memory.clear)
+        clear.click(lambda: [], None, chatbot)
+        clear.click(lambda: [], None, state)
+
+    demo.launch(server_name="0.0.0.0", server_port=10010)
+

external/Grounded-Segment-Anything/cog.yaml

@@ -0,0 +1,27 @@
+# Configuration for Cog ⚙️
+# Reference: https://github.com/replicate/cog/blob/main/docs/yaml.md
+
+build:
+  gpu: true
+  cuda: "11.7"
+  system_packages:
+    - "libgl1-mesa-glx"
+    - "libglib2.0-0"
+  python_version: "3.10"
+  python_packages:
+    - "timm==0.9.2"
+    - "transformers==4.30.2"
+    - "fairscale==0.4.13"
+    - "pycocoevalcap==1.2"
+    - "torch==1.13.0"
+    - "torchvision==0.14.0"
+    - "Pillow==9.5.0"
+    - "scipy==1.10.1"
+    - "opencv-python==4.7.0.72"
+    - "addict==2.4.0"
+    - "yapf==0.40.0"
+    - "supervision==0.10.0"
+    - git+https://github.com/openai/CLIP.git
+    - ipython
+
+predict: "predict.py:Predictor"

external/Grounded-Segment-Anything/gradio_app.py

@@ -0,0 +1,400 @@
+import os
+import random
+import cv2
+from scipy import ndimage
+
+import gradio as gr
+import argparse
+import litellm
+
+import numpy as np
+import torch
+import torchvision
+from PIL import Image, ImageDraw, ImageFont
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam, SamPredictor, SamAutomaticMaskGenerator
+import numpy as np
+
+# diffusers
+import torch
+from diffusers import StableDiffusionInpaintPipeline
+
+# BLIP
+from transformers import BlipProcessor, BlipForConditionalGeneration
+
+import openai
+
+def show_anns(anns):
+    if len(anns) == 0:
+        return
+    sorted_anns = sorted(anns, key=(lambda x: x['area']), reverse=True)
+    full_img = None
+
+    # for ann in sorted_anns:
+    for i in range(len(sorted_anns)):
+        ann = anns[i]
+        m = ann['segmentation']
+        if full_img is None:
+            full_img = np.zeros((m.shape[0], m.shape[1], 3))
+            map = np.zeros((m.shape[0], m.shape[1]), dtype=np.uint16)
+        map[m != 0] = i + 1
+        color_mask = np.random.random((1, 3)).tolist()[0]
+        full_img[m != 0] = color_mask
+    full_img = full_img*255
+    # anno encoding from https://github.com/LUSSeg/ImageNet-S
+    res = np.zeros((map.shape[0], map.shape[1], 3))
+    res[:, :, 0] = map % 256
+    res[:, :, 1] = map // 256
+    res.astype(np.float32)
+    full_img = Image.fromarray(np.uint8(full_img))
+    return full_img, res
+
+def generate_caption(processor, blip_model, raw_image):
+    # unconditional image captioning
+    inputs = processor(raw_image, return_tensors="pt").to("cuda", torch.float16)
+    out = blip_model.generate(**inputs)
+    caption = processor.decode(out[0], skip_special_tokens=True)
+    return caption
+
+def generate_tags(caption, split=',', max_tokens=100, model="gpt-3.5-turbo", openai_api_key=''):
+    openai.api_key = openai_api_key
+    openai.api_base = 'https://closeai.deno.dev/v1'
+    prompt = [
+        {
+            'role': 'system',
+            'content': 'Extract the unique nouns in the caption. Remove all the adjectives. ' + \
+                       f'List the nouns in singular form. Split them by "{split} ". ' + \
+                       f'Caption: {caption}.'
+        }
+    ]
+    response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+    reply = response['choices'][0]['message']['content']
+    # sometimes return with "noun: xxx, xxx, xxx"
+    tags = reply.split(':')[-1].strip()
+    return tags
+
+def transform_image(image_pil):
+
+    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
+
+
+def load_model(model_config_path, model_checkpoint_path, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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, with_logits=True):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # get phrase
+    tokenlizer = model.tokenizer
+    tokenized = tokenlizer(caption)
+    # build pred
+    pred_phrases = []
+    scores = []
+    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)
+        scores.append(logit.max().item())
+
+    return boxes_filt, torch.Tensor(scores), pred_phrases
+
+def draw_mask(mask, draw, random_color=False):
+    if random_color:
+        color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255), 153)
+    else:
+        color = (30, 144, 255, 153)
+
+    nonzero_coords = np.transpose(np.nonzero(mask))
+
+    for coord in nonzero_coords:
+        draw.point(coord[::-1], fill=color)
+
+def draw_box(box, draw, label):
+    # random color
+    color = tuple(np.random.randint(0, 255, size=3).tolist())
+
+    draw.rectangle(((box[0], box[1]), (box[2], box[3])), outline=color,  width=2)
+
+    if label:
+        font = ImageFont.load_default()
+        if hasattr(font, "getbbox"):
+            bbox = draw.textbbox((box[0], box[1]), str(label), font)
+        else:
+            w, h = draw.textsize(str(label), font)
+            bbox = (box[0], box[1], w + box[0], box[1] + h)
+        draw.rectangle(bbox, fill=color)
+        draw.text((box[0], box[1]), str(label), fill="white")
+
+        draw.text((box[0], box[1]), label)
+
+
+
+config_file = 'GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py'
+ckpt_repo_id = "ShilongLiu/GroundingDINO"
+ckpt_filenmae = "groundingdino_swint_ogc.pth"
+sam_checkpoint='sam_vit_h_4b8939.pth' 
+output_dir="outputs"
+device="cuda"
+
+
+blip_processor = None
+blip_model = None
+groundingdino_model = None
+sam_predictor = None
+sam_automask_generator = None
+inpaint_pipeline = None
+
+def run_grounded_sam(input_image, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, iou_threshold, inpaint_mode, scribble_mode, openai_api_key):
+
+    global blip_processor, blip_model, groundingdino_model, sam_predictor, sam_automask_generator, inpaint_pipeline
+
+    # make dir
+    os.makedirs(output_dir, exist_ok=True)
+    # load image
+    image = input_image["image"]
+    scribble = input_image["mask"]
+    size = image.size # w, h
+
+    if sam_predictor is None:
+        # initialize SAM
+        assert sam_checkpoint, 'sam_checkpoint is not found!'
+        sam = build_sam(checkpoint=sam_checkpoint)
+        sam.to(device=device)
+        sam_predictor = SamPredictor(sam)
+        sam_automask_generator = SamAutomaticMaskGenerator(sam)
+
+    if groundingdino_model is None:
+        groundingdino_model = load_model(config_file, ckpt_filenmae, device=device)
+
+    image_pil = image.convert("RGB")
+    image = np.array(image_pil)
+
+    if task_type == 'scribble':
+        sam_predictor.set_image(image)
+        scribble = scribble.convert("RGB")
+        scribble = np.array(scribble)
+        scribble = scribble.transpose(2, 1, 0)[0]
+
+        # 将连通域进行标记
+        labeled_array, num_features = ndimage.label(scribble >= 255)
+
+        # 计算每个连通域的质心
+        centers = ndimage.center_of_mass(scribble, labeled_array, range(1, num_features+1))
+        centers = np.array(centers)
+
+        point_coords = torch.from_numpy(centers)
+        point_coords = sam_predictor.transform.apply_coords_torch(point_coords, image.shape[:2])
+        point_coords = point_coords.unsqueeze(0).to(device)
+        point_labels = torch.from_numpy(np.array([1] * len(centers))).unsqueeze(0).to(device)
+        if scribble_mode == 'split':
+            point_coords = point_coords.permute(1, 0, 2)
+            point_labels = point_labels.permute(1, 0)
+        masks, _, _ = sam_predictor.predict_torch(
+            point_coords=point_coords if len(point_coords) > 0 else None,
+            point_labels=point_labels if len(point_coords) > 0 else None,
+            mask_input = None,
+            boxes = None,
+            multimask_output = False,
+        )
+    elif task_type == 'automask':
+        masks = sam_automask_generator.generate(image)
+    else:
+        transformed_image = transform_image(image_pil)
+
+        if task_type == 'automatic':
+            # generate caption and tags
+            # use Tag2Text can generate better captions
+            # https://huggingface.co/spaces/xinyu1205/Tag2Text
+            # but there are some bugs...
+            blip_processor = blip_processor or BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-large")
+            blip_model = blip_model or BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-large", torch_dtype=torch.float16).to("cuda")
+            text_prompt = generate_caption(blip_processor, blip_model, image_pil)
+            if len(openai_api_key) > 0:
+                text_prompt = generate_tags(text_prompt, split=",", openai_api_key=openai_api_key)
+            print(f"Caption: {text_prompt}")
+
+        # run grounding dino model
+        boxes_filt, scores, pred_phrases = get_grounding_output(
+            groundingdino_model, transformed_image, text_prompt, box_threshold, text_threshold
+        )
+
+        # process boxes
+        H, W = size[1], size[0]
+        for i in range(boxes_filt.size(0)):
+            boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+            boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+            boxes_filt[i][2:] += boxes_filt[i][:2]
+
+        boxes_filt = boxes_filt.cpu()
+
+
+        if task_type == 'seg' or task_type == 'inpainting' or task_type == 'automatic':
+            sam_predictor.set_image(image)
+
+            if task_type == 'automatic':
+                # use NMS to handle overlapped boxes
+                print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+                nms_idx = torchvision.ops.nms(boxes_filt, scores, iou_threshold).numpy().tolist()
+                boxes_filt = boxes_filt[nms_idx]
+                pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+                print(f"After NMS: {boxes_filt.shape[0]} boxes")
+                print(f"Revise caption with number: {text_prompt}")
+
+            transformed_boxes = sam_predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+            masks, _, _ = sam_predictor.predict_torch(
+                point_coords = None,
+                point_labels = None,
+                boxes = transformed_boxes,
+                multimask_output = False,
+            )
+
+    if task_type == 'det':
+        image_draw = ImageDraw.Draw(image_pil)
+        for box, label in zip(boxes_filt, pred_phrases):
+            draw_box(box, image_draw, label)
+
+        return [image_pil]
+    elif task_type == 'automask':
+        full_img, res = show_anns(masks)
+        return [full_img]
+    elif task_type == 'scribble':
+        mask_image = Image.new('RGBA', size, color=(0, 0, 0, 0))
+
+        mask_draw = ImageDraw.Draw(mask_image)
+
+        for mask in masks:
+            draw_mask(mask[0].cpu().numpy(), mask_draw, random_color=True)
+
+        image_pil = image_pil.convert('RGBA')
+        image_pil.alpha_composite(mask_image)
+        return [image_pil, mask_image]
+    elif task_type == 'seg' or task_type == 'automatic':
+        
+        mask_image = Image.new('RGBA', size, color=(0, 0, 0, 0))
+
+        mask_draw = ImageDraw.Draw(mask_image)
+        for mask in masks:
+            draw_mask(mask[0].cpu().numpy(), mask_draw, random_color=True)
+
+        image_draw = ImageDraw.Draw(image_pil)
+
+        for box, label in zip(boxes_filt, pred_phrases):
+            draw_box(box, image_draw, label)
+
+        if task_type == 'automatic':
+            image_draw.text((10, 10), text_prompt, fill='black')
+
+        image_pil = image_pil.convert('RGBA')
+        image_pil.alpha_composite(mask_image)
+        return [image_pil, mask_image]
+    elif task_type == 'inpainting':
+        assert inpaint_prompt, 'inpaint_prompt is not found!'
+        # inpainting pipeline
+        if inpaint_mode == 'merge':
+            masks = torch.sum(masks, dim=0).unsqueeze(0)
+            masks = torch.where(masks > 0, True, False)
+        mask = masks[0][0].cpu().numpy() # simply choose the first mask, which will be refine in the future release
+        mask_pil = Image.fromarray(mask)
+        
+        if inpaint_pipeline is None:
+            inpaint_pipeline = StableDiffusionInpaintPipeline.from_pretrained(
+            "runwayml/stable-diffusion-inpainting", torch_dtype=torch.float16
+            )
+            inpaint_pipeline = inpaint_pipeline.to("cuda")
+
+        image = inpaint_pipeline(prompt=inpaint_prompt, image=image_pil.resize((512, 512)), mask_image=mask_pil.resize((512, 512))).images[0]
+        image = image.resize(size)
+
+        return [image, mask_pil]
+    else:
+        print("task_type:{} error!".format(task_type))
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Grounded SAM demo", add_help=True)
+    parser.add_argument("--debug", action="store_true", help="using debug mode")
+    parser.add_argument("--share", action="store_true", help="share the app")
+    parser.add_argument('--port', type=int, default=7589, help='port to run the server')
+    parser.add_argument('--no-gradio-queue', action="store_true", help='path to the SAM checkpoint')
+    args = parser.parse_args()
+
+    print(args)
+
+    block = gr.Blocks()
+    if not args.no_gradio_queue:
+        block = block.queue()
+
+    with block:
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(source='upload', type="pil", value="assets/demo1.jpg", tool="sketch")
+                task_type = gr.Dropdown(["scribble", "automask", "det", "seg", "inpainting", "automatic"], value="automatic", label="task_type")
+                text_prompt = gr.Textbox(label="Text Prompt")
+                inpaint_prompt = gr.Textbox(label="Inpaint Prompt")
+                run_button = gr.Button(label="Run")
+                with gr.Accordion("Advanced options", open=False):
+                    box_threshold = gr.Slider(
+                        label="Box Threshold", minimum=0.0, maximum=1.0, value=0.3, step=0.05
+                    )
+                    text_threshold = gr.Slider(
+                        label="Text Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.05
+                    )
+                    iou_threshold = gr.Slider(
+                        label="IOU Threshold", minimum=0.0, maximum=1.0, value=0.5, step=0.05
+                    )
+                    inpaint_mode = gr.Dropdown(["merge", "first"], value="merge", label="inpaint_mode")
+                    scribble_mode = gr.Dropdown(["merge", "split"], value="split", label="scribble_mode")
+                    openai_api_key= gr.Textbox(label="(Optional)OpenAI key, enable chatgpt")
+
+            with gr.Column():
+                gallery = gr.Gallery(
+                    label="Generated images", show_label=False, elem_id="gallery"
+                ).style(preview=True, grid=2, object_fit="scale-down")
+
+        run_button.click(fn=run_grounded_sam, inputs=[
+                        input_image, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, iou_threshold, inpaint_mode, scribble_mode, openai_api_key], outputs=gallery)
+
+    block.queue(concurrency_count=100)
+    block.launch(server_name='0.0.0.0', server_port=args.port, debug=args.debug, share=args.share)

external/Grounded-Segment-Anything/grounded_sam_inpainting_demo.py

@@ -0,0 +1,216 @@
+import argparse
+import os
+import copy
+
+import numpy as np
+import torch
+from PIL import Image, ImageDraw, ImageFont
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util import box_ops
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam, SamPredictor 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+# diffusers
+import PIL
+import requests
+import torch
+from io import BytesIO
+from diffusers import StableDiffusionInpaintPipeline
+
+
+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, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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, with_logits=True, device="cpu"):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+    model = model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # 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)
+
+    return boxes_filt, pred_phrases
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+    ax.text(x0, y0, label)
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument(
+        "--grounded_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument("--input_image", type=str, required=True, help="path to image file")
+    parser.add_argument("--det_prompt", type=str, required=True, help="text prompt")
+    parser.add_argument("--inpaint_prompt", type=str, required=True, help="inpaint prompt")
+    parser.add_argument(
+        "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory"
+    )
+    parser.add_argument("--cache_dir", type=str, default=None, help="save your huggingface large model cache")
+    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("--inpaint_mode", type=str, default="first", help="inpaint mode")
+    parser.add_argument("--device", type=str, default="cpu", help="running on cpu only!, default=False")
+    args = parser.parse_args()
+
+    # cfg
+    config_file = args.config  # change the path of the model config file
+    grounded_checkpoint = args.grounded_checkpoint  # change the path of the model
+    sam_checkpoint = args.sam_checkpoint
+    image_path = args.input_image
+    det_prompt = args.det_prompt
+    inpaint_prompt = args.inpaint_prompt
+    output_dir = args.output_dir
+    cache_dir=args.cache_dir
+    box_threshold = args.box_threshold
+    text_threshold = args.text_threshold
+    inpaint_mode = args.inpaint_mode
+    device = args.device
+
+    # 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, grounded_checkpoint, device=device)
+
+    # visualize raw image
+    image_pil.save(os.path.join(output_dir, "raw_image.jpg"))
+
+    # run grounding dino model
+    boxes_filt, pred_phrases = get_grounding_output(
+        model, image, det_prompt, box_threshold, text_threshold, device=device
+    )
+
+    # initialize SAM
+    predictor = SamPredictor(build_sam(checkpoint=sam_checkpoint).to(device))
+    image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    boxes_filt = boxes_filt.cpu()
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+    masks, _, _ = predictor.predict_torch(
+        point_coords = None,
+        point_labels = None,
+        boxes = transformed_boxes.to(device),
+        multimask_output = False,
+    )
+
+    # masks: [1, 1, 512, 512]
+
+    # draw output image
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    for mask in masks:
+        show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    for box, label in zip(boxes_filt, pred_phrases):
+        show_box(box.numpy(), plt.gca(), label)
+    plt.axis('off')
+    plt.savefig(os.path.join(output_dir, "grounded_sam_output.jpg"), bbox_inches="tight")
+
+    # inpainting pipeline
+    if inpaint_mode == 'merge':
+        masks = torch.sum(masks, dim=0).unsqueeze(0)
+        masks = torch.where(masks > 0, True, False)
+    mask = masks[0][0].cpu().numpy() # simply choose the first mask, which will be refine in the future release
+    mask_pil = Image.fromarray(mask)
+    image_pil = Image.fromarray(image)
+    
+    pipe = StableDiffusionInpaintPipeline.from_pretrained(
+    "runwayml/stable-diffusion-inpainting", torch_dtype=torch.float16,cache_dir=cache_dir
+    )
+    pipe = pipe.to("cuda")
+
+    image_pil = image_pil.resize((512, 512))
+    mask_pil = mask_pil.resize((512, 512))
+    # prompt = "A sofa, high quality, detailed"
+    image = pipe(prompt=inpaint_prompt, image=image_pil, mask_image=mask_pil).images[0]
+    image = image.resize(size)
+    image.save(os.path.join(output_dir, "grounded_sam_inpainting_output.jpg"))
+
+

external/Grounded-Segment-Anything/grounded_sam_multi_gpu_demo.py

@@ -0,0 +1,265 @@
+import argparse
+import os
+import sys
+import time
+import torch
+import numpy as np
+import json
+from PIL import Image
+from concurrent.futures import ThreadPoolExecutor
+
+sys.path.append(os.path.join(os.getcwd(), "GroundingDINO"))
+sys.path.append(os.path.join(os.getcwd(), "segment_anything"))
+
+# Grounding DINO imports
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# Segment Anything imports
+from segment_anything import sam_model_registry, sam_hq_model_registry, SamPredictor
+import cv2
+import matplotlib.pyplot as plt
+
+
+def load_image(image_path):
+    image_pil = Image.open(image_path).convert("RGB")
+    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)
+    return image_pil, image
+
+
+def load_model(model_config_path, model_checkpoint_path, device):
+    print("Loading model from...........", device)
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    model = build_model(args)
+    
+    # Load the model checkpoint onto the specific GPU
+    checkpoint = torch.load(model_checkpoint_path, map_location=device)
+    model.load_state_dict(clean_state_dict(checkpoint["model"]), strict=False)
+    model.eval()
+    model.to(device)
+    
+    return model
+
+
+def get_grounding_output(model, image, caption, box_threshold, text_threshold, device="cpu"):
+    caption = caption.lower().strip()
+    if not caption.endswith("."):
+        caption += "."
+    model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].sigmoid()[0]  # Keep it on the device
+    boxes = outputs["pred_boxes"][0]  # Keep it on the device
+
+    filt_mask = logits.max(dim=1)[0] > box_threshold
+    logits_filt = logits[filt_mask]
+    boxes_filt = boxes[filt_mask]
+
+    tokenlizer = model.tokenizer
+    tokenized = tokenlizer(caption)
+    pred_phrases = []
+    for logit, box in zip(logits_filt, boxes_filt):
+        pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer)
+        pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
+
+    return boxes_filt, pred_phrases
+
+
+def process_image(image_path, model, predictor, output_dir, text_prompt, box_threshold, text_threshold, device):
+    
+    # Load the image and move to GPU
+    image_pil, image = load_image(image_path)
+    # image_pil.save(os.path.join(output_dir, f"raw_image_{os.path.basename(image_path)}.jpg"))
+    # Run GroundingDINO model to get bounding boxes and labels
+    boxes_filt, pred_phrases = get_grounding_output(
+        model, image, text_prompt, box_threshold, text_threshold, device=device
+    )
+
+    # Load SAM model onto GPU    
+    image_cv = cv2.imread(image_path)
+    image_cv = cv2.cvtColor(image_cv, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image_cv)
+
+    # Convert boxes to original image size
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.tensor([W, H, W, H], device=device)
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    # Transform boxes to be compatible with SAM
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image_cv.shape[:2]).to(device)
+
+    # Get masks using SAM
+    masks, _, _ = predictor.predict_torch(
+        point_coords=None,
+        point_labels=None,
+        boxes=transformed_boxes.to(device),
+        multimask_output=False,
+    )
+
+    # Visualization and saving
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image_cv)
+    # for mask in masks:
+    #     show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    for box, label in zip(boxes_filt, pred_phrases):
+        show_box(box.cpu().numpy(), plt.gca(), label)
+    image_base_name = os.path.basename(image_path).split('.')[0]
+    plt.axis('off')
+    plt.savefig(
+        os.path.join(output_dir, f"grounded_sam_output_{image_base_name}.jpg"),
+        bbox_inches="tight", dpi=300, pad_inches=0.0
+    )
+    plt.close()
+
+    save_mask_data(output_dir, masks, boxes_filt, pred_phrases, image_base_name)
+    # Clear GPU memory
+    del image, transformed_boxes, masks  # model, sam
+    # torch.cuda.empty_cache()
+
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    # print("mask.shape:", mask.shape)
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0, 0, 0, 0), lw=2))
+    ax.text(x0, y0, label)
+
+
+def save_mask_data(output_dir, mask_list, box_list, label_list, image_base_name=''):
+    value = 0  # 0 for background
+
+    mask_img = torch.zeros(mask_list.shape[-2:], device=mask_list.device)
+    for idx, mask in enumerate(mask_list):
+        mask_img[mask[0] == True] = value + idx + 1
+    plt.figure(figsize=(10, 10))
+    plt.imshow(mask_img.cpu().numpy())
+    plt.axis('off')
+    plt.savefig(os.path.join(output_dir, f'{image_base_name}.jpg'), bbox_inches="tight", dpi=300, pad_inches=0.0)
+    plt.close()
+    json_data = [{
+        'value': value,
+        'label': 'background'
+    }]
+    for label, box in zip(label_list, box_list):
+        value += 1
+        name, logit = label.split('(')
+        logit = logit[:-1]  # the last is ')'
+        json_data.append({
+            'value': value,
+            'label': name,
+            'logit': float(logit),
+            'box': box.cpu().numpy().tolist(),
+        })
+    with open(os.path.join(output_dir, f'{image_base_name}.json'), 'w') as f:
+        json.dump(json_data, f)
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument("--grounded_checkpoint", type=str, required=True, help="path to checkpoint file")
+    parser.add_argument("--sam_version", type=str, default="vit_h", required=False, help="SAM ViT version: vit_b / vit_l / vit_h")
+    parser.add_argument("--sam_checkpoint", type=str, required=False, help="path to sam checkpoint file")
+    parser.add_argument("--sam_hq_checkpoint", type=str, default=None, help="path to sam-hq checkpoint file")
+    parser.add_argument("--use_sam_hq", action="store_true", help="using sam-hq for prediction")
+    parser.add_argument("--input_path", type=str, required=True, help="path to directory containing image files")
+    parser.add_argument("--text_prompt", 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("--device", type=str, default="cuda", help="device to run the inference on, e.g., 'cuda' or 'cuda:0'")
+    args = parser.parse_args()
+
+    torch.backends.cudnn.enabled = False
+    torch.backends.cudnn.benchmark = True
+
+    start_time = time.time()
+    # Determine if we are using a single GPU or all available GPUs
+    if args.device == "cuda":
+        if torch.cuda.device_count() > 1:
+            device_list = [torch.device(f"cuda:{i}") for i in range(torch.cuda.device_count())]  # Use all GPUs
+        else:
+            device_list = [torch.device("cuda:0")]  # Default to first GPU
+    else:
+        device_list = [torch.device(args.device)]
+    print("device_list:", device_list)
+
+    # Get list of images
+    image_paths = [os.path.join(args.input_path, img) for img in os.listdir(args.input_path) if img.endswith(('.png', '.jpg', '.jpeg'))]
+
+    # Split images among available GPUs
+    image_batches = np.array_split(image_paths, len(device_list))
+    print("Processing images:", image_batches)
+    # Function to process a batch of images on the specified device
+    def process_batch(batch_images, model_config, model_checkpoint, sam_version, sam_checkpoint, sam_hq_checkpoint, use_sam_hq, device, output_dir):
+        # Load model onto GPU
+        torch.cuda.set_device(device)
+        model = load_model(model_config, model_checkpoint, device)
+        
+        # Load SAM model onto GPU
+        if use_sam_hq:
+            sam = sam_hq_model_registry[sam_version](checkpoint=sam_hq_checkpoint).to(device)
+        else:
+            sam = sam_model_registry[sam_version](checkpoint=sam_checkpoint).to(device)
+        # Move model to the correct device
+        device = torch.device(device)
+        model.to(device)
+        sam.to(device)
+        predictor = SamPredictor(sam)
+        for image_path in batch_images:
+            # Process each image
+            print("Processing image:", image_path)
+            process_image(
+                image_path=image_path,
+                model=model,
+                predictor=predictor,
+                output_dir=output_dir,
+                text_prompt=args.text_prompt,
+                box_threshold=args.box_threshold,
+                text_threshold=args.text_threshold,
+                device=device
+            )
+            print("Image processing complete {}".format(image_path))
+        # Clear GPU memory after processing the batch
+        # del model, sam
+        torch.cuda.empty_cache()
+
+    # Use ThreadPoolExecutor to parallelize the processing across GPUs
+    with ThreadPoolExecutor(max_workers=len(device_list)*2) as executor:
+        futures = []
+        for i, device in enumerate(device_list):
+            print(f"Processing images on device {device}")
+            print("Image batches for each GPU:", len(image_batches[i]))
+            futures.append(executor.submit(
+                process_batch, image_batches[i], args.config, args.grounded_checkpoint, args.sam_version, args.sam_checkpoint, args.sam_hq_checkpoint, args.use_sam_hq, device, args.output_dir
+            ))
+
+        # Wait for all threads to complete
+        for future in futures:
+            future.result()
+
+    print("Processing complete. Results saved to the output directory.")
+    print(f"Total time taken: {time.time() - start_time:.2f} seconds")

external/Grounded-Segment-Anything/grounded_sam_simple_demo.py

@@ -0,0 +1,107 @@
+import cv2
+import numpy as np
+import supervision as sv
+
+import torch
+import torchvision
+
+from groundingdino.util.inference import Model
+from segment_anything import sam_model_registry, SamPredictor
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# GroundingDINO config and checkpoint
+GROUNDING_DINO_CONFIG_PATH = "GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py"
+GROUNDING_DINO_CHECKPOINT_PATH = "./groundingdino_swint_ogc.pth"
+
+# Segment-Anything checkpoint
+SAM_ENCODER_VERSION = "vit_h"
+SAM_CHECKPOINT_PATH = "./sam_vit_h_4b8939.pth"
+
+# Building GroundingDINO inference model
+grounding_dino_model = Model(model_config_path=GROUNDING_DINO_CONFIG_PATH, model_checkpoint_path=GROUNDING_DINO_CHECKPOINT_PATH)
+
+# Building SAM Model and SAM Predictor
+sam = sam_model_registry[SAM_ENCODER_VERSION](checkpoint=SAM_CHECKPOINT_PATH)
+sam.to(device=DEVICE)
+sam_predictor = SamPredictor(sam)
+
+
+# Predict classes and hyper-param for GroundingDINO
+SOURCE_IMAGE_PATH = "./assets/demo2.jpg"
+CLASSES = ["The running dog"]
+BOX_THRESHOLD = 0.25
+TEXT_THRESHOLD = 0.25
+NMS_THRESHOLD = 0.8
+
+
+# load image
+image = cv2.imread(SOURCE_IMAGE_PATH)
+
+# detect objects
+detections = grounding_dino_model.predict_with_classes(
+    image=image,
+    classes=CLASSES,
+    box_threshold=BOX_THRESHOLD,
+    text_threshold=TEXT_THRESHOLD
+)
+
+# annotate image with detections
+box_annotator = sv.BoxAnnotator()
+labels = [
+    f"{CLASSES[class_id]} {confidence:0.2f}" 
+    for _, _, confidence, class_id, _, _ 
+    in detections]
+annotated_frame = box_annotator.annotate(scene=image.copy(), detections=detections, labels=labels)
+
+# save the annotated grounding dino image
+cv2.imwrite("groundingdino_annotated_image.jpg", annotated_frame)
+
+
+# NMS post process
+print(f"Before NMS: {len(detections.xyxy)} boxes")
+nms_idx = torchvision.ops.nms(
+    torch.from_numpy(detections.xyxy), 
+    torch.from_numpy(detections.confidence), 
+    NMS_THRESHOLD
+).numpy().tolist()
+
+detections.xyxy = detections.xyxy[nms_idx]
+detections.confidence = detections.confidence[nms_idx]
+detections.class_id = detections.class_id[nms_idx]
+
+print(f"After NMS: {len(detections.xyxy)} boxes")
+
+# Prompting SAM with detected boxes
+def segment(sam_predictor: SamPredictor, image: np.ndarray, xyxy: np.ndarray) -> np.ndarray:
+    sam_predictor.set_image(image)
+    result_masks = []
+    for box in xyxy:
+        masks, scores, logits = sam_predictor.predict(
+            box=box,
+            multimask_output=True
+        )
+        index = np.argmax(scores)
+        result_masks.append(masks[index])
+    return np.array(result_masks)
+
+
+# convert detections to masks
+detections.mask = segment(
+    sam_predictor=sam_predictor,
+    image=cv2.cvtColor(image, cv2.COLOR_BGR2RGB),
+    xyxy=detections.xyxy
+)
+
+# annotate image with detections
+box_annotator = sv.BoxAnnotator()
+mask_annotator = sv.MaskAnnotator()
+labels = [
+    f"{CLASSES[class_id]} {confidence:0.2f}" 
+    for _, _, confidence, class_id, _, _ 
+    in detections]
+annotated_image = mask_annotator.annotate(scene=image.copy(), detections=detections)
+annotated_image = box_annotator.annotate(scene=annotated_image, detections=detections, labels=labels)
+
+# save the annotated grounded-sam image
+cv2.imwrite("grounded_sam_annotated_image.jpg", annotated_image)

external/Grounded-Segment-Anything/grounded_sam_visam.py

@@ -0,0 +1,265 @@
+
+from copy import deepcopy
+import json
+
+import os
+import argparse
+import torchvision.transforms.functional as F
+import torch
+import cv2
+import numpy as np
+from tqdm import tqdm
+from pathlib import Path
+import sys
+sys.path.append('VISAM')
+from main import get_args_parser
+from models import build_model
+from util.tool import load_model
+from models.structures import Instances
+
+from torch.utils.data import Dataset, DataLoader
+
+
+# segment anything
+sys.path.append('segment_anything')
+from segment_anything import build_sam, SamPredictor 
+
+
+class Colors:
+    # Ultralytics color palette https://ultralytics.com/
+    def __init__(self):
+        # hex = matplotlib.colors.TABLEAU_COLORS.values()
+        hexs = ('FF3838', 'FF9D97', 'FF701F', 'FFB21D', 'CFD231', '48F90A', '92CC17', '3DDB86', '1A9334', '00D4BB',
+                '2C99A8', '00C2FF', '344593', '6473FF', '0018EC', '8438FF', '520085', 'CB38FF', 'FF95C8', 'FF37C7')
+        self.palette = [self.hex2rgb(f'#{c}') for c in hexs]
+        self.n = len(self.palette)
+
+    def __call__(self, i, bgr=False):
+        c = self.palette[int(i) % self.n]
+        return (c[2], c[1], c[0]) if bgr else c
+
+    @staticmethod
+    def hex2rgb(h):  # rgb order (PIL)
+        return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
+
+
+colors = Colors()  # create instance for 'from utils.plots import colors'
+
+
+class ListImgDataset(Dataset):
+    def __init__(self, mot_path, img_list, det_db) -> None:
+        super().__init__()
+        self.mot_path = mot_path
+        self.img_list = img_list
+        self.det_db = det_db
+
+        '''
+        common settings
+        '''
+        self.img_height = 800
+        self.img_width = 1536
+        self.mean = [0.485, 0.456, 0.406]
+        self.std = [0.229, 0.224, 0.225]
+
+    def load_img_from_file(self, f_path):
+        cur_img = cv2.imread(os.path.join(self.mot_path, f_path))
+        assert cur_img is not None, f_path
+        cur_img = cv2.cvtColor(cur_img, cv2.COLOR_BGR2RGB)
+        proposals = []
+        im_h, im_w = cur_img.shape[:2]
+        for line in self.det_db[f_path[:-4] + '.txt']:
+            l, t, w, h, s = list(map(float, line.split(',')))
+            proposals.append([(l + w / 2) / im_w,
+                                (t + h / 2) / im_h,
+                                w / im_w,
+                                h / im_h,
+                                s])
+        return cur_img, torch.as_tensor(proposals).reshape(-1, 5)
+
+    def init_img(self, img, proposals):
+        ori_img = img.copy()
+        self.seq_h, self.seq_w = img.shape[:2]
+        scale = self.img_height / min(self.seq_h, self.seq_w)
+        if max(self.seq_h, self.seq_w) * scale > self.img_width:
+            scale = self.img_width / max(self.seq_h, self.seq_w)
+        target_h = int(self.seq_h * scale)
+        target_w = int(self.seq_w * scale)
+        img = cv2.resize(img, (target_w, target_h))
+        img = F.normalize(F.to_tensor(img), self.mean, self.std)
+        img = img.unsqueeze(0)
+        return img, ori_img, proposals
+
+    def __len__(self):
+        return len(self.img_list)
+    
+    def __getitem__(self, index):
+        img, proposals = self.load_img_from_file(self.img_list[index])
+        return self.init_img(img, proposals)
+
+
+class Detector(object):
+    def __init__(self, args, model, vid, sam_predictor=None):
+        self.args = args
+        self.detr = model
+
+        self.vid = vid
+        self.seq_num = os.path.basename(vid)
+        img_list = os.listdir(os.path.join(self.args.mot_path, vid, 'img1'))
+        img_list = [os.path.join(vid, 'img1', i) for i in img_list if 'jpg' in i]
+
+        self.img_list = sorted(img_list)
+        self.img_len = len(self.img_list)
+
+        self.predict_path = os.path.join(self.args.output_dir, args.exp_name)
+        os.makedirs(self.predict_path, exist_ok=True)
+        
+        fps = 25
+        size = (1920, 1080) 
+        self.videowriter = cv2.VideoWriter('visam.avi', cv2.VideoWriter_fourcc('M','J','P','G'), fps, size)
+        
+        self.sam_predictor = sam_predictor
+
+    @staticmethod
+    def filter_dt_by_score(dt_instances: Instances, prob_threshold: float) -> Instances:
+        keep = dt_instances.scores > prob_threshold
+        keep &= dt_instances.obj_idxes >= 0
+        return dt_instances[keep]
+
+    @staticmethod
+    def filter_dt_by_area(dt_instances: Instances, area_threshold: float) -> Instances:
+        wh = dt_instances.boxes[:, 2:4] - dt_instances.boxes[:, 0:2]
+        areas = wh[:, 0] * wh[:, 1]
+        keep = areas > area_threshold
+        return dt_instances[keep]
+
+    def detect(self, prob_threshold=0.6, area_threshold=100, vis=False):
+        total_dts = 0
+        total_occlusion_dts = 0
+
+        track_instances = None
+        with open(os.path.join(self.args.mot_path, 'DanceTrack', self.args.det_db)) as f:
+            det_db = json.load(f)
+        loader = DataLoader(ListImgDataset(self.args.mot_path, self.img_list, det_db), 1, num_workers=2)
+        lines = []
+        for i, data in enumerate(tqdm(loader)):
+            cur_img, ori_img, proposals = [d[0] for d in data]
+            cur_img, proposals = cur_img.cuda(), proposals.cuda()
+
+            # track_instances = None
+            if track_instances is not None:
+                track_instances.remove('boxes')
+                track_instances.remove('labels')
+            seq_h, seq_w, _ = ori_img.shape
+
+            res = self.detr.inference_single_image(cur_img, (seq_h, seq_w), track_instances, proposals)
+            track_instances = res['track_instances']
+
+            dt_instances = deepcopy(track_instances)
+
+            # filter det instances by score.
+            dt_instances = self.filter_dt_by_score(dt_instances, prob_threshold)
+            dt_instances = self.filter_dt_by_area(dt_instances, area_threshold)
+
+            total_dts += len(dt_instances)
+
+            bbox_xyxy = dt_instances.boxes.tolist()
+            identities = dt_instances.obj_idxes.tolist()
+
+            img = ori_img.to(torch.device('cpu')).numpy().copy()[..., ::-1]
+            if self.sam_predictor is not None:
+                masks_all = []
+                self.sam_predictor.set_image(ori_img.to(torch.device('cpu')).numpy().copy())
+                
+                for bbox, id in zip(np.array(bbox_xyxy), identities):
+                    masks, iou_predictions, low_res_masks = self.sam_predictor.predict(box=bbox)
+                    index_max = iou_predictions.argsort()[0]
+                    masks = np.concatenate([masks[index_max:(index_max+1)], masks[index_max:(index_max+1)], masks[index_max:(index_max+1)]], axis=0)
+                    masks = masks.astype(np.int32)*np.array(colors(id))[:, None, None]
+                    masks_all.append(masks)
+                
+                self.sam_predictor.reset_image()
+                if len(masks_all):
+                    masks_sum = masks_all[0].copy()
+                    for m in masks_all[1:]:
+                        masks_sum += m
+                else:
+                    masks_sum = np.zeros_like(img).transpose(2, 0, 1)
+
+                img = (img * 0.5 + (masks_sum.transpose(1,2,0) * 30) %128).astype(np.uint8)
+            for bbox in bbox_xyxy:
+                cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0,0,255), thickness=3)
+            self.videowriter.write(img)
+
+            save_format = '{frame},{id},{x1:.2f},{y1:.2f},{w:.2f},{h:.2f},1,-1,-1,-1\n'
+            for xyxy, track_id in zip(bbox_xyxy, identities):
+                if track_id < 0 or track_id is None:
+                    continue
+                x1, y1, x2, y2 = xyxy
+                w, h = x2 - x1, y2 - y1
+                lines.append(save_format.format(frame=i + 1, id=track_id, x1=x1, y1=y1, w=w, h=h))
+        with open(os.path.join(self.predict_path, f'{self.seq_num}.txt'), 'w') as f:
+            f.writelines(lines)
+        print("totally {} dts {} occlusion dts".format(total_dts, total_occlusion_dts))
+
+
+class RuntimeTrackerBase(object):
+    def __init__(self, score_thresh=0.6, filter_score_thresh=0.5, miss_tolerance=10):
+        self.score_thresh = score_thresh
+        self.filter_score_thresh = filter_score_thresh
+        self.miss_tolerance = miss_tolerance
+        self.max_obj_id = 0
+
+    def clear(self):
+        self.max_obj_id = 0
+
+    def update(self, track_instances: Instances):
+        device = track_instances.obj_idxes.device
+
+        track_instances.disappear_time[track_instances.scores >= self.score_thresh] = 0
+        new_obj = (track_instances.obj_idxes == -1) & (track_instances.scores >= self.score_thresh)
+        disappeared_obj = (track_instances.obj_idxes >= 0) & (track_instances.scores < self.filter_score_thresh)
+        num_new_objs = new_obj.sum().item()
+
+        track_instances.obj_idxes[new_obj] = self.max_obj_id + torch.arange(num_new_objs, device=device)
+        self.max_obj_id += num_new_objs
+
+        track_instances.disappear_time[disappeared_obj] += 1
+        to_del = disappeared_obj & (track_instances.disappear_time >= self.miss_tolerance)
+        track_instances.obj_idxes[to_del] = -1
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything VISAM Demo", parents=[get_args_parser()])
+    parser.add_argument('--score_threshold', default=0.5, type=float)
+    parser.add_argument('--update_score_threshold', default=0.5, type=float)
+    parser.add_argument('--miss_tolerance', default=20, type=int)
+    
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument("--video_path", type=str, required=True, help="path to image file")
+
+    args = parser.parse_args()
+
+    # make dir
+    if args.output_dir:
+        Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+    
+    sam_predictor = SamPredictor(build_sam(checkpoint=args.sam_checkpoint))
+    _ = sam_predictor.model.to(device='cuda')
+    
+    # load model and weights
+    detr, _, _ = build_model(args)
+    detr.track_embed.score_thr = args.update_score_threshold
+    detr.track_base = RuntimeTrackerBase(args.score_threshold, args.score_threshold, args.miss_tolerance)
+    checkpoint = torch.load(args.resume, map_location='cpu')
+    detr = load_model(detr, args.resume)
+    detr.eval()
+    detr = detr.cuda()
+    
+    rank = int(os.environ.get('RLAUNCH_REPLICA', '0'))
+    ws = int(os.environ.get('RLAUNCH_REPLICA_TOTAL', '1'))
+    
+    det = Detector(args, model=detr, vid=args.video_path, sam_predictor=sam_predictor)
+    det.detect(args.score_threshold)

external/Grounded-Segment-Anything/grounded_sam_whisper_demo.py

@@ -0,0 +1,260 @@
+import argparse
+import os
+import copy
+
+import numpy as np
+import json
+import torch
+import torchvision
+from PIL import Image, ImageDraw, ImageFont
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util import box_ops
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam, SamPredictor 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+# whisper
+import whisper
+
+
+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, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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,device="cpu"):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+    model = model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # get phrase
+    tokenlizer = model.tokenizer
+    tokenized = tokenlizer(caption)
+    # build pred
+    pred_phrases = []
+    scores = []
+    for logit, box in zip(logits_filt, boxes_filt):
+        pred_phrase = get_phrases_from_posmap(logit > text_threshold, tokenized, tokenlizer)
+        pred_phrases.append(pred_phrase + f"({str(logit.max().item())[:4]})")
+        scores.append(logit.max().item())
+
+    return boxes_filt, torch.Tensor(scores), pred_phrases
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+    ax.text(x0, y0, label)
+
+
+def save_mask_data(output_dir, mask_list, box_list, label_list):
+    value = 0  # 0 for background
+
+    mask_img = torch.zeros(mask_list.shape[-2:])
+    for idx, mask in enumerate(mask_list):
+        mask_img[mask.cpu().numpy()[0] == True] = value + idx + 1
+    plt.figure(figsize=(10, 10))
+    plt.imshow(mask_img.numpy())
+    plt.axis('off')
+    plt.savefig(os.path.join(output_dir, 'mask.jpg'), bbox_inches="tight", dpi=300, pad_inches=0.0)
+
+    json_data = [{
+        'value': value,
+        'label': 'background'
+    }]
+    for label, box in zip(label_list, box_list):
+        value += 1
+        name, logit = label.split('(')
+        logit = logit[:-1] # the last is ')'
+        json_data.append({
+            'value': value,
+            'label': name,
+            'logit': float(logit),
+            'box': box.numpy().tolist(),
+        })
+    with open(os.path.join(output_dir, 'mask.json'), 'w') as f:
+        json.dump(json_data, f)
+    
+
+def speech_recognition(speech_file, model):
+    # whisper
+    # load audio and pad/trim it to fit 30 seconds
+    audio = whisper.load_audio(speech_file)
+    audio = whisper.pad_or_trim(audio)
+
+    # make log-Mel spectrogram and move to the same device as the model
+    mel = whisper.log_mel_spectrogram(audio).to(model.device)
+
+    # detect the spoken language
+    _, probs = model.detect_language(mel)
+    speech_language = max(probs, key=probs.get)
+
+    # decode the audio
+    options = whisper.DecodingOptions()
+    result = whisper.decode(model, mel, options)
+
+    # print the recognized text
+    speech_text = result.text
+    return speech_text, speech_language
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument(
+        "--grounded_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument("--input_image", type=str, required=True, help="path to image file")
+    parser.add_argument("--speech_file", type=str, required=True, help="speech file")
+    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("--iou_threshold", type=float, default=0.5, help="iou threshold")
+
+    parser.add_argument("--device", type=str, default="cpu", help="running on cpu only!, default=False")
+    args = parser.parse_args()
+
+    # cfg
+    config_file = args.config  # change the path of the model config file
+    grounded_checkpoint = args.grounded_checkpoint  # change the path of the model
+    sam_checkpoint = args.sam_checkpoint
+    image_path = args.input_image
+    output_dir = args.output_dir
+    box_threshold = args.box_threshold
+    text_threshold = args.text_threshold
+    iou_threshold = args.iou_threshold
+    device = args.device
+
+    # load speech
+    whisper_model = whisper.load_model("base")
+    speech_text, speech_language = speech_recognition(args.speech_file, whisper_model)
+    print(f"speech_text: {speech_text}")
+    print(f"speech_language: {speech_language}")
+
+    # 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, grounded_checkpoint, device=device)
+
+    # visualize raw image
+    image_pil.save(os.path.join(output_dir, "raw_image.jpg"))
+
+    # run grounding dino model
+    text_prompt = speech_text
+    boxes_filt, scores, pred_phrases = get_grounding_output(
+        model, image, text_prompt, box_threshold, text_threshold, device=device
+    )
+
+    # initialize SAM
+    sam = build_sam(checkpoint=sam_checkpoint)
+    sam.to(device=device)
+    predictor = SamPredictor(sam)
+    image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    boxes_filt = boxes_filt.cpu()
+    # use NMS to handle overlapped boxes
+    print(f"Before NMS: {boxes_filt.shape[0]} boxes")
+    nms_idx = torchvision.ops.nms(boxes_filt, scores, iou_threshold).numpy().tolist()
+    boxes_filt = boxes_filt[nms_idx]
+    pred_phrases = [pred_phrases[idx] for idx in nms_idx]
+    print(f"After NMS: {boxes_filt.shape[0]} boxes")
+
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+    masks, _, _ = predictor.predict_torch(
+        point_coords = None,
+        point_labels = None,
+        boxes = transformed_boxes.to(args.device),
+        multimask_output = False,
+    )
+    
+    # draw output image
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image)
+    for mask in masks:
+        show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    for box, label in zip(boxes_filt, pred_phrases):
+        show_box(box.numpy(), plt.gca(), label)
+    
+    plt.title(speech_text)
+    plt.axis('off')
+    plt.savefig(
+        os.path.join(output_dir, "grounded_sam_whisper_output.jpg"), 
+        bbox_inches="tight", dpi=300, pad_inches=0.0
+    )
+
+
+    save_mask_data(output_dir, masks, boxes_filt, pred_phrases)
+    

external/Grounded-Segment-Anything/grounded_sam_whisper_inpainting_demo.py

@@ -0,0 +1,286 @@
+import argparse
+import os
+from warnings import warn
+
+import numpy as np
+import torch
+from PIL import Image, ImageDraw, ImageFont
+import litellm
+
+# Grounding DINO
+import GroundingDINO.groundingdino.datasets.transforms as T
+from GroundingDINO.groundingdino.models import build_model
+from GroundingDINO.groundingdino.util import box_ops
+from GroundingDINO.groundingdino.util.slconfig import SLConfig
+from GroundingDINO.groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+
+# segment anything
+from segment_anything import build_sam, SamPredictor 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+# diffusers
+import PIL
+import requests
+import torch
+from io import BytesIO
+from diffusers import StableDiffusionInpaintPipeline
+
+# whisper
+import whisper
+
+# ChatGPT
+import openai
+
+
+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, device):
+    args = SLConfig.fromfile(model_config_path)
+    args.device = device
+    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, with_logits=True, device="cpu"):
+    caption = caption.lower()
+    caption = caption.strip()
+    if not caption.endswith("."):
+        caption = caption + "."
+    model = model.to(device)
+    image = image.to(device)
+    with torch.no_grad():
+        outputs = model(image[None], captions=[caption])
+    logits = outputs["pred_logits"].cpu().sigmoid()[0]  # (nq, 256)
+    boxes = outputs["pred_boxes"].cpu()[0]  # (nq, 4)
+    logits.shape[0]
+
+    # filter output
+    logits_filt = logits.clone()
+    boxes_filt = boxes.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
+    logits_filt.shape[0]
+
+    # 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)
+
+    return boxes_filt, pred_phrases
+
+def show_mask(mask, ax, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax, label):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2)) 
+    ax.text(x0, y0, label)
+    
+
+def speech_recognition(speech_file, model):
+    # whisper
+    # load audio and pad/trim it to fit 30 seconds
+    audio = whisper.load_audio(speech_file)
+    audio = whisper.pad_or_trim(audio)
+
+    # make log-Mel spectrogram and move to the same device as the model
+    mel = whisper.log_mel_spectrogram(audio).to(model.device)
+
+    # detect the spoken language
+    _, probs = model.detect_language(mel)
+    speech_language = max(probs, key=probs.get)
+
+    # decode the audio
+    options = whisper.DecodingOptions()
+    result = whisper.decode(model, mel, options)
+
+    # print the recognized text
+    speech_text = result.text
+    return speech_text, speech_language
+
+
+def filter_prompts_with_chatgpt(caption, max_tokens=100, model="gpt-3.5-turbo"):
+    prompt = [
+        {
+            'role': 'system',
+            'content': f"Extract the main object to be replaced and marked it as 'main_object', " + \
+                       f"Extract the remaining part as 'other prompt' " + \
+                       f"Return (main_object, other prompt)" + \
+                       f'Given caption: {caption}.'
+        }
+    ]
+    response = litellm.completion(model=model, messages=prompt, temperature=0.6, max_tokens=max_tokens)
+    reply = response['choices'][0]['message']['content']
+    try:
+        det_prompt, inpaint_prompt = reply.split('\n')[0].split(':')[-1].strip(), reply.split('\n')[1].split(':')[-1].strip()
+    except:
+        warn(f"Failed to extract tags from caption") # use caption as det_prompt, inpaint_prompt
+        det_prompt, inpaint_prompt = caption, caption
+    return det_prompt, inpaint_prompt
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser("Grounded-Segment-Anything Demo", add_help=True)
+    parser.add_argument("--config", type=str, required=True, help="path to config file")
+    parser.add_argument(
+        "--grounded_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument(
+        "--sam_checkpoint", type=str, required=True, help="path to checkpoint file"
+    )
+    parser.add_argument("--input_image", type=str, required=True, help="path to image file")
+    parser.add_argument(
+        "--output_dir", "-o", type=str, default="outputs", required=True, help="output directory"
+    )
+    parser.add_argument("--cache_dir", type=str, default=None, help="save your huggingface large model cache")
+    parser.add_argument("--det_speech_file", type=str, help="grounding speech file")
+    parser.add_argument("--inpaint_speech_file", type=str, help="inpaint speech file")
+    parser.add_argument("--prompt_speech_file", type=str, help="prompt speech file, no need to provide det_speech_file")
+    parser.add_argument("--enable_chatgpt", action="store_true", help="enable chatgpt")
+    parser.add_argument("--openai_key", type=str, help="key for chatgpt")
+    parser.add_argument("--openai_proxy", default=None, type=str, help="proxy for chatgpt")
+    parser.add_argument("--whisper_model", type=str, default="small", help="whisper model version: tiny, base, small, medium, large")
+    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("--inpaint_mode", type=str, default="first", help="inpaint mode")
+    parser.add_argument("--device", type=str, default="cpu", help="running on cpu only!, default=False")
+    parser.add_argument("--prompt_extra", type=str, default=" high resolution, real scene", help="extra prompt for inpaint")
+    args = parser.parse_args()
+
+    # cfg
+    config_file = args.config  # change the path of the model config file
+    grounded_checkpoint = args.grounded_checkpoint  # change the path of the model
+    sam_checkpoint = args.sam_checkpoint
+    image_path = args.input_image
+
+    output_dir = args.output_dir
+    cache_dir=args.cache_dir
+    # if not os.path.exists(cache_dir):
+    #     print(f"create your cache dir:{cache_dir}")
+    #     os.mkdir(cache_dir)   
+    box_threshold = args.box_threshold
+    text_threshold = args.text_threshold
+    inpaint_mode = args.inpaint_mode
+    device = args.device
+
+    # 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, grounded_checkpoint, device=device)
+
+    # visualize raw image
+    image_pil.save(os.path.join(output_dir, "raw_image.jpg"))
+    
+    # recognize speech
+    whisper_model = whisper.load_model(args.whisper_model)
+    
+    if args.enable_chatgpt:
+        openai.api_key = args.openai_key
+        if args.openai_proxy:
+            openai.proxy = {"http": args.openai_proxy, "https": args.openai_proxy}
+        speech_text, _ = speech_recognition(args.prompt_speech_file, whisper_model)
+        det_prompt, inpaint_prompt = filter_prompts_with_chatgpt(speech_text)
+        inpaint_prompt += args.prompt_extra
+        print(f"det_prompt: {det_prompt}, inpaint_prompt: {inpaint_prompt}")
+    else:
+        det_prompt, det_speech_language = speech_recognition(args.det_speech_file, whisper_model)
+        inpaint_prompt, inpaint_speech_language = speech_recognition(args.inpaint_speech_file, whisper_model)
+        print(f"det_prompt: {det_prompt}, using language: {det_speech_language}")
+        print(f"inpaint_prompt: {inpaint_prompt}, using language: {inpaint_speech_language}")
+    
+    # run grounding dino model
+    boxes_filt, pred_phrases = get_grounding_output(
+        model, image, det_prompt, box_threshold, text_threshold, device=device
+    )
+
+    # initialize SAM
+    predictor = SamPredictor(build_sam(checkpoint=sam_checkpoint).to(device))
+    image = cv2.imread(image_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+    for i in range(boxes_filt.size(0)):
+        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
+        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
+        boxes_filt[i][2:] += boxes_filt[i][:2]
+
+    boxes_filt = boxes_filt.cpu()
+    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
+
+    masks, _, _ = predictor.predict_torch(
+        point_coords = None,
+        point_labels = None,
+        boxes = transformed_boxes.to(device),
+        multimask_output = False,
+    )
+
+    # masks: [1, 1, 512, 512]
+
+    # inpainting pipeline
+    if inpaint_mode == 'merge':
+        masks = torch.sum(masks, dim=0).unsqueeze(0)
+        masks = torch.where(masks > 0, True, False)
+    mask = masks[0][0].cpu().numpy() # simply choose the first mask, which will be refine in the future release
+    mask_pil = Image.fromarray(mask)
+    image_pil = Image.fromarray(image)
+    
+    pipe = StableDiffusionInpaintPipeline.from_pretrained(
+    "runwayml/stable-diffusion-inpainting", torch_dtype=torch.float16,cache_dir=cache_dir
+    )
+    pipe = pipe.to("cuda")
+
+    # prompt = "A sofa, high quality, detailed"
+    image = pipe(prompt=inpaint_prompt, image=image_pil, mask_image=mask_pil).images[0]
+    image.save(os.path.join(output_dir, "grounded_sam_inpainting_output.jpg"))
+
+    # draw output image
+    # plt.figure(figsize=(10, 10))
+    # plt.imshow(image)
+    # for mask in masks:
+    #     show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
+    # for box, label in zip(boxes_filt, pred_phrases):
+    #     show_box(box.numpy(), plt.gca(), label)
+    # plt.axis('off')
+    # plt.savefig(os.path.join(output_dir, "grounded_sam_output.jpg"), bbox_inches="tight")
+

external/Grounded-Segment-Anything/playground/README.md

@@ -0,0 +1,19 @@
+## Playground
+
+We will try more interesting **base models** and **build more fun demos** in the playground. In the playground, we will:
+
+- **Simplify the demo code** to make it easier for users to get started.
+- **Keep complete usage notes** and some pitfalls to reduce the burden on users.
+
+## Table of Contents
+- [DeepFloyd: Text-to-Image Generation](./DeepFloyd/)
+  - [Dream: Text-to-Image Generation](./DeepFloyd/dream.py)
+  - [Style Transfer](./DeepFloyd/style_transfer.py)
+- [Paint by Example: Exemplar-based Image Editing with Diffusion Models](./PaintByExample/)
+  - [Diffuser Demo](./PaintByExample/paint_by_example.py)
+  - [PaintByExample with SAM](./PaintByExample/sam_paint_by_example.py)
+- [LaMa: Resolution-robust Large Mask Inpainting with Fourier Convolutions](./LaMa/)
+  - [LaMa Demo](./LaMa/lama_inpaint_demo.py)
+  - [LaMa with SAM](./LaMa/sam_lama.py)
+- [RePaint: Inpainting using Denoising Diffusion Probabilistic Models](./RePaint/)
+  - [RePaint Demo](./RePaint/repaint.py)

external/Grounded-Segment-Anything/recognize-anything/.gitignore

@@ -0,0 +1,140 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# checkpoint
+*.pth
+outputs/
+
+# Editor
+.idea/
+.vscode/
+
+# gradio cache
+gradio_cached_examples/

external/Grounded-Segment-Anything/recognize-anything/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+
+Copyright (c) 2022 OPPO
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

external/Grounded-Segment-Anything/recognize-anything/MANIFEST.in

@@ -0,0 +1,3 @@
+include ram/configs/*.json
+include ram/configs/swin/*.json
+include ram/data/*.txt

external/Grounded-Segment-Anything/recognize-anything/NOTICE.txt

@@ -0,0 +1,481 @@
+# NOTICES AND INFORMATION
+
+This software incorporates material from third parties.
+
+- BLIP
+- Swin Transofmrer
+- pytorch-image-models
+- transformers
+
+
+## Utility: BLIP
+
+### BLIP
+
+**Source**: https://github.com/salesforce/BLIP
+
+Copyright (c) 2022, Salesforce.com, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of Salesforce.com nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## Utility: Swin Transofmrer
+
+### Swin Transformer
+
+**Source**: https://github.com/microsoft/Swin-Transformer
+
+MIT License
+
+Copyright (c) Microsoft Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE
+
+
+## Utility: pytorch-image-models
+
+### pytorch-image-models
+
+**Source**: https://github.com/huggingface/pytorch-image-models
+
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019 Ross Wightman
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+
+
+## Utility: transformers
+
+### transformers
+
+**Source**: https://github.com/huggingface/transformers
+
+Copyright 2018- The Hugging Face team. All rights reserved.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

external/Grounded-Segment-Anything/recognize-anything/README.md

@@ -0,0 +1,601 @@
+# <font size=8> :label: Recognize Anything Model </font>
+
+This project aims to develop a series of open-source and strong fundamental image recognition models.
+
+[![Training Dataset](https://img.shields.io/badge/📦-Training%20Dataset-orange.svg)](#open_book-training-datasets)
+[![Tag List](https://img.shields.io/badge/🏷️-4585%20Tags-green.svg)](ram/data/ram_tag_list.txt)
+[![Web Demo](https://img.shields.io/badge/🤗-HuggingFace%20Space-cyan.svg)](https://huggingface.co/spaces/xinyu1205/Recognize_Anything-Tag2Text)
+[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mhd-medfa/recognize-anything/blob/main/recognize_anything_demo.ipynb)
+[![Open in Bohrium](https://cdn.dp.tech/bohrium/web/static/images/open-in-bohrium.svg)](https://bohrium.dp.tech/notebooks/63116114759)
+
+
+- **Recognize Anything Plus Model (RAM++)** [[Paper](https://arxiv.org/abs/2310.15200)] <br>
+
+  RAM++ is the next generation of RAM, which can **recognize any category with high accuracy**, including **both predefined common categories and diverse open-set categories**.
+
+- **Recognize Anything Model (RAM)** [[Paper](https://arxiv.org/abs/2306.03514)][[Demo](https://huggingface.co/spaces/xinyu1205/recognize-anything)] <br>
+
+  RAM is an image tagging model, which can **recognize any common category with high accuracy**.
+  
+  RAM is accepted at **CVPR 2024 Multimodal Foundation Models Workshop**.
+
+- **Tag2Text (ICLR 2024)**  [[Paper](https://arxiv.org/abs/2303.05657)] [[Demo](https://huggingface.co/spaces/xinyu1205/recognize-anything)]<br>
+
+  Tag2Text is a vision-language model guided by tagging, which can **support tagging and comprehensive captioning simultaneously**.
+  
+  Tag2Text is accepted at **ICLR 2024!** See you in Vienna!
+
+
+
+
+## :bulb: Highlight
+
+### **Superior Image Recognition Capability** 
+
+RAM++ outperforms existing SOTA image fundamental recognition models on common tag categories, uncommon tag categories, and  human-object interaction phrases.
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/ram_plus_compare.jpg" align="center" width="700" ></td>
+  </tr>
+</table>
+   <p align="center">Comparison of zero-shot image recognition performance.</p>
+</p>
+
+
+### **Strong Visual Semantic Analysis** 
+
+
+We have combined Tag2Text and RAM with localization models (Grounding-DINO and SAM) and developed a strong visual semantic analysis pipeline in the [Grounded-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything) project.
+
+![](./images/ram_grounded_sam.jpg)
+
+
+## :sunrise: Model Zoo
+
+<details>
+<summary><font size="3" style="font-weight:bold;">
+RAM++
+</font></summary> 
+
+RAM++ is the next generation of RAM, which can recognize any category with high accuracy, including both predefined common categories and diverse open-set categories.
+
+
+- **For Common Predefined Categoies.** RAM++ exhibits exceptional image tagging capabilities with powerful zero-shot generalization, which maintains the same capabilities as RAM.
+    <!-- - RAM++ showcases impressive zero-shot performance, significantly outperforming CLIP and BLIP.
+    - RAM++ even surpasses the fully supervised manners (ML-Decoder).
+    - RAM++ exhibits competitive performance with the Google tagging API. -->
+- **For Diverse Open-set Categoires.** RAM++ achieves notably enhancements beyond CLIP and RAM.
+    <!-- - RAM++ integrate the image-tags-text triplets within a unified alignment framework.
+    - RAM++ pioneer the intergation of LLM's knowledge into image tagging training. -->
+
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/ram_plus_experiment.png" align="center" width="800" ></td>
+  </tr>
+</table>
+  <p align="center">(Green color means fully supervised learning and others means zero-shot performance.)</p>
+</p>
+
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/ram_plus_visualization.jpg" align="center" width="800" ></td>
+  </tr>
+</table>
+  <p align="center">RAM++ demonstrate a significant improvement in open-set category recognition.</p>
+</p>
+
+
+</details>
+
+
+
+<details>
+<summary><font size="3" style="font-weight:bold;">
+RAM
+</font></summary>
+
+
+RAM is a strong image tagging model, which can recognize any common category with high accuracy.
+- **Strong and general.** RAM exhibits exceptional image tagging capabilities with powerful zero-shot generalization;
+    - RAM showcases impressive zero-shot performance, significantly outperforming CLIP and BLIP.
+    - RAM even surpasses the fully supervised manners (ML-Decoder).
+    - RAM exhibits competitive performance with the Google tagging API.
+- **Reproducible and affordable.** RAM requires Low reproduction cost with open-source and annotation-free dataset;
+- **Flexible and versatile.** RAM offers remarkable flexibility, catering to various application scenarios.
+
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/experiment_comparison.png" align="center" width="800" ></td>
+  </tr>
+</table>
+  <p align="center">(Green color means fully supervised learning and Blue color means zero-shot performance.)</p>
+</p>
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/tagging_results.jpg" align="center" width="800" ></td>
+  </tr>
+</table>
+</p>
+
+RAM significantly improves the tagging ability based on the Tag2text framework.
+- **Accuracy.** RAM utilizes a **data engine** to **generate** additional annotations and **clean** incorrect ones,  **higher accuracy** compared to Tag2Text.
+- **Scope.** RAM upgrades the number of fixed tags from  3,400+ to **[6,400+](./ram/data/ram_tag_list.txt)** (synonymous reduction to 4,500+ different semantic tags), covering **more valuable categories**.
+  Moreover, RAM is equipped with **open-set capability**, feasible to recognize tags not seen during training
+
+
+</details>
+
+
+
+<details>
+<summary><font size="3" style="font-weight:bold;">
+Tag2text
+</font></summary>
+
+
+Tag2Text is an efficient and controllable vision-language model with tagging guidance.
+- **Tagging.** Tag2Text recognizes **[3,400+](./ram/data/tag2text_ori_tag_list.txt)** commonly human-used categories without manual annotations.
+- **Captioning.** Tag2Text integrates **tags information** into text generation as the **guiding elements**, resulting in **more controllable and comprehensive descriptions**. 
+- **Retrieval.** Tag2Text provides **tags** as **additional visible alignment indicators** for image-text retrieval. 
+
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/tag2text_visualization.png" align="center" width="800" ></td>
+  </tr>
+</table>
+    <p align="center">Tag2Text generate more comprehensive captions with tagging guidance.</p>
+</p>
+
+<p align="center">
+ <table class="tg">
+  <tr>
+    <td class="tg-c3ow"><img src="images/tag2text_retrieval_visualization.png" align="center" width="800" ></td>
+  </tr>
+</table>
+    <p align="center">Tag2Text provides tags as additional visible alignment indicators.</p>
+</p>
+
+
+</details>
+
+<!-- ## :sparkles: Highlight Projects with other Models
+- [Tag2Text/RAM with Grounded-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything) is trong and general pipeline for visual semantic analysis, which can automatically **recognize**, detect, and segment for an image!
+- [Ask-Anything](https://github.com/OpenGVLab/Ask-Anything) is a multifunctional video question answering tool. Tag2Text provides powerful tagging and captioning capabilities as a fundamental component.
+- [Prompt-can-anything](https://github.com/positive666/Prompt-Can-Anything) is a gradio web library that integrates SOTA multimodal large models, including Tag2text as the core model for graphic understanding -->
+
+
+<!-- 
+## :fire: News
+
+- **`2023/10/30`**: We release the [Recognize Anything Model Plus Model(RAM++)](), checkpoints and inference code!
+- **`2023/06/08`**: We release the [Recognize Anything Model (RAM) Tag2Text web demo 🤗](https://huggingface.co/spaces/xinyu1205/Recognize_Anything-Tag2Text), checkpoints and inference code!
+- **`2023/06/07`**: We release the [Recognize Anything Model (RAM)](https://recognize-anything.github.io/), a strong image tagging model!
+- **`2023/06/05`**: Tag2Text is combined with [Prompt-can-anything](https://github.com/OpenGVLab/Ask-Anything).
+- **`2023/05/20`**: Tag2Text is combined with [VideoChat](https://github.com/OpenGVLab/Ask-Anything).
+- **`2023/04/20`**: We marry Tag2Text with with [Grounded-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything).
+- **`2023/04/10`**: Code and checkpoint is available Now!
+- **`2023/03/14`**: [Tag2Text web demo 🤗](https://huggingface.co/spaces/xinyu1205/Recognize_Anything-Tag2Text) is available on Hugging Face Space!   -->
+
+
+
+
+<!-- 
+## :writing_hand: TODO 
+
+- [x] Release checkpoints.
+- [x] Release inference code.
+- [x] Release demo and checkpoints.
+- [x] Release training codes.
+- [x] Release training datasets.
+- [ ] Release full training codes and scripts. -->
+
+
+## :open_book: Training Datasets
+
+### **Image Texts and Tags** 
+
+These annotation files come from the [Tag2Text](https://arxiv.org/abs/2303.05657) and [RAM](https://recognize-anything.github.io/). Tag2Text automatically extracts image tags from image-text pairs. RAM further augments both tags and texts via an automatic data engine.
+
+
+| DataSet  | Size    | Images | Texts | Tags  |
+|----------|---------|--------|-------|-------|
+| [COCO](https://huggingface.co/datasets/xinyu1205/recognize-anything-dataset/blob/main/coco_train_rmcocodev_ram.json)     | 168 MB  | 113K   | 680K  | 3.2M  |
+| [VG](https://huggingface.co/datasets/xinyu1205/recognize-anything-dataset/blob/main/vg_ram.json)       | 55 MB   | 100K   | 923K  | 2.7M  |
+| [SBU](https://huggingface.co/datasets/xinyu1205/recognize-anything-dataset/blob/main/sbu_ram.json)      | 234 MB  | 849K   | 1.7M  | 7.6M  |
+| [CC3M](https://huggingface.co/datasets/xinyu1205/recognize-anything-dataset/blob/main/cc3m_train_ram.json)     | 766 MB  | 2.8M   | 5.6M  | 28.2M |
+| [CC3M-val](https://huggingface.co/datasets/xinyu1205/recognize-anything-dataset/blob/main/cc3m_val_ram.json) | 3.5 MB  | 12K    | 26K   | 132K  |
+
+CC12M to be released in the next update.
+
+### **LLM Tag Descriptions** 
+
+These tag descriptions files come from the [RAM++](https://arxiv.org/abs/2310.15200) by calling GPT api. You can also customize any tag categories by [generate_tag_des_llm.py](generate_tag_des_llm.py).
+
+| Tag Descriptions    | Tag List |
+|---------------------|----------|
+| [RAM Tag List](https://huggingface.co/datasets/xinyu1205/recognize-anything-plus-model-tag-descriptions/blob/main/ram_tag_list_4585_llm_tag_descriptions.json)        | [4,585](ram/data/ram_tag_list.txt)    |
+| [OpenImages Uncommon](./datasets/openimages_rare_200/openimages_rare_200_llm_tag_descriptions.json) | [200](datasets/openimages_rare_200/openimages_rare_200_ram_taglist.txt)      |
+
+## :toolbox: Checkpoints
+Note : you need to create 'pretrained' folder and download these checkpoints into this folder.
+<!-- insert a table -->
+<table>
+  <thead>
+    <tr style="text-align: right;">
+      <th></th>
+      <th>Name</th>
+      <th>Backbone</th>
+      <th>Data</th>
+      <th>Illustration</th>
+      <th>Checkpoint</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th>1</th>
+      <td>RAM++ (14M)</td>
+      <td>Swin-Large</td>
+      <td>COCO, VG, SBU, CC3M, CC3M-val, CC12M</td>
+      <td>Provide strong image tagging ability for any category.</td>
+      <td><a href="https://huggingface.co/xinyu1205/recognize-anything-plus-model/blob/main/ram_plus_swin_large_14m.pth">Download  link</a></td>
+    </tr>
+    <tr>
+      <th>2</th>
+      <td>RAM (14M)</td>
+      <td>Swin-Large</td>
+      <td>COCO, VG, SBU, CC3M, CC3M-val, CC12M</td>
+      <td>Provide strong image tagging ability for common category.</td>
+      <td><a href="https://huggingface.co/spaces/xinyu1205/Recognize_Anything-Tag2Text/blob/main/ram_swin_large_14m.pth">Download  link</a></td>
+    </tr>
+    <tr>
+      <th>3</th>
+      <td>Tag2Text (14M)</td>
+      <td>Swin-Base</td>
+      <td>COCO, VG, SBU, CC3M, CC3M-val, CC12M</td>
+      <td>Support comprehensive captioning and tagging.</td>
+      <td><a href="https://huggingface.co/spaces/xinyu1205/Recognize_Anything-Tag2Text/blob/main/tag2text_swin_14m.pth">Download  link</a></td>
+    </tr>
+  </tbody>
+</table>
+
+
+## :running: Model Inference
+
+### **Setting Up** ###
+
+1. Create and activate a Conda environment:
+
+```bash
+conda create -n recognize-anything python=3.8 -y
+conda activate recognize-anything
+```
+
+2. Install `recognize-anything` as a package:
+
+```bash
+pip install git+https://github.com/xinyu1205/recognize-anything.git
+```
+
+3. Or, for development, you may build from source:
+
+```bash
+git clone https://github.com/xinyu1205/recognize-anything.git
+cd recognize-anything
+pip install -e .
+```
+
+Then the RAM++, RAM, and Tag2Text models can be imported in other projects:
+
+```python
+from ram.models import ram_plus, ram, tag2text
+```
+
+### **RAM++ Inference** ###
+
+Get the English and Chinese outputs of the images:
+
+```bash
+python inference_ram_plus.py --image images/demo/demo1.jpg --pretrained pretrained/ram_plus_swin_large_14m.pth
+```
+
+
+The output will look like the following:
+
+```
+Image Tags:  armchair | blanket | lamp | carpet | couch | dog | gray | green | hassock | home | lay | living room | picture frame | pillow | plant | room | wall lamp | sit | wood floor
+图像标签:  扶手椅  | 毯子/覆盖层 | 灯  | 地毯  | 沙发 | 狗 | 灰色 | 绿色  | 坐垫/搁脚凳/草丛 | 家/住宅 | 躺  | 客厅  | 相框  | 枕头  | 植物  | 房间  | 壁灯  | 坐/放置/坐落 | 木地板
+```
+
+### **RAM++ Inference on Unseen Categories (Open-Set)** ##
+
+1. Get the [OpenImages-Uncommon categories](./datasets/openimages_rare_200/openimages_rare_200_ram_taglist.txt) of the image:
+
+We have released the LLM tag descriptions of OpenImages-Uncommon categories in [openimages_rare_200_llm_tag_descriptions](./datasets/openimages_rare_200/).
+
+<pre/>
+python inference_ram_plus_openset.py  --image images/openset_example.jpg \
+--pretrained pretrained/ram_plus_swin_large_14m.pth \
+--llm_tag_des datasets/openimages_rare_200/openimages_rare_200_llm_tag_descriptions.json
+</pre>
+
+The output will look like the following:
+```
+Image Tags: Close-up | Compact car | Go-kart | Horse racing | Sport utility vehicle | Touring car
+```
+
+2. You can also customize any tag categories for recognition through tag descriptions:
+
+Modify [categories](./generate_tag_des_llm.py#L56), and call GPT api to generate corresponding tag descriptions:
+
+<pre/>
+python generate_tag_des_llm.py \
+--openai_api_key 'your openai api key' \
+--output_file_path datasets/openimages_rare_200/openimages_rare_200_llm_tag_descriptions.json
+</pre>
+
+<details>
+<summary><font size="4" style="font-weight:bold;">
+RAM Inference
+</font></summary>
+
+Get the English and Chinese outputs of the images:
+
+<pre/>
+python inference_ram.py  --image images/demo/demo1.jpg \
+--pretrained pretrained/ram_swin_large_14m.pth
+</pre>
+
+The output will look like the following:
+
+```
+Image Tags:  armchair | blanket | lamp | carpet | couch | dog | floor | furniture | gray | green | living room | picture frame | pillow | plant | room | sit | stool | wood floor
+图像标签:  扶手椅  | 毯子/覆盖层 | 灯  | 地毯  | 沙发 | 狗 | 地板/地面 | 家具  | 灰色 | 绿色  | 客厅  | 相框  | 枕头  | 植物  | 房间  | 坐/放置/坐落 | 凳子  | 木地板 
+```
+
+</details>
+
+
+<details>
+<summary><font size="4" style="font-weight:bold;">
+RAM Inference on Unseen Categories (Open-Set)
+</font></summary>
+
+
+Firstly, custom recognition categories in [build_openset_label_embedding](./ram/utils/openset_utils.py), then get the tags of the images:
+
+<pre/>
+python inference_ram_openset.py  --image images/openset_example.jpg \
+--pretrained pretrained/ram_swin_large_14m.pth
+</pre>
+
+The output will look like the following:
+```
+Image Tags: Black-and-white | Go-kart
+```
+
+
+</details>
+
+<details>
+<summary><font size="4" style="font-weight:bold;">
+Tag2Text Inference
+</font></summary>
+
+
+Get the tagging and captioning results:
+<pre/>
+python inference_tag2text.py  --image images/demo/demo1.jpg \
+--pretrained pretrained/tag2text_swin_14m.pth
+</pre>
+Or get the tagging and sepcifed captioning results (optional):
+<pre/>python inference_tag2text.py  --image images/demo/demo1.jpg \
+--pretrained pretrained/tag2text_swin_14m.pth \
+--specified-tags "cloud,sky"</pre>
+
+</details>
+
+### **Batch Inference and Evaluation** ##
+We release two datasets `OpenImages-common` (214 common tag classes) and `OpenImages-rare` (200 uncommon tag classes). Copy or sym-link test images of [OpenImages v6](https://storage.googleapis.com/openimages/web/download_v6.html) to `datasets/openimages_common_214/imgs/` and `datasets/openimages_rare_200/imgs`.
+
+To evaluate RAM++ on `OpenImages-common`:
+
+```bash
+python batch_inference.py \
+  --model-type ram_plus \
+  --checkpoint pretrained/ram_plus_swin_large_14m.pth \
+  --dataset openimages_common_214 \
+  --output-dir outputs/ram_plus
+```
+
+To evaluate RAM++ open-set capability on `OpenImages-rare`:
+
+```bash
+python batch_inference.py \
+  --model-type ram_plus \
+  -- pretrained/ram_plus_swin_large_14m.pth \
+  --open-set \
+  --dataset openimages_rare_200 \
+  --output-dir outputs/ram_plus_openset
+```
+
+To evaluate RAM on `OpenImages-common`:
+
+```bash
+python batch_inference.py \
+  --model-type ram \
+  -- pretrained/ram_swin_large_14m.pth \
+  --dataset openimages_common_214 \
+  --output-dir outputs/ram
+```
+
+To evaluate RAM open-set capability on `OpenImages-rare`:
+
+```bash
+python batch_inference.py \
+  --model-type ram \
+  -- pretrained/ram_swin_large_14m.pth \
+  --open-set \
+  --dataset openimages_rare_200 \
+  --output-dir outputs/ram_openset
+```
+
+To evaluate Tag2Text on `OpenImages-common`:
+
+```bash
+python batch_inference.py \
+  --model-type tag2text \
+  -- pretrained/tag2text_swin_14m.pth \
+  --dataset openimages_common_214 \
+  --output-dir outputs/tag2text
+```
+
+Please refer to `batch_inference.py` for more options. To get P/R in table 3 of RAM paper, pass `--threshold=0.86` for RAM and `--threshold=0.68` for Tag2Text.
+
+To batch inference custom images, you can set up you own datasets following the given two datasets.
+
+
+## :golfing: Model Training/Finetuning
+
+### **RAM++** ##
+
+1. Download [RAM training datasets](#open_book-training-datasets) where each json file contains a list. Each item in the list is a dictonary with three key-value pairs: {'image_path': path_of_image, 'caption': text_of_image, 'union_label_id': image tags for tagging which including parsed tags and pseudo tags }.
+
+2. In ram/configs/pretrain.yaml, set 'train_file' as the paths for the json files.
+
+3. Prepare [pretained Swin-Transformer](https://github.com/microsoft/Swin-Transformer), and set 'ckpt' in ram/configs/swin.
+
+4. Download RAM++ frozen tag embedding file "[ram_plus_tag_embedding_class_4585_des_51.pth](https://huggingface.co/xinyu1205/recognize-anything-plus-model/blob/main/ram_plus_tag_embedding_class_4585_des_51.pth)", and set file in "ram/data/frozen_tag_embedding/ram_plus_tag_embedding_class_4585_des_51.pth"
+
+5. Pre-train the model using 8 A100 GPUs:
+
+```bash
+python -m torch.distributed.run --nproc_per_node=8 pretrain.py \
+  --model-type ram_plus \
+  --config ram/configs/pretrain.yaml  \
+  --output-dir outputs/ram_plus
+```
+
+6. Fine-tune the pre-trained checkpoint using 8 A100 GPUs:
+
+```bash
+python -m torch.distributed.run --nproc_per_node=8 finetune.py \
+  --model-type ram_plus \
+  --config ram/configs/finetune.yaml  \
+  --checkpoint outputs/ram_plus/checkpoint_04.pth \
+  --output-dir outputs/ram_plus_ft
+```
+
+
+<details>
+<summary><font size="4" style="font-weight:bold;">
+RAM 
+</font></summary>
+
+1. Download [RAM training datasets](#open_book-training-datasets) where each json file contains a list. Each item in the list is a dictonary with four key-value pairs: {'image_path': path_of_image, 'caption': text_of_image, 'union_label_id': image tags for tagging which including parsed tags and pseudo tags, 'parse_label_id': image tags parsed from caption }.
+
+2. In ram/configs/pretrain.yaml, set 'train_file' as the paths for the json files.
+
+3. Prepare [pretained Swin-Transformer](https://github.com/microsoft/Swin-Transformer), and set 'ckpt' in ram/configs/swin.
+
+4. Download RAM frozen tag embedding file "[ram_tag_embedding_class_4585.pth](https://huggingface.co/xinyu1205/recognize_anything_model/blob/main/ram_tag_embedding_class_4585.pth)", and set file in "ram/data/frozen_tag_embedding/ram_tag_embedding_class_4585.pth"
+
+5. Pre-train the model using 8 A100 GPUs:
+
+```bash
+python -m torch.distributed.run --nproc_per_node=8 pretrain.py \
+  --model-type ram \
+  --config ram/configs/pretrain.yaml  \
+  --output-dir outputs/ram
+```
+
+6. Fine-tune the pre-trained checkpoint using 8 A100 GPUs:
+
+```bash
+python -m torch.distributed.run --nproc_per_node=8 finetune.py \
+  --model-type ram \
+  --config ram/configs/finetune.yaml  \
+  --checkpoint outputs/ram/checkpoint_04.pth \
+  --output-dir outputs/ram_ft
+```
+
+</details>
+
+
+<details>
+<summary><font size="4" style="font-weight:bold;">
+Tag2Text 
+</font></summary>
+
+1. Download [RAM training datasets](#open_book-training-datasets) where each json file contains a list. Each item in the list is a dictonary with three key-value pairs: {'image_path': path_of_image, 'caption': text_of_image, 'parse_label_id': image tags parsed from caption }.
+
+2. In ram/configs/pretrain_tag2text.yaml, set 'train_file' as the paths for the json files.
+
+3. Prepare [pretained Swin-Transformer](https://github.com/microsoft/Swin-Transformer), and set 'ckpt' in ram/configs/swin.
+
+4. Pre-train the model using 8 A100 GPUs:
+
+```bash
+python -m torch.distributed.run --nproc_per_node=8 pretrain.py \
+  --model-type tag2text \
+  --config ram/configs/pretrain_tag2text.yaml  \
+  --output-dir outputs/tag2text
+```
+
+5. Fine-tune the pre-trained checkpoint using 8 A100 GPUs:
+
+```bash
+python -m torch.distributed.run --nproc_per_node=8 finetune.py \
+  --model-type tag2text \
+  --config ram/configs/finetune_tag2text.yaml  \
+  --checkpoint outputs/tag2text/checkpoint_04.pth \
+  --output-dir outputs/tag2text_ft
+```
+
+</details>
+
+
+## :black_nib: Citation
+If you find our work to be useful for your research, please consider citing.
+
+```
+@article{huang2023open,
+  title={Open-Set Image Tagging with Multi-Grained Text Supervision},
+  author={Huang, Xinyu and Huang, Yi-Jie and Zhang, Youcai and Tian, Weiwei and Feng, Rui and Zhang, Yuejie and Xie, Yanchun and Li, Yaqian and Zhang, Lei},
+  journal={arXiv e-prints},
+  pages={arXiv--2310},
+  year={2023}
+}
+
+@article{zhang2023recognize,
+  title={Recognize Anything: A Strong Image Tagging Model},
+  author={Zhang, Youcai and Huang, Xinyu and Ma, Jinyu and Li, Zhaoyang and Luo, Zhaochuan and Xie, Yanchun and Qin, Yuzhuo and Luo, Tong and Li, Yaqian and Liu, Shilong and others},
+  journal={arXiv preprint arXiv:2306.03514},
+  year={2023}
+}
+
+@article{huang2023tag2text,
+  title={Tag2Text: Guiding Vision-Language Model via Image Tagging},
+  author={Huang, Xinyu and Zhang, Youcai and Ma, Jinyu and Tian, Weiwei and Feng, Rui and Zhang, Yuejie and Li, Yaqian and Guo, Yandong and Zhang, Lei},
+  journal={arXiv preprint arXiv:2303.05657},
+  year={2023}
+}
+```
+
+## :hearts: Acknowledgements
+This work is done with the help of the amazing code base of [BLIP](https://github.com/salesforce/BLIP), thanks very much!
+
+We want to thank @Cheng Rui @Shilong Liu @Ren Tianhe for their help in [marrying RAM/Tag2Text with Grounded-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything).
+
+We also want to thank [Ask-Anything](https://github.com/OpenGVLab/Ask-Anything), [Prompt-can-anything](https://github.com/positive666/Prompt-Can-Anything) for  combining RAM/Tag2Text, which greatly expands the application boundaries of RAM/Tag2Text.

external/Grounded-Segment-Anything/recognize-anything/batch_inference.py

@@ -0,0 +1,491 @@
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import Dict, List, Optional, TextIO, Tuple
+
+import torch
+from PIL import Image, UnidentifiedImageError
+from torch import Tensor
+from torch.nn import Module, Parameter
+from torch.nn.functional import relu, sigmoid
+from torch.utils.data import DataLoader, Dataset
+from tqdm import tqdm
+import torch.nn.functional as F
+import os
+import json
+
+from ram import get_transform
+from ram.models import ram_plus, ram, tag2text
+from ram.utils import build_openset_llm_label_embedding, build_openset_label_embedding, get_mAP, get_PR
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+class _Dataset(Dataset):
+    def __init__(self, imglist, input_size):
+        self.imglist = imglist
+        self.transform = get_transform(input_size)
+
+    def __len__(self):
+        return len(self.imglist)
+
+    def __getitem__(self, index):
+        try:
+            img = Image.open(self.imglist[index]+".jpg")
+        except (OSError, FileNotFoundError, UnidentifiedImageError):
+            img = Image.new('RGB', (10, 10), 0)
+            print("Error loading image:", self.imglist[index])
+        return self.transform(img)
+
+
+def parse_args():
+    parser = ArgumentParser()
+    # model
+    parser.add_argument("--model-type",
+                        type=str,
+                        choices=("ram_plus", "ram", "tag2text"),
+                        required=True)
+    parser.add_argument("--checkpoint",
+                        type=str,
+                        required=True)
+    parser.add_argument("--backbone",
+                        type=str,
+                        choices=("swin_l", "swin_b"),
+                        default=None,
+                        help="If `None`, will judge from `--model-type`")
+    parser.add_argument("--open-set",
+                        action="store_true",
+                        help=(
+                            "Treat all categories in the taglist file as "
+                            "unseen and perform open-set classification. Only "
+                            "works with RAM."
+                        ))
+    # data
+    parser.add_argument("--dataset",
+                        type=str,
+                        choices=(
+                            "openimages_common_214",
+                            "openimages_rare_200"
+                        ),
+                        required=True)
+    parser.add_argument("--input-size",
+                        type=int,
+                        default=384)
+    # threshold
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--threshold",
+                       type=float,
+                       default=None,
+                       help=(
+                           "Use custom threshold for all classes. Mutually "
+                           "exclusive with `--threshold-file`. If both "
+                           "`--threshold` and `--threshold-file` is `None`, "
+                           "will use a default threshold setting."
+                       ))
+    group.add_argument("--threshold-file",
+                       type=str,
+                       default=None,
+                       help=(
+                           "Use custom class-wise thresholds by providing a "
+                           "text file. Each line is a float-type threshold, "
+                           "following the order of the tags in taglist file. "
+                           "See `ram/data/ram_tag_list_threshold.txt` as an "
+                           "example. Mutually exclusive with `--threshold`. "
+                           "If both `--threshold` and `--threshold-file` is "
+                           "`None`, will use default threshold setting."
+                       ))
+    # miscellaneous
+    parser.add_argument("--output-dir", type=str, default="./outputs")
+    parser.add_argument("--batch-size", type=int, default=128)
+    parser.add_argument("--num-workers", type=int, default=4)
+
+    args = parser.parse_args()
+
+    # post process and validity check
+    args.model_type = args.model_type.lower()
+
+    assert not (args.model_type == "tag2text" and args.open_set)
+
+    if args.backbone is None:
+        args.backbone = "swin_l" if args.model_type == "ram_plus" or args.model_type == "ram" else "swin_b"
+
+    return args
+
+
+def load_dataset(
+    dataset: str,
+    model_type: str,
+    input_size: int,
+    batch_size: int,
+    num_workers: int
+) -> Tuple[DataLoader, Dict]:
+    dataset_root = str(Path(__file__).resolve().parent / "datasets" / dataset)
+    img_root = dataset_root + "/imgs"
+    # Label system of tag2text contains duplicate tag texts, like
+    # "train" (noun) and "train" (verb). Therefore, for tag2text, we use
+    # `tagid` instead of `tag`.
+    if model_type == "ram_plus" or model_type == "ram":
+        tag_file = dataset_root + f"/{dataset}_ram_taglist.txt"
+        annot_file = dataset_root + f"/{dataset}_ram_annots.txt"
+    else:
+        tag_file = dataset_root + f"/{dataset}_tag2text_tagidlist.txt"
+        annot_file = dataset_root + f"/{dataset}_{model_type}_idannots.txt"
+
+    with open(tag_file, "r", encoding="utf-8") as f:
+        taglist = [line.strip() for line in f]
+
+    with open(annot_file, "r", encoding="utf-8") as f:
+        imglist = [img_root + "/" + line.strip().split(",")[0] for line in f]
+
+    loader = DataLoader(
+        dataset=_Dataset(imglist,input_size),
+        shuffle=False,
+        drop_last=False,
+        pin_memory=True,
+        batch_size=batch_size,
+        num_workers=num_workers
+    )
+    
+    open_tag_des = dataset_root + f"/{dataset}_llm_tag_descriptions.json"
+    if os.path.exists(open_tag_des):
+        with open(open_tag_des, 'rb') as fo:
+            tag_des = json.load(fo)
+
+    else:
+        tag_des = None
+    info = {
+        "taglist": taglist,
+        "imglist": imglist,
+        "annot_file": annot_file,
+        "img_root": img_root,
+        "tag_des": tag_des
+    }
+
+    return loader, info
+
+
+def get_class_idxs(
+    model_type: str,
+    open_set: bool,
+    taglist: List[str]
+) -> Optional[List[int]]:
+    """Get indices of required categories in the label system."""
+    if model_type == "ram_plus" or model_type == "ram":
+        if not open_set:
+            model_taglist_file = "ram/data/ram_tag_list.txt"
+            with open(model_taglist_file, "r", encoding="utf-8") as f:
+                model_taglist = [line.strip() for line in f]
+            return [model_taglist.index(tag) for tag in taglist]
+        else:
+            return None
+    else:  # for tag2text, we directly use tagid instead of text-form of tag.
+        # here tagid equals to tag index.
+        return [int(tag) for tag in taglist]
+
+
+def load_thresholds(
+    threshold: Optional[float],
+    threshold_file: Optional[str],
+    model_type: str,
+    open_set: bool,
+    class_idxs: List[int],
+    num_classes: int,
+) -> List[float]:
+    """Decide what threshold(s) to use."""
+    if not threshold_file and not threshold:  # use default
+        if model_type == "ram_plus" or model_type == "ram":
+            if not open_set:  # use class-wise tuned thresholds
+                ram_threshold_file = "ram/data/ram_tag_list_threshold.txt"
+                with open(ram_threshold_file, "r", encoding="utf-8") as f:
+                    idx2thre = {
+                        idx: float(line.strip()) for idx, line in enumerate(f)
+                    }
+                    return [idx2thre[idx] for idx in class_idxs]
+            else:
+                return [0.5] * num_classes
+        else:
+            return [0.68] * num_classes
+    elif threshold_file:
+        with open(threshold_file, "r", encoding="utf-8") as f:
+            thresholds = [float(line.strip()) for line in f]
+        assert len(thresholds) == num_classes
+        return thresholds
+    else:
+        return [threshold] * num_classes
+
+
+def gen_pred_file(
+    imglist: List[str],
+    tags: List[List[str]],
+    img_root: str,
+    pred_file: str
+) -> None:
+    """Generate text file of tag prediction results."""
+    with open(pred_file, "w", encoding="utf-8") as f:
+        for image, tag in zip(imglist, tags):
+            # should be relative to img_root to match the gt file.
+            s = str(Path(image).relative_to(img_root))
+            if tag:
+                s = s + "," + ",".join(tag)
+            f.write(s + "\n")
+
+def load_ram_plus(
+    backbone: str,
+    checkpoint: str,
+    input_size: int,
+    taglist: List[str],
+    tag_des: List[str],
+    open_set: bool,
+    class_idxs: List[int],
+) -> Module:
+    model = ram_plus(pretrained=checkpoint, image_size=input_size, vit=backbone)
+    # trim taglist for faster inference
+    if open_set:
+        print("Building tag embeddings ...")
+        label_embed, _ = build_openset_llm_label_embedding(tag_des)
+        model.label_embed = Parameter(label_embed.float())
+        model.num_class = len(tag_des)
+    else:
+        model.label_embed = Parameter(model.label_embed.data.reshape(model.num_class,51,512)[class_idxs, :, :].reshape(len(class_idxs)*51, 512))
+        model.num_class = len(class_idxs)
+    return model.to(device).eval()
+
+
+def load_ram(
+    backbone: str,
+    checkpoint: str,
+    input_size: int,
+    taglist: List[str],
+    open_set: bool,
+    class_idxs: List[int],
+) -> Module:
+    model = ram(pretrained=checkpoint, image_size=input_size, vit=backbone)
+    # trim taglist for faster inference
+    if open_set:
+        print("Building tag embeddings ...")
+        label_embed, _ = build_openset_label_embedding(taglist)
+        model.label_embed = Parameter(label_embed.float())
+    else:
+        model.label_embed = Parameter(model.label_embed[class_idxs, :])
+    return model.to(device).eval()
+
+
+def load_tag2text(
+    backbone: str,
+    checkpoint: str,
+    input_size: int
+) -> Module:
+    model = tag2text(
+        pretrained=checkpoint,
+        image_size=input_size,
+        vit=backbone
+    )
+    return model.to(device).eval()
+
+@torch.no_grad()
+def forward_ram_plus(model: Module, imgs: Tensor) -> Tensor:
+    image_embeds = model.image_proj(model.visual_encoder(imgs.to(device)))
+    image_atts = torch.ones(
+        image_embeds.size()[:-1], dtype=torch.long).to(device)
+
+    image_cls_embeds = image_embeds[:, 0, :]
+    image_spatial_embeds = image_embeds[:, 1:, :]
+
+    bs = image_spatial_embeds.shape[0]
+
+    des_per_class = int(model.label_embed.shape[0] / model.num_class)
+
+    image_cls_embeds = image_cls_embeds / image_cls_embeds.norm(dim=-1, keepdim=True)
+    reweight_scale = model.reweight_scale.exp()
+    logits_per_image = (reweight_scale * image_cls_embeds @ model.label_embed.t())
+    logits_per_image = logits_per_image.view(bs, -1,des_per_class)
+
+    weight_normalized = F.softmax(logits_per_image, dim=2)
+    label_embed_reweight = torch.empty(bs, model.num_class, 512).cuda()
+    weight_normalized = F.softmax(logits_per_image, dim=2)
+    label_embed_reweight = torch.empty(bs, model.num_class, 512).cuda()
+    for i in range(bs):
+        reshaped_value = model.label_embed.view(-1, des_per_class, 512)
+        product = weight_normalized[i].unsqueeze(-1) * reshaped_value
+        label_embed_reweight[i] = product.sum(dim=1)
+
+    label_embed = relu(model.wordvec_proj(label_embed_reweight))
+
+    tagging_embed, _ = model.tagging_head(
+        encoder_embeds=label_embed,
+        encoder_hidden_states=image_embeds,
+        encoder_attention_mask=image_atts,
+        return_dict=False,
+        mode='tagging',
+    )
+    return sigmoid(model.fc(tagging_embed).squeeze(-1))
+
+@torch.no_grad()
+def forward_ram(model: Module, imgs: Tensor) -> Tensor:
+    image_embeds = model.image_proj(model.visual_encoder(imgs.to(device)))
+    image_atts = torch.ones(
+        image_embeds.size()[:-1], dtype=torch.long).to(device)
+    label_embed = relu(model.wordvec_proj(model.label_embed)).unsqueeze(0)\
+        .repeat(imgs.shape[0], 1, 1)
+    tagging_embed, _ = model.tagging_head(
+        encoder_embeds=label_embed,
+        encoder_hidden_states=image_embeds,
+        encoder_attention_mask=image_atts,
+        return_dict=False,
+        mode='tagging',
+    )
+    return sigmoid(model.fc(tagging_embed).squeeze(-1))
+
+
+@torch.no_grad()
+def forward_tag2text(
+    model: Module,
+    class_idxs: List[int],
+    imgs: Tensor
+) -> Tensor:
+    image_embeds = model.visual_encoder(imgs.to(device))
+    image_atts = torch.ones(
+        image_embeds.size()[:-1], dtype=torch.long).to(device)
+    label_embed = model.label_embed.weight.unsqueeze(0)\
+        .repeat(imgs.shape[0], 1, 1)
+    tagging_embed, _ = model.tagging_head(
+        encoder_embeds=label_embed,
+        encoder_hidden_states=image_embeds,
+        encoder_attention_mask=image_atts,
+        return_dict=False,
+        mode='tagging',
+    )
+    return sigmoid(model.fc(tagging_embed))[:, class_idxs]
+
+
+def print_write(f: TextIO, s: str):
+    print(s)
+    f.write(s + "\n")
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # set up output paths
+    output_dir = args.output_dir
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    pred_file, pr_file, ap_file, summary_file, logit_file = [
+        output_dir + "/" + name for name in
+        ("pred.txt", "pr.txt", "ap.txt", "summary.txt", "logits.pth")
+    ]
+    with open(summary_file, "w", encoding="utf-8") as f:
+        print_write(f, "****************")
+        for key in (
+            "model_type", "backbone", "checkpoint", "open_set",
+            "dataset", "input_size",
+            "threshold", "threshold_file",
+            "output_dir", "batch_size", "num_workers"
+        ):
+            print_write(f, f"{key}: {getattr(args, key)}")
+        print_write(f, "****************")
+
+    # prepare data
+    loader, info = load_dataset(
+        dataset=args.dataset,
+        model_type=args.model_type,
+        input_size=args.input_size,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers
+    )
+    taglist, imglist, annot_file, img_root, tag_des = \
+        info["taglist"], info["imglist"], info["annot_file"], info["img_root"], info["tag_des"]
+
+    # get class idxs
+    class_idxs = get_class_idxs(
+        model_type=args.model_type,
+        open_set=args.open_set,
+        taglist=taglist
+    )
+
+    # set up threshold(s)
+    thresholds = load_thresholds(
+        threshold=args.threshold,
+        threshold_file=args.threshold_file,
+        model_type=args.model_type,
+        open_set=args.open_set,
+        class_idxs=class_idxs,
+        num_classes=len(taglist)
+    )
+
+    # inference
+    if Path(logit_file).is_file():
+
+        logits = torch.load(logit_file)
+
+    else:
+        # load model
+        if args.model_type == "ram_plus":
+            model = load_ram_plus(
+                backbone=args.backbone,
+                checkpoint=args.checkpoint,
+                input_size=args.input_size,
+                taglist=taglist,
+                tag_des = tag_des,
+                open_set=args.open_set,
+                class_idxs=class_idxs
+            )
+        elif args.model_type == "ram":
+            model = load_ram(
+                backbone=args.backbone,
+                checkpoint=args.checkpoint,
+                input_size=args.input_size,
+                taglist=taglist,
+                open_set=args.open_set,
+                class_idxs=class_idxs
+            )
+        elif args.model_type == "tag2text":
+            model = load_tag2text(
+                backbone=args.backbone,
+                checkpoint=args.checkpoint,
+                input_size=args.input_size
+            )
+
+        # inference
+        logits = torch.empty(len(imglist), len(taglist))
+        pos = 0
+        for imgs in tqdm(loader, desc="inference"):
+            if args.model_type == "ram_plus":
+                out = forward_ram_plus(model, imgs)
+            elif args.model_type == "ram":
+                out = forward_ram(model, imgs)
+            else:
+                out = forward_tag2text(model, class_idxs, imgs)
+            bs = imgs.shape[0]
+            logits[pos:pos+bs, :] = out.cpu()
+            pos += bs
+
+        # save logits, making threshold-tuning super fast
+        torch.save(logits, logit_file)
+
+    # filter with thresholds
+    pred_tags = []
+    for scores in logits.tolist():
+        pred_tags.append([
+            taglist[i] for i, s in enumerate(scores) if s >= thresholds[i]
+        ])
+
+    # generate result file
+    gen_pred_file(imglist, pred_tags, img_root, pred_file)
+
+    # evaluate and record
+    mAP, APs = get_mAP(logits.numpy(), annot_file, taglist)
+    CP, CR, Ps, Rs = get_PR(pred_file, annot_file, taglist)
+
+    with open(ap_file, "w", encoding="utf-8") as f:
+        f.write("Tag,AP\n")
+        for tag, AP in zip(taglist, APs):
+            f.write(f"{tag},{AP*100.0:.2f}\n")
+
+    with open(pr_file, "w", encoding="utf-8") as f:
+        f.write("Tag,Precision,Recall\n")
+        for tag, P, R in zip(taglist, Ps, Rs):
+            f.write(f"{tag},{P*100.0:.2f},{R*100.0:.2f}\n")
+
+    with open(summary_file, "w", encoding="utf-8") as f:
+        print_write(f, f"mAP: {mAP*100.0}")
+        print_write(f, f"CP: {CP*100.0}")
+        print_write(f, f"CR: {CR*100.0}")

external/Grounded-Segment-Anything/recognize-anything/finetune.py

@@ -0,0 +1,291 @@
+'''
+ * RAM++ & RAM & Tag2Text finetune
+ * Written by Xinyu Huang
+'''
+import argparse
+import os
+import ruamel.yaml as yaml
+import numpy as np
+import random
+import time
+import datetime
+import json
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+
+from ram.models import ram_plus, ram, tag2text
+import utils
+from utils import cosine_lr_schedule
+from ram.data import create_dataset, create_sampler, create_loader
+
+import clip
+
+def build_text_embed(model_clip, caption):
+    run_on_gpu = torch.cuda.is_available()
+    with torch.no_grad():
+
+        texts = clip.tokenize(caption,truncate = True)  # tokenize
+        if run_on_gpu:
+            texts = texts.cuda()
+            model_clip = model_clip.cuda()
+        text_embeddings = model_clip.encode_text(texts)
+        text_embeddings /= text_embeddings.norm(dim=-1, keepdim=True)
+    return text_embeddings
+
+
+
+def train_ram_plus(model, data_loader, optimizer, epoch, device, config, model_clip):
+    # train
+    model.train()  
+    
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss_tag', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_dis', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_alignment', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50   
+    
+    data_loader.sampler.set_epoch(epoch)
+
+    for i, (image, image_224, caption, image_tag, parse_tag) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+
+        optimizer.zero_grad()
+
+        batch_text_embed = build_text_embed(model_clip,caption)
+        
+        image = image.to(device,non_blocking=True)
+        image_224 = image_224.to(device,non_blocking=True)
+
+        with torch.no_grad():
+            clip_image_feature = model_clip.encode_image(image_224)
+
+        loss_tag, loss_dis, loss_alignment = model(image, caption, image_tag, clip_image_feature, batch_text_embed)  
+        loss = loss_tag + loss_dis + loss_alignment
+
+        loss.backward()
+        optimizer.step()    
+
+        metric_logger.update(loss_tag=loss_tag.item())
+        metric_logger.update(loss_dis=loss_dis.item())
+        metric_logger.update(loss_alignment=loss_alignment.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])  
+
+        
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())     
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}  
+
+
+
+def train_ram(model, data_loader, optimizer, epoch, device, config, model_clip):
+    # train
+    model.train()  
+    
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss_t2t', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_tag', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_dis', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50   
+    
+    data_loader.sampler.set_epoch(epoch)
+
+    for i, (image, image_224, caption, image_tag, parse_tag) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+
+        optimizer.zero_grad()
+        
+        image = image.to(device,non_blocking=True)
+        image_224 = image_224.to(device,non_blocking=True)
+
+        with torch.no_grad():
+            clip_image_feature = model_clip.encode_image(image_224)
+
+        loss_t2t, loss_tag, loss_dis = model(image, caption, image_tag, parse_tag, clip_image_feature)  
+        loss = loss_t2t + loss_tag/(loss_tag/loss_t2t).detach() + loss_dis  
+
+        loss.backward()
+        optimizer.step()    
+
+        metric_logger.update(loss_t2t=loss_t2t.item())
+        metric_logger.update(loss_tag=loss_tag.item())
+        metric_logger.update(loss_dis=loss_dis.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])  
+
+        
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())     
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}  
+
+
+def train_tag2text(model, data_loader, optimizer, epoch, device, config):
+    # train
+    model.train()  
+    
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss_t2t', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_tag', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50   
+    
+    data_loader.sampler.set_epoch(epoch)
+
+    for i, (image, _, caption, _, parse_tag) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+
+
+        optimizer.zero_grad()
+        
+        image = image.to(device,non_blocking=True)
+
+        loss_t2t, loss_tag = model(image, caption, parse_tag)  
+        loss = loss_t2t + loss_tag/(loss_tag/loss_t2t).detach()   
+
+        loss.backward()
+        optimizer.step()    
+
+        metric_logger.update(loss_t2t=loss_t2t.item())
+        metric_logger.update(loss_tag=loss_tag.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])  
+
+        
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())     
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}  
+
+
+def main(args, config):
+    utils.init_distributed_mode(args)    
+    
+    device = torch.device(args.device)
+
+    # fix the seed for reproducibility
+    seed = args.seed + utils.get_rank()
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    cudnn.benchmark = True
+
+    #### Dataset #### 
+    print("Creating dataset")
+    datasets = [create_dataset('finetune', config, min_scale=0.2)]
+    print('number of training samples: %d'%len(datasets[0]))
+
+    num_tasks = utils.get_world_size()
+    global_rank = utils.get_rank()            
+    samplers = create_sampler(datasets, [True], num_tasks, global_rank)         
+
+    data_loader = create_loader(datasets,samplers,batch_size=[config['batch_size']], num_workers=[4], is_trains=[True], collate_fns=[None])[0]      
+    
+    print("Creating model")
+    if args.checkpoint:  
+        print("load from:", args.checkpoint)
+
+    #### Model #### 
+    if args.model_type == 'ram_plus':
+        print("Creating pretrained CLIP model")
+        model_clip, _ = clip.load("ViT-B/16", device=device)
+
+        print("Creating RAM model")
+        model = ram_plus(pretrained = args.checkpoint,image_size=config['image_size'], vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], 
+                                vit_ckpt_layer=config['vit_ckpt_layer'])
+
+    elif args.model_type == 'ram':
+        print("Creating pretrained CLIP model")
+        model_clip, _ = clip.load("ViT-B/16", device=device)
+        
+        print("Creating RAM model")
+        model = ram(pretrained = args.checkpoint,image_size=config['image_size'], vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], 
+                                vit_ckpt_layer=config['vit_ckpt_layer'])
+
+    elif args.model_type == 'tag2text':
+        print("Creating Tag2Text model")
+        model = tag2text(pretrained = args.checkpoint,image_size=config['image_size'], vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], 
+                                vit_ckpt_layer=config['vit_ckpt_layer'], tag_list='ram/data/ram_tag_list.txt')
+    model = model.to(device)   
+
+    ### Frozen CLIP model ###
+    model_clip = model_clip.to(device)
+    for _, param in model_clip.named_parameters():
+        param.requires_grad = False
+
+    ### Frozen label embedding for open-set recogniztion ###
+    model.label_embed.requires_grad = False
+    optimizer = torch.optim.AdamW(filter(lambda x: x.requires_grad, model.parameters()), lr=config['init_lr'], weight_decay=config['weight_decay'])
+    
+    start_epoch = 0
+    
+    model_without_ddp = model
+    if args.distributed:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
+        model_without_ddp = model.module    
+        
+    print("Start training")
+    start_time = time.time()    
+    for epoch in range(start_epoch, config['max_epoch']):
+        
+        cosine_lr_schedule(optimizer, epoch, config['max_epoch'], config['init_lr'], config['min_lr'])
+
+        if args.model_type == 'ram_plus':
+            train_stats = train_ram_plus(model, data_loader, optimizer, epoch, device, config, model_clip) 
+        elif args.model_type == 'ram':
+            train_stats = train_ram(model, data_loader, optimizer, epoch, device, config, model_clip) 
+        elif args.model_type == 'tag2text':
+            train_stats = train_tag2text(model, data_loader, optimizer, epoch, device, config) 
+
+        if utils.is_main_process():  
+            log_stats = {**{f'train_{k}': v for k, v in train_stats.items()},
+                         'epoch': epoch,
+                        }                     
+            save_obj = {
+                'model': model_without_ddp.state_dict(),
+                'optimizer': optimizer.state_dict(),
+                'config': config,
+                'epoch': epoch,
+            }
+            torch.save(save_obj, os.path.join(args.output_dir, 'checkpoint_%02d.pth'%epoch))  
+            
+            with open(os.path.join(args.output_dir, "log.txt"),"a") as f:
+                f.write(json.dumps(log_stats) + "\n")
+
+        dist.barrier()        
+                
+    total_time = time.time() - start_time
+    total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+    print('Training time {}'.format(total_time_str)) 
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', default='./configs/pretrain.yaml')
+    parser.add_argument("--model-type",type=str,choices=("ram_plus", "ram", "tag2text"),required=True)
+    parser.add_argument('--output-dir', default='output/Pretrain')  
+    parser.add_argument('--checkpoint', default='')    
+    parser.add_argument('--evaluate', action='store_true')    
+    parser.add_argument('--device', default='cuda')
+    parser.add_argument('--seed', default=42, type=int)
+    parser.add_argument('--world_size', default=1, type=int, help='number of distributed processes')    
+    parser.add_argument('--dist_url', default='env://', help='url used to set up distributed training')
+    parser.add_argument('--distributed', default=True, type=bool)
+    args = parser.parse_args()
+
+    config = yaml.load(open(args.config, 'r'), Loader=yaml.Loader)
+
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+        
+    yaml.dump(config, open(os.path.join(args.output_dir, 'config.yaml'), 'w'))    
+    
+    main(args, config)

external/Grounded-Segment-Anything/recognize-anything/generate_tag_des_llm.py

@@ -0,0 +1,68 @@
+import openai
+import json
+from tqdm import tqdm
+import argparse
+from ram.utils.openset_utils import openimages_rare_unseen
+
+parser = argparse.ArgumentParser(
+    description='Generate LLM tag descriptions for RAM++ open-set recognition')
+parser.add_argument('--openai_api_key',
+                    default='sk-xxxxx')
+parser.add_argument('--output_file_path',
+                    help='save path of llm tag descriptions',
+                    default='datasets/openimages_rare_200/openimages_rare_200_llm_tag_descriptions.json')
+
+
+def analyze_tags(tag):
+    # Generate LLM tag descriptions
+
+    llm_prompts = [ f"Describe concisely what a(n) {tag} looks like:", \
+                    f"How can you identify a(n) {tag} concisely?", \
+                    f"What does a(n) {tag} look like concisely?",\
+                    f"What are the identifying characteristics of a(n) {tag}:", \
+                    f"Please provide a concise description of the visual characteristics of {tag}:"]
+
+    results = {}
+    result_lines = []
+
+    result_lines.append(f"a photo of a {tag}.")
+
+    for llm_prompt in tqdm(llm_prompts):
+
+        # send message
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "assistant", "content": llm_prompt}],
+            max_tokens=77,
+            temperature=0.99,
+            n=10,
+            stop=None
+        )
+
+        # parse the response
+        for item in response.choices:
+            result_lines.append(item.message['content'].strip())
+        results[tag] = result_lines
+    return results
+
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+
+    # set OpenAI API key
+    openai.api_key = args.openai_api_key
+
+    categories = openimages_rare_unseen
+
+    tag_descriptions = []
+
+    for tag in categories:
+        result = analyze_tags(tag)
+        tag_descriptions.append(result)
+
+    output_file_path = args.output_file_path
+
+    with open(output_file_path, 'w') as w:
+        json.dump(tag_descriptions, w, indent=3)
+

external/Grounded-Segment-Anything/recognize-anything/inference_ram.py

@@ -0,0 +1,54 @@
+'''
+ * The Recognize Anything Model (RAM)
+ * Written by Xinyu Huang
+'''
+import argparse
+import numpy as np
+import random
+
+import torch
+
+from PIL import Image
+from ram.models import ram
+from ram import inference_ram as inference
+from ram import get_transform
+
+
+parser = argparse.ArgumentParser(
+    description='Tag2Text inferece for tagging and captioning')
+parser.add_argument('--image',
+                    metavar='DIR',
+                    help='path to dataset',
+                    default='images/demo/demo1.jpg')
+parser.add_argument('--pretrained',
+                    metavar='DIR',
+                    help='path to pretrained model',
+                    default='pretrained/ram_swin_large_14m.pth')
+parser.add_argument('--image-size',
+                    default=384,
+                    type=int,
+                    metavar='N',
+                    help='input image size (default: 384)')
+
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    transform = get_transform(image_size=args.image_size)
+
+    #######load model
+    model = ram(pretrained=args.pretrained,
+                             image_size=args.image_size,
+                             vit='swin_l')
+    model.eval()
+
+    model = model.to(device)
+
+    image = transform(Image.open(args.image)).unsqueeze(0).to(device)
+
+    res = inference(image, model)
+    print("Image Tags: ", res[0])
+    print("图像标签: ", res[1])

external/Grounded-Segment-Anything/recognize-anything/inference_ram_openset.py

@@ -0,0 +1,68 @@
+'''
+ * The Recognize Anything Model (RAM) inference on unseen classes
+ * Written by Xinyu Huang
+'''
+import argparse
+import numpy as np
+import random
+
+import torch
+
+from PIL import Image
+from ram.models import ram
+from ram import inference_ram_openset as inference
+from ram import get_transform
+
+from ram.utils import build_openset_label_embedding
+from torch import nn
+
+parser = argparse.ArgumentParser(
+    description='Tag2Text inferece for tagging and captioning')
+parser.add_argument('--image',
+                    metavar='DIR',
+                    help='path to dataset',
+                    default='images/openset_example.jpg')
+parser.add_argument('--pretrained',
+                    metavar='DIR',
+                    help='path to pretrained model',
+                    default='pretrained/ram_swin_large_14m.pth')
+parser.add_argument('--image-size',
+                    default=384,
+                    type=int,
+                    metavar='N',
+                    help='input image size (default: 448)')
+
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    transform = get_transform(image_size=args.image_size)
+
+    #######load model
+    model = ram(pretrained=args.pretrained,
+                             image_size=args.image_size,
+                             vit='swin_l')
+    
+    #######set openset interference
+    openset_label_embedding, openset_categories = build_openset_label_embedding()
+
+    model.tag_list = np.array(openset_categories)
+    
+    model.label_embed = nn.Parameter(openset_label_embedding.float())
+
+    model.num_class = len(openset_categories)
+    # the threshold for unseen categories is often lower
+    model.class_threshold = torch.ones(model.num_class) * 0.5
+    #######
+
+    model.eval()
+
+    model = model.to(device)
+
+    image = transform(Image.open(args.image)).unsqueeze(0).to(device)
+
+    res = inference(image, model)
+    print("Image Tags: ", res)

external/Grounded-Segment-Anything/recognize-anything/inference_ram_plus.py

@@ -0,0 +1,54 @@
+'''
+ * The Recognize Anything Plus Model (RAM++)
+ * Written by Xinyu Huang
+'''
+import argparse
+import numpy as np
+import random
+
+import torch
+
+from PIL import Image
+from ram.models import ram_plus
+from ram import inference_ram as inference
+from ram import get_transform
+
+
+parser = argparse.ArgumentParser(
+    description='Tag2Text inferece for tagging and captioning')
+parser.add_argument('--image',
+                    metavar='DIR',
+                    help='path to dataset',
+                    default='images/demo/demo1.jpg')
+parser.add_argument('--pretrained',
+                    metavar='DIR',
+                    help='path to pretrained model',
+                    default='pretrained/ram_plus_swin_large_14m.pth')
+parser.add_argument('--image-size',
+                    default=384,
+                    type=int,
+                    metavar='N',
+                    help='input image size (default: 448)')
+
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    transform = get_transform(image_size=args.image_size)
+
+    #######load model
+    model = ram_plus(pretrained=args.pretrained,
+                             image_size=args.image_size,
+                             vit='swin_l')
+    model.eval()
+
+    model = model.to(device)
+
+    image = transform(Image.open(args.image)).unsqueeze(0).to(device)
+
+    res = inference(image, model)
+    print("Image Tags: ", res[0])
+    print("图像标签: ", res[1])

external/Grounded-Segment-Anything/recognize-anything/inference_ram_plus_openset.py

@@ -0,0 +1,76 @@
+'''
+ * The Recognize Anything Plus Model (RAM++) inference on unseen classes
+ * Written by Xinyu Huang
+'''
+import argparse
+import numpy as np
+import random
+
+import torch
+
+from PIL import Image
+from ram.models import ram_plus
+from ram import inference_ram_openset as inference
+from ram import get_transform
+
+from ram.utils import build_openset_llm_label_embedding
+from torch import nn
+import json
+
+parser = argparse.ArgumentParser(
+    description='Tag2Text inferece for tagging and captioning')
+parser.add_argument('--image',
+                    metavar='DIR',
+                    help='path to dataset',
+                    default='images/openset_example.jpg')
+parser.add_argument('--pretrained',
+                    metavar='DIR',
+                    help='path to pretrained model',
+                    default='pretrained/ram_plus_swin_large_14m.pth')
+parser.add_argument('--image-size',
+                    default=384,
+                    type=int,
+                    metavar='N',
+                    help='input image size (default: 448)')
+parser.add_argument('--llm_tag_des',
+                    metavar='DIR',
+                    help='path to LLM tag descriptions',
+                    default='datasets/openimages_rare_200/openimages_rare_200_llm_tag_descriptions.json')
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    transform = get_transform(image_size=args.image_size)
+
+    #######load model
+    model = ram_plus(pretrained=args.pretrained,
+                             image_size=args.image_size,
+                             vit='swin_l')
+
+    #######set openset interference
+
+    print('Building tag embedding:')
+    with open(args.llm_tag_des, 'rb') as fo:
+        llm_tag_des = json.load(fo)
+    openset_label_embedding, openset_categories = build_openset_llm_label_embedding(llm_tag_des)
+
+    model.tag_list = np.array(openset_categories)
+    
+    model.label_embed = nn.Parameter(openset_label_embedding.float())
+
+    model.num_class = len(openset_categories)
+    # the threshold for unseen categories is often lower
+    model.class_threshold = torch.ones(model.num_class) * 0.5
+    #######
+
+    model.eval()
+
+    model = model.to(device)
+
+    image = transform(Image.open(args.image)).unsqueeze(0).to(device)
+
+    res = inference(image, model)
+    print("Image Tags: ", res)

external/Grounded-Segment-Anything/recognize-anything/inference_tag2text.py

@@ -0,0 +1,69 @@
+'''
+ * The Tag2Text Model
+ * Written by Xinyu Huang
+'''
+import argparse
+import numpy as np
+import random
+
+import torch
+
+from PIL import Image
+from ram.models import tag2text
+from ram import inference_tag2text as inference
+from ram import get_transform
+
+
+parser = argparse.ArgumentParser(
+    description='Tag2Text inferece for tagging and captioning')
+parser.add_argument('--image',
+                    metavar='DIR',
+                    help='path to dataset',
+                    default='images/1641173_2291260800.jpg')
+parser.add_argument('--pretrained',
+                    metavar='DIR',
+                    help='path to pretrained model',
+                    default='pretrained/tag2text_swin_14m.pth')
+parser.add_argument('--image-size',
+                    default=384,
+                    type=int,
+                    metavar='N',
+                    help='input image size (default: 384)')
+parser.add_argument('--thre',
+                    default=0.68,
+                    type=float,
+                    metavar='N',
+                    help='threshold value')
+parser.add_argument('--specified-tags',
+                    default='None',
+                    help='User input specified tags')
+
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    transform = get_transform(image_size=args.image_size)
+
+    # delete some tags that may disturb captioning
+    # 127: "quarter"; 2961: "back", 3351: "two"; 3265: "three"; 3338: "four"; 3355: "five"; 3359: "one"
+    delete_tag_index = [127,2961, 3351, 3265, 3338, 3355, 3359]
+
+    #######load model
+    model = tag2text(pretrained=args.pretrained,
+                             image_size=args.image_size,
+                             vit='swin_b',
+                             delete_tag_index=delete_tag_index)
+    model.threshold = args.thre  # threshold for tagging
+    model.eval()
+
+    model = model.to(device)
+
+    image = transform(Image.open(args.image)).unsqueeze(0).to(device)
+
+    res = inference(image, model, args.specified_tags)
+    print("Model Identified Tags: ", res[0])
+    print("User Specified Tags: ", res[1])
+    print("Image Caption: ", res[2])

external/Grounded-Segment-Anything/recognize-anything/pretrain.py

@@ -0,0 +1,303 @@
+'''
+ * RAM++ & RAM & Tag2Text pretrain
+ * Written by Xinyu Huang
+'''
+import argparse
+import os
+import ruamel.yaml as yaml
+import numpy as np
+import random
+import time
+import datetime
+import json
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+
+from ram.models import ram_plus, ram, tag2text
+import utils
+from utils import warmup_lr_schedule, step_lr_schedule
+from ram.data import create_dataset, create_sampler, create_loader
+
+import clip
+
+def build_text_embed(model_clip, caption):
+    run_on_gpu = torch.cuda.is_available()
+    with torch.no_grad():
+
+        texts = clip.tokenize(caption,truncate = True)  # tokenize
+        if run_on_gpu:
+            texts = texts.cuda()
+            model_clip = model_clip.cuda()
+        text_embeddings = model_clip.encode_text(texts)
+        text_embeddings /= text_embeddings.norm(dim=-1, keepdim=True)
+        # text_embedding = text_embeddings.mean(dim=0)
+        # text_embedding /= text_embedding.norm()
+    return text_embeddings
+
+
+
+def train_ram_plus(model, data_loader, optimizer, epoch, device, config, model_clip):
+    # train
+    model.train()  
+    
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss_tag', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_dis', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_alignment', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50   
+    
+    data_loader.sampler.set_epoch(epoch)
+
+    for i, (image, caption, image_tag, parse_tag) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+        
+        if epoch==0:
+            warmup_lr_schedule(optimizer, i, config['warmup_steps'], config['warmup_lr'], config['init_lr'])
+            
+        optimizer.zero_grad()
+
+        batch_text_embed = build_text_embed(model_clip,caption)
+        
+        image = image.to(device,non_blocking=True)
+
+        with torch.no_grad():
+            clip_image_feature = model_clip.encode_image(image)
+
+        loss_tag, loss_dis, loss_alignment = model(image, caption, image_tag, clip_image_feature, batch_text_embed)  
+        loss = loss_tag + loss_dis + loss_alignment
+
+        loss.backward()
+        optimizer.step()    
+
+        metric_logger.update(loss_tag=loss_tag.item())
+        metric_logger.update(loss_dis=loss_dis.item())
+        metric_logger.update(loss_alignment=loss_alignment.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])  
+
+        
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())     
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}  
+
+
+
+def train_ram(model, data_loader, optimizer, epoch, device, config, model_clip):
+    # train
+    model.train()  
+    
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss_t2t', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_tag', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_dis', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50   
+    
+    data_loader.sampler.set_epoch(epoch)
+
+    for i, (image, caption, image_tag, parse_tag) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+        
+        if epoch==0:
+            warmup_lr_schedule(optimizer, i, config['warmup_steps'], config['warmup_lr'], config['init_lr'])
+            
+        optimizer.zero_grad()
+        
+        image = image.to(device,non_blocking=True)
+
+        with torch.no_grad():
+            clip_image_feature = model_clip.encode_image(image)
+
+        loss_t2t, loss_tag, loss_dis = model(image, caption, image_tag, parse_tag, clip_image_feature)  
+        loss = loss_t2t + loss_tag/(loss_tag/loss_t2t).detach() + loss_dis  
+
+        loss.backward()
+        optimizer.step()    
+
+        metric_logger.update(loss_t2t=loss_t2t.item())
+        metric_logger.update(loss_tag=loss_tag.item())
+        metric_logger.update(loss_dis=loss_dis.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])  
+
+        
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())     
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}  
+
+
+def train_tag2text(model, data_loader, optimizer, epoch, device, config):
+    # train
+    model.train()  
+    
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss_t2t', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    metric_logger.add_meter('loss_tag', utils.SmoothedValue(window_size=50, fmt='{value:.4f}'))
+    
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50   
+    
+    data_loader.sampler.set_epoch(epoch)
+
+    for i, (image, caption, _, parse_tag) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+        
+        if epoch==0:
+            warmup_lr_schedule(optimizer, i, config['warmup_steps'], config['warmup_lr'], config['init_lr'])
+            
+        optimizer.zero_grad()
+        
+        image = image.to(device,non_blocking=True)
+
+        loss_t2t, loss_tag = model(image, caption, parse_tag)  
+        loss = loss_t2t + loss_tag/(loss_tag/loss_t2t).detach()   
+
+        loss.backward()
+        optimizer.step()    
+
+        metric_logger.update(loss_t2t=loss_t2t.item())
+        metric_logger.update(loss_tag=loss_tag.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])  
+
+        
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())     
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}  
+
+
+def main(args, config):
+    utils.init_distributed_mode(args)    
+    
+    device = torch.device(args.device)
+
+    # fix the seed for reproducibility
+    seed = args.seed + utils.get_rank()
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    cudnn.benchmark = True
+
+    #### Dataset #### 
+    print("Creating dataset")
+    datasets = [create_dataset('pretrain', config, min_scale=0.2)]
+    print('number of training samples: %d'%len(datasets[0]))
+
+    num_tasks = utils.get_world_size()
+    global_rank = utils.get_rank()            
+    samplers = create_sampler(datasets, [True], num_tasks, global_rank)         
+
+    data_loader = create_loader(datasets,samplers,batch_size=[config['batch_size']], num_workers=[4], is_trains=[True], collate_fns=[None])[0]      
+    
+    #### Model #### 
+    if args.model_type == 'ram_plus':
+        print("Creating pretrained CLIP model")
+        model_clip, _ = clip.load("ViT-B/16", device=device)
+
+        print("Creating RAM model")
+        model = ram_plus(image_size=config['image_size'], vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], 
+                                vit_ckpt_layer=config['vit_ckpt_layer'], stage = 'train_from_scratch')
+
+    elif args.model_type == 'ram':
+        print("Creating pretrained CLIP model")
+        model_clip, _ = clip.load("ViT-B/16", device=device)
+
+        print("Creating RAM model")
+        model = ram(image_size=config['image_size'], vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], 
+                                vit_ckpt_layer=config['vit_ckpt_layer'], stage = 'train_from_scratch')
+
+    elif args.model_type == 'tag2text':
+        print("Creating Tag2Text model")
+        model = tag2text(image_size=config['image_size'], vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], 
+                                vit_ckpt_layer=config['vit_ckpt_layer'], stage = 'train_from_scratch', tag_list='ram/data/ram_tag_list.txt')
+    model = model.to(device)   
+    
+    ### Frozen CLIP model ###
+    model_clip = model_clip.to(device)
+    for _, param in model_clip.named_parameters():
+        param.requires_grad = False
+
+    ### Frozen label embedding for open-set recogniztion ###
+    model.label_embed.requires_grad = False
+    optimizer = torch.optim.AdamW(filter(lambda x: x.requires_grad, model.parameters()), lr=config['init_lr'], weight_decay=config['weight_decay'])
+    
+    start_epoch = 0
+    if args.checkpoint:    
+        checkpoint = torch.load(args.checkpoint, map_location='cpu') 
+        state_dict = checkpoint['model']    
+        model.load_state_dict(state_dict)    
+        
+        optimizer.load_state_dict(checkpoint['optimizer'])
+        start_epoch = checkpoint['epoch']+1                
+        print('resume checkpoint from %s'%args.checkpoint)    
+    
+    model_without_ddp = model
+    if args.distributed:
+        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
+        model_without_ddp = model.module    
+        
+    print("Start training")
+    start_time = time.time()    
+    for epoch in range(start_epoch, config['max_epoch']):
+        
+        step_lr_schedule(optimizer, epoch, config['init_lr'], config['min_lr'], config['lr_decay_rate'])
+
+        if args.model_type == 'ram_plus':
+            train_stats = train_ram_plus(model, data_loader, optimizer, epoch, device, config, model_clip) 
+        elif args.model_type == 'ram':
+            train_stats = train_ram(model, data_loader, optimizer, epoch, device, config, model_clip) 
+        elif args.model_type == 'tag2text':
+            train_stats = train_tag2text(model, data_loader, optimizer, epoch, device, config) 
+
+        if utils.is_main_process():  
+            log_stats = {**{f'train_{k}': v for k, v in train_stats.items()},
+                         'epoch': epoch,
+                        }                     
+            save_obj = {
+                'model': model_without_ddp.state_dict(),
+                'optimizer': optimizer.state_dict(),
+                'config': config,
+                'epoch': epoch,
+            }
+            torch.save(save_obj, os.path.join(args.output_dir, 'checkpoint_%02d.pth'%epoch))  
+            
+            with open(os.path.join(args.output_dir, "log.txt"),"a") as f:
+                f.write(json.dumps(log_stats) + "\n")
+
+        dist.barrier()        
+                
+    total_time = time.time() - start_time
+    total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+    print('Training time {}'.format(total_time_str)) 
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', default='./configs/pretrain.yaml')
+    parser.add_argument("--model-type",type=str,choices=("ram_plus", "ram", "tag2text"),required=True)
+    parser.add_argument('--output-dir', default='output/Pretrain')  
+    parser.add_argument('--checkpoint', default='')    
+    parser.add_argument('--evaluate', action='store_true')    
+    parser.add_argument('--device', default='cuda')
+    parser.add_argument('--seed', default=42, type=int)
+    parser.add_argument('--world_size', default=1, type=int, help='number of distributed processes')    
+    parser.add_argument('--dist_url', default='env://', help='url used to set up distributed training')
+    parser.add_argument('--distributed', default=True, type=bool)
+    args = parser.parse_args()
+
+    config = yaml.load(open(args.config, 'r'), Loader=yaml.Loader)
+
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+        
+    yaml.dump(config, open(os.path.join(args.output_dir, 'config.yaml'), 'w'))    
+    
+    main(args, config)

external/Grounded-Segment-Anything/recognize-anything/requirements.txt

@@ -0,0 +1,9 @@
+timm==0.4.12
+transformers>=4.25.1
+fairscale==0.4.4
+pycocoevalcap
+torch
+torchvision
+Pillow
+scipy
+clip @ git+https://github.com/openai/CLIP.git

external/Grounded-Segment-Anything/recognize-anything/setup.cfg

@@ -0,0 +1,15 @@
+[metadata]
+name = ram
+version = 0.0.1
+description = Recognize Anything Plus Model, Recognize Anything Model and Tag2Text Model
+
+[options]
+packages = find:
+include_package_data = True
+
+[options.packages.find]
+exclude =
+    datasets
+    images
+    outputs
+    pretrained

external/Grounded-Segment-Anything/recognize-anything/setup.py

@@ -0,0 +1,2 @@
+import setuptools
+setuptools.setup()

external/Grounded-Segment-Anything/recognize-anything/utils.py

@@ -0,0 +1,279 @@
+import math
+def cosine_lr_schedule(optimizer, epoch, max_epoch, init_lr, min_lr):
+    """Decay the learning rate"""
+    lr = (init_lr - min_lr) * 0.5 * (1. + math.cos(math.pi * epoch / max_epoch)) + min_lr
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+        
+def warmup_lr_schedule(optimizer, step, max_step, init_lr, max_lr):
+    """Warmup the learning rate"""
+    lr = min(max_lr, init_lr + (max_lr - init_lr) * step / max_step)
+    for param_group in optimizer.param_groups:
+
+        param_group['lr'] = lr    
+
+def step_lr_schedule(optimizer, epoch, init_lr, min_lr, decay_rate):        
+    """Decay the learning rate"""
+    lr = max(min_lr, init_lr * (decay_rate**epoch))
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr    
+        
+import numpy as np
+import io
+import os
+import time
+from collections import defaultdict, deque
+import datetime
+
+import torch
+import torch.distributed as dist
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not is_dist_avail_and_initialized():
+            return
+        t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
+        dist.barrier()
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value)
+
+
+class MetricLogger(object):
+    def __init__(self, delimiter="\t"):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError("'{}' object has no attribute '{}'".format(
+            type(self).__name__, attr))
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {}".format(name, str(meter))
+            )
+        return self.delimiter.join(loss_str)
+
+    def global_avg(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {:.4f}".format(name, meter.global_avg)
+            )
+        return self.delimiter.join(loss_str)    
+    
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes()
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ''
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt='{avg:.4f}')
+        data_time = SmoothedValue(fmt='{avg:.4f}')
+        space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
+        log_msg = [
+            header,
+            '[{0' + space_fmt + '}/{1}]',
+            'eta: {eta}',
+            '{meters}',
+            'time: {time}',
+            'data: {data}'
+        ]
+        if torch.cuda.is_available():
+            log_msg.append('max mem: {memory:.0f}')
+        log_msg = self.delimiter.join(log_msg)
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0 or i == len(iterable) - 1:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time),
+                        memory=torch.cuda.max_memory_allocated() / MB))
+                else:
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time)))
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print('{} Total time: {} ({:.4f} s / it)'.format(
+            header, total_time_str, total_time / len(iterable)))
+        
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+
+def compute_acc(logits, label, reduction='mean'):
+    ret = (torch.argmax(logits, dim=1) == label).float()
+    if reduction == 'none':
+        return ret.detach()
+    elif reduction == 'mean':
+        return ret.mean().item()
+
+def compute_n_params(model, return_str=True):
+    tot = 0
+    for p in model.parameters():
+        w = 1
+        for x in p.shape:
+            w *= x
+        tot += w
+    if return_str:
+        if tot >= 1e6:
+            return '{:.1f}M'.format(tot / 1e6)
+        else:
+            return '{:.1f}K'.format(tot / 1e3)
+    else:
+        return tot
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop('force', False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+    if is_main_process():
+        torch.save(*args, **kwargs)
+
+
+def init_distributed_mode(args):
+    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
+        args.rank = int(os.environ["RANK"])
+        args.world_size = int(os.environ['WORLD_SIZE'])
+        args.gpu = int(os.environ['LOCAL_RANK'])
+    elif 'SLURM_PROCID' in os.environ:
+        args.rank = int(os.environ['SLURM_PROCID'])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print('Not using distributed mode')
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = 'nccl'
+    print('| distributed init (rank {}, word {}): {}'.format(
+        args.rank, args.world_size, args.dist_url), flush=True)
+    torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+                                         world_size=args.world_size, rank=args.rank)
+    torch.distributed.barrier()
+    setup_for_distributed(args.rank == 0)        
+        
+        

external/Grounded-Segment-Anything/voxelnext_3d_box/README.md

@@ -0,0 +1,72 @@
+# 3D-Box via Segment Anything
+
+We extend [Segment Anything](https://github.com/facebookresearch/segment-anything) to 3D perception by combining it with [VoxelNeXt](https://github.com/dvlab-research/VoxelNeXt). Note that this project is still in progress. We are improving it and developing more examples. Any issue or pull request is welcome!
+
+<p align="center"> <img src="images/sam-voxelnext.png" width="100%"> </p>
+
+## Why this project?
+[Segment Anything](https://github.com/facebookresearch/segment-anything) and its following projects
+focus on 2D images. In this project, we extend the scope to 3D world by combining [Segment Anything](https://github.com/facebookresearch/segment-anything) and [VoxelNeXt](https://github.com/dvlab-research/VoxelNeXt). When we provide a prompt (e.g., a point / box), the result is not only 2D segmentation mask, but also 3D boxes.
+
+The core idea is that [VoxelNeXt](https://github.com/dvlab-research/VoxelNeXt) is a fully sparse 3D detector. It predicts 3D object upon each sparse voxel. We project 3D sparse voxels onto 2D images. And then 3D boxes can be generated for voxels in the SAM mask. 
+
+- This project makes 3D object detection to be promptable.
+- VoxelNeXt is based on sparse voxels that are easy to be related to the mask generated from segment anything.
+- This project could facilitate 3D box labeling. 3D box can be obtained via a simple click on image. It might largely save human efforts, especially on autonuous driving scenes.
+
+## Installation
+1. Basic requirements
+`pip install -r requirements.txt
+`
+2. Segment anything
+`pip install git+https://github.com/facebookresearch/segment-anything.git
+`
+3. spconv
+`pip install spconv
+`
+or cuda version spconv `pip install spconv-cu111` based on your cuda version. Please use spconv 2.2 / 2.3 version, for example spconv==2.3.5
+
+
+## Getting Started
+Please try it via [seg_anything_and_3D.ipynb](seg_anything_and_3D.ipynb).
+We provide this example on nuScenes dataset. You can use other image-points pairs. 
+
+- The demo point for one frame is provided here [points_demo.npy](https://drive.google.com/file/d/1br0VDamameu7B1G1p4HEjj6LshGs5dHB/view?usp=share_link).
+- The point to image translation infos on nuScenes val can be download [here](https://drive.google.com/file/d/1nJqdfs0gMTIo4fjOwytSbM0fdBOJ4IGb/view?usp=share_link).
+- The weight in the demo is [voxelnext_nuscenes_kernel1.pth](https://drive.google.com/file/d/17mQRXXUsaD0dlRzAKep3MQjfj8ugDsp9/view?usp=share_link).
+- The nuScenes info file is [nuscenes_infos_10sweeps_val.pkl](https://drive.google.com/file/d/1Kaxtubzr1GofcoFz97S6qwAIG2wzhPo_/view?usp=share_link). This is generated from [OpenPCDet](https://github.com/open-mmlab/OpenPCDet) codebase.
+
+
+<p align="center"> <img src="images/mask_box.png" width="100%"> </p>
+<p align="center"> <img src="images/image_boxes1.png" width="100%"> </p>
+<p align="center"> <img src="images/image_boxes2.png" width="100%"> </p>
+<p align="center"> <img src="images/image_boxes3.png" width="100%"> </p>
+
+## TODO List
+- - [ ] Zero-shot version VoxelNeXt.
+- - [ ] Examples on more datasets.
+- - [ ] Indoor scenes.
+
+## Citation 
+If you find this project useful in your research, please consider citing:
+```
+@article{kirillov2023segany,
+  title={Segment Anything}, 
+  author={Kirillov, Alexander and Mintun, Eric and Ravi, Nikhila and Mao, Hanzi and Rolland, Chloe and Gustafson, Laura and Xiao, Tete and Whitehead, Spencer and Berg, Alexander C. and Lo, Wan-Yen and Doll{\'a}r, Piotr and Girshick, Ross},
+  journal={arXiv:2304.02643},
+  year={2023}
+}
+
+@inproceedings{chen2023voxenext,
+  title={VoxelNeXt: Fully Sparse VoxelNet for 3D Object Detection and Tracking},
+  author={Yukang Chen and Jianhui Liu and Xiangyu Zhang and Xiaojuan Qi and Jiaya Jia},
+  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+  year={2023}
+}
+
+```
+
+## Acknowledgement
+-  [Segment Anything](https://github.com/facebookresearch/segment-anything)
+- [VoxelNeXt](https://github.com/dvlab-research/VoxelNeXt)
+- [UVTR](https://github.com/dvlab-research/UVTR) for 3D to 2D translation.

external/Grounded-Segment-Anything/voxelnext_3d_box/config.yaml

@@ -0,0 +1,56 @@
+SAM_TYPE: "vit_h"
+SAM_CHECKPOINT: "sam_vit_h_4b8939.pth"
+
+POINT_CLOUD_RANGE: [-51.2, -51.2, -5.0, 51.2, 51.2, 3.0]
+USED_FEATURE_LIST: ['x', 'y', 'z', 'intensity', 'timestamp']
+DATA_PROCESSOR:
+    - NAME: mask_points_and_boxes_outside_range
+      REMOVE_OUTSIDE_BOXES: True
+
+    - NAME: shuffle_points
+      SHUFFLE_ENABLED: {
+        'train': True,
+        'test': True
+      }
+
+    - NAME: transform_points_to_voxels
+      VOXEL_SIZE: [0.075, 0.075, 0.2]
+      MAX_POINTS_PER_VOXEL: 10
+      MAX_NUMBER_OF_VOXELS: {
+        'train': 120000,
+        'test': 160000
+      }
+
+VOXELNEXT_CHECKPOINT: "voxelnext_nuscenes_kernel1.pth"
+INPUT_CHANNELS: 5
+GRID_SIZE: [1440, 1440, 40]
+
+CLASS_NAMES: ['car','truck', 'construction_vehicle', 'bus', 'trailer',
+  'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone']
+
+KERNEL_SIZE_HEAD: 1
+
+VOXEL_SIZE: [0.075, 0.075, 0.2]
+CLASS_NAMES_EACH_HEAD: [
+  ['car'],
+  ['truck', 'construction_vehicle'],
+  ['bus', 'trailer'],
+  ['barrier'],
+  ['motorcycle', 'bicycle'],
+  ['pedestrian', 'traffic_cone'],
+]
+
+SEPARATE_HEAD_CFG:
+    HEAD_ORDER: ['center', 'center_z', 'dim', 'rot', 'vel']
+    HEAD_DICT: {
+        'center': {'out_channels': 2, 'num_conv': 2},
+        'center_z': {'out_channels': 1, 'num_conv': 2},
+        'dim': {'out_channels': 3, 'num_conv': 2},
+        'rot': {'out_channels': 2, 'num_conv': 2},
+        'vel': {'out_channels': 2, 'num_conv': 2},
+    }
+
+POST_PROCESSING:
+    SCORE_THRESH: 0
+    POST_CENTER_LIMIT_RANGE: [-61.2, -61.2, -10.0, 61.2, 61.2, 10.0]
+    MAX_OBJ_PER_SAMPLE: 500

external/Grounded-Segment-Anything/voxelnext_3d_box/model.py

@@ -0,0 +1,142 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from .models.data_processor import DataProcessor
+from .models.mean_vfe import MeanVFE
+from .models.spconv_backbone_voxelnext import VoxelResBackBone8xVoxelNeXt
+from .models.voxelnext_head import VoxelNeXtHead
+
+from .utils.image_projection import _proj_voxel_image
+from segment_anything import SamPredictor, sam_model_registry
+
+class VoxelNeXt(nn.Module):
+    def __init__(self, model_cfg):
+        super().__init__()
+
+        point_cloud_range = np.array(model_cfg.POINT_CLOUD_RANGE, dtype=np.float32)
+
+        self.data_processor = DataProcessor(
+            model_cfg.DATA_PROCESSOR, point_cloud_range=point_cloud_range,
+            training=False, num_point_features=len(model_cfg.USED_FEATURE_LIST)
+        )
+
+        input_channels = model_cfg.get('INPUT_CHANNELS', 5)
+        grid_size = np.array(model_cfg.get('GRID_SIZE', [1440, 1440, 40]))
+
+        class_names = model_cfg.get('CLASS_NAMES')
+        kernel_size_head = model_cfg.get('KERNEL_SIZE_HEAD', 1)
+        self.point_cloud_range = torch.Tensor(model_cfg.get('POINT_CLOUD_RANGE', [-51.2, -51.2, -5.0, 51.2, 51.2, 3.0]))
+        self.voxel_size = torch.Tensor(model_cfg.get('VOXEL_SIZE', [0.075, 0.075, 0.2]))
+        CLASS_NAMES_EACH_HEAD = model_cfg.get('CLASS_NAMES_EACH_HEAD')
+        SEPARATE_HEAD_CFG = model_cfg.get('SEPARATE_HEAD_CFG')
+        POST_PROCESSING = model_cfg.get('POST_PROCESSING')
+        self.voxelization = MeanVFE()
+        self.backbone_3d = VoxelResBackBone8xVoxelNeXt(input_channels, grid_size)
+        self.dense_head = VoxelNeXtHead(class_names, self.point_cloud_range, self.voxel_size, kernel_size_head,
+                 CLASS_NAMES_EACH_HEAD, SEPARATE_HEAD_CFG, POST_PROCESSING)
+
+
+class Model(nn.Module):
+    def __init__(self, model_cfg, device="cuda"):
+        super().__init__()
+
+        sam_type = model_cfg.get('SAM_TYPE', "vit_b")
+        sam_checkpoint = model_cfg.get('SAM_CHECKPOINT', "/data/sam_vit_b_01ec64.pth")
+
+        sam = sam_model_registry[sam_type](checkpoint=sam_checkpoint).to(device=device)
+        self.sam_predictor = SamPredictor(sam)
+
+        voxelnext_checkpoint = model_cfg.get('VOXELNEXT_CHECKPOINT', "/data/voxelnext_nuscenes_kernel1.pth")
+        model_dict = torch.load(voxelnext_checkpoint)
+        self.voxelnext = VoxelNeXt(model_cfg).to(device=device)
+        self.voxelnext.load_state_dict(model_dict)
+        self.point_features = {}
+        self.device = device
+
+    def image_embedding(self, image):
+        self.sam_predictor.set_image(image)
+
+    def point_embedding(self, data_dict, image_id):
+        data_dict = self.voxelnext.data_processor.forward(
+            data_dict=data_dict
+        )
+        data_dict['voxels'] = torch.Tensor(data_dict['voxels']).to(self.device)
+        data_dict['voxel_num_points'] = torch.Tensor(data_dict['voxel_num_points']).to(self.device)
+        data_dict['voxel_coords'] = torch.Tensor(data_dict['voxel_coords']).to(self.device)
+
+        data_dict = self.voxelnext.voxelization(data_dict)
+        n_voxels = data_dict['voxel_coords'].shape[0]
+        device = data_dict['voxel_coords'].device
+        dtype = data_dict['voxel_coords'].dtype
+        data_dict['voxel_coords'] = torch.cat([torch.zeros((n_voxels, 1), device=device, dtype=dtype), data_dict['voxel_coords']], dim=1)
+        data_dict['batch_size'] = 1
+
+        if not image_id in self.point_features:
+            data_dict = self.voxelnext.backbone_3d(data_dict)
+            self.point_features[image_id] = data_dict
+        else:
+            data_dict = self.point_features[image_id]
+        pred_dicts = self.voxelnext.dense_head(data_dict)
+
+        voxel_coords = data_dict['out_voxels'][pred_dicts[0]['voxel_ids'].squeeze(-1)] * self.voxelnext.dense_head.feature_map_stride
+
+        return pred_dicts, voxel_coords
+
+    def generate_3D_box(self, lidar2img_rt, mask, voxel_coords, pred_dicts, quality_score=0.1):
+        device = voxel_coords.device
+        points_image, depth = _proj_voxel_image(voxel_coords, lidar2img_rt, self.voxelnext.voxel_size.to(device), self.voxelnext.point_cloud_range.to(device))
+        points = points_image.permute(1, 0).int().cpu().numpy()
+        selected_voxels = torch.zeros_like(depth).squeeze(0)
+
+        for i in range(points.shape[0]):
+            point = points[i]
+            if point[0] < 0 or point[1] < 0 or point[0] >= mask.shape[1] or point[1] >= mask.shape[0]:
+                continue
+            if mask[point[1], point[0]]:
+                selected_voxels[i] = 1
+
+        mask_extra = (pred_dicts[0]['pred_scores'] > quality_score)
+        if mask_extra.sum() == 0:
+            print("no high quality 3D box related.")
+            return None
+
+        selected_voxels *= mask_extra
+        if selected_voxels.sum() > 0:
+            selected_box_id = pred_dicts[0]['pred_scores'][selected_voxels.bool()].argmax()
+            selected_box = pred_dicts[0]['pred_boxes'][selected_voxels.bool()][selected_box_id]
+        else:
+            grid_x, grid_y = torch.meshgrid(torch.arange(mask.shape[0]), torch.arange(mask.shape[1]))
+            mask_x, mask_y = grid_x[mask], grid_y[mask]
+            mask_center = torch.Tensor([mask_y.float().mean(), mask_x.float().mean()]).to(
+                pred_dicts[0]['pred_boxes'].device).unsqueeze(1)
+
+            dist = ((points_image - mask_center) ** 2).sum(0)
+            selected_id = dist[mask_extra].argmin()
+            selected_box = pred_dicts[0]['pred_boxes'][mask_extra][selected_id]
+        return selected_box
+
+    def forward(self, image, point_dict, prompt_point, lidar2img_rt, image_id, quality_score=0.1):
+        self.image_embedding(image)
+        pred_dicts, voxel_coords = self.point_embedding(point_dict, image_id)
+
+        masks, scores, _ = self.sam_predictor.predict(point_coords=prompt_point, point_labels=np.array([1]))
+        mask = masks[0]
+
+        box3d = self.generate_3D_box(lidar2img_rt, mask, voxel_coords, pred_dicts, quality_score=quality_score)
+        return mask, box3d
+
+
+if __name__ == '__main__':
+    cfg_dataset = 'nuscenes_dataset.yaml'
+    cfg_model = 'config.yaml'
+
+    dataset_cfg = cfg_from_yaml_file(cfg_dataset, cfg)
+    model_cfg = cfg_from_yaml_file(cfg_model, cfg)
+
+    nuscenes_dataset = NuScenesDataset(dataset_cfg)
+    model = Model(model_cfg)
+
+    index = 0
+    data_dict = nuscenes_dataset._get_points(index)
+    model.point_embedding(data_dict)
+

external/Grounded-Segment-Anything/voxelnext_3d_box/requirements.txt

@@ -0,0 +1,10 @@
+numpy
+torch
+torchvision
+easydict
+pyyaml
+opencv-python
+pycocotools
+matplotlib
+onnxruntime
+onnx

external/PerspectiveFields/.gitattributes

@@ -0,0 +1,6 @@
+models/paramnet_360cities_edina_rpf.pth filter=lfs diff=lfs merge=lfs -text
+models/paramnet_gsv_rpfpp.pth filter=lfs diff=lfs merge=lfs -text
+models/paramnet_gsv_rpf.pth filter=lfs diff=lfs merge=lfs -text
+assets/imgs/ filter=lfs diff=lfs merge=lfs -text
+models/cvpr2023.pth filter=lfs diff=lfs merge=lfs -text
+models/paramnet_360cities_edina_rpfpp.pth filter=lfs diff=lfs merge=lfs -text

external/PerspectiveFields/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+*/__pycache__/*
+.python-version
+*.so
+*.pyc
+*.egg-info/
+*.pth
+*/.ipynb_checkpoints/*
+.ipynb_checkpoints/
+flagged/

external/PerspectiveFields/LICENSE

@@ -0,0 +1,15 @@
+Adobe Research License Terms
+
+1. You may use, reproduce, modify, and display the research materials provided under this license (the “Research
+Materials”) solely for noncommercial purposes. Noncommercial purposes include academic research, teaching, and
+testing, but do not include commercial licensing or distribution, development of commercial products, or any other
+activity which results in commercial gain. You may not redistribute the Research Materials.
+
+2. You agree to (a) comply with all laws and regulations applicable to your use of the Research Materials under this license,
+including but not limited to any import or export laws; (b) preserve any copyright or other notices from the Research
+Materials; and (c) for any Research Materials in object code, not attempt to modify, reverse engineer, or decompile
+such Research Materials except as permitted by applicable law.
+
+3. THE RESEARCH MATERIALS ARE PROVIDED “AS IS,” WITHOUT WARRANTY OF ANY KIND, AND YOU ASSUME ALL RISKS
+ASSOCIATED WITH THEIR USE. IN NO EVENT WILL ANYONE BE LIABLE TO YOU FOR ANY ACTUAL, INCIDENTAL, SPECIAL,
+OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION WITH USE OF THE RESEARCH MATERIALS.

external/PerspectiveFields/README.md

@@ -0,0 +1,220 @@
+<!-- omit in toc -->
+Perspective Fields for Single Image Camera Calibration
+================================================================
+[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/jinlinyi/PerspectiveFields)
+
+###  [Project Page](https://jinlinyi.github.io/PerspectiveFields/)  | [Paper](https://arxiv.org/abs/2212.03239) | [Live Demo 🤗](https://huggingface.co/spaces/jinlinyi/PerspectiveFields)
+
+CVPR 2023 (✨Highlight)
+<h4>
+
+[Linyi Jin](https://jinlinyi.github.io/)<sup>1</sup>, [Jianming Zhang](https://jimmie33.github.io/)<sup>2</sup>, [Yannick Hold-Geoffroy](https://yannickhold.com/)<sup>2</sup>, [Oliver Wang](http://www.oliverwang.info/)<sup>2</sup>, [Kevin Matzen](http://kmatzen.com/)<sup>2</sup>, [Matthew Sticha](https://www.linkedin.com/in/matthew-sticha-746325202/)<sup>1</sup>, [David Fouhey](https://web.eecs.umich.edu/~fouhey/)<sup>1</sup>
+
+<span style="font-size: 14pt; color: #555555">
+ <sup>1</sup>University of Michigan, <sup>2</sup>Adobe Research
+</span>
+</h4>
+<hr>
+
+<p align="center">
+
+![alt text](assets/teaser-field.jpg)
+</p>
+We propose Perspective Fields as a representation that models the local perspective properties of an image. Perspective Fields contain per-pixel information about the camera view, parameterized as an up vector and a latitude value. 
+
+<p align="center">
+<img height="100" alt="swiping-1" src="assets/swiping-1.gif"> <img height="100" alt="swiping-2" src="assets/swiping-2.gif"> <img height="100" alt="swiping-3" src="assets/swiping-3.gif"> <img height="100" alt="swiping-4" src="assets/swiping-4.gif">
+</p>
+
+📷 From Perspective Fields, you can also get camera parameters if you assume certain camera models. We provide models to recover camera roll, pitch, fov and principal point location.
+
+<p align="center">
+  <img src="assets/vancouver/IMG_2481.jpg" alt="Image 1" height="200px" style="margin-right:10px;">
+  <img src="assets/vancouver/pred_pers.png" alt="Image 2" height="200px" style="margin-center:10px;">
+  <img src="assets/vancouver/pred_param.png" alt="Image 2" height="200px" style="margin-left:10px;">
+</p>
+
+<!-- omit in toc -->
+Updates
+------------------
+- [April 2024]: 🚀 We've launched an inference version (`main` branch) with minimal dependencies. For training and evaluation, please checkout [`train_eval` branch](https://github.com/jinlinyi/PerspectiveFields/tree/train_eval). 
+- [July 2023]: We released a new model trained on [360cities](https://www.360cities.net/) and [EDINA](https://github.com/tien-d/EgoDepthNormal/blob/main/README_dataset.md) dataset, consisting of indoor🏠, outdoor🏙️, natural🌳, and egocentric👋 data!
+- [May 2023]: Live demo released 🤗. https://huggingface.co/spaces/jinlinyi/PerspectiveFields. Thanks Huggingface for funding this demo!
+
+<!-- omit in toc -->
+Table of Contents
+------------------
+- [Environment Setup](#environment-setup)
+  - [Inference](#inference)
+  - [Train / Eval](#train--eval)
+- [Demo](#demo)
+- [Model Zoo](#model-zoo)
+- [Coordinate Frame](#coordinate-frame)
+- [Camera Parameters to Perspective Fields](#camera-parameters-to-perspective-fields)
+- [Visualize Perspective Fields](#visualize-perspective-fields)
+- [Citation](#citation)
+- [Acknowledgment](#acknowledgment)
+
+
+[1]: ./docs/environment.md
+[2]: ./jupyter-notebooks/camera2perspective.ipynb
+[3]: ./jupyter-notebooks/predict_perspective_fields.ipynb
+[4]: ./jupyter-notebooks/perspective_paramnet.ipynb
+[5]: ./docs/train.md
+[6]: ./docs/test.md
+[7]: ./docs/models.md
+
+
+
+## Environment Setup
+### Inference
+PerspectiveFields requires python >= 3.8 and [PyTorch](https://pytorch.org/).
+| ***Pro tip:*** *use [mamba](https://github.com/conda-forge/miniforge) in place of conda for much faster installs.*
+```bash
+# install pytorch compatible to your system https://pytorch.org/get-started/previous-versions/
+conda install pytorch=1.10.0 torchvision cudatoolkit=11.3 -c pytorch
+pip install git+https://github.com/jinlinyi/PerspectiveFields.git
+```
+Alternatively, install the package locally,
+```bash
+git clone git@github.com:jinlinyi/PerspectiveFields.git
+# create virtual env
+conda create -n perspective python=3.9
+conda activate perspective
+# install pytorch compatible to your system https://pytorch.org/get-started/previous-versions/
+# conda install pytorch torchvision cudatoolkit -c pytorch
+conda install pytorch=1.10.0 torchvision cudatoolkit=11.3 -c pytorch
+# install Perspective Fields.
+cd PerspectiveFields
+pip install -e .
+```
+
+### Train / Eval
+For training and evaluation, please checkout the [`train_eval` branch](https://github.com/jinlinyi/PerspectiveFields/tree/train_eval).
+
+
+## Demo
+Here is a minimal script to run on a single image, see [`demo/demo.py`](demo/demo.py):
+```python
+import cv2
+from perspective2d import PerspectiveFields
+# specify model version
+version = 'Paramnet-360Cities-edina-centered'
+# load model
+pf_model = PerspectiveFields(version).eval().cuda()
+# load image
+img_bgr = cv2.imread('assets/imgs/cityscape.jpg')
+# inference
+predictions = pf_model.inference(img_bgr=img_bgr)
+
+# alternatively, inference a batch of images
+predictions = pf_model.inference_batch(img_bgr_list=[img_bgr_0, img_bgr_1, img_bgr_2])
+```
+- Or checkout [Live Demo 🤗](https://huggingface.co/spaces/jinlinyi/PerspectiveFields). 
+- Notebook to [Predict Perspective Fields](./notebooks/predict_perspective_fields.ipynb). 
+
+
+## Model Zoo
+| Model Name and Weights                                                                                                    | Training Dataset                                                                                                          | Config File                                  | Outputs                                                           | Expected input                                                                                     |
+| ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| [NEW][Paramnet-360Cities-edina-centered](https://www.dropbox.com/s/z2dja70bgy007su/paramnet_360cities_edina_rpf.pth)       | [360cities](https://www.360cities.net/) and [EDINA](https://github.com/tien-d/EgoDepthNormal/blob/main/README_dataset.md) | [paramnet_360cities_edina_rpf.yaml](models/paramnet_360cities_edina_rpf.yaml) | Perspective Field + camera parameters (roll, pitch, vfov)         | Uncropped, indoor🏠, outdoor🏙️, natural🌳, and egocentric👋 data                              |
+| [NEW][Paramnet-360Cities-edina-uncentered](https://www.dropbox.com/s/nt29e1pi83mm1va/paramnet_360cities_edina_rpfpp.pth)  | [360cities](https://www.360cities.net/) and [EDINA](https://github.com/tien-d/EgoDepthNormal/blob/main/README_dataset.md) | [paramnet_360cities_edina_rpfpp.yaml](models/paramnet_360cities_edina_rpfpp.yaml) | Perspective Field + camera parameters (roll, pitch, vfov, cx, cy) | Cropped, indoor🏠, outdoor🏙️, natural🌳, and egocentric👋 data                                |
+| [PersNet-360Cities](https://www.dropbox.com/s/czqrepqe7x70b7y/cvpr2023.pth)                                               | [360cities](https://www.360cities.net)                                                                                    | [cvpr2023.yaml](models/cvpr2023.yaml)              | Perspective Field                                                 | Indoor🏠, outdoor🏙️, and natural🌳 data.                                                     |
+| [PersNet_paramnet-GSV-centered](https://www.dropbox.com/s/g6xwbgnkggapyeu/paramnet_gsv_rpf.pth)                           | [GSV](https://research.google/pubs/pub36899/)                                                                             | [paramnet_gsv_rpf.yaml](models/paramnet_gsv_rpf.yaml)      | Perspective Field + camera parameters (roll, pitch, vfov)         | Uncropped, street view🏙️ data.                                                              |
+| [PersNet_Paramnet-GSV-uncentered](https://www.dropbox.com/s/ufdadxigewakzlz/paramnet_gsv_rpfpp.pth)                       | [GSV](https://research.google/pubs/pub36899/)                                                                             | [paramnet_gsv_rpfpp.yaml](models/paramnet_gsv_rpfpp.yaml)    | Perspective Field + camera parameters (roll, pitch, vfov, cx, cy) | Cropped, street view🏙️ data.                                                               |
+
+## Coordinate Frame
+
+<p align="center">
+
+![alt text](assets/coordinate.png)
+
+`yaw / azimuth`: camera rotation about the y-axis
+`pitch / elevation`: camera rotation about the x-axis
+`roll`: camera rotation about the z-axis
+
+Extrinsics: `rotz(roll).dot(rotx(elevation)).dot(roty(azimuth))`
+
+</p>
+
+
+## Camera Parameters to Perspective Fields
+Checkout [Jupyter Notebook](./notebooks/camera2perspective.ipynb). 
+Perspective Fields can be calculated from camera parameters. If you prefer, you can also manually calculate the corresponding Up-vector and Latitude map by following Equations 1 and 2 in our paper.
+Our code currently supports:
+1) [Pinhole model](https://hedivision.github.io/Pinhole.html) [Hartley and Zisserman 2004] (Perspective Projection) 
+```python
+from perspective2d.utils.panocam import PanoCam
+# define parameters
+roll = 0
+pitch = 20
+vfov = 70
+width = 640
+height = 480
+# get Up-vectors.
+up = PanoCam.get_up(np.radians(vfov), width, height, np.radians(pitch), np.radians(roll))
+# get Latitude.
+lati = PanoCam.get_lat(np.radians(vfov), width, height, np.radians(pitch), np.radians(roll))
+```
+2) [Unified Spherical Model](https://drive.google.com/file/d/1pZgR3wNS6Mvb87W0ixOHmEVV6tcI8d50/view) [Barreto 2006; Mei and Rives 2007] (Distortion). 
+```python
+xi = 0.5 # distortion parameter from Unified Spherical Model
+
+x = -np.sin(np.radians(vfov/2))
+z = np.sqrt(1 - x**2)
+f_px_effective = -0.5*(width/2)*(xi+z)/x
+crop, _, _, _, up, lat, xy_map = PanoCam.crop_distortion(equi_img,
+                                             f=f_px_effective,
+                                             xi=xi,
+                                             H=height,
+                                             W=width,
+                                             az=yaw, # degrees
+                                             el=-pitch,
+                                             roll=-roll)
+```
+
+## Visualize Perspective Fields
+We provide a one-line code to blend Perspective Fields onto input image.
+```python
+import matplotlib.pyplot as plt
+from perspective2d.utils import draw_perspective_fields
+# Draw up and lati on img. lati is in radians.
+blend = draw_perspective_fields(img, up, lati)
+# visualize with matplotlib
+plt.imshow(blend)
+plt.show()
+```
+Perspective Fields can serve as an easy visual check for correctness of the camera parameters.
+
+- For example, we can visualize the Perspective Fields based on calibration results from this awesome [repo](https://github.com/dompm/spherical-distortion-dataset).
+
+
+<p align="center">
+
+![alt text](assets/distortion_vis.png)
+
+- Left: We plot the perspective fields based on the numbers printed on the image, they look accurate😊;
+
+- Mid: If we try a number that is 10% off (0.72*0.9=0.648), we see mismatch in Up directions at the top right corner;
+
+- Right: If distortion is 20% off (0.72*0.8=0.576), the mismatch becomes more obvious.
+</p>
+
+
+Citation
+--------
+If you find this code useful, please consider citing:
+
+```text
+@inproceedings{jin2023perspective,
+      title={Perspective Fields for Single Image Camera Calibration},
+      author={Linyi Jin and Jianming Zhang and Yannick Hold-Geoffroy and Oliver Wang and Kevin Matzen and Matthew Sticha and David F. Fouhey},
+      booktitle = {CVPR},
+      year={2023}
+}
+```
+
+Acknowledgment
+--------------
+This work was partially funded by the DARPA Machine Common Sense Program.
+We thank authors from [A Deep Perceptual Measure for Lens and Camera Calibration](https://github.com/dompm/spherical-distortion-dataset) for releasing their code on Unified Spherical Model.

external/PerspectiveFields/demo/demo.py

@@ -0,0 +1,165 @@
+import cv2
+import torch
+import os
+import numpy as np
+from perspective2d import PerspectiveFields
+from perspective2d.utils import draw_perspective_fields, draw_from_r_p_f_cx_cy
+
+
+
+def log_results(img_rgb, pred, output_folder, param_on):
+    """
+    Save perspective field prediction visualizations.
+
+    Args:
+        img_rgb (np.ndarray): The input image in RGB format.
+        pred (dict): The model predictions.
+        output_folder (str): The path to save the visualizations to.
+        param_on (bool): A flag indicating whether to include parameter predictions.
+
+    Returns:
+        None
+    """
+    def resize_fix_aspect_ratio(img, field, target_width=None, target_height=None):
+        """
+        Resize image and perspective field to target width or height while maintaining aspect ratio.
+        """
+        height = img.shape[0]
+        width = img.shape[1]
+        if target_height is None:
+            factor = target_width / width
+        elif target_width is None:
+            factor = target_height / height
+        else:
+            factor = max(target_width / width, target_height / height)
+        if factor == target_width / width:
+            target_height = int(height * factor)
+        else:
+            target_width = int(width * factor)
+
+        img = cv2.resize(img, (target_width, target_height))
+        for key in field:
+            if key not in ["up", "lati"]:
+                continue
+            tmp = field[key].numpy()
+            transpose = len(tmp.shape) == 3
+            if transpose:
+                tmp = tmp.transpose(1, 2, 0)
+            tmp = cv2.resize(tmp, (target_width, target_height))
+            if transpose:
+                tmp = tmp.transpose(2, 0, 1)
+            field[key] = torch.tensor(tmp)
+        return img, field
+
+    os.makedirs(output_folder, exist_ok=True)
+    field = {
+        "up": pred["pred_gravity_original"].cpu().detach(),
+        "lati": pred["pred_latitude_original"].cpu().detach(),
+    }
+    img_rgb, field = resize_fix_aspect_ratio(img_rgb, field, 640)
+    pred_vis = draw_perspective_fields(
+        img_rgb, field["up"], torch.deg2rad(field["lati"]), color=(0,1,0), return_img=False
+    )
+    pred_vis.save(os.path.join(output_folder, "perspective_pred"))
+    
+    if not param_on:
+        return
+
+    # Draw perspective field from ParamNet predictions
+    param_vis = draw_from_r_p_f_cx_cy(
+        img_rgb,
+        pred["pred_roll"].item(),
+        pred["pred_pitch"].item(),
+        pred["pred_general_vfov"].item(),
+        pred["pred_rel_cx"].item(),
+        pred["pred_rel_cy"].item(),
+        "deg",
+        up_color=(0, 1, 0),
+    ).astype(np.uint8)
+
+    param_vis = cv2.cvtColor(param_vis, cv2.COLOR_RGB2BGR)
+    pred_roll = f"roll: {pred['pred_roll'].item() :.2f}"
+    pred_pitch = f"pitch: {pred['pred_pitch'].item() :.2f}"
+    pred_vfov = f"vfov: {pred['pred_general_vfov'].item() :.2f}"
+    pred_cx = f"cx: {pred['pred_rel_cx'].item() :.2f}"
+    pred_cy = f"cy: {pred['pred_rel_cy'].item() :.2f}"
+
+    print(pred_roll)
+    print(pred_pitch)
+    print(pred_vfov)
+    print(pred_cx)
+    print(pred_cy)
+    # Write parameter predictions on the visualization
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = 0.75
+    param_vis = cv2.putText(
+        param_vis,
+        pred_roll,
+        (int(param_vis.shape[1] * 0.6) - 2, int(param_vis.shape[0] * 0.1)),
+        font,
+        font_scale,
+        (0, 0, 255),
+        2,
+    )
+    param_vis = cv2.putText(
+        param_vis,
+        pred_pitch,
+        (int(param_vis.shape[1] * 0.6) - 2, int(param_vis.shape[0] * 0.1) + 25),
+        font,
+        font_scale,
+        (0, 0, 255),
+        2,
+    )
+    param_vis = cv2.putText(
+        param_vis,
+        pred_vfov,
+        (int(param_vis.shape[1] * 0.6) - 2, int(param_vis.shape[0] * 0.1) + 50),
+        font,
+        font_scale,
+        (0, 0, 255),
+        2,
+    )
+    param_vis = cv2.putText(
+        param_vis,
+        pred_cx,
+        (int(param_vis.shape[1] * 0.6) - 2, int(param_vis.shape[0] * 0.1) + 75),
+        font,
+        font_scale,
+        (0, 0, 255),
+        2,
+    )
+    param_vis = cv2.putText(
+        param_vis,
+        pred_cy,
+        (int(param_vis.shape[1] * 0.6) - 2, int(param_vis.shape[0] * 0.1) + 100),
+        font,
+        font_scale,
+        (0, 0, 255),
+        2,
+    )
+    cv2.imwrite(os.path.join(output_folder, "param_pred.png"), param_vis)
+
+
+PerspectiveFields.versions()
+
+version = 'Paramnet-360Cities-edina-centered'
+# version = 'Paramnet-360Cities-edina-uncentered'
+# version = 'PersNet_Paramnet-GSV-centered'
+# version = 'PersNet_Paramnet-GSV-uncentered'
+# version = 'PersNet-360Cities'
+pf_model = PerspectiveFields(version).eval().cuda()
+img_bgr = cv2.imread('assets/imgs/cityscape.jpg')
+predictions = pf_model.inference(img_bgr=img_bgr)
+
+log_results(img_bgr[..., ::-1], predictions, output_folder="debug", param_on=pf_model.param_on)
+
+print("\nexpected output: ")
+print("""roll: 4.54
+pitch: 48.88
+vfov: 52.82
+cx: 0.00
+cy: 0.00""")
+
+print("Alternatively, inference a batch of images")
+predictions = pf_model.inference_batch(img_bgr_list=[img_bgr, img_bgr, img_bgr])
+breakpoint()

external/PerspectiveFields/perspective2d/__init__.py

@@ -0,0 +1,2 @@
+from .perspectivefields import PerspectiveFields
+

external/PerspectiveFields/perspective2d/config/__init__.py

@@ -0,0 +1 @@
+from .config import get_perspective2d_cfg_defaults

external/PerspectiveFields/perspective2d/config/config.py

@@ -0,0 +1,137 @@
+from yacs.config import CfgNode as CN
+
+
+def get_perspective2d_cfg_defaults():
+    """
+    PerspectiveNet and ParamNet configs.
+    """
+    cfg = CN()
+    cfg.VIS_PERIOD = 100
+    cfg.INPUT = CN()
+    cfg.INPUT.ONLINE_CROP = False
+    cfg.INPUT.FORMAT = "BGR"
+    cfg.DATASETS = CN()
+    cfg.DATASETS.TRAIN = []
+    cfg.DATASETS.TEST = []
+
+    cfg.DATALOADER = CN()
+    cfg.DATALOADER.AUGMENTATION = False
+    cfg.DATALOADER.AUGMENTATION_TYPE = "geometry"
+    cfg.DATALOADER.RESIZE = [320, 320]  # Height, Width
+    cfg.DATALOADER.AUGMENTATION_FUN = "default"
+    cfg.DATALOADER.NO_GEOMETRY_AUG = False  # requested by R3 cvpr2023
+
+    cfg.MODEL = CN()
+    cfg.MODEL.GRAVITY_ON = False
+    cfg.MODEL.LATITUDE_ON = False
+    cfg.MODEL.RECOVER_RPF = False
+    cfg.MODEL.RECOVER_PP = False
+
+    cfg.MODEL.BACKBONE = CN()
+    cfg.MODEL.BACKBONE.NAME = "mitb3"
+
+    cfg.MODEL.PERSFORMER_HEADS = CN()
+    cfg.MODEL.WEIGHTS = ""
+    cfg.MODEL.PERSFORMER_HEADS.NAME = "StandardPersformerHeads"
+    cfg.MODEL.LATITUDE_DECODER = CN()
+    cfg.MODEL.LATITUDE_DECODER.NAME = "LatitudeDecoder"
+    cfg.MODEL.LATITUDE_DECODER.LOSS_WEIGHT = 1.0
+    cfg.MODEL.LATITUDE_DECODER.LOSS_TYPE = "regression"
+    cfg.MODEL.LATITUDE_DECODER.NUM_CLASSES = 1
+    cfg.MODEL.LATITUDE_DECODER.IGNORE_VALUE = -1
+    cfg.MODEL.GRAVITY_DECODER = CN()
+    cfg.MODEL.GRAVITY_DECODER.NAME = "GravityDecoder"
+    cfg.MODEL.GRAVITY_DECODER.LOSS_WEIGHT = 1.0
+    cfg.MODEL.GRAVITY_DECODER.LOSS_TYPE = "classification"
+    cfg.MODEL.GRAVITY_DECODER.NUM_CLASSES = 73
+    cfg.MODEL.GRAVITY_DECODER.IGNORE_VALUE = 72
+    cfg.MODEL.HEIGHT_DECODER = CN()
+    cfg.MODEL.HEIGHT_DECODER.NAME = "HeightDecoder"
+    cfg.MODEL.HEIGHT_DECODER.LOSS_WEIGHT = 1.0
+
+    cfg.MODEL.PARAM_DECODER = CN()
+    cfg.MODEL.PARAM_DECODER.NAME = "ParamNet"
+    cfg.MODEL.PARAM_DECODER.LOSS_TYPE = "regression"
+    cfg.MODEL.PARAM_DECODER.LOSS_WEIGHT = 1.0
+    cfg.MODEL.PARAM_DECODER.PREDICT_PARAMS = [
+        "roll",
+        "pitch",
+        "rel_focal",
+        "rel_cx",
+        "rel_cy",
+    ]
+    cfg.MODEL.PARAM_DECODER.SYNTHETIC_PRETRAIN = False
+    cfg.MODEL.PARAM_DECODER.INPUT_SIZE = 320
+    cfg.MODEL.PARAM_DECODER.DEBUG_LAT = False
+    cfg.MODEL.PARAM_DECODER.DEBUG_UP = False
+
+    cfg.MODEL.FREEZE = []
+    cfg.DEBUG_ON = False
+    cfg.OVERFIT_ON = False
+
+    """
+    The configs below are not used.
+    """
+    cfg.MODEL.CENTER_ON = False
+    cfg.MODEL.HEIGHT_ON = False
+    cfg.MODEL.PIXEL_MEAN = [103.53, 116.28, 123.675]
+    cfg.MODEL.PIXEL_STD = [1.0, 1.0, 1.0]
+
+    cfg.MODEL.FPN_HEADS = CN()
+    cfg.MODEL.FPN_HEADS.NAME = "StandardFPNHeads"
+    # Gravity
+
+    cfg.MODEL.FPN_GRAVITY_HEAD = CN()
+    cfg.MODEL.FPN_GRAVITY_HEAD.NAME = "GravityFPNHead"
+    cfg.MODEL.FPN_GRAVITY_HEAD.IN_FEATURES = ["p2", "p3", "p4", "p5"]
+    # Label in the semantic segmentation ground truth that is ignored, i.e., no loss is calculated for
+    # the correposnding pixel.
+    cfg.MODEL.FPN_GRAVITY_HEAD.IGNORE_VALUE = 360
+    # Number of classes in the semantic segmentation head
+    cfg.MODEL.FPN_GRAVITY_HEAD.NUM_CLASSES = 361
+    # Number of channels in the 3x3 convs inside semantic-FPN heads.
+    cfg.MODEL.FPN_GRAVITY_HEAD.CONVS_DIM = 128
+    # Outputs from semantic-FPN heads are up-scaled to the COMMON_STRIDE stride.
+    cfg.MODEL.FPN_GRAVITY_HEAD.COMMON_STRIDE = 4
+    # Normalization method for the convolution layers. Options: "" (no norm), "GN".
+    cfg.MODEL.FPN_GRAVITY_HEAD.NORM = "GN"
+    cfg.MODEL.FPN_GRAVITY_HEAD.LOSS_WEIGHT = 1.0
+
+    # Latitude
+
+    cfg.MODEL.FPN_LATITUDE_HEAD = CN()
+    cfg.MODEL.FPN_LATITUDE_HEAD.NAME = "LatitudeFPNHead"
+    cfg.MODEL.FPN_LATITUDE_HEAD.IN_FEATURES = ["p2", "p3", "p4", "p5"]
+    # Label in the semantic segmentation ground truth that is ignored, i.e., no loss is calculated for
+    # the correposnding pixel.
+    cfg.MODEL.FPN_LATITUDE_HEAD.IGNORE_VALUE = -1
+    # Number of classes in the semantic segmentation head
+    cfg.MODEL.FPN_LATITUDE_HEAD.NUM_CLASSES = 9
+    # Number of channels in the 3x3 convs inside semantic-FPN heads.
+    cfg.MODEL.FPN_LATITUDE_HEAD.CONVS_DIM = 128
+    # Outputs from semantic-FPN heads are up-scaled to the COMMON_STRIDE stride.
+    cfg.MODEL.FPN_LATITUDE_HEAD.COMMON_STRIDE = 4
+    # Normalization method for the convolution layers. Options: "" (no norm), "GN".
+    cfg.MODEL.FPN_LATITUDE_HEAD.NORM = "GN"
+    cfg.MODEL.FPN_LATITUDE_HEAD.LOSS_WEIGHT = 1.0
+    # Center
+
+    cfg.MODEL.FPN_CENTER_HEAD = CN()
+    cfg.MODEL.FPN_CENTER_HEAD.NAME = "CenterFPNHead"
+    cfg.MODEL.FPN_CENTER_HEAD.IN_FEATURES = ["p2", "p3", "p4", "p5"]
+    # Label in the semantic segmentation ground truth that is ignored, i.e., no loss is calculated for
+    # the correposnding pixel.
+    cfg.MODEL.FPN_CENTER_HEAD.IGNORE_VALUE = 360
+    # Number of classes in the semantic segmentation head
+    cfg.MODEL.FPN_CENTER_HEAD.NUM_CLASSES = 30
+    # Number of channels in the 3x3 convs inside semantic-FPN heads.
+    cfg.MODEL.FPN_CENTER_HEAD.CONVS_DIM = 128
+    # Outputs from semantic-FPN heads are up-scaled to the COMMON_STRIDE stride.
+    cfg.MODEL.FPN_CENTER_HEAD.COMMON_STRIDE = 4
+    # Normalization method for the convolution layers. Options: "" (no norm), "GN".
+    cfg.MODEL.FPN_CENTER_HEAD.NORM = "GN"
+    cfg.MODEL.FPN_CENTER_HEAD.LOSS_WEIGHT = 1.0
+
+    ############################################################
+
+    return cfg