Spaces:
Running
on
T4
Running
on
T4
| import subprocess, io, os, sys, time | |
| os.environ["CUDA_VISIBLE_DEVICES"] = "0" | |
| 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, './GroundingDINO') | |
| 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}') | |
| import gradio as gr | |
| import argparse | |
| import copy | |
| from loguru import logger | |
| 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.pyplot as plt | |
| from lama_cleaner.model_manager import ModelManager | |
| from lama_cleaner.schema import Config | |
| # segment anything | |
| from segment_anything import build_sam, SamPredictor | |
| # diffusers | |
| import PIL | |
| import requests | |
| import torch | |
| from io import BytesIO | |
| from diffusers import StableDiffusionInpaintPipeline | |
| from huggingface_hub import hf_hub_download | |
| def get_device(): | |
| from numba import cuda | |
| if cuda.is_available(): | |
| device = 'cuda:0' # cuda.get_current_device() | |
| else: | |
| device = 'cpu' | |
| return device | |
| 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) | |
| draw.text((x0, y0), str(label), fill="white") | |
| mask_draw.rectangle([x0, y0, x1, y1], fill=255, width=6) | |
| return image_pil, mask | |
| def load_image(image_path): | |
| # # load image | |
| 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 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=device) #"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 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)) | |
| 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" | |
| device = get_device() | |
| print(f'device={device}') | |
| # initialize groundingdino model | |
| logger.info(f"initialize groundingdino model...") | |
| groundingdino_model = load_model_hf(config_file, ckpt_repo_id, ckpt_filenmae) | |
| # initialize SAM | |
| logger.info(f"initialize SAM model...") | |
| sam_predictor = SamPredictor(build_sam(checkpoint=sam_checkpoint)) | |
| # initialize stable-diffusion-inpainting | |
| logger.info(f"initialize stable-diffusion-inpainting...") | |
| sd_pipe = None | |
| if os.environ.get('IS_MY_DEBUG') is None: | |
| sd_pipe = StableDiffusionInpaintPipeline.from_pretrained( | |
| "runwayml/stable-diffusion-inpainting", | |
| torch_dtype=torch.float16 | |
| ) | |
| sd_pipe = sd_pipe.to(device) | |
| # initialize lama_cleaner | |
| logger.info(f"initialize lama_cleaner...") | |
| from lama_cleaner.helper import ( | |
| load_img, | |
| numpy_to_bytes, | |
| resize_max_size, | |
| ) | |
| lama_cleaner_model = ModelManager( | |
| name='lama', | |
| device=device, | |
| ) | |
| def lama_cleaner_process(image, mask): | |
| 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 | |
| ori_image = np.transpose(image[::-1, ...][:, ::-1], axes=(1, 0, 2))[::-1, ...] | |
| image = ori_image | |
| original_shape = ori_image.shape | |
| interpolation = cv2.INTER_CUBIC | |
| size_limit = 1080 | |
| if size_limit == "Original": | |
| size_limit = max(image.shape) | |
| else: | |
| size_limit = int(size_limit) | |
| config = 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, | |
| ) | |
| if config.sd_seed == -1: | |
| config.sd_seed = random.randint(1, 999999999) | |
| # logger.info(f"Origin image shape_0_: {original_shape} / {size_limit}") | |
| 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)}") | |
| mask = resize_max_size(mask, size_limit=size_limit, interpolation=interpolation) | |
| # logger.info(f"mask image shape_1_: {mask.shape} / {type(mask)}") | |
| res_np_img = lama_cleaner_model(image, mask, config) | |
| torch.cuda.empty_cache() | |
| image = Image.open(io.BytesIO(numpy_to_bytes(res_np_img, 'png'))) | |
| return image | |
| mask_source_draw = "draw a mask on input image" | |
| mask_source_segment = "type what to detect below" | |
| def run_grounded_sam(input_image, text_prompt, task_type, inpaint_prompt, box_threshold, text_threshold, | |
| iou_threshold, inpaint_mode, mask_source_radio, remove_mode, remove_mask_extend): | |
| if (task_type == 'inpainting' or task_type == 'remove') and mask_source_radio == mask_source_draw: | |
| pass | |
| else: | |
| assert text_prompt, 'text_prompt is not found!' | |
| logger.info(f'run_grounded_sam_1_') | |
| # make dir | |
| os.makedirs(output_dir, exist_ok=True) | |
| # load image | |
| input_mask_pil = input_image['mask'] | |
| input_mask = np.array(input_mask_pil.convert("L")) | |
| image_pil, image = load_image(input_image['image'].convert("RGB")) | |
| file_temp = int(time.time()) | |
| # visualize raw image | |
| # image_pil.save(os.path.join(output_dir, f"raw_image_{file_temp}.jpg")) | |
| size = image_pil.size | |
| output_images = [] | |
| # 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!") | |
| groundingdino_device = 'cpu' | |
| boxes_filt, pred_phrases = get_grounding_output( | |
| groundingdino_model, image, text_prompt, box_threshold, text_threshold, device=groundingdino_device | |
| ) | |
| boxes_filt_ori = copy.deepcopy(boxes_filt) | |
| pred_dict = { | |
| "boxes": boxes_filt, | |
| "size": [size[1], size[0]], # H,W | |
| "labels": pred_phrases, | |
| } | |
| image_with_box = plot_boxes_to_image(copy.deepcopy(image_pil), pred_dict)[0] | |
| image_path = os.path.join(output_dir, f"grounding_dino_output_{file_temp}.jpg") | |
| image_with_box.save(image_path) | |
| detection_image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) | |
| os.remove(image_path) | |
| output_images.append(detection_image_result) | |
| logger.info(f'run_grounded_sam_2_') | |
| if task_type == 'segment' or ((task_type == 'inpainting' or task_type == 'remove') and mask_source_radio == mask_source_segment): | |
| image = np.array(input_image['image']) | |
| sam_predictor.set_image(image) | |
| 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 = 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!' | |
| # 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') | |
| image_path = os.path.join(output_dir, f"grounding_seg_output_{file_temp}.jpg") | |
| plt.savefig(image_path, bbox_inches="tight") | |
| segment_image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) | |
| os.remove(image_path) | |
| output_images.append(segment_image_result) | |
| logger.info(f'run_grounded_sam_3_') | |
| if task_type == 'detection' or task_type == 'segment': | |
| logger.info(f'run_grounded_sam_9_{task_type}_') | |
| return output_images | |
| elif task_type == 'inpainting' or task_type == 'remove': | |
| if inpaint_prompt.strip() == '' and mask_source_radio == mask_source_segment: | |
| task_type = 'remove' | |
| logger.info(f'run_grounded_sam_4_{task_type}_') | |
| if mask_source_radio == mask_source_draw: | |
| mask_pil = input_mask_pil | |
| mask = input_mask | |
| else: | |
| 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) | |
| image_path = os.path.join(output_dir, f"image_mask_{file_temp}.jpg") | |
| mask_pil.convert("RGB").save(image_path) | |
| image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) | |
| os.remove(image_path) | |
| output_images.append(image_result) | |
| if task_type == 'inpainting': | |
| # inpainting pipeline | |
| image_source_for_inpaint = image_pil.resize((512, 512)) | |
| image_mask_for_inpaint = mask_pil.resize((512, 512)) | |
| image_inpainting = sd_pipe(prompt=inpaint_prompt, image=image_source_for_inpaint, mask_image=image_mask_for_inpaint).images[0] | |
| else: | |
| # remove from mask | |
| if mask_source_radio == mask_source_segment: | |
| mask_imgs = [] | |
| masks_shape = masks.shape | |
| boxes_filt_ori_array = boxes_filt_ori.numpy() | |
| if inpaint_mode == 'merge': | |
| extend_shape_0 = masks_shape[0] | |
| extend_shape_1 = masks_shape[1] | |
| else: | |
| extend_shape_0 = 1 | |
| extend_shape_1 = 1 | |
| for i in range(extend_shape_0): | |
| for j in range(extend_shape_1): | |
| mask = masks[i][j].cpu().numpy() | |
| mask_pil = Image.fromarray(mask) | |
| if remove_mode == 'segment': | |
| useRectangle = False | |
| else: | |
| useRectangle = True | |
| try: | |
| remove_mask_extend = int(remove_mask_extend) | |
| except: | |
| remove_mask_extend = 10 | |
| mask_pil_exp = mask_extend(copy.deepcopy(mask_pil).convert("RGB"), | |
| xywh_to_xyxy(torch.tensor(boxes_filt_ori_array[i]), size[0], size[1]), | |
| extend_pixels=remove_mask_extend, useRectangle=useRectangle) | |
| mask_imgs.append(mask_pil_exp) | |
| mask_pil = mix_masks(mask_imgs) | |
| image_path = os.path.join(output_dir, f"image_mask_{file_temp}.jpg") | |
| mask_pil.convert("RGB").save(image_path) | |
| image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) | |
| os.remove(image_path) | |
| output_images.append(image_result) | |
| image_inpainting = lama_cleaner_process(np.array(image_pil), np.array(mask_pil.convert("L"))) | |
| image_inpainting = image_inpainting.resize((image_pil.size[0], image_pil.size[1])) | |
| image_path = os.path.join(output_dir, f"grounded_sam_inpainting_output_{file_temp}.jpg") | |
| image_inpainting.save(image_path) | |
| image_result = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB) | |
| os.remove(image_path) | |
| logger.info(f'run_grounded_sam_9_{task_type}_') | |
| output_images.append(image_result) | |
| return output_images | |
| else: | |
| logger.info(f"task_type:{task_type} error!") | |
| logger.info(f'run_grounded_sam_9_9_') | |
| return output_images | |
| def change_radio_display(task_type, mask_source_radio): | |
| text_prompt_visible = True | |
| inpaint_prompt_visible = False | |
| mask_source_radio_visible = False | |
| 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 | |
| return gr.Textbox.update(visible=text_prompt_visible), gr.Textbox.update(visible=inpaint_prompt_visible), gr.Radio.update(visible=mask_source_radio_visible) | |
| 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") | |
| args = parser.parse_args() | |
| print(f'args = {args}') | |
| block = gr.Blocks().queue() | |
| with block: | |
| with gr.Row(): | |
| with gr.Column(): | |
| input_image = gr.Image(source='upload', elem_id="image_upload", tool='sketch', type='pil', label="Upload") | |
| task_type = gr.Radio(["detection", "segment", "inpainting", "remove"], value="detection", | |
| label='Task type',interactive=True, visible=True) | |
| mask_source_radio = gr.Radio([mask_source_draw, mask_source_segment], | |
| value=mask_source_segment, label="Mask from", | |
| interactive=True, visible=False) | |
| text_prompt = gr.Textbox(label="Detection Prompt", placeholder="Cannot be empty") | |
| inpaint_prompt = gr.Textbox(label="Inpaint Prompt (if this is empty, then remove)", visible=False) | |
| 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.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.5, 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(): | |
| gallery = gr.Gallery( | |
| label="Generated images", show_label=False, elem_id="gallery" | |
| ).style(grid=[2], full_width=True, full_height=True) | |
| run_button.click(fn=run_grounded_sam, 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], outputs=[gallery]) | |
| task_type.change(fn=change_radio_display, inputs=[task_type, mask_source_radio], outputs=[text_prompt, inpaint_prompt, mask_source_radio]) | |
| mask_source_radio.change(fn=change_radio_display, inputs=[task_type, mask_source_radio], outputs=[text_prompt, inpaint_prompt, mask_source_radio]) | |
| DESCRIPTION = '### This demo from [Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything). 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) | |
| block.launch(server_name='0.0.0.0', debug=args.debug, share=args.share) | |