Delete tasks

tasks/__init__.py

@@ -1,11 +0,0 @@
-from .img_cap import image_captioning
-from .open_inst import open_instseg
-from .open_pano import open_panoseg
-from .open_sem import open_semseg
-from .ref_cap import referring_captioning
-from .ref_in import referring_inpainting
-from .ref_seg import referring_segmentation
-from .text_ret import text_retrieval
-from .reg_ret import region_retrieval
-from .ref_in_gpt3 import referring_inpainting_gpt3
-from . import img_cap, open_inst, open_pano, open_sem, ref_cap, ref_in, ref_seg, text_ret

tasks/img_cap.py

@@ -1,54 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import cv2
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-
-
-t = []
-t.append(transforms.Resize(224, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform_v = transforms.Compose(t)
-
-def image_captioning(model, image, texts, inpainting_text, *args, **kwargs):
-    with torch.no_grad():
-        image_ori = transform_v(image)
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image_ori = np.asarray(image_ori)
-
-        image = transform(image)
-        image = np.asarray(image)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width, 'image_id': 0}]
-        outputs = model.model.evaluate_captioning(batch_inputs)
-        text = outputs[-1]['captioning_text']
-
-        image_ori = image_ori.copy()
-        cv2.rectangle(image_ori, (0, height-60), (width, height), (0,0,0), -1)
-        font                   = cv2.FONT_HERSHEY_DUPLEX
-        fontScale              = 1.2
-        thickness              = 2
-        lineType               = 2
-        bottomLeftCornerOfText = (10, height-20)
-        fontColor              = [255,255,255]
-        cv2.putText(image_ori, text,
-            bottomLeftCornerOfText,
-            font, 
-            fontScale,
-            fontColor,
-            thickness,
-            lineType)
-    torch.cuda.empty_cache()
-    return Image.fromarray(image_ori), text, None

tasks/open_inst.py

@@ -1,60 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from detectron2.utils.colormap import random_color
-from detectron2.data import MetadataCatalog
-from detectron2.structures import BitMasks
-
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-metadata = MetadataCatalog.get('ade20k_panoptic_train')
-
-def open_instseg(model, image, texts, inpainting_text, *args, **kwargs):
-    thing_classes = [x.strip() for x in texts.split(',')]
-    thing_colors = [random_color(rgb=True, maximum=255).astype(np.int32).tolist() for _ in range(len(thing_classes))]
-    thing_dataset_id_to_contiguous_id = {x:x for x in range(len(thing_classes))}
-
-    MetadataCatalog.get("demo").set(
-        thing_colors=thing_colors,
-        thing_classes=thing_classes,
-        thing_dataset_id_to_contiguous_id=thing_dataset_id_to_contiguous_id,
-    )
-
-    with torch.no_grad():
-        model.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(thing_classes + ["background"], is_eval=True)
-
-        metadata = MetadataCatalog.get('demo')
-        model.model.metadata = metadata
-        model.model.sem_seg_head.num_classes = len(thing_classes)
-
-        image_ori = transform(image)
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image = np.asarray(image_ori)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width}]
-        outputs = model.forward(batch_inputs)
-        visual = Visualizer(image_ori, metadata=metadata)
-
-        inst_seg = outputs[-1]['instances']
-        inst_seg.pred_masks = inst_seg.pred_masks.cpu()
-        inst_seg.pred_boxes = BitMasks(inst_seg.pred_masks > 0).get_bounding_boxes()
-        demo = visual.draw_instance_predictions(inst_seg) # rgb Image
-        res = demo.get_image()
-
-
-    MetadataCatalog.remove('demo')
-    torch.cuda.empty_cache()
-    return Image.fromarray(res), '', None

tasks/open_pano.py

