app.py

import gradio as gr
import subprocess

import os
print("A")
#os.system("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > install.sh")
#os.system("sh install.sh -y")
#os.system('export PATH="$HOME/.cargo/bin:$PATH"')
print("B")
#os.system('pip install tokenizers==0.8.1rc1')
print("C")

os.system('wget https://huggingface.co/yxchng/elia_refcoco/resolve/main/model_best_refcoco_0508.pth')
image_path = './image001.png'
sentence = 'spoon on the dish'
weights = 'model_best_refcoco_0508.pth'
device = 'cpu'

# pre-process the input image
from PIL import Image
import torchvision.transforms as T
import numpy as np
import datetime
import os
import time

import torch
import torch.utils.data
from torch import nn

from bert.multimodal_bert import MultiModalBert
import torchvision

from lib import multimodal_segmentation_ppm
#import transforms as T
import utils

import numpy as np
from PIL import Image
import torch.nn.functional as F

from modeling.MaskFormerModel import MaskFormerHead
from addict import Dict
#from bert.modeling_bert import BertLMPredictionHead, BertEncoder
import cv2
import textwrap

class WrapperModel(nn.Module):
    def __init__(self, image_model, language_model, classifier) :
        super(WrapperModel, self).__init__()
        self.image_model = image_model
        self.language_model = language_model
        self.classifier = classifier

        config = Dict({
          "architectures": [
           "BertForMaskedLM"
          ],
          "attention_probs_dropout_prob": 0.1,
          "gradient_checkpointing": False,
          "hidden_act": "gelu",
          "hidden_dropout_prob": 0.1,
          "hidden_size": 512,
          "initializer_range": 0.02,
          "intermediate_size": 3072,
          "layer_norm_eps": 1e-12,
          #"max_position_embeddings": 16+20,
          "model_type": "bert",
          "num_attention_heads": 8,
          "num_hidden_layers": 8,
         "pad_token_id": 0,
          "position_embedding_type": "absolute",
          "transformers_version": "4.6.0.dev0",
          "type_vocab_size": 2,
          "use_cache": True,
          "vocab_size": 30522
        })



    def _get_binary_mask(self, target):
        # 返回每类的binary mask
        y, x = target.size()
        target_onehot = torch.zeros(self.num_classes + 1, y, x)
        target_onehot = target_onehot.scatter(dim=0, index=target.unsqueeze(0), value=1)
        return target_onehot[1:]

    def semantic_inference(self, mask_cls, mask_pred):       
        mask_cls = F.softmax(mask_cls, dim=1)[...,1:]
        mask_pred = mask_pred.sigmoid()      
        semseg = torch.einsum("bqc,bqhw->bchw", mask_cls, mask_pred)        
        return semseg

    def forward(self, image, sentences, attentions): 
        print(image.sum(), sentences.sum(), attentions.sum())
        input_shape = image.shape[-2:]
        l_mask = attentions.unsqueeze(dim=-1)

        i0, Wh, Ww = self.image_model.forward_stem(image)
        l0, extended_attention_mask = self.language_model.forward_stem(sentences, attentions)

        i1 = self.image_model.forward_stage1(i0, Wh, Ww)
        l1 = self.language_model.forward_stage1(l0, extended_attention_mask)
        i1_residual, H, W, i1_temp, Wh, Ww  = self.image_model.forward_pwam1(i1, Wh, Ww, l1, l_mask)
        l1_residual, l1 = self.language_model.forward_pwam1(i1, l1, extended_attention_mask) 
        i1 = i1_temp

        i2 = self.image_model.forward_stage2(i1, Wh, Ww)
        l2 = self.language_model.forward_stage2(l1, extended_attention_mask)
        i2_residual, H, W, i2_temp, Wh, Ww  = self.image_model.forward_pwam2(i2, Wh, Ww, l2, l_mask)
        l2_residual, l2 = self.language_model.forward_pwam2(i2, l2, extended_attention_mask) 
        i2 = i2_temp

        i3 = self.image_model.forward_stage3(i2, Wh, Ww)
        l3 = self.language_model.forward_stage3(l2, extended_attention_mask)
        i3_residual, H, W, i3_temp, Wh, Ww  = self.image_model.forward_pwam3(i3, Wh, Ww, l3, l_mask)
        l3_residual, l3 = self.language_model.forward_pwam3(i3, l3, extended_attention_mask) 
        i3 = i3_temp

        i4 = self.image_model.forward_stage4(i3, Wh, Ww)
        l4 = self.language_model.forward_stage4(l3, extended_attention_mask)
        i4_residual, H, W, i4_temp, Wh, Ww  = self.image_model.forward_pwam4(i4, Wh, Ww, l4, l_mask)
        l4_residual, l4 = self.language_model.forward_pwam4(i4, l4, extended_attention_mask) 
        i4 = i4_temp

        #i1_residual, i2_residual, i3_residual, i4_residual = features
        #x = self.classifier(i4_residual, i3_residual, i2_residual, i1_residual)
        #x = F.interpolate(x, size=input_shape, mode='bilinear', align_corners=True)
        outputs = {}
        outputs['s1'] = i1_residual
        outputs['s2'] = i2_residual
        outputs['s3'] = i3_residual
        outputs['s4'] = i4_residual

        predictions = self.classifier(outputs)
        return predictions

