m

handler.py

@@ -0,0 +1,1070 @@
+import warnings
+warnings.filterwarnings('ignore')
+
+import subprocess, io, os, sys, time
+
+is_production = True
+os.environ['CUDA_HOME'] = '/usr/local/cuda-11.7/' if is_production else '/usr/local/cuda-12.1/'
+
+run_gradio = False
+
+if run_gradio:
+    os.system("pip install gradio==3.50.2")
+
+import gradio as gr
+
+from loguru import logger
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+if is_production:
+    os.chdir("/repository")
+    sys.path.insert(0, '/repository')
+
+if os.environ.get('IS_MY_DEBUG') is None:
+    result = subprocess.run(['pip', 'install', '-e', 'GroundingDINO'], check=True)
+    print(f'pip install GroundingDINO = {result}')
+
+# result = subprocess.run(['pip', 'list'], check=True)
+# print(f'pip list = {result}')
+
+sys.path.insert(0, '/repository/GroundingDINO' if is_production else "./GroundingDINO")
+
+import argparse
+import copy
+
+import numpy as np
+import torch
+from PIL import Image, ImageDraw, ImageFont, ImageOps
+
+# 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
+
+import cv2
+import numpy as np
+import matplotlib
+matplotlib.use('AGG')
+plt = matplotlib.pyplot
+# import matplotlib.pyplot as plt
+
+groundingdino_enable = True
+sam_enable = True
+inpainting_enable = True
+ram_enable = True
+
+lama_cleaner_enable = True
+
+kosmos_enable = False
+
+# qwen_enable = True
+# from qwen_utils import *
+
+if os.environ.get('IS_MY_DEBUG') is not None:
+    sam_enable = False
+    ram_enable = False
+    inpainting_enable = False
+    kosmos_enable = False
+
+if lama_cleaner_enable:
+    try:    
+        from lama_cleaner.model_manager import ModelManager
+        from lama_cleaner.schema import Config as lama_Config    
+    except Exception as e:
+        lama_cleaner_enable = False
+
+# segment anything
+from segment_anything import build_sam, SamPredictor, SamAutomaticMaskGenerator
+
+# diffusers
+import PIL
+import requests
+import torch
+from io import BytesIO
+from diffusers import StableDiffusionInpaintPipeline
+from huggingface_hub import hf_hub_download
+
+from util_computer import computer_info
+
+# relate anything
+from ram_utils import iou, sort_and_deduplicate, relation_classes, MLP, show_anns, ram_show_mask
+from ram_train_eval import RamModel, RamPredictor
+from mmengine.config import Config as mmengine_Config
+
+if lama_cleaner_enable:
+    from lama_cleaner.helper import (
+        load_img,
+        numpy_to_bytes,
+        resize_max_size,
+    )
+
+# from transformers import AutoProcessor, AutoModelForVision2Seq
+import ast
+
+if kosmos_enable:
+    os.system("pip install transformers@git+https://github.com/huggingface/transformers.git@main")
+    # os.system("pip install transformers==4.32.0")
+
+from kosmos_utils import *
+
+from util_tencent import getTextTrans
+
+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 = 'cpu'
+os.makedirs(output_dir, exist_ok=True)
+groundingdino_model = None
+sam_device = "cuda"
+sam_model = None
+
+
+def get_sam_vit_h_4b8939():
+    if not os.path.exists('./sam_vit_h_4b8939.pth'):
+        logger.info(f"get sam_vit_h_4b8939.pth...")
+        result = subprocess.run(['wget', 'https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth'], check=True)
+        print(f'wget sam_vit_h_4b8939.pth result = {result}')
+
+get_sam_vit_h_4b8939()
+logger.info(f"initialize SAM model...")
+sam_device = "cuda"
+sam_model = build_sam(checkpoint=sam_checkpoint).to(sam_device)
+sam_predictor = SamPredictor(sam_model)
+sam_mask_generator = SamAutomaticMaskGenerator(sam_model)
+
+sam_mask_generator = None
+sd_model = None
+lama_cleaner_model= None
+ram_model = None
+kosmos_model = None
+kosmos_processor = None
+
+def load_model_hf(model_config_path, repo_id, filename, device='cpu'):
+    args = SLConfig.fromfile(model_config_path) 
+    model = build_model(args)
+    args.device = device
+
+    cache_file = hf_hub_download(repo_id=repo_id, filename=filename)
+    checkpoint = torch.load(cache_file, map_location=device)
+    log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)
+    print("Model loaded from {} \n => {}".format(cache_file, log))
+    _ = model.eval()
+    return model    
+
+def plot_boxes_to_image(image_pil, tgt):
+    H, W = tgt["size"]
+    boxes = tgt["boxes"]
+    labels = tgt["labels"]
+    assert len(boxes) == len(labels), "boxes and labels must have same length"
+
+    draw = ImageDraw.Draw(image_pil)
+    mask = Image.new("L", image_pil.size, 0)
+    mask_draw = ImageDraw.Draw(mask)
+
+    # draw boxes and masks
+    for box, label in zip(boxes, labels):
+        # from 0..1 to 0..W, 0..H
+        box = box * torch.Tensor([W, H, W, H])
+        # from xywh to xyxy
+        box[:2] -= box[2:] / 2
+        box[2:] += box[:2]
+        # random color
+        color = tuple(np.random.randint(0, 255, size=3).tolist())
+        # draw
+        x0, y0, x1, y1 = box
+        x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1)
+
+        draw.rectangle([x0, y0, x1, y1], outline=color, width=6)
+        # draw.text((x0, y0), str(label), fill=color)
+
+        font = ImageFont.load_default()
+        if hasattr(font, "getbbox"):
+            bbox = draw.textbbox((x0, y0), str(label), font)
+        else:
+            w, h = draw.textsize(str(label), font)
+            bbox = (x0, y0, w + x0, y0 + h)
+        # bbox = draw.textbbox((x0, y0), str(label))
+        draw.rectangle(bbox, fill=color)
+
+        try:
+            font = os.path.join(cv2.__path__[0],'qt','fonts','DejaVuSans.ttf')
+            font_size = 36
+            new_font = ImageFont.truetype(font, font_size)
+
+            draw.text((x0+2, y0+2), str(label), font=new_font, fill="white")
+        except Exception as e:
+            pass
+
+        mask_draw.rectangle([x0, y0, x1, y1], fill=255, width=6)
+
+
+    return image_pil, mask
+
+def load_image(image_path):
+    # # load image
+    if isinstance(image_path, PIL.Image.Image):
+        image_pil = image_path
+    else:
+        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 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 xywh_to_xyxy(box, sizeW, sizeH):
+    if isinstance(box, list):
+        box = torch.Tensor(box)
+    box = box * torch.Tensor([sizeW, sizeH, sizeW, sizeH])
+    box[:2] -= box[2:] / 2
+    box[2:] += box[:2]
+    box = box.numpy()
+    return box
+
+def mask_extend(img, box, extend_pixels=10, useRectangle=True):
+    box[0] = int(box[0])
+    box[1] = int(box[1])
+    box[2] = int(box[2])
+    box[3] = int(box[3])
+    region = img.crop(tuple(box))
+    new_width = box[2] - box[0] + 2*extend_pixels
+    new_height = box[3] - box[1] + 2*extend_pixels
+
+    region_BILINEAR = region.resize((int(new_width), int(new_height)))
+    if useRectangle:
+        region_draw = ImageDraw.Draw(region_BILINEAR)
+        region_draw.rectangle((0, 0, new_width, new_height), fill=(255, 255, 255))    
+    img.paste(region_BILINEAR, (int(box[0]-extend_pixels), int(box[1]-extend_pixels)))
+    return img
+
+def mix_masks(imgs):
+    re_img =  1 - np.asarray(imgs[0].convert("1"))
+    for i in range(len(imgs)-1):
+        re_img = np.multiply(re_img, 1 - np.asarray(imgs[i+1].convert("1")))
+    re_img =  1 - re_img
+    return  Image.fromarray(np.uint8(255*re_img))
+
+def set_device():
+    if os.environ.get('IS_MY_DEBUG') is None:
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    else:
+        device = 'cpu'
+    print(f'device={device}')
+    return device
+
+def load_groundingdino_model(device):
+    # initialize groundingdino model
+    logger.info(f"initialize groundingdino model...")
+    groundingdino_model = load_model_hf(config_file, ckpt_repo_id, ckpt_filenmae, device=device) #'cpu')
+    return groundingdino_model
+
+
+
+def load_sam_model(device):
+    # initialize SAM
+    global sam_model, sam_predictor, sam_mask_generator, sam_device
+    get_sam_vit_h_4b8939()
+    logger.info(f"initialize SAM model...")
+    sam_device = device
+    sam_model = build_sam(checkpoint=sam_checkpoint).to(sam_device)
+    sam_predictor = SamPredictor(sam_model)
+    sam_mask_generator = SamAutomaticMaskGenerator(sam_model)
+
+def load_sd_model(device):
+    # initialize stable-diffusion-inpainting
+    global sd_model
+    logger.info(f"initialize stable-diffusion-inpainting...")
+    sd_model = None
+    if os.environ.get('IS_MY_DEBUG') is None:
+        sd_model = StableDiffusionInpaintPipeline.from_pretrained(
+                "runwayml/stable-diffusion-inpainting", 
+                revision="fp16",
+                # "stabilityai/stable-diffusion-2-inpainting",
+                torch_dtype=torch.float16,
+        )
+        sd_model = sd_model.to(device)
+
+def load_lama_cleaner_model(device):
+    # initialize lama_cleaner
+    global lama_cleaner_model
+    logger.info(f"initialize lama_cleaner...")
+
+    lama_cleaner_model = ModelManager(
+            name='lama',
+            device=device,
+        )
+
+def lama_cleaner_process(image, mask, cleaner_size_limit=1080):
+    try:
+        logger.info(f'_______lama_cleaner_process_______1____') 
+        ori_image = image
+        if mask.shape[0] == image.shape[1] and mask.shape[1] == image.shape[0] and mask.shape[0] != mask.shape[1]:
+            # rotate image
+            logger.info(f'_______lama_cleaner_process_______2____')
+            ori_image = np.transpose(image[::-1, ...][:, ::-1], axes=(1, 0, 2))[::-1, ...]
+            logger.info(f'_______lama_cleaner_process_______3____')
+            image = ori_image
+        
+        logger.info(f'_______lama_cleaner_process_______4____')
+        original_shape = ori_image.shape
+        logger.info(f'_______lama_cleaner_process_______5____')
+        interpolation = cv2.INTER_CUBIC
+        
+        size_limit = cleaner_size_limit
+        if size_limit == -1:
+            logger.info(f'_______lama_cleaner_process_______6____')
+            size_limit = max(image.shape)
+        else:
+            logger.info(f'_______lama_cleaner_process_______7____')
+            size_limit = int(size_limit)
+
+        logger.info(f'_______lama_cleaner_process_______8____')
+        config = lama_Config(
+            ldm_steps=25,
+            ldm_sampler='plms',
+            zits_wireframe=True,
+            hd_strategy='Original',
+            hd_strategy_crop_margin=196,
+            hd_strategy_crop_trigger_size=1280,
+            hd_strategy_resize_limit=2048,
+            prompt='',
+            use_croper=False,
+            croper_x=0,
+            croper_y=0,
+            croper_height=512,
+            croper_width=512,
+            sd_mask_blur=5,
+            sd_strength=0.75,
+            sd_steps=50,
+            sd_guidance_scale=7.5,
+            sd_sampler='ddim',
+            sd_seed=42,
+            cv2_flag='INPAINT_NS',
+            cv2_radius=5,
+        )
+        
+        logger.info(f'_______lama_cleaner_process_______9____')
+        if config.sd_seed == -1:
+            config.sd_seed = random.randint(1, 999999999)
+
+        # logger.info(f"Origin image shape_0_: {original_shape} / {size_limit}")
+        logger.info(f'_______lama_cleaner_process_______10____')
+        image = resize_max_size(image, size_limit=size_limit, interpolation=interpolation)
+        # logger.info(f"Resized image shape_1_: {image.shape}")
+        
+        # logger.info(f"mask image shape_0_: {mask.shape} / {type(mask)}")
+        logger.info(f'_______lama_cleaner_process_______11____')
+        mask = resize_max_size(mask, size_limit=size_limit, interpolation=interpolation)
+        # logger.info(f"mask image shape_1_: {mask.shape} / {type(mask)}")
+
+        logger.info(f'_______lama_cleaner_process_______12____')
+        res_np_img = lama_cleaner_model(image, mask, config)
+        logger.info(f'_______lama_cleaner_process_______13____')
+        torch.cuda.empty_cache()
+    
+        logger.info(f'_______lama_cleaner_process_______14____')
+        image = Image.open(io.BytesIO(numpy_to_bytes(res_np_img, 'png')))
+        logger.info(f'_______lama_cleaner_process_______15____')
+    except Exception as e:
+        logger.info(f'lama_cleaner_process[Error]:' + str(e))
+        image = None        
+    return  image
+
+class Ram_Predictor(RamPredictor):
+    def __init__(self, config, device='cpu'):
+        self.config = config
+        self.device = torch.device(device)
+        self._build_model()
+
+    def _build_model(self):
+        self.model = RamModel(**self.config.model).to(self.device)
+        if self.config.load_from is not None:
+            self.model.load_state_dict(torch.load(self.config.load_from, map_location=self.device))
+        self.model.train()
+
+def load_ram_model(device):
+    # load ram model
+    global ram_model
+    if os.environ.get('IS_MY_DEBUG') is not None:
+        return
+    model_path = "./checkpoints/ram_epoch12.pth"
+    ram_config = dict(
+        model=dict(
+            pretrained_model_name_or_path='bert-base-uncased',
+            load_pretrained_weights=False,
+            num_transformer_layer=2,
+            input_feature_size=256,
+            output_feature_size=768,
+            cls_feature_size=512,
+            num_relation_classes=56,
+            pred_type='attention',
+            loss_type='multi_label_ce',
+        ),
+        load_from=model_path,
+    )
+    ram_config = mmengine_Config(ram_config)
+    ram_model = Ram_Predictor(ram_config, device)
+
+# visualization
+def draw_selected_mask(mask, draw):
+    color = (255, 0, 0, 153)
+    nonzero_coords = np.transpose(np.nonzero(mask))
+    for coord in nonzero_coords:
+        draw.point(coord[::-1], fill=color)
+
+def draw_object_mask(mask, draw):
+    color = (0, 0, 255, 153)
+    nonzero_coords = np.transpose(np.nonzero(mask))
+    for coord in nonzero_coords:
+        draw.point(coord[::-1], fill=color)
+
+def create_title_image(word1, word2, word3, width, font_path='./assets/OpenSans-Bold.ttf'):
+    # Define the colors to use for each word
+    color_red = (255, 0, 0)
+    color_black = (0, 0, 0)
+    color_blue = (0, 0, 255)
+
+    # Define the initial font size and spacing between words
+    font_size = 40
+
+    # Create a new image with the specified width and white background
+    image = Image.new('RGB', (width, 60), (255, 255, 255))
+
+    try:
+        # Load the specified font
+        font = ImageFont.truetype(font_path, font_size)
+
+        # Keep increasing the font size until all words fit within the desired width
+        while True:
+            # Create a draw object for the image
+            draw = ImageDraw.Draw(image)
+            
+            word_spacing = font_size / 2
+            # Draw each word in the appropriate color
+            x_offset = word_spacing
+            draw.text((x_offset, 0), word1, color_red, font=font)
+            x_offset += font.getsize(word1)[0] + word_spacing
+            draw.text((x_offset, 0), word2, color_black, font=font)
+            x_offset += font.getsize(word2)[0] + word_spacing
+            draw.text((x_offset, 0), word3, color_blue, font=font)
+            
+            word_sizes = [font.getsize(word) for word in [word1, word2, word3]]
+            total_width = sum([size[0] for size in word_sizes]) + word_spacing * 3
+
+            # Stop increasing font size if the image is within the desired width
+            if total_width <= width:
+                break
+                
+            # Increase font size and reset the draw object
+            font_size -= 1
+            image = Image.new('RGB', (width, 50), (255, 255, 255))
+            font = ImageFont.truetype(font_path, font_size)
+            draw = None
+    except Exception as e:
+        pass
+
+    return image
+
+def concatenate_images_vertical(image1, image2):
+    # Get the dimensions of the two images
+    width1, height1 = image1.size
+    width2, height2 = image2.size
+
+    # Create a new image with the combined height and the maximum width
+    new_image = Image.new('RGBA', (max(width1, width2), height1 + height2))
+
+    # Paste the first image at the top of the new image
+    new_image.paste(image1, (0, 0))
+
+    # Paste the second image below the first image
+    new_image.paste(image2, (0, height1))
+
+    return new_image
+
+def relate_anything(input_image, k):    
+    logger.info(f'relate_anything_1_{input_image.size}_')
+    w, h = input_image.size
+    max_edge = 1500
+    if w > max_edge or h > max_edge:
+        ratio = max(w, h) / max_edge
+        new_size = (int(w / ratio), int(h / ratio))
+        input_image.thumbnail(new_size)
+    
+    logger.info(f'relate_anything_2_')
+    # load image
+    pil_image = input_image.convert('RGBA')
+    image = np.array(input_image)
+    sam_masks = sam_mask_generator.generate(image)
+    filtered_masks = sort_and_deduplicate(sam_masks)
+
+    logger.info(f'relate_anything_3_')
+    feat_list = []
+    for fm in filtered_masks:
+        feat = torch.Tensor(fm['feat']).unsqueeze(0).unsqueeze(0).to(device)
+        feat_list.append(feat)
+    feat = torch.cat(feat_list, dim=1).to(device)
+    matrix_output, rel_triplets = ram_model.predict(feat)
+
+    logger.info(f'relate_anything_4_')
+    pil_image_list = []
+    for i, rel in enumerate(rel_triplets[:k]):
+        s,o,r = int(rel[0]),int(rel[1]),int(rel[2])
+        relation = relation_classes[r]
+
+        mask_image = Image.new('RGBA', pil_image.size, color=(0, 0, 0, 0))
+        mask_draw = ImageDraw.Draw(mask_image)
+            
+        draw_selected_mask(filtered_masks[s]['segmentation'], mask_draw)
+        draw_object_mask(filtered_masks[o]['segmentation'], mask_draw)
+
+        current_pil_image = pil_image.copy()
+        current_pil_image.alpha_composite(mask_image)
+                
+        title_image = create_title_image('Red', relation, 'Blue', current_pil_image.size[0])
+        concate_pil_image = concatenate_images_vertical(current_pil_image, title_image)
+        pil_image_list.append(concate_pil_image)
+
+    logger.info(f'relate_anything_5_{len(pil_image_list)}')
+    return pil_image_list
+
+mask_source_draw = "draw a mask on input image"
+mask_source_segment = "type what to detect below"
+
+def get_time_cost(run_task_time, time_cost_str):
+    now_time = int(time.time()*1000)
+    if run_task_time == 0:
+        time_cost_str = 'start'
+    else:
+        if time_cost_str != '': 
+            time_cost_str += f'-->'
+        time_cost_str += f'{now_time - run_task_time}'
+    run_task_time = now_time
+    return run_task_time, time_cost_str
+
+def run_anything_task(input_image, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, 
+            iou_threshold, inpaint_mode, mask_source_radio, remove_mode, remove_mask_extend, num_relation, kosmos_input, cleaner_size_limit=1080):
+
+    text_prompt = getTextTrans(text_prompt, source='zh', target='en')
+    inpaint_prompt = getTextTrans(inpaint_prompt, source='zh', target='en')
+
+    run_task_time = 0
+    time_cost_str = ''
+    run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)
+
+    text_prompt = text_prompt.strip()
+    if not ((task_type == 'inpainting' or task_type == 'remove') and mask_source_radio == mask_source_draw):
+        if text_prompt == '':
+            return [], gr.Gallery.update(label='Detection prompt is not found!😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None
+
+    if input_image is None:
+            return [], gr.Gallery.update(label='Please upload a image!😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None
+
+    file_temp = int(time.time())
+    logger.info(f'run_anything_task_002/{device}_[{file_temp}]_{task_type}/{inpaint_mode}/[{mask_source_radio}]/{remove_mode}/{remove_mask_extend}_[{text_prompt}]/[{inpaint_prompt}]___1_')
+
+    output_images = []
+
+    image_pil, image = load_image(input_image.convert("RGB"))
+    input_img = input_image
+    run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)
+
+    size = image_pil.size
+    H, W = size[1], size[0]
+
+    # run grounding dino model
+    if (task_type == 'inpainting' or task_type == 'remove') and mask_source_radio == mask_source_draw:
+        pass
+    else:
+        groundingdino_device = 'cpu'
+        if device != 'cpu':
+            try:
+                from groundingdino import _C
+                groundingdino_device = 'cuda:0'
+            except:
+                warnings.warn("Failed to load custom C++ ops. Running on CPU mode Only in groundingdino!")
+
+        boxes_filt, pred_phrases = get_grounding_output(
+            groundingdino_model, image, text_prompt, box_threshold, text_threshold, device=groundingdino_device
+        )
+        if boxes_filt.size(0) == 0:
+            logger.info(f'run_anything_task_[{file_temp}]_{task_type}_[{text_prompt}]_1___{groundingdino_device}/[No objects detected, please try others.]_')
+            return [], gr.Gallery.update(label='No objects detected, please try others.😂😂😂😂'), time_cost_str, gr.Textbox.update(visible=(time_cost_str !='')), None, None, None
+        boxes_filt_ori = copy.deepcopy(boxes_filt)
+
+    logger.info(f'run_anything_task_[{file_temp}]_{task_type}_2_')
+    if task_type == 'segment' or ((task_type == 'inpainting' or task_type == 'remove') and mask_source_radio == mask_source_segment):
+        image = np.array(input_img)
+        if sam_predictor:
+            sam_predictor.set_image(image)
+
+        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]
+
+        if sam_predictor:
+            boxes_filt = boxes_filt.to(sam_device)
+            transformed_boxes = sam_predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2])
+
+            masks, _, _, _ = sam_predictor.predict_torch(
+                point_coords = None,
+                point_labels = None,
+                boxes = transformed_boxes,
+                multimask_output = False,
+            )
+            # masks: [9, 1, 512, 512]
+            assert sam_checkpoint, 'sam_checkpoint is not found!'
+        else:
+            masks = torch.zeros(len(boxes_filt), 1, H, W)   
+            mask_count = 0         
+            for box in boxes_filt:
+                masks[mask_count, 0, int(box[1]):int(box[3]), int(box[0]):int(box[2])] = 1  
+                mask_count += 1   
+            masks = torch.where(masks > 0, True, False)      
+            run_mode = "rectangle"
+
+        # 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.cpu().numpy(), plt.gca(), label)
+        plt.axis('off')
+        image_path = os.path.join(output_dir, f"grounding_seg_output_{file_temp}.jpg")
+        plt.savefig(image_path, bbox_inches="tight")
+        plt.clf()
+        plt.close('all')
+        segment_image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB)
+        os.remove(image_path)
+        output_images.append(Image.fromarray(segment_image_result)) 
+        run_task_time, time_cost_str = get_time_cost(run_task_time, time_cost_str)       
+
+    print(sam_predictor)
+
+    if inpaint_prompt.strip() == '' and mask_source_radio == mask_source_segment:
+        task_type = 'remove'
+
+    logger.info(f'run_anything_task_[{file_temp}]_{task_type}_4_')  
+    if mask_source_radio == mask_source_draw:
+        mask_pil = input_mask_pil
+        mask = input_mask          
+    else:
+        masks_ori = copy.deepcopy(masks)
+        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()
+        mask_pil = Image.fromarray(mask)
+    output_images.append(mask_pil.convert("RGB"))
+    return mask_pil
+
+def change_radio_display(task_type, mask_source_radio):
+    text_prompt_visible = True
+    inpaint_prompt_visible = False
+    mask_source_radio_visible = False
+    num_relation_visible = False
+
+    image_gallery_visible = True
+    kosmos_input_visible = False
+    kosmos_output_visible = False
+    kosmos_text_output_visible = False
+
+    if task_type == "Kosmos-2":
+        if kosmos_enable:
+            text_prompt_visible = False
+            image_gallery_visible = False
+            kosmos_input_visible = True
+            kosmos_output_visible = True
+            kosmos_text_output_visible = True        
+
+    if task_type == "inpainting":
+        inpaint_prompt_visible = True
+    if task_type == "inpainting" or task_type == "remove":
+        mask_source_radio_visible = True   
+        if mask_source_radio == mask_source_draw:
+            text_prompt_visible = False
+    if task_type == "relate anything":
+        text_prompt_visible = False
+        num_relation_visible = True
+
+    return  (gr.Textbox.update(visible=text_prompt_visible), 
+            gr.Textbox.update(visible=inpaint_prompt_visible), 
+            gr.Radio.update(visible=mask_source_radio_visible), 
+            gr.Slider.update(visible=num_relation_visible),
+            gr.Gallery.update(visible=image_gallery_visible),
+            gr.Radio.update(visible=kosmos_input_visible),
+            gr.Image.update(visible=kosmos_output_visible),
+            gr.HighlightedText.update(visible=kosmos_text_output_visible))
+
+def get_model_device(module):
+    try:
+        if module is None:
+            return 'None'
+        if isinstance(module, torch.nn.DataParallel):
+            module = module.module
+        for submodule in module.children():
+            if hasattr(submodule, "_parameters"):
+                parameters = submodule._parameters
+                if "weight" in parameters:
+                    return parameters["weight"].device
+        return 'UnKnown'
+    except Exception as e:
+        return 'Error'
+
+def main_gradio(args):
+    block = gr.Blocks().queue()
+    with block:
+        with gr.Row():
+            with gr.Column():
+                task_types = ["detection"]
+                if sam_enable:
+                    task_types.append("segment")
+                if inpainting_enable:
+                    task_types.append("inpainting")
+                if lama_cleaner_enable:
+                    task_types.append("remove")
+                if ram_enable:
+                    task_types.append("relate anything")
+                if kosmos_enable:
+                    task_types.append("Kosmos-2")           
+         
+                input_image = gr.Image(source='upload', elem_id="image_upload", tool='sketch', type='pil', label="Upload",
+                                    height=512, brush_color='#00FFFF', mask_opacity=0.6)    
+                task_type = gr.Radio(task_types,  value="detection", 
+                                                label='Task type', visible=True) 
+                mask_source_radio = gr.Radio([mask_source_draw, mask_source_segment], 
+                                    value=mask_source_segment, label="Mask from",
+                                    visible=False) 
+                text_prompt = gr.Textbox(label="Detection Prompt[To detect multiple objects, seperating each with '.', like this: cat . dog . chair ]", placeholder="Cannot be empty")                                                
+                inpaint_prompt = gr.Textbox(label="Inpaint Prompt (if this is empty, then remove)", visible=False)
+                num_relation = gr.Slider(label="How many relations do you want to see", minimum=1, maximum=20, value=5, step=1, visible=False)
+                
+                kosmos_input = gr.Radio(["Brief", "Detailed"], label="Kosmos Description Type", value="Brief", visible=False)
+
+                run_button = gr.Button(label="Run", visible=True)
+                with gr.Accordion("Advanced options", open=False) as advanced_options:
+                    box_threshold = gr.Slider(
+                        label="Box Threshold", minimum=0.0, maximum=1.0, value=0.3, step=0.001
+                    )
+                    text_threshold = gr.Slider(
+                        label="Text Threshold", minimum=0.0, maximum=1.0, value=0.25, step=0.001
+                    )
+                    iou_threshold = gr.Slider(
+                        label="IOU Threshold", minimum=0.0, maximum=1.0, value=0.8, step=0.001
+                    )                    
+                    inpaint_mode = gr.Radio(["merge", "first"], value="merge", label="inpaint_mode")
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            remove_mode = gr.Radio(["segment", "rectangle"],  value="segment", label='remove mode') 
+                        with gr.Column(scale=1):
+                            remove_mask_extend = gr.Textbox(label="remove_mask_extend", value='10')
+
+            with gr.Column():
+                image_gallery = gr.Gallery(label="result images", show_label=True, elem_id="gallery", height=512, visible=True
+                    ).style(preview=True, columns=[5], object_fit="scale-down", height="auto")   
+                time_cost = gr.Textbox(label="Time cost by step (ms):", visible=False, interactive=False)
+
+                kosmos_output = gr.Image(type="pil", label="result images", visible=False)
+                kosmos_text_output = gr.HighlightedText(
+                                    label="Generated Description",
+                                    combine_adjacent=False,
+                                    show_legend=True,
+                                    visible=False,
+                                ).style(color_map=color_map)
+                # record which text span (label) is selected
+                selected = gr.Number(-1, show_label=False, placeholder="Selected", visible=False)
+
+                # record the current `entities`
+                entity_output = gr.Textbox(visible=False)
+
+                # get the current selected span label
+                def get_text_span_label(evt: gr.SelectData):
+                    if evt.value[-1] is None:
+                        return -1
+                    return int(evt.value[-1])
+                # and set this information to `selected`
+                kosmos_text_output.select(get_text_span_label, None, selected)
+                
+                # update output image when we change the span (enity) selection
+                def update_output_image(img_input, image_output, entities, idx):
+                    entities = ast.literal_eval(entities)
+                    updated_image = draw_entity_boxes_on_image(img_input, entities, entity_index=idx)
+                    return updated_image
+                selected.change(update_output_image, [kosmos_output, kosmos_output, entity_output, selected], [kosmos_output])
+
+            run_button.click(fn=run_anything_task, inputs=[
+                            input_image, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, 
+                            iou_threshold, inpaint_mode, mask_source_radio, remove_mode, remove_mask_extend, num_relation, kosmos_input], 
+                            outputs=[image_gallery, image_gallery, time_cost, time_cost, kosmos_output, kosmos_text_output, entity_output], show_progress=True, queue=True)
+            
+            mask_source_radio.change(fn=change_radio_display, inputs=[task_type, mask_source_radio], 
+                            outputs=[text_prompt, inpaint_prompt, mask_source_radio, num_relation])
+            task_type.change(fn=change_radio_display, inputs=[task_type, mask_source_radio], 
+                            outputs=[text_prompt, inpaint_prompt, mask_source_radio, num_relation,
+                            image_gallery, kosmos_input, kosmos_output, kosmos_text_output
+                            ])
+
+        DESCRIPTION = f'### This demo from [Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything). <br>'
+        if lama_cleaner_enable:
+            DESCRIPTION += f'Remove(cleaner) from [lama-cleaner](https://github.com/Sanster/lama-cleaner). <br>'
+        if kosmos_enable:
+            DESCRIPTION += f'Kosmos-2 from [Kosmos-2](https://github.com/microsoft/unilm/tree/master/kosmos-2). <br>'
+        if ram_enable:
+            DESCRIPTION += f'RAM from [RelateAnything](https://github.com/Luodian/RelateAnything). <br>'
+        DESCRIPTION += f'Thanks for their excellent work.'
+        DESCRIPTION += f'<p>For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings. \
+                        <a href="https://huggingface.co/spaces/yizhangliu/Grounded-Segment-Anything?duplicate=true"><img style="display: inline; margin-top: 0em; margin-bottom: 0em" src="https://bit.ly/3gLdBN6" alt="Duplicate Space" /></a></p>'
+        gr.Markdown(DESCRIPTION)
+
+    print(f'device = {device}')
+    print(f'torch.cuda.is_available = {torch.cuda.is_available()}')
+    computer_info()
+    block.launch(server_name='0.0.0.0', server_port=args.port, debug=args.debug, share=args.share)
+
+import signal
+import json
+from datetime import date, datetime, timedelta
+from gevent import pywsgi
+import base64 
+
+def imgFile_to_base64(image_file):
+    with open(image_file, "rb") as f:
+        im_bytes = f.read()  
+    im_b64_encode = base64.b64encode(im_bytes)
+    im_b64 = im_b64_encode.decode("utf8")
+    return im_b64
+
+def base64_to_bytes(im_b64):
+    im_b64_encode = im_b64.encode("utf-8")
+    im_bytes = base64.b64decode(im_b64_encode)
+    return im_bytes
+
+def base64_to_PILImage(im_b64):
+    im_bytes = base64_to_bytes(im_b64)
+    pil_img = Image.open(io.BytesIO(im_bytes))
+    return pil_img
+
+class API_Starter:
+    def __init__(self):    
+        from flask import Flask, request, jsonify, make_response
+        from flask_cors import CORS, cross_origin
+        import logging
+
+        app = Flask(__name__)
+        app.logger.setLevel(logging.ERROR)
+        CORS(app, supports_credentials=True, resources={r"/*": {"origins": "*"}})
+
+        @app.route('/imgCLeaner', methods=['GET', 'POST'])
+        @cross_origin()
+        def processAssist():
+            if request.method == 'GET':
+                ret_json = {'code': -1, 'reason':'no support to get'}
+            elif request.method == 'POST':
+                request_data = request.data.decode('utf-8')
+                data = json.loads(request_data)
+                result = self.handle_data(data)
+                if result is None:
+                    ret_json = {'code': -2, 'reason':'handle error'}
+                else:
+                    ret_json = {'code': 0, 'result':result}
+            return jsonify(ret_json)
+        
+        self.app = app
+        now_time = datetime.now().strftime('%Y%m%d_%H%M%S')
+        logger.add(f'./logs/logger_[{args.port}]_{now_time}.log')  
+        signal.signal(signal.SIGINT, self.signal_handler)
+    
+    def handle_data(self, data):
+        im_b64 = data['img']
+        img = base64_to_PILImage(im_b64)
+        remove_texts = data['remove_texts']
+        remove_mask_extend = data['mask_extend']
+        results = run_anything_task(input_image = img, 
+                            text_prompt = f"{remove_texts}",  
+                            task_type = 'remove', 
+                            inpaint_prompt = '', 
+                            box_threshold = 0.3, 
+                            text_threshold = 0.25, 
+                            iou_threshold = 0.8, 
+                            inpaint_mode = "merge", 
+                            mask_source_radio = "type what to detect below", 
+                            remove_mode = "rectangle",   # ["segment", "rectangle"]
+                            remove_mask_extend = f"{remove_mask_extend}", 
+                            num_relation = 5,
+                            kosmos_input = None,
+                            cleaner_size_limit = -1,
+                            )
+        output_images = results[0]
+        if output_images is None:
+            return None
+        ret_json_images = []
+        file_temp = int(time.time())
+        count = 0
+        output_images = output_images[-1:]
+        for image_pil in output_images:
+            try:
+                img_format = image_pil.format.lower()
+            except Exception as e:
+                img_format = 'png'                
+            image_path = os.path.join(output_dir, f"api_images_{file_temp}_{count}.{img_format}")
+            count += 1
+            try:
+                image_pil.save(image_path)
+            except Exception as e:
+                Image.fromarray(image_pil).save(image_path)               
+            im_b64 = imgFile_to_base64(image_path)
+            ret_json_images.append(im_b64)
+            os.remove(image_path)
+        data = {
+            'imgs': ret_json_images,
+            }
+        return data
+  
+    def signal_handler(self, signal, frame):
+        print('\nSignal Catched! You have just type Ctrl+C!')
+        sys.exit(0)
+  
+    def run(self):
+        from gevent import pywsgi
+        logger.info(f'\nargs={args}\n')
+        computer_info()
+        print(f"Start a api server: http://0.0.0.0:{args.port}/imgCLeaner")
+        server = pywsgi.WSGIServer(('0.0.0.0', args.port), self.app)
+        server.serve_forever()  
+
+def main_api(args):
+    if args.port == 0:
+        print('Please give valid port!')
+    else:
+        api_starter = API_Starter()
+        api_starter.run() 
+
+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", "-p", type=int, default=7860, help="port")
+    args, _ = parser.parse_known_args()
+    print(f'args = {args}')
+
+    if os.environ.get('IS_MY_DEBUG') is None:
+        os.system("pip list")
+    
+    device = set_device()
+    if device == 'cpu':
+        kosmos_enable = False
+
+    if kosmos_enable:
+        kosmos_model, kosmos_processor = load_kosmos_model(device)
+        
+    if groundingdino_enable:
+        groundingdino_model = load_groundingdino_model('cpu')
+    
+    if sam_enable:
+        load_sam_model(device)
+
+    if inpainting_enable:
+        load_sd_model(device)
+
+    if lama_cleaner_enable:
+        load_lama_cleaner_model(device)
+
+    if ram_enable:
+        load_ram_model(device)
+    
+    if os.environ.get('IS_MY_DEBUG') is None:
+        os.system("pip list")
+
+def just_fucking_get_sd_mask(input_pil, prompt):
+    return run_anything_task(input_pil, prompt, "inpainting", "", 0.3, 0.25, 0.8, "merge", "type what to detect below", "segment", "10", 5, "Brief")
+
+just_fucking_get_sd_mask(Image.open("chick.png"), "face . shoes").save("fucking.png")
+just_fucking_get_sd_mask(Image.open("chick.png"), "face . shoes").save("fucking2.png")
+
+class EndpointHandler():
+    def __init__(self, path=""):
+        pass
+
+    def __call__(self, data):
+        original_link = data.get("original_link")
+        response = requests.get(original_link, verify=False)
+        byte_arr = response.content
+        original_image = Image.open(io.BytesIO(byte_arr))
+
+        mask_pil = just_fucking_get_sd_mask(original_image, "person")
+
+        img_byte_arr = io.BytesIO()
+        mask_pil.save(img_byte_arr, format="PNG")
+        img_byte_arr = img_byte_arr.getvalue()
+
+        # Upload to file.io
+        response = requests.post('https://file.io', files={'file': img_byte_arr})
+        link = response.json()['link']
+
+        return link
+
+print(EndpointHandler()({
+    "original_link": "https://cdn.karneval-megastore.de/images/rep_art/gra/310/6/310698/justice-league-wonder-woman-damenkostum-lizenzware-blau-gold-rot.jpg"
+}))

requirements.txt

@@ -15,8 +15,10 @@ setuptools
 supervision
 termcolor
 timm
-torch==2.0.0
-torchvision==0.15.1
+# torch==2.0.0 # is production
+# torchvision==0.15.1 # is production
+# torch
+# torchvision
 
 gevent
 yapf
@@ -33,7 +35,7 @@ transformers==4.27.4
 # lama-cleaner==1.2.4
 lama-cleaner@git+https://github.com/yizhangliu/lama-cleaner.git@main
 
-mmcv==2.0.0
+mmcv==1.7.1
 mmengine
 openmim==0.3.9