@@ -1,70 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from detectron2.utils.colormap import random_color
-from detectron2.data import MetadataCatalog
-
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-metadata = MetadataCatalog.get('ade20k_panoptic_train')
-
-def open_panoseg(model, image, texts, inpainting_text, *args, **kwargs):
-    stuff_classes = [x.strip() for x in texts.split(';')[0].replace('stuff:','').split(',')]
-    thing_classes = [x.strip() for x in texts.split(';')[1].replace('thing:','').split(',')]
-    thing_colors = [random_color(rgb=True, maximum=255).astype(np.int32).tolist() for _ in range(len(thing_classes))]
-    stuff_colors = [random_color(rgb=True, maximum=255).astype(np.int32).tolist() for _ in range(len(stuff_classes))]
-    thing_dataset_id_to_contiguous_id = {x:x for x in range(len(thing_classes))}
-    stuff_dataset_id_to_contiguous_id = {x+len(thing_classes):x for x in range(len(stuff_classes))}
-
-    MetadataCatalog.get("demo").set(
-        thing_colors=thing_colors,
-        thing_classes=thing_classes,
-        thing_dataset_id_to_contiguous_id=thing_dataset_id_to_contiguous_id,
-        stuff_colors=stuff_colors,
-        stuff_classes=stuff_classes,
-        stuff_dataset_id_to_contiguous_id=stuff_dataset_id_to_contiguous_id,
-    )
-    model.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(thing_classes + stuff_classes + ["background"], is_eval=True)
-    metadata = MetadataCatalog.get('demo')
-    model.model.metadata = metadata
-    model.model.sem_seg_head.num_classes = len(thing_classes + stuff_classes)
-
-    with torch.no_grad():
-        image_ori = transform(image)
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image = transform(image_ori)
-        image = np.asarray(image)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width}]
-        outputs = model.forward(batch_inputs)
-        visual = Visualizer(image_ori, metadata=metadata)
-
-        pano_seg = outputs[-1]['panoptic_seg'][0]
-        pano_seg_info = outputs[-1]['panoptic_seg'][1]
-
-        for i in range(len(pano_seg_info)):
-            if pano_seg_info[i]['category_id'] in metadata.thing_dataset_id_to_contiguous_id.keys():
-                pano_seg_info[i]['category_id'] = metadata.thing_dataset_id_to_contiguous_id[pano_seg_info[i]['category_id']]
-            else:
-                pano_seg_info[i]['isthing'] = False
-                pano_seg_info[i]['category_id'] = metadata.stuff_dataset_id_to_contiguous_id[pano_seg_info[i]['category_id']]
-
-        demo = visual.draw_panoptic_seg(pano_seg.cpu(), pano_seg_info) # rgb Image
-        res = demo.get_image()
-
-    MetadataCatalog.remove('demo')
-    torch.cuda.empty_cache()
-    return Image.fromarray(res), '', None

tasks/open_sem.py

@@ -1,57 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import os
-import cv2
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from detectron2.utils.colormap import random_color
-from detectron2.data import MetadataCatalog
-
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-metadata = MetadataCatalog.get('ade20k_panoptic_train')
-
-def open_semseg(model, image, texts, inpainting_text, *args, **kwargs):    
-    stuff_classes = [x.strip() for x in texts.split(',')]
-    stuff_colors = [random_color(rgb=True, maximum=255).astype(np.int32).tolist() for _ in range(len(stuff_classes))]
-    stuff_dataset_id_to_contiguous_id = {x:x for x in range(len(stuff_classes))}
-
-    MetadataCatalog.get("demo").set(
-        stuff_colors=stuff_colors,
-        stuff_classes=stuff_classes,
-        stuff_dataset_id_to_contiguous_id=stuff_dataset_id_to_contiguous_id,
-    )
-    model.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(stuff_classes + ["background"], is_eval=True)
-    metadata = MetadataCatalog.get('demo')
-    model.model.metadata = metadata
-    model.model.sem_seg_head.num_classes = len(stuff_classes)
-
-    with torch.no_grad():
-        image_ori = transform(image)
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image = transform(image_ori)
-        image = np.asarray(image)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width}]
-        outputs = model.forward(batch_inputs)
-        visual = Visualizer(image_ori, metadata=metadata)
-
-        sem_seg = outputs[-1]['sem_seg'].max(0)[1]
-        demo = visual.draw_sem_seg(sem_seg.cpu(), alpha=0.5) # rgb Image
-        res = demo.get_image()
-        
-    MetadataCatalog.remove('demo')
-    torch.cuda.empty_cache()
-    return Image.fromarray(res), '', None

tasks/ref_cap.py