#img = Image.open(image_path).convert("RGB")

# pre-process the raw sentence
from bert.tokenization_bert import BertTokenizer
import torch

# initialize model and load weights
#from bert.modeling_bert import BertModel
#from lib import segmentation

# construct a mini args class; like from a config file


class args:
    swin_type = 'base'
    window12 = True
    mha = ''
    fusion_drop = 0.0


#single_model = segmentation.__dict__['lavt'](pretrained='', args=args)
single_model = multimodal_segmentation_ppm.__dict__['lavt'](pretrained='',args=args)
single_model.to(device)
model_class = MultiModalBert
single_bert_model = model_class.from_pretrained('bert-base-uncased', embed_dim=single_model.backbone.embed_dim)
single_bert_model.pooler = None

input_shape = dict()
input_shape['s1'] = Dict({'channel': 128,  'stride': 4})
input_shape['s2'] = Dict({'channel': 256,  'stride': 8})
input_shape['s3'] = Dict({'channel': 512,  'stride': 16})
input_shape['s4'] = Dict({'channel': 1024, 'stride': 32})



cfg = Dict()
cfg.MODEL.SEM_SEG_HEAD.COMMON_STRIDE = 4
cfg.MODEL.MASK_FORMER.DROPOUT = 0.0 
cfg.MODEL.MASK_FORMER.NHEADS = 8
cfg.MODEL.SEM_SEG_HEAD.TRANSFORMER_ENC_LAYERS = 4
cfg.MODEL.SEM_SEG_HEAD.CONVS_DIM = 256
cfg.MODEL.SEM_SEG_HEAD.MASK_DIM = 256
cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_IN_FEATURES = ["s1", "s2", "s3", "s4"]

cfg.MODEL.SEM_SEG_HEAD.NUM_CLASSES = 1
cfg.MODEL.MASK_FORMER.HIDDEN_DIM = 256
cfg.MODEL.MASK_FORMER.NUM_OBJECT_QUERIES = 1
cfg.MODEL.MASK_FORMER.DIM_FEEDFORWARD = 2048
cfg.MODEL.MASK_FORMER.DEC_LAYERS = 10
cfg.MODEL.MASK_FORMER.PRE_NORM = False


maskformer_head = MaskFormerHead(cfg, input_shape)


model = WrapperModel(single_model.backbone, single_bert_model, maskformer_head)



checkpoint = torch.load(weights, map_location='cpu')

model.load_state_dict(checkpoint['model'], strict=False)
model.to(device)
model.eval()
#single_bert_model.load_state_dict(checkpoint['bert_model'])
#single_model.load_state_dict(checkpoint['model'])
#model = single_model.to(device)
#bert_model = single_bert_model.to(device)


# inference
#import torch.nn.functional as F
#last_hidden_states = bert_model(padded_sent_toks, attention_mask=attention_mask)[0]
#embedding = last_hidden_states.permute(0, 2, 1)
#output = model(img, embedding, l_mask=attention_mask.unsqueeze(-1))
#output = output.argmax(1, keepdim=True)  # (1, 1, 480, 480)
#output = F.interpolate(output.float(), (original_h, original_w))  # 'nearest'; resize to the original image size
#output = output.squeeze()  # (orig_h, orig_w)
#output = output.cpu().data.numpy()  # (orig_h, orig_w)