@@ -1,68 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import torch
-import torch.nn.functional as F
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from detectron2.data import MetadataCatalog
-
-t = []
-t.append(transforms.Resize(224, interpolation=Image.BICUBIC))
-transform_ret = transforms.Compose(t)
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform_grd = transforms.Compose(t)
-
-metedata = MetadataCatalog.get('coco_2017_train_panoptic')
-
-def referring_captioning(model, image, texts, inpainting_text, *args, **kwargs):
-    model_last, model_cap = model
-    with torch.no_grad():
-        image_ori = image
-        image = transform_grd(image)
-        width = image.size[0]
-        height = image.size[1]
-        image = np.asarray(image)
-        image_ori_ = image
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-        texts_input = [[texts.strip() if texts.endswith('.') else (texts + '.')]]
-
-        batch_inputs = [{'image': images, 'groundings': {'texts':texts_input}, 'height': height, 'width': width}]
-        outputs = model_last.model.evaluate_grounding(batch_inputs, None)
-
-        grd_mask = (outputs[-1]['grounding_mask'] > 0).float()
-        grd_mask_ = (1 - F.interpolate(grd_mask[None,], (224, 224), mode='nearest')[0]).bool()
-
-        color = [252/255, 91/255, 129/255]
-        visual = Visualizer(image_ori_, metadata=metedata)
-        demo = visual.draw_binary_mask(grd_mask.cpu().numpy()[0], color=color, text=texts)
-        res = demo.get_image()
-
-        if (1 - grd_mask_.float()).sum() < 5:
-            torch.cuda.empty_cache()
-            return Image.fromarray(res), 'n/a', None
-
-        grd_mask_ = grd_mask_ * 0
-        image = transform_ret(image_ori)
-        image_ori = np.asarray(image_ori)
-        image = np.asarray(image)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-        batch_inputs = [{'image': images, 'image_id': 0, 'captioning_mask': grd_mask_}]
-
-        token_text = texts.replace('.','') if texts.endswith('.') else texts
-        token = model_cap.model.sem_seg_head.predictor.lang_encoder.tokenizer.encode(token_text)
-        token = torch.tensor(token)[None,:-1]
-
-        outputs = model_cap.model.evaluate_captioning(batch_inputs, extra={'token': token})
-        # outputs = model_cap.model.evaluate_captioning(batch_inputs, extra={})
-        text = outputs[-1]['captioning_text']
-
-    torch.cuda.empty_cache()
-    return Image.fromarray(res), text, None 

tasks/ref_in.py

@@ -1,77 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Jianwei Yang (jianwyan@microsoft.com), Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import torch
-import numpy as np
-from PIL import Image
-from utils.inpainting import pad_image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from diffusers import StableDiffusionInpaintPipeline
-from detectron2.utils.colormap import random_color
-from detectron2.data import MetadataCatalog
-from scipy import ndimage
-
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-metadata = MetadataCatalog.get('ade20k_panoptic_train')
-
-pipe = StableDiffusionInpaintPipeline.from_pretrained(
-    # "stabilityai/stable-diffusion-2-inpainting",
-    "runwayml/stable-diffusion-inpainting",
-    revision="fp16", 
-    torch_dtype=torch.float16,
-).to("cuda")
-
-def crop_image(input_image):
-    crop_w, crop_h = np.floor(np.array(input_image.size) / 64).astype(int) * 64
-    im_cropped = Image.fromarray(np.array(input_image)[:crop_h, :crop_w])
-    return im_cropped
-
-def referring_inpainting(model, image, texts, inpainting_text, *args, **kwargs):
-    model.model.metadata = metadata
-    texts = [[texts if texts.strip().endswith('.') else (texts.strip() + '.')]]
-    image_ori = crop_image(transform(image))
-
-    with torch.no_grad():
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image = np.asarray(image_ori)
-        image_ori_np = np.asarray(image_ori)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width, 'groundings': {'texts': texts}}]        
-        outputs = model.model.evaluate_grounding(batch_inputs, None)
-        visual = Visualizer(image_ori_np, metadata=metadata)
-
-        grd_mask = (outputs[0]['grounding_mask'] > 0).float().cpu().numpy()
-        for idx, mask in enumerate(grd_mask):
-            color = random_color(rgb=True, maximum=1).astype(np.int32).tolist()
-            demo = visual.draw_binary_mask(mask, color=color, text=texts[idx])
-        res = demo.get_image()
-    
-    if inpainting_text not in ['no', '']:
-        # if we want to do inpainting
-        image_crop = image_ori
-        struct2 = ndimage.generate_binary_structure(2, 2)
-        mask_dilated = ndimage.binary_dilation(grd_mask[0], structure=struct2, iterations=3).astype(grd_mask[0].dtype)
-        mask = Image.fromarray(mask_dilated * 255).convert('RGB')
-        image_and_mask = {
-            "image": image_crop,
-            "mask": mask,
-        }
-        width = image_crop.size[0]; height = image_crop.size[1]
-        images_inpainting = pipe(prompt = inpainting_text.strip(), image=image_and_mask['image'], mask_image=image_and_mask['mask'], height=height, width=width).images[0]
-        # put images_inpainting back to original image
-        # image_ori.paste(images_inpainting)        
-        torch.cuda.empty_cache()
-        return Image.fromarray(res) ,'' , images_inpainting
-    else:
-        torch.cuda.empty_cache()
-        return image_ori, 'text', Image.fromarray(res)

tasks/ref_in_gpt3.py

@@ -1,109 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Jianwei Yang (jianwyan@microsoft.com)
-# --------------------------------------------------------
-import os
-import openai
-import torch
-import numpy as np
-from scipy import ndimage
-from PIL import Image
-from utils.inpainting import pad_image, crop_image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from diffusers import StableDiffusionInpaintPipeline
-from detectron2.utils.colormap import random_color
-from detectron2.data import MetadataCatalog
-
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-metadata = MetadataCatalog.get('ade20k_panoptic_train')
-
-pipe = StableDiffusionInpaintPipeline.from_pretrained(
-    # "stabilityai/stable-diffusion-2-inpainting",
-    "runwayml/stable-diffusion-inpainting",
-    revision="fp16", 
-    torch_dtype=torch.float16,
-).to("cuda")
-
-prompts = []
-prompts.append("instruction: remove the person, task: (referring editing), source: [person], target:<clean and empty scene>.")
-prompts.append("instruction: remove the person in the middle, task: (referring editing), source: [person in the middle], target:<clean and empty scene>.")
-prompts.append("instruction: remove the dog on the left side, task: (referring editing), source: [dog on the left side], target:<clean and empty scene>.")
-prompts.append("instruction: change the apple to a pear, task: (referring editing), source: [apple], target: <pear>.")
-prompts.append("instruction: change the red apple to a green one, task: (referring editing), source: [red apple], target: <green apple>.")
-prompts.append("instruction: change the color of bird's feathers from white to blue, task: (referring editing), source: [white bird], target: <blue bird>.")
-prompts.append("instruction: replace the dog with a cat, task: (referring editing), source: [dot], target: <cat>.")
-prompts.append("instruction: replace the red apple with a green one, task: (referring editing), source: [red apple], target: <green apple>.")
-
-#openai.api_type = "azure"
-#openai.api_base = "https://xdecoder.openai.azure.com/"
-#openai.api_version = "2022-12-01"
-openai.organization = os.environ["OPENAI_ORG"]
-openai.api_key = os.environ["OPENAI_API_KEY"]
-
-def get_gpt3_response(prompt):
-    response = openai.Completion.create(
-      model="text-davinci-003",
-      prompt=prompt,
-      temperature=0.7,
-      max_tokens=512,
-      top_p=1,
-      frequency_penalty=0,
-      presence_penalty=0,
-    )
-    
-    return response
-
-def referring_inpainting_gpt3(model, image, instruction, *args, **kwargs):    
-    # convert instruction to source and target
-    instruction = instruction.replace('.', '')
-    print(instruction)
-    resp = get_gpt3_response(' '.join(prompts) + ' instruction: ' + instruction + ',')
-    resp_text = resp['choices'][0]['text']
-    print(resp_text)
-    ref_text = resp_text[resp_text.find('[')+1:resp_text.find(']')]
-    inp_text = resp_text[resp_text.find('<')+1:resp_text.find('>')]
-
-    model.model.metadata = metadata
-    texts = [[ref_text if ref_text.strip().endswith('.') else (ref_text.strip() + '.')]]
-    image_ori = crop_image(transform(image))
-
-    with torch.no_grad():
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image = np.asarray(image_ori)
-        image_ori_np = np.asarray(image_ori)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width, 'groundings': {'texts': texts}}]        
-        outputs = model.model.evaluate_grounding(batch_inputs, None)
-        visual = Visualizer(image_ori_np, metadata=metadata)
-
-        grd_mask = (outputs[0]['grounding_mask'] > 0).float().cpu().numpy()
-        for idx, mask in enumerate(grd_mask):
-            color = random_color(rgb=True, maximum=1).astype(np.int32).tolist()
-            demo = visual.draw_binary_mask(mask, color=color, text=texts[idx])
-        res = demo.get_image()
-    
-    if inp_text not in ['no', '']:
-        image_crop = image_ori
-        struct2 = ndimage.generate_binary_structure(2, 2)
-        mask_dilated = ndimage.binary_dilation(grd_mask[0], structure=struct2, iterations=3).astype(grd_mask[0].dtype)
-        mask = Image.fromarray(mask_dilated * 255).convert('RGB')
-        image_and_mask = {
-            "image": image_crop,
-            "mask": mask,
-        }
-        # images_inpainting = inpainting(inpainting_model, image_and_mask, inp_text, ddim_steps, num_samples, scale, seed)
-        width = image_ori.size[0]; height = image_ori.size[1]
-        images_inpainting = pipe(prompt = inp_text.strip(), image=image_and_mask['image'], mask_image=image_and_mask['mask'], height=height, width=width).images
-        torch.cuda.empty_cache()
-        return images_inpainting[0]
-    else:
-        torch.cuda.empty_cache()
-        return Image.fromarray(res)