#output = pred_masks[0]

#output = output.cpu()



#print(output.shape)
#output_mask = output.argmax(1).data.numpy()
#output = (output > 0.5).data.cpu().numpy()


# show/save results
def overlay_davis(image, mask, colors=[[0, 0, 0], [255, 0, 0]], cscale=1, alpha=0.4):
    from scipy.ndimage.morphology import binary_dilation

    colors = np.reshape(colors, (-1, 3))
    colors = np.atleast_2d(colors) * cscale

    im_overlay = image.copy()
    object_ids = np.unique(mask)

    for object_id in object_ids[1:]:
        # Overlay color on  binary mask
        foreground = image*alpha + np.ones(image.shape)*(1-alpha) * np.array(colors[object_id])
        binary_mask = mask == object_id

        # Compose image
        im_overlay[binary_mask] = foreground[binary_mask]

        # countours = skimage.morphology.binary.binary_dilation(binary_mask) - binary_mask
        countours = binary_dilation(binary_mask) ^ binary_mask
        # countours = cv2.dilate(binary_mask, cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))) - binary_mask
        im_overlay[countours, :] = 0

    return im_overlay.astype(image.dtype)


def run_model(img, sentence):

#img = Image.open(image_path).convert("RGB")
    img = Image.fromarray(img)
    img = img.convert("RGB")
    #print(img.shape)
    img_ndarray = np.array(img)  # (orig_h, orig_w, 3); for visualization
    original_w, original_h = img.size  # PIL .size returns width first and height second

    image_transforms = T.Compose(
        [
         T.Resize((480, 480)),
         T.ToTensor(),
         T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        ]
    )

    img = image_transforms(img).unsqueeze(0)  # (1, 3, 480, 480)
    img = img.to(device)  # for inference (input)

    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    sentence_tokenized = tokenizer.encode(text=sentence, add_special_tokens=True)
    sentence_tokenized = sentence_tokenized[:20]  # if the sentence is longer than 20, then this truncates it to 20 words
    # pad the tokenized sentence
    padded_sent_toks = [0] * 20
    padded_sent_toks[:len(sentence_tokenized)] = sentence_tokenized
    # create a sentence token mask: 1 for real words; 0 for padded tokens
    attention_mask = [0] * 20
    attention_mask[:len(sentence_tokenized)] = [1]*len(sentence_tokenized)
    # convert lists to tensors
    padded_sent_toks = torch.tensor(padded_sent_toks).unsqueeze(0)  # (1, 20)
    attention_mask = torch.tensor(attention_mask).unsqueeze(0)  # (1, 20)
    padded_sent_toks = padded_sent_toks.to(device)  # for inference (input)
    attention_mask = attention_mask.to(device)  # for inference (input)

    output = model(img, padded_sent_toks, attention_mask)[0]
    #print(output[0].keys())
    #print(output[1].shape)
    mask_cls_results = output["pred_logits"]
    mask_pred_results = output["pred_masks"]

    target_shape = img_ndarray.shape[:2]
    #print(target_shape, mask_pred_results.shape)
    mask_pred_results = F.interpolate(mask_pred_results, size=(480,480), mode='bilinear', align_corners=True)

    pred_masks = model.semantic_inference(mask_cls_results, mask_pred_results)                

    output = torch.nn.functional.interpolate(pred_masks, target_shape)
    output = (output > 0.5).data.cpu().numpy()

    output = output.astype(np.uint8)  # (orig_h, orig_w), np.uint8
    # Overlay the mask on the image
    print(img_ndarray.shape, output.shape)
    visualization = overlay_davis(img_ndarray, output[0][0])  # red
    visualization = Image.fromarray(visualization)
    # show the visualization
    #visualization.show()
    # Save the visualization
    #visualization.save('./demo/spoon_on_the_dish.jpg')
    return visualization




demo = gr.Interface(run_model, inputs=[gr.Image(), "text"], outputs=["image"])
demo.launch()