tasks/ref_seg.py

@@ -1,46 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from utils.visualizer import Visualizer
-from detectron2.utils.colormap import random_color
-from detectron2.data import MetadataCatalog
-
-
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform = transforms.Compose(t)
-metadata = MetadataCatalog.get('ade20k_panoptic_train')
-
-def referring_segmentation(model, image, texts, inpainting_text, *args, **kwargs):
-    model.model.metadata = metadata
-    texts = texts.strip()
-    texts = [[text.strip() if text.endswith('.') else (text + '.')] for text in texts.split(',')]
-    image_ori = transform(image)
-
-    with torch.no_grad():
-        width = image_ori.size[0]
-        height = image_ori.size[1]
-        image = np.asarray(image_ori)
-        image_ori_np = np.asarray(image_ori)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-
-        batch_inputs = [{'image': images, 'height': height, 'width': width, 'groundings': {'texts': texts}}]        
-        outputs = model.model.evaluate_grounding(batch_inputs, None)
-        visual = Visualizer(image_ori_np, metadata=metadata)
-
-        grd_mask = (outputs[0]['grounding_mask'] > 0).float().cpu().numpy()
-        for idx, mask in enumerate(grd_mask):
-            color = random_color(rgb=True, maximum=1).astype(np.int32).tolist()
-            demo = visual.draw_binary_mask(mask, color=color, text=texts[idx])
-        res = demo.get_image()
-    
-    torch.cuda.empty_cache()
-    return Image.fromarray(res), '', None

tasks/reg_ret.py

@@ -1,72 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import glob
-import os
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from detectron2.data import MetadataCatalog
-from utils.visualizer import Visualizer
-from xdecoder.language.loss import vl_similarity
-from detectron2.utils.colormap import random_color
-
-
-t = []
-t.append(transforms.Resize((224,224), interpolation=Image.BICUBIC))
-transform_ret = transforms.Compose(t)
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform_grd = transforms.Compose(t)
-metadata = MetadataCatalog.get('coco_2017_train_panoptic')
-
-imgs_root = 'images/coco'
-img_pths = sorted(glob.glob(os.path.join(imgs_root, '*.jpg')))
-imgs = [Image.open(x).convert('RGB') for x in img_pths]
-v_emb = torch.load("v_emb.da")
-
-def region_retrieval(model, image, texts, inpainting_text, *args, **kwargs):
-    model_novg, model_seg = model
-    with torch.no_grad():
-        # images = [transform_ret(x) for x in imgs]
-        # images = [np.asarray(x) for x in imgs]
-        # images = [torch.from_numpy(x.copy()).permute(2,0,1).cuda() for x in images]
-        # batch_inputs = [{'image': image, 'image_id': 0} for image in images]
-        # outputs = model_novg.model.evaluate(batch_inputs)
-        # v_emb = torch.cat([x['captions'][-1:] for x in outputs])
-        # v_emb = v_emb / (v_emb.norm(dim=-1, keepdim=True) + 1e-7)
-        # torch.save(v_emb, "v_emb.da")
-        # exit()
-
-        texts_ = [[x.strip() if x.strip().endswith('.') else (x.strip() + '.')] for x in texts.split(',')]
-        model_novg.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(texts_, is_eval=False, name='caption', prompt=False)
-        t_emb = getattr(model_novg.model.sem_seg_head.predictor.lang_encoder, '{}_text_embeddings'.format('caption'))
-        temperature = model_novg.model.sem_seg_head.predictor.lang_encoder.logit_scale
-
-        logits = vl_similarity(v_emb, t_emb, temperature)
-        prob, idx = logits[:,0].softmax(-1).max(0)
-        image_ori = imgs[idx]
-        image = transform_grd(image_ori)
-        width, height = image.size
-        image = np.asarray(image)
-        image_ori = np.asarray(image)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-        batch_inputs = [{'image': images, 'height': height, 'width': width, 'groundings': {'texts': texts_}}]
-        model_seg.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(texts_, is_eval=False, name='caption', prompt=False)
-        outputs = model_seg.model.evaluate_grounding(batch_inputs, None)
-
-        visual = Visualizer(image_ori, metadata=metadata)
-        grd_masks = (outputs[0]['grounding_mask'] > 0).float().cpu().numpy()
-
-        for text, mask in zip([x[0] for x in texts_], grd_masks):
-            color = random_color(rgb=True, maximum=1).astype(np.int32).tolist()
-            demo = visual.draw_binary_mask(mask, color=color, text=texts, alpha=0.5)
-        res = demo.get_image()
-
-    torch.cuda.empty_cache()
-    return Image.fromarray(res), "Selected Image Probability: {:.2f}".format(prob.item()), None

tasks/text_ret.py

@@ -1,46 +0,0 @@
-# --------------------------------------------------------
-# X-Decoder -- Generalized Decoding for Pixel, Image, and Language
-# Copyright (c) 2022 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Xueyan Zou (xueyan@cs.wisc.edu)
-# --------------------------------------------------------
-
-import torch
-import numpy as np
-from PIL import Image
-from torchvision import transforms
-from detectron2.data import MetadataCatalog
-from xdecoder.language.loss import vl_similarity
-
-
-t = []
-t.append(transforms.Resize(224, interpolation=Image.BICUBIC))
-transform_ret = transforms.Compose(t)
-t = []
-t.append(transforms.Resize(512, interpolation=Image.BICUBIC))
-transform_grd = transforms.Compose(t)
-
-metedata = MetadataCatalog.get('coco_2017_train_panoptic')
-
-def text_retrieval(model, image, texts, inpainting_text, *args, **kwargs):
-    out_str = ''
-    with torch.no_grad():
-        image = transform_ret(image)
-        image = np.asarray(image)
-        images = torch.from_numpy(image.copy()).permute(2,0,1).cuda()
-        batch_inputs = [{'image': images, 'image_id': 0}]
-        outputs = model.model.evaluate(batch_inputs)
-        v_emb = torch.cat([x['captions'][-1:] for x in outputs])
-        v_emb = v_emb / (v_emb.norm(dim=-1, keepdim=True) + 1e-7)
-        
-        texts = [x.strip() for x in texts.split(',')]
-        model.model.sem_seg_head.predictor.lang_encoder.get_text_embeddings(texts, is_eval=False, name='caption', prompt=False)
-        t_emb = getattr(model.model.sem_seg_head.predictor.lang_encoder, '{}_text_embeddings'.format('caption'))
-        temperature = model.model.sem_seg_head.predictor.lang_encoder.logit_scale
-        logits = vl_similarity(v_emb, t_emb, temperature)
-        topk_prob, topk_idx = logits.softmax(-1)[0].topk(min(5, len(texts)))
-        
-        for prob, idx in zip(topk_prob, topk_idx):
-            out_str += "{}:{:.2f}; ".format(texts[idx.item()], prob.item())
-    torch.cuda.empty_cache()
-    return None, out_str, None