Add files using upload-large-folder tool

external/Grounded-Segment-Anything/EfficientSAM/EdgeSAM/common.py

@@ -0,0 +1,118 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from typing import Type
+
+
+class MLPBlock(nn.Module):
+    def __init__(
+        self,
+        embedding_dim: int,
+        mlp_dim: int,
+        act: Type[nn.Module] = nn.GELU,
+    ) -> None:
+        super().__init__()
+        self.lin1 = nn.Linear(embedding_dim, mlp_dim)
+        self.lin2 = nn.Linear(mlp_dim, embedding_dim)
+        self.act = act()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.lin2(self.act(self.lin1(x)))
+
+
+# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py # noqa
+# Itself from https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119  # noqa
+class LayerNorm2d(nn.Module):
+    def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(num_channels))
+        self.bias = nn.Parameter(torch.zeros(num_channels))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        u = x.mean(1, keepdim=True)
+        s = (x - u).pow(2).mean(1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.eps)
+        x = self.weight[:, None, None] * x + self.bias[:, None, None]
+        return x
+
+
+def val2list(x: list or tuple or any, repeat_time=1) -> list:
+    if isinstance(x, (list, tuple)):
+        return list(x)
+    return [x for _ in range(repeat_time)]
+
+
+def val2tuple(x: list or tuple or any, min_len: int = 1, idx_repeat: int = -1) -> tuple:
+    x = val2list(x)
+
+    # repeat elements if necessary
+    if len(x) > 0:
+        x[idx_repeat:idx_repeat] = [x[idx_repeat] for _ in range(min_len - len(x))]
+
+    return tuple(x)
+
+
+def list_sum(x: list) -> any:
+    return x[0] if len(x) == 1 else x[0] + list_sum(x[1:])
+
+
+def resize(
+        x: torch.Tensor,
+        size: any or None = None,
+        scale_factor=None,
+        mode: str = "bicubic",
+        align_corners: bool or None = False,
+) -> torch.Tensor:
+    if mode in ["bilinear", "bicubic"]:
+        return F.interpolate(
+            x,
+            size=size,
+            scale_factor=scale_factor,
+            mode=mode,
+            align_corners=align_corners,
+        )
+    elif mode in ["nearest", "area"]:
+        return F.interpolate(x, size=size, scale_factor=scale_factor, mode=mode)
+    else:
+        raise NotImplementedError(f"resize(mode={mode}) not implemented.")
+
+
+class UpSampleLayer(nn.Module):
+    def __init__(
+            self,
+            mode="bicubic",
+            size=None,
+            factor=2,
+            align_corners=False,
+    ):
+        super(UpSampleLayer, self).__init__()
+        self.mode = mode
+        self.size = val2list(size, 2) if size is not None else None
+        self.factor = None if self.size is not None else factor
+        self.align_corners = align_corners
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return resize(x, self.size, self.factor, self.mode, self.align_corners)
+
+
+class OpSequential(nn.Module):
+    def __init__(self, op_list):
+        super(OpSequential, self).__init__()
+        valid_op_list = []
+        for op in op_list:
+            if op is not None:
+                valid_op_list.append(op)
+        self.op_list = nn.ModuleList(valid_op_list)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        for op in self.op_list:
+            x = op(x)
+        return x

external/Grounded-Segment-Anything/EfficientSAM/EdgeSAM/rep_vit.py

@@ -0,0 +1,370 @@
+import torch.nn as nn
+from EdgeSAM.common import LayerNorm2d, UpSampleLayer, OpSequential
+
+__all__ = ['rep_vit_m1', 'rep_vit_m2', 'rep_vit_m3', 'RepViT']
+
+m1_cfgs = [
+    # k, t, c, SE, HS, s
+    [3, 2, 48, 1, 0, 1],
+    [3, 2, 48, 0, 0, 1],
+    [3, 2, 48, 0, 0, 1],
+    [3, 2, 96, 0, 0, 2],
+    [3, 2, 96, 1, 0, 1],
+    [3, 2, 96, 0, 0, 1],
+    [3, 2, 96, 0, 0, 1],
+    [3, 2, 192, 0, 1, 2],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 1, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 192, 0, 1, 1],
+    [3, 2, 384, 0, 1, 2],
+    [3, 2, 384, 1, 1, 1],
+    [3, 2, 384, 0, 1, 1]
+]
+
+m2_cfgs = [
+    # k, t, c, SE, HS, s
+    [3, 2, 64, 1, 0, 1],
+    [3, 2, 64, 0, 0, 1],
+    [3, 2, 64, 0, 0, 1],
+    [3, 2, 128, 0, 0, 2],
+    [3, 2, 128, 1, 0, 1],
+    [3, 2, 128, 0, 0, 1],
+    [3, 2, 128, 0, 0, 1],
+    [3, 2, 256, 0, 1, 2],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 512, 0, 1, 2],
+    [3, 2, 512, 1, 1, 1],
+    [3, 2, 512, 0, 1, 1]
+]
+
+m3_cfgs = [
+    # k, t, c, SE, HS, s
+    [3, 2, 64, 1, 0, 1],
+    [3, 2, 64, 0, 0, 1],
+    [3, 2, 64, 1, 0, 1],
+    [3, 2, 64, 0, 0, 1],
+    [3, 2, 64, 0, 0, 1],
+    [3, 2, 128, 0, 0, 2],
+    [3, 2, 128, 1, 0, 1],
+    [3, 2, 128, 0, 0, 1],
+    [3, 2, 128, 1, 0, 1],
+    [3, 2, 128, 0, 0, 1],
+    [3, 2, 128, 0, 0, 1],
+    [3, 2, 256, 0, 1, 2],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 1, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 256, 0, 1, 1],
+    [3, 2, 512, 0, 1, 2],
+    [3, 2, 512, 1, 1, 1],
+    [3, 2, 512, 0, 1, 1]
+]
+
+
+def _make_divisible(v, divisor, min_value=None):
+    """
+    This function is taken from the original tf repo.
+    It ensures that all layers have a channel number that is divisible by 8
+    It can be seen here:
+    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
+    :param v:
+    :param divisor:
+    :param min_value:
+    :return:
+    """
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than 10%.
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v
+
+
+from timm.models.layers import SqueezeExcite
+
+import torch
+
+
+class Conv2d_BN(torch.nn.Sequential):
+    def __init__(self, a, b, ks=1, stride=1, pad=0, dilation=1,
+                 groups=1, bn_weight_init=1, resolution=-10000):
+        super().__init__()
+        self.add_module('c', torch.nn.Conv2d(
+            a, b, ks, stride, pad, dilation, groups, bias=False))
+        self.add_module('bn', torch.nn.BatchNorm2d(b))
+        torch.nn.init.constant_(self.bn.weight, bn_weight_init)
+        torch.nn.init.constant_(self.bn.bias, 0)
+
+    @torch.no_grad()
+    def fuse(self):
+        c, bn = self._modules.values()
+        w = bn.weight / (bn.running_var + bn.eps) ** 0.5
+        w = c.weight * w[:, None, None, None]
+        b = bn.bias - bn.running_mean * bn.weight / \
+            (bn.running_var + bn.eps) ** 0.5
+        m = torch.nn.Conv2d(w.size(1) * self.c.groups, w.size(
+            0), w.shape[2:], stride=self.c.stride, padding=self.c.padding, dilation=self.c.dilation,
+                            groups=self.c.groups,
+                            device=c.weight.device)
+        m.weight.data.copy_(w)
+        m.bias.data.copy_(b)
+        return m
+
+
+class Residual(torch.nn.Module):
+    def __init__(self, m, drop=0.):
+        super().__init__()
+        self.m = m
+        self.drop = drop
+
+    def forward(self, x):
+        if self.training and self.drop > 0:
+            return x + self.m(x) * torch.rand(x.size(0), 1, 1, 1,
+                                              device=x.device).ge_(self.drop).div(1 - self.drop).detach()
+        else:
+            return x + self.m(x)
+
+    @torch.no_grad()
+    def fuse(self):
+        if isinstance(self.m, Conv2d_BN):
+            m = self.m.fuse()
+            assert (m.groups == m.in_channels)
+            identity = torch.ones(m.weight.shape[0], m.weight.shape[1], 1, 1)
+            identity = torch.nn.functional.pad(identity, [1, 1, 1, 1])
+            m.weight += identity.to(m.weight.device)
+            return m
+        elif isinstance(self.m, torch.nn.Conv2d):
+            m = self.m
+            assert (m.groups != m.in_channels)
+            identity = torch.ones(m.weight.shape[0], m.weight.shape[1], 1, 1)
+            identity = torch.nn.functional.pad(identity, [1, 1, 1, 1])
+            m.weight += identity.to(m.weight.device)
+            return m
+        else:
+            return self
+
+
+class RepVGGDW(torch.nn.Module):
+    def __init__(self, ed) -> None:
+        super().__init__()
+        self.conv = Conv2d_BN(ed, ed, 3, 1, 1, groups=ed)
+        self.conv1 = Conv2d_BN(ed, ed, 1, 1, 0, groups=ed)
+        self.dim = ed
+
+    def forward(self, x):
+        return self.conv(x) + self.conv1(x) + x
+
+    @torch.no_grad()
+    def fuse(self):
+        conv = self.conv.fuse()
+        conv1 = self.conv1.fuse()
+
+        conv_w = conv.weight
+        conv_b = conv.bias
+        conv1_w = conv1.weight
+        conv1_b = conv1.bias
+
+        conv1_w = torch.nn.functional.pad(conv1_w, [1, 1, 1, 1])
+
+        identity = torch.nn.functional.pad(torch.ones(conv1_w.shape[0], conv1_w.shape[1], 1, 1, device=conv1_w.device),
+                                           [1, 1, 1, 1])
+
+        final_conv_w = conv_w + conv1_w + identity
+        final_conv_b = conv_b + conv1_b
+
+        conv.weight.data.copy_(final_conv_w)
+        conv.bias.data.copy_(final_conv_b)
+        return conv
+
+
+class RepViTBlock(nn.Module):
+    def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se, use_hs, skip_downsample=False):
+        super(RepViTBlock, self).__init__()
+        assert stride in [1, 2]
+
+        self.identity = stride == 1 and inp == oup
+        assert (hidden_dim == 2 * inp)
+
+        if stride == 2:
+            if skip_downsample:
+                stride = 1
+            self.token_mixer = nn.Sequential(
+                Conv2d_BN(inp, inp, kernel_size, stride, (kernel_size - 1) // 2, groups=inp),
+                SqueezeExcite(inp, 0.25) if use_se else nn.Identity(),
+                Conv2d_BN(inp, oup, ks=1, stride=1, pad=0)
+            )
+            self.channel_mixer = Residual(nn.Sequential(
+                # pw
+                Conv2d_BN(oup, 2 * oup, 1, 1, 0),
+                nn.GELU() if use_hs else nn.GELU(),
+                # pw-linear
+                Conv2d_BN(2 * oup, oup, 1, 1, 0, bn_weight_init=0),
+            ))
+        else:
+            assert (self.identity)
+            self.token_mixer = nn.Sequential(
+                RepVGGDW(inp),
+                SqueezeExcite(inp, 0.25) if use_se else nn.Identity(),
+            )
+            self.channel_mixer = Residual(nn.Sequential(
+                # pw
+                Conv2d_BN(inp, hidden_dim, 1, 1, 0),
+                nn.GELU() if use_hs else nn.GELU(),
+                # pw-linear
+                Conv2d_BN(hidden_dim, oup, 1, 1, 0, bn_weight_init=0),
+            ))
+
+    def forward(self, x):
+        return self.channel_mixer(self.token_mixer(x))
+
+
+from timm.models.vision_transformer import trunc_normal_
+
+
+class BN_Linear(torch.nn.Sequential):
+    def __init__(self, a, b, bias=True, std=0.02):
+        super().__init__()
+        self.add_module('bn', torch.nn.BatchNorm1d(a))
+        self.add_module('l', torch.nn.Linear(a, b, bias=bias))
+        trunc_normal_(self.l.weight, std=std)
+        if bias:
+            torch.nn.init.constant_(self.l.bias, 0)
+
+    @torch.no_grad()
+    def fuse(self):
+        bn, l = self._modules.values()
+        w = bn.weight / (bn.running_var + bn.eps) ** 0.5
+        b = bn.bias - self.bn.running_mean * \
+            self.bn.weight / (bn.running_var + bn.eps) ** 0.5
+        w = l.weight * w[None, :]
+        if l.bias is None:
+            b = b @ self.l.weight.T
+        else:
+            b = (l.weight @ b[:, None]).view(-1) + self.l.bias
+        m = torch.nn.Linear(w.size(1), w.size(0), device=l.weight.device)
+        m.weight.data.copy_(w)
+        m.bias.data.copy_(b)
+        return m
+
+
+class RepViT(nn.Module):
+    arch_settings = {
+        'm1': m1_cfgs,
+        'm2': m2_cfgs,
+        'm3': m3_cfgs
+    }
+
+    def __init__(self, arch, img_size=1024, upsample_mode='bicubic'):
+        super(RepViT, self).__init__()
+        # setting of inverted residual blocks
+        self.cfgs = self.arch_settings[arch]
+        self.img_size = img_size
+
+        # building first layer
+        input_channel = self.cfgs[0][2]
+        patch_embed = torch.nn.Sequential(Conv2d_BN(3, input_channel // 2, 3, 2, 1), torch.nn.GELU(),
+                                          Conv2d_BN(input_channel // 2, input_channel, 3, 2, 1))
+        layers = [patch_embed]
+        # building inverted residual blocks
+        block = RepViTBlock
+        self.stage_idx = []
+        prev_c = input_channel
+        for idx, (k, t, c, use_se, use_hs, s) in enumerate(self.cfgs):
+            output_channel = _make_divisible(c, 8)
+            exp_size = _make_divisible(input_channel * t, 8)
+            skip_downsample = False
+            if c != prev_c:
+                self.stage_idx.append(idx - 1)
+                prev_c = c
+            layers.append(block(input_channel, exp_size, output_channel, k, s, use_se, use_hs, skip_downsample))
+            input_channel = output_channel
+        self.stage_idx.append(idx)
+        self.features = nn.ModuleList(layers)
+
+        stage2_channels = _make_divisible(self.cfgs[self.stage_idx[2]][2], 8)
+        stage3_channels = _make_divisible(self.cfgs[self.stage_idx[3]][2], 8)
+        self.fuse_stage2 = nn.Conv2d(stage2_channels, 256, kernel_size=1, bias=False)
+        self.fuse_stage3 = OpSequential([
+            nn.Conv2d(stage3_channels, 256, kernel_size=1, bias=False),
+            UpSampleLayer(factor=2, mode=upsample_mode),
+        ])
+
+        self.neck = nn.Sequential(
+            nn.Conv2d(256, 256, kernel_size=1, bias=False),
+            LayerNorm2d(256),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
+            LayerNorm2d(256),
+        )
+
+    def forward(self, x):
+        counter = 0
+        output_dict = dict()
+        # patch_embed
+        x = self.features[0](x)
+        output_dict['stem'] = x
+        # stages
+        for idx, f in enumerate(self.features[1:]):
+            x = f(x)
+            if idx in self.stage_idx:
+                output_dict[f'stage{counter}'] = x
+                counter += 1
+
+        x = self.fuse_stage2(output_dict['stage2']) + self.fuse_stage3(output_dict['stage3'])
+
+        x = self.neck(x)
+        # hack this place because we modified the predictor of SAM for HQ-SAM in
+        # segment_anything/segment_anything/predictor.py line 91 to return intern features of the backbone
+        # self.features, self.interm_features = self.model.image_encoder(input_image)
+        return x, None
+
+
+def rep_vit_m1(img_size=1024, **kwargs):
+    return RepViT('m1', img_size, **kwargs)
+
+
+def rep_vit_m2(img_size=1024, **kwargs):
+    return RepViT('m2', img_size, **kwargs)
+
+
+def rep_vit_m3(img_size=1024, **kwargs):
+    return RepViT('m3', img_size, **kwargs)

external/Grounded-Segment-Anything/EfficientSAM/EdgeSAM/setup_edge_sam.py

@@ -0,0 +1,90 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+
+from functools import partial
+
+from segment_anything.modeling import ImageEncoderViT, MaskDecoder, PromptEncoder, Sam, TwoWayTransformer
+from EdgeSAM.rep_vit import RepViT
+
+
+prompt_embed_dim = 256
+image_size = 1024
+vit_patch_size = 16
+image_embedding_size = image_size // vit_patch_size
+
+
+def build_edge_sam(checkpoint=None, upsample_mode="bicubic"):
+    image_encoder = RepViT(
+        arch="m1",
+        img_size=image_size,
+        upsample_mode=upsample_mode
+    )
+    return _build_sam(image_encoder, checkpoint)
+
+
+sam_model_registry = {
+    "default": build_edge_sam,
+    "edge_sam": build_edge_sam,
+}
+
+def _build_sam_encoder(
+    encoder_embed_dim,
+    encoder_depth,
+    encoder_num_heads,
+    encoder_global_attn_indexes,
+):
+    image_encoder = ImageEncoderViT(
+        depth=encoder_depth,
+        embed_dim=encoder_embed_dim,
+        img_size=image_size,
+        mlp_ratio=4,
+        norm_layer=partial(torch.nn.LayerNorm, eps=1e-6),
+        num_heads=encoder_num_heads,
+        patch_size=vit_patch_size,
+        qkv_bias=True,
+        use_rel_pos=True,
+        global_attn_indexes=encoder_global_attn_indexes,
+        window_size=14,
+        out_chans=prompt_embed_dim,
+    )
+    return image_encoder
+
+
+def _build_sam(
+    image_encoder,
+    checkpoint=None,
+):
+    sam = Sam(
+        image_encoder=image_encoder,
+        prompt_encoder=PromptEncoder(
+            embed_dim=prompt_embed_dim,
+            image_embedding_size=(image_embedding_size, image_embedding_size),
+            input_image_size=(image_size, image_size),
+            mask_in_chans=16,
+        ),
+        mask_decoder=MaskDecoder(
+            num_multimask_outputs=3,
+            transformer=TwoWayTransformer(
+                depth=2,
+                embedding_dim=prompt_embed_dim,
+                mlp_dim=2048,
+                num_heads=8,
+            ),
+            transformer_dim=prompt_embed_dim,
+            iou_head_depth=3,
+            iou_head_hidden_dim=256,
+        ),
+        pixel_mean=[123.675, 116.28, 103.53],
+        pixel_std=[58.395, 57.12, 57.375],
+    )
+    sam.eval()
+    if checkpoint is not None:
+        with open(checkpoint, "rb") as f:
+            state_dict = torch.load(f, map_location="cpu")
+        sam.load_state_dict(state_dict)
+    return sam

external/Grounded-Segment-Anything/EfficientSAM/FastSAM/tools.py

@@ -0,0 +1,413 @@
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import cv2
+import torch
+import os
+import clip
+
+
+def convert_box_xywh_to_xyxy(box):
+    x1 = box[0]
+    y1 = box[1]
+    x2 = box[0] + box[2]
+    y2 = box[1] + box[3]
+    return [x1, y1, x2, y2]
+
+
+def segment_image(image, bbox):
+    image_array = np.array(image)
+    segmented_image_array = np.zeros_like(image_array)
+    x1, y1, x2, y2 = bbox
+    segmented_image_array[y1:y2, x1:x2] = image_array[y1:y2, x1:x2]
+    segmented_image = Image.fromarray(segmented_image_array)
+    black_image = Image.new("RGB", image.size, (255, 255, 255))
+    # transparency_mask = np.zeros_like((), dtype=np.uint8)
+    transparency_mask = np.zeros(
+        (image_array.shape[0], image_array.shape[1]), dtype=np.uint8
+    )
+    transparency_mask[y1:y2, x1:x2] = 255
+    transparency_mask_image = Image.fromarray(transparency_mask, mode="L")
+    black_image.paste(segmented_image, mask=transparency_mask_image)
+    return black_image
+
+
+def format_results(result, filter=0):
+    annotations = []
+    n = len(result.masks.data)
+    for i in range(n):
+        annotation = {}
+        mask = result.masks.data[i] == 1.0
+
+        if torch.sum(mask) < filter:
+            continue
+        annotation["id"] = i
+        annotation["segmentation"] = mask.cpu().numpy()
+        annotation["bbox"] = result.boxes.data[i]
+        annotation["score"] = result.boxes.conf[i]
+        annotation["area"] = annotation["segmentation"].sum()
+        annotations.append(annotation)
+    return annotations
+
+
+def filter_masks(annotations):  # filte the overlap mask
+    annotations.sort(key=lambda x: x["area"], reverse=True)
+    to_remove = set()
+    for i in range(0, len(annotations)):
+        a = annotations[i]
+        for j in range(i + 1, len(annotations)):
+            b = annotations[j]
+            if i != j and j not in to_remove:
+                # check if
+                if b["area"] < a["area"]:
+                    if (a["segmentation"] & b["segmentation"]).sum() / b[
+                        "segmentation"
+                    ].sum() > 0.8:
+                        to_remove.add(j)
+
+    return [a for i, a in enumerate(annotations) if i not in to_remove], to_remove
+
+
+def get_bbox_from_mask(mask):
+    mask = mask.astype(np.uint8)
+    contours, hierarchy = cv2.findContours(
+        mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+    x1, y1, w, h = cv2.boundingRect(contours[0])
+    x2, y2 = x1 + w, y1 + h
+    if len(contours) > 1:
+        for b in contours:
+            x_t, y_t, w_t, h_t = cv2.boundingRect(b)
+            # 将多个bbox合并成一个
+            x1 = min(x1, x_t)
+            y1 = min(y1, y_t)
+            x2 = max(x2, x_t + w_t)
+            y2 = max(y2, y_t + h_t)
+        h = y2 - y1
+        w = x2 - x1
+    return [x1, y1, x2, y2]
+
+
+def fast_process(
+    annotations, args, mask_random_color, bbox=None, points=None, edges=False
+):
+    if isinstance(annotations[0], dict):
+        annotations = [annotation["segmentation"] for annotation in annotations]
+    result_name = os.path.basename(args.img_path)
+    image = cv2.imread(args.img_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    original_h = image.shape[0]
+    original_w = image.shape[1]
+    plt.figure(figsize=(original_w/100, original_h/100))
+    plt.imshow(image)
+    if args.better_quality == True:
+        if isinstance(annotations[0], torch.Tensor):
+            annotations = np.array(annotations.cpu())
+        for i, mask in enumerate(annotations):
+            mask = cv2.morphologyEx(
+                mask.astype(np.uint8), cv2.MORPH_CLOSE, np.ones((3, 3), np.uint8)
+            )
+            annotations[i] = cv2.morphologyEx(
+                mask.astype(np.uint8), cv2.MORPH_OPEN, np.ones((8, 8), np.uint8)
+            )
+    if args.device == "cpu":
+        annotations = np.array(annotations)
+        fast_show_mask(
+            annotations,
+            plt.gca(),
+            random_color=mask_random_color,
+            bbox=bbox,
+            points=points,
+            pointlabel=args.point_label,
+            retinamask=args.retina,
+            target_height=original_h,
+            target_width=original_w,
+        )
+    else:
+        if isinstance(annotations[0], np.ndarray):
+            annotations = torch.from_numpy(annotations)
+        fast_show_mask_gpu(
+            annotations,
+            plt.gca(),
+            random_color=args.randomcolor,
+            bbox=bbox,
+            points=points,
+            pointlabel=args.point_label,
+            retinamask=args.retina,
+            target_height=original_h,
+            target_width=original_w,
+        )
+    if isinstance(annotations, torch.Tensor):
+        annotations = annotations.cpu().numpy()
+    if args.withContours == True:
+        contour_all = []
+        temp = np.zeros((original_h, original_w, 1))
+        for i, mask in enumerate(annotations):
+            if type(mask) == dict:
+                mask = mask["segmentation"]
+            annotation = mask.astype(np.uint8)
+            if args.retina == False:
+                annotation = cv2.resize(
+                    annotation,
+                    (original_w, original_h),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+            contours, hierarchy = cv2.findContours(
+                annotation, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+            )
+            for contour in contours:
+                contour_all.append(contour)
+        cv2.drawContours(temp, contour_all, -1, (255, 255, 255), 2)
+        color = np.array([0 / 255, 0 / 255, 255 / 255, 0.8])
+        contour_mask = temp / 255 * color.reshape(1, 1, -1)
+        plt.imshow(contour_mask)
+
+    save_path = args.output
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+    plt.axis("off")
+    fig = plt.gcf()
+    plt.draw()
+    buf = fig.canvas.tostring_rgb()
+    cols, rows = fig.canvas.get_width_height()
+    img_array = np.fromstring(buf, dtype=np.uint8).reshape(rows, cols, 3)
+    return img_array
+    # cv2.imwrite(os.path.join(save_path, result_name), cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR))
+
+
+
+#   CPU post process
+def fast_show_mask(
+    annotation,
+    ax,
+    random_color=False,
+    bbox=None,
+    points=None,
+    pointlabel=None,
+    retinamask=True,
+    target_height=960,
+    target_width=960,
+):
+    msak_sum = annotation.shape[0]
+    height = annotation.shape[1]
+    weight = annotation.shape[2]
+    # 将annotation 按照面积 排序
+    areas = np.sum(annotation, axis=(1, 2))
+    sorted_indices = np.argsort(areas)
+    annotation = annotation[sorted_indices]
+
+    index = (annotation != 0).argmax(axis=0)
+    if random_color == True:
+        color = np.random.random((msak_sum, 1, 1, 3))
+    else:
+        color = np.ones((msak_sum, 1, 1, 3)) * np.array(
+            [30 / 255, 144 / 255, 255 / 255]
+        )
+    transparency = np.ones((msak_sum, 1, 1, 1)) * 0.6
+    visual = np.concatenate([color, transparency], axis=-1)
+    mask_image = np.expand_dims(annotation, -1) * visual
+
+    show = np.zeros((height, weight, 4))
+    h_indices, w_indices = np.meshgrid(
+        np.arange(height), np.arange(weight), indexing="ij"
+    )
+    indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
+    # 使用向量化索引更新show的值
+    show[h_indices, w_indices, :] = mask_image[indices]
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        ax.add_patch(
+            plt.Rectangle(
+                (x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor="b", linewidth=1
+            )
+        )
+    # draw point
+    if points is not None:
+        plt.scatter(
+            [point[0] for i, point in enumerate(points) if pointlabel[i] == 1],
+            [point[1] for i, point in enumerate(points) if pointlabel[i] == 1],
+            s=20,
+            c="y",
+        )
+        plt.scatter(
+            [point[0] for i, point in enumerate(points) if pointlabel[i] == 0],
+            [point[1] for i, point in enumerate(points) if pointlabel[i] == 0],
+            s=20,
+            c="m",
+        )
+
+    if retinamask == False:
+        show = cv2.resize(
+            show, (target_width, target_height), interpolation=cv2.INTER_NEAREST
+        )
+    ax.imshow(show)
+
+
+def fast_show_mask_gpu(
+    annotation,
+    ax,
+    random_color=False,
+    bbox=None,
+    points=None,
+    pointlabel=None,
+    retinamask=True,
+    target_height=960,
+    target_width=960,
+):
+    msak_sum = annotation.shape[0]
+    height = annotation.shape[1]
+    weight = annotation.shape[2]
+    areas = torch.sum(annotation, dim=(1, 2))
+    sorted_indices = torch.argsort(areas, descending=False)
+    annotation = annotation[sorted_indices]
+    # 找每个位置第一个非零值下标
+    index = (annotation != 0).to(torch.long).argmax(dim=0)
+    if random_color == True:
+        color = torch.rand((msak_sum, 1, 1, 3)).to(annotation.device)
+    else:
+        color = torch.ones((msak_sum, 1, 1, 3)).to(annotation.device) * torch.tensor(
+            [30 / 255, 144 / 255, 255 / 255]
+        ).to(annotation.device)
+    transparency = torch.ones((msak_sum, 1, 1, 1)).to(annotation.device) * 0.6
+    visual = torch.cat([color, transparency], dim=-1)
+    mask_image = torch.unsqueeze(annotation, -1) * visual
+    # 按index取数，index指每个位置选哪个batch的数，把mask_image转成一个batch的形式
+    show = torch.zeros((height, weight, 4)).to(annotation.device)
+    h_indices, w_indices = torch.meshgrid(
+        torch.arange(height), torch.arange(weight), indexing="ij"
+    )
+    indices = (index[h_indices, w_indices], h_indices, w_indices, slice(None))
+    # 使用向量化索引更新show的值
+    show[h_indices, w_indices, :] = mask_image[indices]
+    show_cpu = show.cpu().numpy()
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        ax.add_patch(
+            plt.Rectangle(
+                (x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor="b", linewidth=1
+            )
+        )
+    # draw point
+    if points is not None:
+        plt.scatter(
+            [point[0] for i, point in enumerate(points) if pointlabel[i] == 1],
+            [point[1] for i, point in enumerate(points) if pointlabel[i] == 1],
+            s=20,
+            c="y",
+        )
+        plt.scatter(
+            [point[0] for i, point in enumerate(points) if pointlabel[i] == 0],
+            [point[1] for i, point in enumerate(points) if pointlabel[i] == 0],
+            s=20,
+            c="m",
+        )
+    if retinamask == False:
+        show_cpu = cv2.resize(
+            show_cpu, (target_width, target_height), interpolation=cv2.INTER_NEAREST
+        )
+    ax.imshow(show_cpu)
+
+
+# clip
+@torch.no_grad()
+def retriev(
+    model, preprocess, elements, search_text: str, device
+) -> int:
+    preprocessed_images = [preprocess(image).to(device) for image in elements]
+    tokenized_text = clip.tokenize([search_text]).to(device)
+    stacked_images = torch.stack(preprocessed_images)
+    image_features = model.encode_image(stacked_images)
+    text_features = model.encode_text(tokenized_text)
+    image_features /= image_features.norm(dim=-1, keepdim=True)
+    text_features /= text_features.norm(dim=-1, keepdim=True)
+    probs = 100.0 * image_features @ text_features.T
+    return probs[:, 0].softmax(dim=0)
+
+
+def crop_image(annotations, image_path):
+    image = Image.open(image_path)
+    ori_w, ori_h = image.size
+    mask_h, mask_w = annotations[0]["segmentation"].shape
+    if ori_w != mask_w or ori_h != mask_h:
+        image = image.resize((mask_w, mask_h))
+    cropped_boxes = []
+    cropped_images = []
+    not_crop = []
+    filter_id = []
+    # annotations, _ = filter_masks(annotations)
+    # filter_id = list(_)
+    for _, mask in enumerate(annotations):
+        if np.sum(mask["segmentation"]) <= 100:
+            filter_id.append(_)
+            continue
+        bbox = get_bbox_from_mask(mask["segmentation"])  # mask 的 bbox
+        cropped_boxes.append(segment_image(image, bbox))  # 保存裁剪的图片
+        # cropped_boxes.append(segment_image(image,mask["segmentation"]))
+        cropped_images.append(bbox)  # 保存裁剪的图片的bbox
+
+    return cropped_boxes, cropped_images, not_crop, filter_id, annotations
+
+
+def box_prompt(masks, bbox, target_height, target_width):
+    h = masks.shape[1]
+    w = masks.shape[2]
+    if h != target_height or w != target_width:
+        bbox = [
+            int(bbox[0] * w / target_width),
+            int(bbox[1] * h / target_height),
+            int(bbox[2] * w / target_width),
+            int(bbox[3] * h / target_height),
+        ]
+    bbox[0] = round(bbox[0]) if round(bbox[0]) > 0 else 0
+    bbox[1] = round(bbox[1]) if round(bbox[1]) > 0 else 0
+    bbox[2] = round(bbox[2]) if round(bbox[2]) < w else w
+    bbox[3] = round(bbox[3]) if round(bbox[3]) < h else h
+
+    # IoUs = torch.zeros(len(masks), dtype=torch.float32)
+    bbox_area = (bbox[3] - bbox[1]) * (bbox[2] - bbox[0])
+
+    masks_area = torch.sum(masks[:, bbox[1] : bbox[3], bbox[0] : bbox[2]], dim=(1, 2))
+    orig_masks_area = torch.sum(masks, dim=(1, 2))
+
+    union = bbox_area + orig_masks_area - masks_area
+    IoUs = masks_area / union
+    max_iou_index = torch.argmax(IoUs)
+
+    return masks[max_iou_index].cpu().numpy(), max_iou_index
+
+
+def point_prompt(masks, points, pointlabel, target_height, target_width):  # numpy 处理
+    h = masks[0]["segmentation"].shape[0]
+    w = masks[0]["segmentation"].shape[1]
+    if h != target_height or w != target_width:
+        points = [
+            [int(point[0] * w / target_width), int(point[1] * h / target_height)]
+            for point in points
+        ]
+    onemask = np.zeros((h, w))
+    for i, annotation in enumerate(masks):
+        if type(annotation) == dict:
+            mask = annotation["segmentation"]
+        else:
+            mask = annotation
+        for i, point in enumerate(points):
+            if mask[point[1], point[0]] == 1 and pointlabel[i] == 1:
+                onemask += mask
+            if mask[point[1], point[0]] == 1 and pointlabel[i] == 0:
+                onemask -= mask
+    onemask = onemask >= 1
+    return onemask, 0
+
+
+def text_prompt(annotations, args):
+    cropped_boxes, cropped_images, not_crop, filter_id, annotaions = crop_image(
+        annotations, args.img_path
+    )
+    clip_model, preprocess = clip.load("ViT-B/32", device=args.device)
+    scores = retriev(
+        clip_model, preprocess, cropped_boxes, args.text_prompt, device=args.device
+    )
+    max_idx = scores.argsort()
+    max_idx = max_idx[-1]
+    max_idx += sum(np.array(filter_id) <= int(max_idx))
+    return annotaions[max_idx]["segmentation"], max_idx

external/Grounded-Segment-Anything/EfficientSAM/LightHQSAM/setup_light_hqsam.py

@@ -0,0 +1,45 @@
+from LightHQSAM.tiny_vit_sam import TinyViT
+from segment_anything.modeling import MaskDecoderHQ, PromptEncoder, Sam, TwoWayTransformer
+
+def setup_model():
+    prompt_embed_dim = 256
+    image_size = 1024
+    vit_patch_size = 16
+    image_embedding_size = image_size // vit_patch_size
+    mobile_sam = Sam(
+            image_encoder=TinyViT(img_size=1024, in_chans=3, num_classes=1000,
+                embed_dims=[64, 128, 160, 320],
+                depths=[2, 2, 6, 2],
+                num_heads=[2, 4, 5, 10],
+                window_sizes=[7, 7, 14, 7],
+                mlp_ratio=4.,
+                drop_rate=0.,
+                drop_path_rate=0.0,
+                use_checkpoint=False,
+                mbconv_expand_ratio=4.0,
+                local_conv_size=3,
+                layer_lr_decay=0.8
+            ),
+            prompt_encoder=PromptEncoder(
+            embed_dim=prompt_embed_dim,
+            image_embedding_size=(image_embedding_size, image_embedding_size),
+            input_image_size=(image_size, image_size),
+            mask_in_chans=16,
+            ),
+            mask_decoder=MaskDecoderHQ(
+                    num_multimask_outputs=3,
+                    transformer=TwoWayTransformer(
+                    depth=2,
+                    embedding_dim=prompt_embed_dim,
+                    mlp_dim=2048,
+                    num_heads=8,
+                ),
+                transformer_dim=prompt_embed_dim,
+                iou_head_depth=3,
+                iou_head_hidden_dim=256,
+                vit_dim=160,
+            ),
+            pixel_mean=[123.675, 116.28, 103.53],
+            pixel_std=[58.395, 57.12, 57.375],
+        )
+    return mobile_sam

external/Grounded-Segment-Anything/EfficientSAM/LightHQSAM/tiny_vit_sam.py

@@ -0,0 +1,724 @@
+# --------------------------------------------------------
+# TinyViT Model Architecture
+# Copyright (c) 2022 Microsoft
+# Adapted from LeViT and Swin Transformer
+#   LeViT: (https://github.com/facebookresearch/levit)
+#   Swin: (https://github.com/microsoft/swin-transformer)
+# Build the TinyViT Model
+# --------------------------------------------------------
+
+import itertools
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+from timm.models.layers import DropPath as TimmDropPath,\
+    to_2tuple, trunc_normal_
+from timm.models.registry import register_model
+from typing import Tuple
+
+
+class Conv2d_BN(torch.nn.Sequential):
+    def __init__(self, a, b, ks=1, stride=1, pad=0, dilation=1,
+                 groups=1, bn_weight_init=1):
+        super().__init__()
+        self.add_module('c', torch.nn.Conv2d(
+            a, b, ks, stride, pad, dilation, groups, bias=False))
+        bn = torch.nn.BatchNorm2d(b)
+        torch.nn.init.constant_(bn.weight, bn_weight_init)
+        torch.nn.init.constant_(bn.bias, 0)
+        self.add_module('bn', bn)
+
+    @torch.no_grad()
+    def fuse(self):
+        c, bn = self._modules.values()
+        w = bn.weight / (bn.running_var + bn.eps)**0.5
+        w = c.weight * w[:, None, None, None]
+        b = bn.bias - bn.running_mean * bn.weight / \
+            (bn.running_var + bn.eps)**0.5
+        m = torch.nn.Conv2d(w.size(1) * self.c.groups, w.size(
+            0), w.shape[2:], stride=self.c.stride, padding=self.c.padding, dilation=self.c.dilation, groups=self.c.groups)
+        m.weight.data.copy_(w)
+        m.bias.data.copy_(b)
+        return m
+
+
+class DropPath(TimmDropPath):
+    def __init__(self, drop_prob=None):
+        super().__init__(drop_prob=drop_prob)
+        self.drop_prob = drop_prob
+
+    def __repr__(self):
+        msg = super().__repr__()
+        msg += f'(drop_prob={self.drop_prob})'
+        return msg
+
+
+class PatchEmbed(nn.Module):
+    def __init__(self, in_chans, embed_dim, resolution, activation):
+        super().__init__()
+        img_size: Tuple[int, int] = to_2tuple(resolution)
+        self.patches_resolution = (img_size[0] // 4, img_size[1] // 4)
+        self.num_patches = self.patches_resolution[0] * \
+            self.patches_resolution[1]
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+        n = embed_dim
+        self.seq = nn.Sequential(
+            Conv2d_BN(in_chans, n // 2, 3, 2, 1),
+            activation(),
+            Conv2d_BN(n // 2, n, 3, 2, 1),
+        )
+
+    def forward(self, x):
+        return self.seq(x)
+
+
+class MBConv(nn.Module):
+    def __init__(self, in_chans, out_chans, expand_ratio,
+                 activation, drop_path):
+        super().__init__()
+        self.in_chans = in_chans
+        self.hidden_chans = int(in_chans * expand_ratio)
+        self.out_chans = out_chans
+
+        self.conv1 = Conv2d_BN(in_chans, self.hidden_chans, ks=1)
+        self.act1 = activation()
+
+        self.conv2 = Conv2d_BN(self.hidden_chans, self.hidden_chans,
+                               ks=3, stride=1, pad=1, groups=self.hidden_chans)
+        self.act2 = activation()
+
+        self.conv3 = Conv2d_BN(
+            self.hidden_chans, out_chans, ks=1, bn_weight_init=0.0)
+        self.act3 = activation()
+
+        self.drop_path = DropPath(
+            drop_path) if drop_path > 0. else nn.Identity()
+
+    def forward(self, x):
+        shortcut = x
+
+        x = self.conv1(x)
+        x = self.act1(x)
+
+        x = self.conv2(x)
+        x = self.act2(x)
+
+        x = self.conv3(x)
+
+        x = self.drop_path(x)
+
+        x += shortcut
+        x = self.act3(x)
+
+        return x
+
+
+class PatchMerging(nn.Module):
+    def __init__(self, input_resolution, dim, out_dim, activation):
+        super().__init__()
+
+        self.input_resolution = input_resolution
+        self.dim = dim
+        self.out_dim = out_dim
+        self.act = activation()
+        self.conv1 = Conv2d_BN(dim, out_dim, 1, 1, 0)
+        stride_c=2
+        if(out_dim==320 or out_dim==448 or out_dim==576):
+            stride_c=1
+        self.conv2 = Conv2d_BN(out_dim, out_dim, 3, stride_c, 1, groups=out_dim)
+        self.conv3 = Conv2d_BN(out_dim, out_dim, 1, 1, 0)
+
+    def forward(self, x):
+        if x.ndim == 3:
+            H, W = self.input_resolution
+            B = len(x)
+            # (B, C, H, W)
+            x = x.view(B, H, W, -1).permute(0, 3, 1, 2)
+
+        x = self.conv1(x)
+        x = self.act(x)
+
+        x = self.conv2(x)
+        x = self.act(x)
+        x = self.conv3(x)
+        x = x.flatten(2).transpose(1, 2)
+        return x
+
+
+class ConvLayer(nn.Module):
+    def __init__(self, dim, input_resolution, depth,
+                 activation,
+                 drop_path=0., downsample=None, use_checkpoint=False,
+                 out_dim=None,
+                 conv_expand_ratio=4.,
+                 ):
+
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            MBConv(dim, dim, conv_expand_ratio, activation,
+                   drop_path[i] if isinstance(drop_path, list) else drop_path,
+                   )
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(
+                input_resolution, dim=dim, out_dim=out_dim, activation=activation)
+        else:
+            self.downsample = None
+
+    def forward(self, x):
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x)
+            else:
+                x = blk(x)
+        if self.downsample is not None:
+            x = self.downsample(x)
+        return x
+
+
+class Mlp(nn.Module):
+    def __init__(self, in_features, hidden_features=None,
+                 out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.norm = nn.LayerNorm(in_features)
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.act = act_layer()
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.norm(x)
+
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+class Attention(torch.nn.Module):
+    def __init__(self, dim, key_dim, num_heads=8,
+                 attn_ratio=4,
+                 resolution=(14, 14),
+                 ):
+        super().__init__()
+        # (h, w)
+        assert isinstance(resolution, tuple) and len(resolution) == 2
+        self.num_heads = num_heads
+        self.scale = key_dim ** -0.5
+        self.key_dim = key_dim
+        self.nh_kd = nh_kd = key_dim * num_heads
+        self.d = int(attn_ratio * key_dim)
+        self.dh = int(attn_ratio * key_dim) * num_heads
+        self.attn_ratio = attn_ratio
+        h = self.dh + nh_kd * 2
+
+        self.norm = nn.LayerNorm(dim)
+        self.qkv = nn.Linear(dim, h)
+        self.proj = nn.Linear(self.dh, dim)
+
+        points = list(itertools.product(
+            range(resolution[0]), range(resolution[1])))
+        N = len(points)
+        attention_offsets = {}
+        idxs = []
+        for p1 in points:
+            for p2 in points:
+                offset = (abs(p1[0] - p2[0]), abs(p1[1] - p2[1]))
+                if offset not in attention_offsets:
+                    attention_offsets[offset] = len(attention_offsets)
+                idxs.append(attention_offsets[offset])
+        self.attention_biases = torch.nn.Parameter(
+            torch.zeros(num_heads, len(attention_offsets)))
+        self.register_buffer('attention_bias_idxs',
+                             torch.LongTensor(idxs).view(N, N),
+                             persistent=False)
+
+    @torch.no_grad()
+    def train(self, mode=True):
+        super().train(mode)
+        if mode and hasattr(self, 'ab'):
+            del self.ab
+        else:
+            self.register_buffer('ab',
+                                 self.attention_biases[:, self.attention_bias_idxs],
+                                 persistent=False)
+
+    def forward(self, x):  # x (B,N,C)
+        B, N, _ = x.shape
+
+        # Normalization
+        x = self.norm(x)
+
+        qkv = self.qkv(x)
+        # (B, N, num_heads, d)
+        q, k, v = qkv.view(B, N, self.num_heads, -
+                           1).split([self.key_dim, self.key_dim, self.d], dim=3)
+        # (B, num_heads, N, d)
+        q = q.permute(0, 2, 1, 3)
+        k = k.permute(0, 2, 1, 3)
+        v = v.permute(0, 2, 1, 3)
+
+        attn = (
+            (q @ k.transpose(-2, -1)) * self.scale
+            +
+            (self.attention_biases[:, self.attention_bias_idxs]
+             if self.training else self.ab)
+        )
+        attn = attn.softmax(dim=-1)
+        x = (attn @ v).transpose(1, 2).reshape(B, N, self.dh)
+        x = self.proj(x)
+        return x
+
+
+class TinyViTBlock(nn.Module):
+    r""" TinyViT Block.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int, int]): Input resolution.
+        num_heads (int): Number of attention heads.
+        window_size (int): Window size.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        drop (float, optional): Dropout rate. Default: 0.0
+        drop_path (float, optional): Stochastic depth rate. Default: 0.0
+        local_conv_size (int): the kernel size of the convolution between
+                               Attention and MLP. Default: 3
+        activation: the activation function. Default: nn.GELU
+    """
+
+    def __init__(self, dim, input_resolution, num_heads, window_size=7,
+                 mlp_ratio=4., drop=0., drop_path=0.,
+                 local_conv_size=3,
+                 activation=nn.GELU,
+                 ):
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.num_heads = num_heads
+        assert window_size > 0, 'window_size must be greater than 0'
+        self.window_size = window_size
+        self.mlp_ratio = mlp_ratio
+
+        self.drop_path = DropPath(
+            drop_path) if drop_path > 0. else nn.Identity()
+
+        assert dim % num_heads == 0, 'dim must be divisible by num_heads'
+        head_dim = dim // num_heads
+
+        window_resolution = (window_size, window_size)
+        self.attn = Attention(dim, head_dim, num_heads,
+                              attn_ratio=1, resolution=window_resolution)
+
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        mlp_activation = activation
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim,
+                       act_layer=mlp_activation, drop=drop)
+
+        pad = local_conv_size // 2
+        self.local_conv = Conv2d_BN(
+            dim, dim, ks=local_conv_size, stride=1, pad=pad, groups=dim)
+
+    def forward(self, x):
+        H, W = self.input_resolution
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+        res_x = x
+        if H == self.window_size and W == self.window_size:
+            x = self.attn(x)
+        else:
+            x = x.view(B, H, W, C)
+            pad_b = (self.window_size - H %
+                     self.window_size) % self.window_size
+            pad_r = (self.window_size - W %
+                     self.window_size) % self.window_size
+            padding = pad_b > 0 or pad_r > 0
+
+            if padding:
+                x = F.pad(x, (0, 0, 0, pad_r, 0, pad_b))
+
+            pH, pW = H + pad_b, W + pad_r
+            nH = pH // self.window_size
+            nW = pW // self.window_size
+            # window partition
+            x = x.view(B, nH, self.window_size, nW, self.window_size, C).transpose(2, 3).reshape(
+                B * nH * nW, self.window_size * self.window_size, C)
+            x = self.attn(x)
+            # window reverse
+            x = x.view(B, nH, nW, self.window_size, self.window_size,
+                       C).transpose(2, 3).reshape(B, pH, pW, C)
+
+            if padding:
+                x = x[:, :H, :W].contiguous()
+
+            x = x.view(B, L, C)
+
+        x = res_x + self.drop_path(x)
+
+        x = x.transpose(1, 2).reshape(B, C, H, W)
+        x = self.local_conv(x)
+        x = x.view(B, C, L).transpose(1, 2)
+
+        x = x + self.drop_path(self.mlp(x))
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \
+               f"window_size={self.window_size}, mlp_ratio={self.mlp_ratio}"
+
+
+class BasicLayer(nn.Module):
+    """ A basic TinyViT layer for one stage.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resolution.
+        depth (int): Number of blocks.
+        num_heads (int): Number of attention heads.
+        window_size (int): Local window size.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        drop (float, optional): Dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+        local_conv_size: the kernel size of the depthwise convolution between attention and MLP. Default: 3
+        activation: the activation function. Default: nn.GELU
+        out_dim: the output dimension of the layer. Default: dim
+    """
+
+    def __init__(self, dim, input_resolution, depth, num_heads, window_size,
+                 mlp_ratio=4., drop=0.,
+                 drop_path=0., downsample=None, use_checkpoint=False,
+                 local_conv_size=3,
+                 activation=nn.GELU,
+                 out_dim=None,
+                 ):
+
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            TinyViTBlock(dim=dim, input_resolution=input_resolution,
+                         num_heads=num_heads, window_size=window_size,
+                         mlp_ratio=mlp_ratio,
+                         drop=drop,
+                         drop_path=drop_path[i] if isinstance(
+                             drop_path, list) else drop_path,
+                         local_conv_size=local_conv_size,
+                         activation=activation,
+                         )
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(
+                input_resolution, dim=dim, out_dim=out_dim, activation=activation)
+        else:
+            self.downsample = None
+
+    def forward(self, x):
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x)
+            else:
+                x = blk(x)
+        if self.downsample is not None:
+            x = self.downsample(x)
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"
+
+class LayerNorm2d(nn.Module):
+    def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(num_channels))
+        self.bias = nn.Parameter(torch.zeros(num_channels))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        u = x.mean(1, keepdim=True)
+        s = (x - u).pow(2).mean(1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.eps)
+        x = self.weight[:, None, None] * x + self.bias[:, None, None]
+        return x
+class TinyViT(nn.Module):
+    def __init__(self, img_size=224, in_chans=3, num_classes=1000,
+                 embed_dims=[96, 192, 384, 768], depths=[2, 2, 6, 2],
+                 num_heads=[3, 6, 12, 24],
+                 window_sizes=[7, 7, 14, 7],
+                 mlp_ratio=4.,
+                 drop_rate=0.,
+                 drop_path_rate=0.1,
+                 use_checkpoint=False,
+                 mbconv_expand_ratio=4.0,
+                 local_conv_size=3,
+                 layer_lr_decay=1.0,
+                 ):
+        super().__init__()
+        self.img_size=img_size
+        self.num_classes = num_classes
+        self.depths = depths
+        self.num_layers = len(depths)
+        self.mlp_ratio = mlp_ratio
+
+        activation = nn.GELU
+
+        self.patch_embed = PatchEmbed(in_chans=in_chans,
+                                      embed_dim=embed_dims[0],
+                                      resolution=img_size,
+                                      activation=activation)
+
+        patches_resolution = self.patch_embed.patches_resolution
+        self.patches_resolution = patches_resolution
+
+        # stochastic depth
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate,
+                                                sum(depths))]  # stochastic depth decay rule
+
+        # build layers
+        self.layers = nn.ModuleList()
+        for i_layer in range(self.num_layers):
+            kwargs = dict(dim=embed_dims[i_layer],
+                        input_resolution=(patches_resolution[0] // (2 ** (i_layer-1 if i_layer == 3 else i_layer)),
+                                patches_resolution[1] // (2 ** (i_layer-1 if i_layer == 3 else i_layer))),
+                        #   input_resolution=(patches_resolution[0] // (2 ** i_layer),
+                        #                     patches_resolution[1] // (2 ** i_layer)),
+                          depth=depths[i_layer],
+                          drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                          downsample=PatchMerging if (
+                              i_layer < self.num_layers - 1) else None,
+                          use_checkpoint=use_checkpoint,
+                          out_dim=embed_dims[min(
+                              i_layer + 1, len(embed_dims) - 1)],
+                          activation=activation,
+                          )
+            if i_layer == 0:
+                layer = ConvLayer(
+                    conv_expand_ratio=mbconv_expand_ratio,
+                    **kwargs,
+                )
+            else:
+                layer = BasicLayer(
+                    num_heads=num_heads[i_layer],
+                    window_size=window_sizes[i_layer],
+                    mlp_ratio=self.mlp_ratio,
+                    drop=drop_rate,
+                    local_conv_size=local_conv_size,
+                    **kwargs)
+            self.layers.append(layer)
+
+        # Classifier head
+        self.norm_head = nn.LayerNorm(embed_dims[-1])
+        self.head = nn.Linear(
+            embed_dims[-1], num_classes) if num_classes > 0 else torch.nn.Identity()
+
+        # init weights
+        self.apply(self._init_weights)
+        self.set_layer_lr_decay(layer_lr_decay)
+        self.neck = nn.Sequential(
+            nn.Conv2d(
+                embed_dims[-1],
+                256,
+                kernel_size=1,
+                bias=False,
+            ),
+            LayerNorm2d(256),
+            nn.Conv2d(
+                256,
+                256,
+                kernel_size=3,
+                padding=1,
+                bias=False,
+            ),
+            LayerNorm2d(256),
+        )
+    def set_layer_lr_decay(self, layer_lr_decay):
+        decay_rate = layer_lr_decay
+
+        # layers -> blocks (depth)
+        depth = sum(self.depths)
+        lr_scales = [decay_rate ** (depth - i - 1) for i in range(depth)]
+        #print("LR SCALES:", lr_scales)
+
+        def _set_lr_scale(m, scale):
+            for p in m.parameters():
+                p.lr_scale = scale
+
+        self.patch_embed.apply(lambda x: _set_lr_scale(x, lr_scales[0]))
+        i = 0
+        for layer in self.layers:
+            for block in layer.blocks:
+                block.apply(lambda x: _set_lr_scale(x, lr_scales[i]))
+                i += 1
+            if layer.downsample is not None:
+                layer.downsample.apply(
+                    lambda x: _set_lr_scale(x, lr_scales[i - 1]))
+        assert i == depth
+        for m in [self.norm_head, self.head]:
+            m.apply(lambda x: _set_lr_scale(x, lr_scales[-1]))
+
+        for k, p in self.named_parameters():
+            p.param_name = k
+
+        def _check_lr_scale(m):
+            for p in m.parameters():
+                assert hasattr(p, 'lr_scale'), p.param_name
+
+        self.apply(_check_lr_scale)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    @torch.jit.ignore
+    def no_weight_decay_keywords(self):
+        return {'attention_biases'}
+
+    def forward_features(self, x):
+        # x: (N, C, H, W)
+        x = self.patch_embed(x)
+
+        x = self.layers[0](x)
+        start_i = 1
+
+        interm_embeddings=[]
+        for i in range(start_i, len(self.layers)):
+            layer = self.layers[i]
+            x = layer(x)
+            # print('x shape:', x.shape, '---i:', i)
+            if i == 1:
+                interm_embeddings.append(x.view(x.shape[0], 64, 64, -1))
+
+        B,_,C=x.size()
+        x = x.view(B, 64, 64, C)
+        x=x.permute(0, 3, 1, 2)
+        x=self.neck(x)
+        return x, interm_embeddings
+
+    def forward(self, x):
+        x, interm_embeddings = self.forward_features(x)
+        #x = self.norm_head(x)
+        #x = self.head(x)
+        # print('come to here is correct'* 3)
+        return x, interm_embeddings
+
+
+_checkpoint_url_format = \
+    'https://github.com/wkcn/TinyViT-model-zoo/releases/download/checkpoints/{}.pth'
+_provided_checkpoints = {
+    'tiny_vit_5m_224': 'tiny_vit_5m_22kto1k_distill',
+    'tiny_vit_11m_224': 'tiny_vit_11m_22kto1k_distill',
+    'tiny_vit_21m_224': 'tiny_vit_21m_22kto1k_distill',
+    'tiny_vit_21m_384': 'tiny_vit_21m_22kto1k_384_distill',
+    'tiny_vit_21m_512': 'tiny_vit_21m_22kto1k_512_distill',
+}
+
+
+def register_tiny_vit_model(fn):
+    '''Register a TinyViT model
+    It is a wrapper of `register_model` with loading the pretrained checkpoint.
+    '''
+    def fn_wrapper(pretrained=False, **kwargs):
+        model = fn()
+        if pretrained:
+            model_name = fn.__name__
+            assert model_name in _provided_checkpoints, \
+                f'Sorry that the checkpoint `{model_name}` is not provided yet.'
+            url = _checkpoint_url_format.format(
+                _provided_checkpoints[model_name])
+            checkpoint = torch.hub.load_state_dict_from_url(
+                url=url,
+                map_location='cpu', check_hash=False,
+            )
+            model.load_state_dict(checkpoint['model'])
+
+        return model
+
+    # rename the name of fn_wrapper
+    fn_wrapper.__name__ = fn.__name__
+    return register_model(fn_wrapper)
+
+
+@register_tiny_vit_model
+def tiny_vit_5m_224(pretrained=False, num_classes=1000, drop_path_rate=0.0):
+    return TinyViT(
+        num_classes=num_classes,
+        embed_dims=[64, 128, 160, 320],
+        depths=[2, 2, 6, 2],
+        num_heads=[2, 4, 5, 10],
+        window_sizes=[7, 7, 14, 7],
+        drop_path_rate=drop_path_rate,
+    )
+
+
+@register_tiny_vit_model
+def tiny_vit_11m_224(pretrained=False, num_classes=1000, drop_path_rate=0.1):
+    return TinyViT(
+        num_classes=num_classes,
+        embed_dims=[64, 128, 256, 448],
+        depths=[2, 2, 6, 2],
+        num_heads=[2, 4, 8, 14],
+        window_sizes=[7, 7, 14, 7],
+        drop_path_rate=drop_path_rate,
+    )
+
+
+@register_tiny_vit_model
+def tiny_vit_21m_224(pretrained=False, num_classes=1000, drop_path_rate=0.2):
+    return TinyViT(
+        num_classes=num_classes,
+        embed_dims=[96, 192, 384, 576],
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 18],
+        window_sizes=[7, 7, 14, 7],
+        drop_path_rate=drop_path_rate,
+    )
+
+
+@register_tiny_vit_model
+def tiny_vit_21m_384(pretrained=False, num_classes=1000, drop_path_rate=0.1):
+    return TinyViT(
+        img_size=384,
+        num_classes=num_classes,
+        embed_dims=[96, 192, 384, 576],
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 18],
+        window_sizes=[12, 12, 24, 12],
+        drop_path_rate=drop_path_rate,
+    )
+
+
+@register_tiny_vit_model
+def tiny_vit_21m_512(pretrained=False, num_classes=1000, drop_path_rate=0.1):
+    return TinyViT(
+        img_size=512,
+        num_classes=num_classes,
+        embed_dims=[96, 192, 384, 576],
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 18],
+        window_sizes=[16, 16, 32, 16],
+        drop_path_rate=drop_path_rate,
+    )

external/Grounded-Segment-Anything/EfficientSAM/RepViTSAM/repvit.py

@@ -0,0 +1,364 @@
+import torch.nn as nn
+
+
+__all__ = ['repvit_m1']
+
+
+def _make_divisible(v, divisor, min_value=None):
+    """
+    This function is taken from the original tf repo.
+    It ensures that all layers have a channel number that is divisible by 8
+    It can be seen here:
+    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
+    :param v:
+    :param divisor:
+    :param min_value:
+    :return:
+    """
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than 10%.
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v
+
+from timm.models.layers import SqueezeExcite
+
+import torch
+
+# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py # noqa
+# Itself from https://github.com/facebookresearch/ConvNeXt/blob/d1fa8f6fef0a165b27399986cc2bdacc92777e40/models/convnext.py#L119  # noqa
+class LayerNorm2d(nn.Module):
+    def __init__(self, num_channels: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(num_channels))
+        self.bias = nn.Parameter(torch.zeros(num_channels))
+        self.eps = eps
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        u = x.mean(1, keepdim=True)
+        s = (x - u).pow(2).mean(1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.eps)
+        x = self.weight[:, None, None] * x + self.bias[:, None, None]
+        return x
+    
+class Conv2d_BN(torch.nn.Sequential):
+    def __init__(self, a, b, ks=1, stride=1, pad=0, dilation=1,
+                 groups=1, bn_weight_init=1, resolution=-10000):
+        super().__init__()
+        self.add_module('c', torch.nn.Conv2d(
+            a, b, ks, stride, pad, dilation, groups, bias=False))
+        self.add_module('bn', torch.nn.BatchNorm2d(b))
+        torch.nn.init.constant_(self.bn.weight, bn_weight_init)
+        torch.nn.init.constant_(self.bn.bias, 0)
+
+    @torch.no_grad()
+    def fuse(self):
+        c, bn = self._modules.values()
+        w = bn.weight / (bn.running_var + bn.eps)**0.5
+        w = c.weight * w[:, None, None, None]
+        b = bn.bias - bn.running_mean * bn.weight / \
+            (bn.running_var + bn.eps)**0.5
+        m = torch.nn.Conv2d(w.size(1) * self.c.groups, w.size(
+            0), w.shape[2:], stride=self.c.stride, padding=self.c.padding, dilation=self.c.dilation, groups=self.c.groups,
+            device=c.weight.device)
+        m.weight.data.copy_(w)
+        m.bias.data.copy_(b)
+        return m
+
+class Residual(torch.nn.Module):
+    def __init__(self, m, drop=0.):
+        super().__init__()
+        self.m = m
+        self.drop = drop
+
+    def forward(self, x):
+        if self.training and self.drop > 0:
+            return x + self.m(x) * torch.rand(x.size(0), 1, 1, 1,
+                                              device=x.device).ge_(self.drop).div(1 - self.drop).detach()
+        else:
+            return x + self.m(x)
+    
+    @torch.no_grad()
+    def fuse(self):
+        if isinstance(self.m, Conv2d_BN):
+            m = self.m.fuse()
+            assert(m.groups == m.in_channels)
+            identity = torch.ones(m.weight.shape[0], m.weight.shape[1], 1, 1)
+            identity = torch.nn.functional.pad(identity, [1,1,1,1])
+            m.weight += identity.to(m.weight.device)
+            return m
+        elif isinstance(self.m, torch.nn.Conv2d):
+            m = self.m
+            assert(m.groups != m.in_channels)
+            identity = torch.ones(m.weight.shape[0], m.weight.shape[1], 1, 1)
+            identity = torch.nn.functional.pad(identity, [1,1,1,1])
+            m.weight += identity.to(m.weight.device)
+            return m
+        else:
+            return self
+
+
+class RepVGGDW(torch.nn.Module):
+    def __init__(self, ed) -> None:
+        super().__init__()
+        self.conv = Conv2d_BN(ed, ed, 3, 1, 1, groups=ed)
+        self.conv1 = torch.nn.Conv2d(ed, ed, 1, 1, 0, groups=ed)
+        self.dim = ed
+        self.bn = torch.nn.BatchNorm2d(ed)
+    
+    def forward(self, x):
+        return self.bn((self.conv(x) + self.conv1(x)) + x)
+    
+    @torch.no_grad()
+    def fuse(self):
+        conv = self.conv.fuse()
+        conv1 = self.conv1
+        
+        conv_w = conv.weight
+        conv_b = conv.bias
+        conv1_w = conv1.weight
+        conv1_b = conv1.bias
+        
+        conv1_w = torch.nn.functional.pad(conv1_w, [1,1,1,1])
+
+        identity = torch.nn.functional.pad(torch.ones(conv1_w.shape[0], conv1_w.shape[1], 1, 1, device=conv1_w.device), [1,1,1,1])
+
+        final_conv_w = conv_w + conv1_w + identity
+        final_conv_b = conv_b + conv1_b
+
+        conv.weight.data.copy_(final_conv_w)
+        conv.bias.data.copy_(final_conv_b)
+
+        bn = self.bn
+        w = bn.weight / (bn.running_var + bn.eps)**0.5
+        w = conv.weight * w[:, None, None, None]
+        b = bn.bias + (conv.bias - bn.running_mean) * bn.weight / \
+            (bn.running_var + bn.eps)**0.5
+        conv.weight.data.copy_(w)
+        conv.bias.data.copy_(b)
+        return conv
+
+
+class RepViTBlock(nn.Module):
+    def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se, use_hs):
+        super(RepViTBlock, self).__init__()
+        assert stride in [1, 2]
+
+        self.identity = stride == 1 and inp == oup
+        assert(hidden_dim == 2 * inp)
+
+        if stride == 2:
+            self.token_mixer = nn.Sequential(
+                Conv2d_BN(inp, inp, kernel_size, stride if inp != 320 else 1, (kernel_size - 1) // 2, groups=inp),
+                SqueezeExcite(inp, 0.25) if use_se else nn.Identity(),
+                Conv2d_BN(inp, oup, ks=1, stride=1, pad=0)
+            )
+            self.channel_mixer = Residual(nn.Sequential(
+                    # pw
+                    Conv2d_BN(oup, 2 * oup, 1, 1, 0),
+                    nn.GELU() if use_hs else nn.GELU(),
+                    # pw-linear
+                    Conv2d_BN(2 * oup, oup, 1, 1, 0, bn_weight_init=0),
+                ))
+        else:
+            # assert(self.identity)
+            self.token_mixer = nn.Sequential(
+                RepVGGDW(inp),
+                SqueezeExcite(inp, 0.25) if use_se else nn.Identity(),
+            )
+            if self.identity:
+                self.channel_mixer = Residual(nn.Sequential(
+                        # pw
+                        Conv2d_BN(inp, hidden_dim, 1, 1, 0),
+                        nn.GELU() if use_hs else nn.GELU(),
+                        # pw-linear
+                        Conv2d_BN(hidden_dim, oup, 1, 1, 0, bn_weight_init=0),
+                    ))
+            else:
+                self.channel_mixer = nn.Sequential(
+                        # pw
+                        Conv2d_BN(inp, hidden_dim, 1, 1, 0),
+                        nn.GELU() if use_hs else nn.GELU(),
+                        # pw-linear
+                        Conv2d_BN(hidden_dim, oup, 1, 1, 0, bn_weight_init=0),
+                    )
+
+    def forward(self, x):
+        return self.channel_mixer(self.token_mixer(x))
+
+from timm.models.vision_transformer import trunc_normal_
+class BN_Linear(torch.nn.Sequential):
+    def __init__(self, a, b, bias=True, std=0.02):
+        super().__init__()
+        self.add_module('bn', torch.nn.BatchNorm1d(a))
+        self.add_module('l', torch.nn.Linear(a, b, bias=bias))
+        trunc_normal_(self.l.weight, std=std)
+        if bias:
+            torch.nn.init.constant_(self.l.bias, 0)
+
+    @torch.no_grad()
+    def fuse(self):
+        bn, l = self._modules.values()
+        w = bn.weight / (bn.running_var + bn.eps)**0.5
+        b = bn.bias - self.bn.running_mean * \
+            self.bn.weight / (bn.running_var + bn.eps)**0.5
+        w = l.weight * w[None, :]
+        if l.bias is None:
+            b = b @ self.l.weight.T
+        else:
+            b = (l.weight @ b[:, None]).view(-1) + self.l.bias
+        m = torch.nn.Linear(w.size(1), w.size(0), device=l.weight.device)
+        m.weight.data.copy_(w)
+        m.bias.data.copy_(b)
+        return m
+
+class Classfier(nn.Module):
+    def __init__(self, dim, num_classes, distillation=True):
+        super().__init__()
+        self.classifier = BN_Linear(dim, num_classes) if num_classes > 0 else torch.nn.Identity()
+        self.distillation = distillation
+        if distillation:
+            self.classifier_dist = BN_Linear(dim, num_classes) if num_classes > 0 else torch.nn.Identity()
+
+    def forward(self, x):
+        if self.distillation:
+            x = self.classifier(x), self.classifier_dist(x)
+            if not self.training:
+                x = (x[0] + x[1]) / 2
+        else:
+            x = self.classifier(x)
+        return x
+
+    @torch.no_grad()
+    def fuse(self):
+        classifier = self.classifier.fuse()
+        if self.distillation:
+            classifier_dist = self.classifier_dist.fuse()
+            classifier.weight += classifier_dist.weight
+            classifier.bias += classifier_dist.bias
+            classifier.weight /= 2
+            classifier.bias /= 2
+            return classifier
+        else:
+            return classifier
+
+class RepViT(nn.Module):
+    def __init__(self, cfgs, num_classes=1000, distillation=False, img_size=1024):
+        super(RepViT, self).__init__()
+        # setting of inverted residual blocks
+        self.cfgs = cfgs
+
+        self.img_size = img_size
+
+        # building first layer
+        input_channel = self.cfgs[0][2]
+        patch_embed = torch.nn.Sequential(Conv2d_BN(3, input_channel // 2, 3, 2, 1), torch.nn.GELU(),
+                           Conv2d_BN(input_channel // 2, input_channel, 3, 2, 1))
+        layers = [patch_embed]
+        # building inverted residual blocks
+        block = RepViTBlock
+        for k, t, c, use_se, use_hs, s in self.cfgs:
+            output_channel = _make_divisible(c, 8)
+            exp_size = _make_divisible(input_channel * t, 8)
+            layers.append(block(input_channel, exp_size, output_channel, k, s, use_se, use_hs))
+            input_channel = output_channel
+        self.features = nn.ModuleList(layers)
+        # self.classifier = Classfier(output_channel, num_classes, distillation)
+        
+        self.neck = nn.Sequential(
+            nn.Conv2d(
+                output_channel,
+                256,
+                kernel_size=1,
+                bias=False,
+            ),
+            LayerNorm2d(256),
+            nn.Conv2d(
+                256,
+                256,
+                kernel_size=3,
+                padding=1,
+                bias=False,
+            ),
+            LayerNorm2d(256),
+        )
+
+    def forward(self, x):
+        # x = self.features(x)
+        for f in self.features:
+            x = f(x)
+        # x = torch.nn.functional.adaptive_avg_pool2d(x, 1).flatten(1)
+        x = self.neck(x)
+        return x, None
+
+from timm.models import register_model
+
+@register_model
+def repvit(pretrained=False, num_classes = 1000, distillation=False, **kwargs):
+    """
+    Constructs a MobileNetV3-Large model
+    """
+    cfgs = [
+        # k, t, c, SE, HS, s 
+        [3,   2,  80, 1, 0, 1],
+        [3,   2,  80, 0, 0, 1],
+        [3,   2,  80, 1, 0, 1],
+        [3,   2,  80, 0, 0, 1],
+        [3,   2,  80, 1, 0, 1],
+        [3,   2,  80, 0, 0, 1],
+        [3,   2,  80, 0, 0, 1],
+        [3,   2,  160, 0, 0, 2],
+        [3,   2,  160, 1, 0, 1],
+        [3,   2,  160, 0, 0, 1],
+        [3,   2,  160, 1, 0, 1],
+        [3,   2,  160, 0, 0, 1],
+        [3,   2,  160, 1, 0, 1],
+        [3,   2,  160, 0, 0, 1],
+        [3,   2,  160, 0, 0, 1],
+        [3,   2,  320, 0, 1, 2],
+        [3,   2,  320, 1, 1, 1],
+        [3,   2,  320, 0, 1, 1],
+        [3,   2,  320, 1, 1, 1],
+        [3,   2,  320, 0, 1, 1],
+        [3,   2,  320, 1, 1, 1],
+        [3,   2,  320, 0, 1, 1],
+        [3,   2,  320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 1, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        # [3,   2, 320, 1, 1, 1],
+        # [3,   2, 320, 0, 1, 1],
+        [3,   2, 320, 0, 1, 1],
+        [3,   2, 640, 0, 1, 2],
+        [3,   2, 640, 1, 1, 1],
+        [3,   2, 640, 0, 1, 1],
+        # [3,   2, 640, 1, 1, 1],
+        # [3,   2, 640, 0, 1, 1]
+    ]    
+    return RepViT(cfgs, num_classes=num_classes, distillation=distillation)

external/Grounded-Segment-Anything/EfficientSAM/RepViTSAM/setup_repvit_sam.py

@@ -0,0 +1,53 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from functools import partial
+from segment_anything.modeling import ImageEncoderViT, MaskDecoder, PromptEncoder, Sam, TwoWayTransformer
+from RepViTSAM import repvit
+from timm.models import create_model
+
+def build_sam_repvit(checkpoint=None):
+    prompt_embed_dim = 256
+    image_size = 1024
+    vit_patch_size = 16
+    image_embedding_size = image_size // vit_patch_size
+    repvit_sam = Sam(
+            image_encoder=create_model('repvit'),
+            prompt_encoder=PromptEncoder(
+            embed_dim=prompt_embed_dim,
+            image_embedding_size=(image_embedding_size, image_embedding_size),
+            input_image_size=(image_size, image_size),
+            mask_in_chans=16,
+            ),
+            mask_decoder=MaskDecoder(
+                    num_multimask_outputs=3,
+                    transformer=TwoWayTransformer(
+                    depth=2,
+                    embedding_dim=prompt_embed_dim,
+                    mlp_dim=2048,
+                    num_heads=8,
+                ),
+                transformer_dim=prompt_embed_dim,
+                iou_head_depth=3,
+                iou_head_hidden_dim=256,
+            ),
+            pixel_mean=[123.675, 116.28, 103.53],
+            pixel_std=[58.395, 57.12, 57.375],
+        )
+
+    repvit_sam.eval()
+    if checkpoint is not None:
+        with open(checkpoint, "rb") as f:
+            state_dict = torch.load(f)
+        repvit_sam.load_state_dict(state_dict)
+    return repvit_sam
+
+from functools import partial
+
+sam_model_registry = {
+    "repvit": partial(build_sam_repvit),
+}

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

@@ -0,0 +1,161 @@
+## DeepFloyd
+
+:grapes: [[Official Project Page](https://github.com/deep-floyd/IF)]   :apple:[[Official Online Demo](https://huggingface.co/spaces/DeepFloyd/IF)]
+
+> DeepFloyd IF is a novel state-of-the-art open-source text-to-image model with a high degree of photorealism and language understanding. 
+
+We've thoughtfully put together some important details for you to keep in mind while using the DeepFloyd models. We sincerely hope this will assist you in creating even more interesting demos with IF. Enjoy your creative journey!
+
+## Table of Contents
+- [Installation Details](#installation)
+  - [Detailed installation guide](#detailed-installation-guide)
+  - [Additional note for bug fixing](#additional-notes-for-bug-fixing)
+- [Requirements before running demo](#requirements-before-running-demos)
+- [DeepFloyd Demos](#deepfloyd-demos)
+  - [Dream: Text to Image](#dream)
+  - [Style Transfer](#style-transfer)
+
+
+## TODO
+- [x] Add installation guide (Continual Updating)
+- [x] Test Text-to-Image model
+- [x] Test Style-Transfer model
+- [ ] Add Inpaint demo (seems not work well)
+- [ ] Add SAM inpaint and Grounded-SAM inpaint demo
+
+## Installation
+### Detailed installation guide
+There're more things you should take care for installing DeepFloyd despite of their official guide. You can install DeepFloyd as follows:
+
+- Create a new environment using `Python=3.10`
+
+```bash
+conda create -n floyd python=3.10 -y
+conda activate floyd
+```
+
+- DeepFloyd need [xformers](https://github.com/facebookresearch/xformers) to accelerate some attention mechanism and reduce the GPU memory usage. And `xformers` requires at least [PyTorch 1.12.1, PyTorch 1.13.1 or 2.0.0 installed with conda](https://pytorch.org/get-started/locally/).
+  - If you only have CUDA 11.4 or lower CUDA version installed, you can only PyTorch 1.12.1 locally as:
+  ```bash
+  conda install pytorch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1 -c pytorch
+  ```
+  - After installing PyTorch, it's highly recommended to install xformers using conda:
+  ```bash
+  conda install xformers -c xformers
+  ```
+
+- Then install deepfloyd following their official guidance:
+```bash
+pip install deepfloyd_if==1.0.2rc0
+pip install git+https://github.com/openai/CLIP.git --no-deps
+```
+
+### Additional notes for bug fixing
+
+- [Attention] To use DeepFloyd with diffusers for saving GPU memory usage, you should update your transformers to at least `4.27.0` and accelerate to `0.17.0`.
+
+```bash
+pip install transformers==4.27.1
+pip install accelerate==0.17.0
+```
+
+- And refer to [DeepFloyd/issue64](https://github.com/deep-floyd/IF/pull/64), there are some bugs with inpainting demos, you need `protobuf==3.19.0` to load T5Embedder and `scikit-image` for inpainting
+
+```bash
+pip install protobuf==3.19.0
+pip install scikit-image
+```
+
+However this bug has not been updated to the python package of `DeepFloyd`, so the users should update the code manually follow issue64 or install `DeepFloyd` locally as:
+
+```bash
+git clone https://github.com/deep-floyd/IF.git
+cd IF
+pip install -e .
+```
+
+## Requirements before running demos
+Before running DeepFloyd demo, please refer to [Integration with DIffusers](https://github.com/deep-floyd/IF#integration-with--diffusers) for some requirements for the pretrained weights.
+
+If you want to download the weights into **specific dir**, you can set `cache_dir` as follows:
+
+- *Under diffusers*
+```python
+from diffusers import DiffusionPipeline
+from diffusers.utils import pt_to_pil
+import torch
+
+cache_dir = "path/to/specific_dir"
+# stage 1
+stage_1 = DiffusionPipeline.from_pretrained(
+    "DeepFloyd/IF-I-XL-v1.0", 
+    variant="fp16", 
+    torch_dtype=torch.float16,
+    cache_dir=cache_dir  # loading model from specific dir
+  )
+stage_1.enable_xformers_memory_efficient_attention()  # remove line if torch.__version__ >= 2.0.0
+stage_1.enable_model_cpu_offload()
+```
+
+- *Runing locally*
+```python
+from deepfloyd_if.modules import IFStageI, IFStageII, StableStageIII
+from deepfloyd_if.modules.t5 import T5Embedder
+
+cache_dir = "path/to/cache_dir"
+device = 'cuda:0'
+if_I = IFStageI('IF-I-XL-v1.0', device=device, cache_dir=cache_dir)
+if_II = IFStageII('IF-II-L-v1.0', device=device, cache_dir=cache_dir)
+if_III = StableStageIII('stable-diffusion-x4-upscaler', device=device, cache_dir=cache_dir)
+t5 = T5Embedder(device="cpu", cache_dir=cache_dir)
+```
+
+## DeepFloyd Demos
+
+- 16GB vRAM for IF-I-XL (4.3B text to 64x64 base module) & IF-II-L (1.2B to 256x256 upscaler module)
+- 24GB vRAM for IF-I-XL (4.3B text to 64x64 base module) & IF-II-L (1.2B to 256x256 upscaler module) & Stable x4 (to 1024x1024 upscaler)
+- ***(Highlight)*** `xformers` and set env variable `FORCE_MEM_EFFICIENT_ATTN=1`, which may help you to save lots of GPU memory usage
+```bash
+export FORCE_MEM_EFFICIENT_ATTN=1
+```
+
+### Dream
+The `text-to-image` mode for DeepFloyd
+```python
+cd playground/DeepFloyd
+
+export FORCE_MEM_EFFICIENT_ATTN=1 
+python dream.py
+```
+It takes around `26GB` GPU memory usage for this demo. You can download the following awesome generated images from [inpaint playground storage](https://github.com/IDEA-Research/detrex-storage/tree/main/assets/grounded_sam/inpaint_playground).
+
+<!-- <div style="text-align: center;">
+    <img src="./example/dream1.jpg" style="margin:auto;" width="60%">
+</div> -->
+
+
+| Prompt (Generated by GPT-4) | Generated Image |
+|:----   |  :----: |
+| Underneath the galaxy sky, luminescent stars scatter across the vast expanse like diamond dust. Swirls of cosmic purple and blue nebulae coalesce, creating an ethereal canvas. A solitary tree silhouetted against the astral backdrop, roots burrowed deep into the earth, reaching towards the heavens. Leaves shimmer, reflecting the stellar light show. A lone figure, small against the celestial spectacle, contemplates their insignificance in the grandeur of the universe. The galaxy's reflection on a still, tranquil lake creates a stunning mirror image, tying the earth and cosmos together in a mesmerizing dance of light, space, and time. | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/dream1.jpg?raw=True) |
+|Beneath the vast sky, a mesmerizing seascape unfolds. The cerulean sea stretches out to infinity, its surface gently disturbed by the breath of the wind, creating delicate ripples. Sunlight dances on the water, transforming the ocean into a shimmering tapestry of light and shadow. A solitary sailboat navigates the expanse, its white sail billowing against the sapphire backdrop. Nearby, a lighthouse stands resolute on a rocky outcrop, its beacon piercing through the soft maritime mist. Shoreline meets the sea in a frothy embrace, while seagulls wheel overhead, their cries echoing the eternal song of the sea. The scent of salt and freedom fills the air, painting a picture of unbound exploration and serene beauty. | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/dream2.jpg?raw=True) |
+| In the heart of the wilderness, an enchanting forest reveals itself. Towering trees, their trunks sturdy and thick, reach skyward, their leafy canopies forming a natural cathedral. Verdant moss clings to bark, and tendrils of ivy climb ambitiously towards the sun-dappled treetops. The forest floor is a tapestry of fallen leaves, sprinkled with delicate wildflowers. The soft chatter of wildlife resonates, while a nearby brook babbles, its clear waters winking in the dappled light. Sunrays filter through the foliage, casting an emerald glow that dances on the woodland floor. Amidst the tranquility, the forest teems with life, whispering ancient secrets on the breeze. |![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/dream3.jpg?raw=True) |
+
+
+### Style Transfer
+Download the original image from [here](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/style_transfer/original.jpg), which is borrowed from DeepFloyd official image.
+
+<div style="text-align: center">
+<img src="https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/style_transfer/original.jpg?raw=True" width=50%>
+</div>
+
+```python
+cd playground/DeepFloyd
+
+export FORCE_MEM_EFFICIENT_ATTN=1 
+python style_transfer.py
+```
+
+Style | Transfer Image (W/O SuperResolution) |
+|  :----: |  :----: |
+| *colorful and cute kawaii art* | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/style_transfer/style_transfer_0.jpg?raw=True) |
+| *boho-chic textile patterns* | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/inpaint_playground/style_transfer/style_transfer_1.jpg?raw=True) |

external/Grounded-Segment-Anything/playground/DeepFloyd/dream.py

@@ -0,0 +1,39 @@
+from deepfloyd_if.modules import IFStageI, IFStageII, StableStageIII
+from deepfloyd_if.modules.t5 import T5Embedder
+from deepfloyd_if.pipelines import dream
+
+# Run locally
+device = 'cuda'
+cache_dir = "/path/to/storage/IF"
+if_I = IFStageI('IF-I-L-v1.0', device=device, cache_dir=cache_dir)
+if_II = IFStageII('IF-II-L-v1.0', device=device, cache_dir=cache_dir)
+if_III = StableStageIII('stable-diffusion-x4-upscaler', device=device, cache_dir=cache_dir)
+t5 = T5Embedder(device=device, cache_dir=cache_dir)
+
+prompt = "In the heart of the wilderness, an enchanting forest reveals itself. \
+    Towering trees, their trunks sturdy and thick, reach skyward, their leafy canopies \
+    forming a natural cathedral. Verdant moss clings to bark, and tendrils of ivy climb ambitiously towards the sun-dappled treetops. \
+    The forest floor is a tapestry of fallen leaves, sprinkled with delicate wildflowers. The soft chatter of wildlife resonates, while a nearby brook babbles, its clear waters winking in the dappled light. \
+    Sunrays filter through the foliage, casting an emerald glow that dances on the woodland floor. Amidst the tranquility, the forest teems with life, whispering ancient secrets on the breeze."
+count = 1
+
+result = dream(
+    t5=t5, if_I=if_I, if_II=if_II, if_III=if_III,
+    prompt=[prompt]*count,
+    seed=42,
+    if_I_kwargs={
+        "guidance_scale": 7.0,
+        "sample_timestep_respacing": "smart100",
+    },
+    if_II_kwargs={
+        "guidance_scale": 4.0,
+        "sample_timestep_respacing": "smart50",
+    },
+    if_III_kwargs={
+        "guidance_scale": 9.0,
+        "noise_level": 20,
+        "sample_timestep_respacing": "75",
+    },
+)
+result['III'][0].save("./dream_figure.jpg")
+

external/Grounded-Segment-Anything/playground/DeepFloyd/inpaint.py

@@ -0,0 +1,59 @@
+import PIL
+import requests
+from io import BytesIO
+from torchvision.transforms import ToTensor
+
+from deepfloyd_if.modules import IFStageI, IFStageII, StableStageIII
+from deepfloyd_if.modules.t5 import T5Embedder
+from deepfloyd_if.pipelines import inpainting
+
+def download_image(url):
+    response = requests.get(url)
+    return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+img_url = "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/image/example_1.png"
+mask_url = "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/mask/example_1.png"
+
+init_image = download_image(img_url).resize((512, 512))
+mask_image = download_image(mask_url).resize((512, 512))
+
+# convert mask_image to torch.Tensor to avoid bug
+mask_image = ToTensor()(mask_image).unsqueeze(0)  # (1, 3, 512, 512)
+
+# Run locally
+device = 'cuda:5'
+cache_dir = "/comp_robot/rentianhe/weights/IF/"
+if_I = IFStageI('IF-I-L-v1.0', device=device, cache_dir=cache_dir)
+if_II = IFStageII('IF-II-L-v1.0', device=device, cache_dir=cache_dir)
+if_III = StableStageIII('stable-diffusion-x4-upscaler', device=device, cache_dir=cache_dir)
+t5 = T5Embedder(device=device, cache_dir=cache_dir)
+result = inpainting(
+    t5=t5, if_I=if_I,
+    if_II=if_II,
+    if_III=if_III,
+    support_pil_img=init_image,
+    inpainting_mask=mask_image,
+    prompt=[
+        'A Panda'
+    ],
+    seed=42,
+    if_I_kwargs={
+        "guidance_scale": 7.0,
+        "sample_timestep_respacing": "10,10,10,10,10,0,0,0,0,0",
+        'support_noise_less_qsample_steps': 0,
+    },
+    if_II_kwargs={
+        "guidance_scale": 4.0,
+        'aug_level': 0.0,
+        "sample_timestep_respacing": '100',
+    },
+    if_III_kwargs={
+        "guidance_scale": 9.0,
+        "noise_level": 20,
+        "sample_timestep_respacing": "75",
+    },
+)
+if_I.show(result['I'], 2, 3)
+if_I.show(result['II'], 2, 6)
+if_I.show(result['III'], 2, 14)
+

external/Grounded-Segment-Anything/playground/DeepFloyd/style_transfer.py

@@ -0,0 +1,43 @@
+from PIL import Image
+
+from deepfloyd_if.modules import IFStageI, IFStageII
+from deepfloyd_if.modules.t5 import T5Embedder
+from deepfloyd_if.pipelines import style_transfer
+
+# Run locally
+device = 'cuda'
+cache_dir = "/path/to/storage/IF"
+if_I = IFStageI('IF-I-XL-v1.0', device=device, cache_dir=cache_dir)
+if_II = IFStageII('IF-II-L-v1.0', device=device, cache_dir=cache_dir)
+t5 = T5Embedder(device=device, cache_dir=cache_dir)
+
+# Style generate from GPT-4
+style_prompt = [
+    "in style of colorful and cute kawaii art",
+    "in style of boho-chic textile patterns",
+]
+
+raw_pil_image = Image.open("/path/to/image")
+
+result = style_transfer(
+    t5=t5, if_I=if_I, if_II=if_II,
+    support_pil_img=raw_pil_image,
+    style_prompt=style_prompt,
+    seed=42,
+    if_I_kwargs={
+        "guidance_scale": 10.0,
+        "sample_timestep_respacing": "10,10,10,10,10,10,10,10,0,0",
+        'support_noise_less_qsample_steps': 5,
+    },
+    if_II_kwargs={
+        "guidance_scale": 4.0,
+        "sample_timestep_respacing": 'smart50',
+        "support_noise_less_qsample_steps": 5,
+    },
+)
+
+# save all the images generated in StageII
+for i, image in enumerate(result["II"]):
+    image.save("./style_transfer_{}.jpg".format(i))
+
+

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

@@ -0,0 +1,77 @@
+## ImageBind with SAM
+
+This is an experimental demo aims to combine [ImageBind](https://github.com/facebookresearch/ImageBind) and [SAM](https://github.com/facebookresearch/segment-anything) to generate mask **with different modalities**.
+
+This basic idea is followed with [IEA: Image Editing Anything](https://github.com/feizc/IEA) and [CLIP-SAM](https://github.com/maxi-w/CLIP-SAM) which generate the referring mask with the following steps:
+
+- Step 1: Generate auto masks with `SamAutomaticMaskGenerator`
+- Step 2: Crop all the box region from the masks
+- Step 3: Compute the similarity with cropped images and different modalities
+- Step 4: Merge the highest similarity mask region
+
+## Table of contents
+- [Installation](#installation)
+- [ImageBind-SAM Demo](#run-the-demo)
+- [Audio Referring Segment](#run-audio-referring-segment-demo)
+- [Text Referring Segment](#run-text-referring-segment-demo)
+- [Image Referring Segment](#run-image-referring-segmentation-demo)
+
+
+
+## Installation
+- Download the pretrained checkpoints
+
+```bash
+cd playground/ImageBind_SAM
+
+mkdir .checkpoints
+cd .checkpoints
+
+# download imagebind weights
+wget https://dl.fbaipublicfiles.com/imagebind/imagebind_huge.pth
+wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
+```
+
+- Install ImageBind follow the [official installation guidance](https://github.com/facebookresearch/ImageBind#usage).
+- Install Grounded-SAM follow [install Grounded-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything#installation).
+
+
+## Run the demo
+```bash
+python demo.py
+```
+
+We implement `Text Seg` and `Audio Seg` in this demo, the generate masks will be saved as `text_sam_merged_mask.jpg` and `audio_sam_merged_mask.jpg`:
+
+<div align="center">
+
+| Input Model | Modality | Generate Mask |
+|:----:|:----:|:----:|
+| ![](./.assets/car_image.jpg) | [car audio](./.assets/car_audio.wav) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/imagebind_sam/audio_sam_merged_mask_new.jpg?raw=true) |
+| ![](./.assets/car_image.jpg) | "A car" | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/imagebind_sam/text_sam_merged_mask.jpg?raw=true) |
+| ![](./.assets/car_image.jpg) | <div style="text-align: center"> <img src="https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/imagebind_sam/referring_car_image.jpg?raw=true" width=55%></div> | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/imagebind_sam/image_referring_sam_merged_mask.jpg?raw=true) |
+
+
+</div>
+
+By setting different threshold may influence a lot on the final results.
+
+## Run image referring segmentation demo
+```bash
+# download the referring image
+cd .assets
+wget https://github.com/IDEA-Research/detrex-storage/releases/download/grounded-sam-storage/referring_car_image.jpg
+cd ..
+
+python image_referring_seg_demo.py
+```
+
+## Run audio referring segmentation demo
+```bash
+python audio_referring_seg_demo.py
+```
+
+## Run text referring segmentation demo
+```bash
+python text_referring_seg_demo.py
+```

external/Grounded-Segment-Anything/playground/ImageBind_SAM/audio_referring_seg_demo.py

@@ -0,0 +1,97 @@
+import data
+import cv2
+import torch
+from PIL import Image, ImageDraw
+from tqdm import tqdm
+from models import imagebind_model
+from models.imagebind_model import ModalityType
+
+from segment_anything import build_sam, SamAutomaticMaskGenerator
+
+from utils import (
+    segment_image, 
+    convert_box_xywh_to_xyxy,
+    get_indices_of_values_above_threshold,
+)
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+"""
+Step 1: Instantiate model
+"""
+# Segment Anything
+mask_generator = SamAutomaticMaskGenerator(
+    build_sam(checkpoint=".checkpoints/sam_vit_h_4b8939.pth").to(device),
+    points_per_side=16,
+)
+
+# ImageBind
+bind_model = imagebind_model.imagebind_huge(pretrained=True)
+bind_model.eval()
+bind_model.to(device)
+
+
+"""
+Step 2: Generate auto masks with SAM
+"""
+image_path = ".assets/car_image.jpg"
+image = cv2.imread(image_path)
+image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+masks = mask_generator.generate(image)
+
+
+"""
+Step 3: Get cropped images based on mask and box
+"""
+cropped_boxes = []
+image = Image.open(image_path)
+for mask in tqdm(masks):
+    cropped_boxes.append(segment_image(image, mask["segmentation"]).crop(convert_box_xywh_to_xyxy(mask["bbox"])))
+
+
+"""
+Step 4: Run ImageBind model to get similarity between cropped image and different modalities
+"""
+def retriev_vision_and_audio(elements, audio_list):
+    inputs = {
+        ModalityType.VISION: data.load_and_transform_vision_data_from_pil_image(elements, device),
+        ModalityType.AUDIO: data.load_and_transform_audio_data(audio_list, device),
+    }
+    with torch.no_grad():
+        embeddings = bind_model(inputs)
+    vision_audio = torch.softmax(embeddings[ModalityType.VISION] @ embeddings[ModalityType.AUDIO].T, dim=0),
+    return vision_audio 
+
+vision_audio_result = retriev_vision_and_audio(cropped_boxes, [".assets/car_audio.wav"])
+
+
+"""
+Step 5: Merge the top similarity masks to get the final mask and save the merged mask
+
+This is the audio retrival result
+"""
+
+# get highest similar mask with threshold
+# result[0] shape: [113, 1]
+threshold = 0.025
+index = get_indices_of_values_above_threshold(vision_audio_result[0], threshold)
+
+segmentation_masks = []
+for seg_idx in index:
+    segmentation_mask_image = Image.fromarray(masks[seg_idx]["segmentation"].astype('uint8') * 255)
+    segmentation_masks.append(segmentation_mask_image)
+
+original_image = Image.open(image_path)
+overlay_image = Image.new('RGBA', image.size, (0, 0, 0, 255))
+overlay_color = (255, 255, 255, 0)
+
+draw = ImageDraw.Draw(overlay_image)
+for segmentation_mask_image in segmentation_masks:
+    draw.bitmap((0, 0), segmentation_mask_image, fill=overlay_color)
+
+# return Image.alpha_composite(original_image.convert('RGBA'), overlay_image) 
+mask_image = overlay_image.convert("RGB")
+mask_image.save("./audio_sam_merged_mask.jpg")
+

external/Grounded-Segment-Anything/playground/ImageBind_SAM/data.py

@@ -0,0 +1,373 @@
+#!/usr/bin/env python3
+# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+
+import torch
+import torch.nn as nn
+import torchaudio
+import logging
+
+from models.multimodal_preprocessors import SimpleTokenizer
+from PIL import Image
+from pytorchvideo import transforms as pv_transforms
+from pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
+from pytorchvideo.data.encoded_video import EncodedVideo
+
+from torchvision import transforms
+from torchvision.transforms._transforms_video import NormalizeVideo
+
+DEFAULT_AUDIO_FRAME_SHIFT_MS = 10  # in milliseconds
+
+BPE_PATH = "bpe/bpe_simple_vocab_16e6.txt.gz"
+
+
+def waveform2melspec(waveform, sample_rate, num_mel_bins, target_length):
+    # Based on https://github.com/YuanGongND/ast/blob/d7d8b4b8e06cdaeb6c843cdb38794c1c7692234c/src/dataloader.py#L102
+    waveform -= waveform.mean()
+    fbank = torchaudio.compliance.kaldi.fbank(
+        waveform,
+        htk_compat=True,
+        sample_frequency=sample_rate,
+        use_energy=False,
+        window_type="hanning",
+        num_mel_bins=num_mel_bins,
+        dither=0.0,
+        frame_length=25,
+        frame_shift=DEFAULT_AUDIO_FRAME_SHIFT_MS,
+    )
+    # Convert to [mel_bins, num_frames] shape
+    fbank = fbank.transpose(0, 1)
+    # Pad to target_length
+    n_frames = fbank.size(1)
+    p = target_length - n_frames
+    # if p is too large (say >20%), flash a warning
+    if abs(p) / n_frames > 0.2:
+        logging.warning(
+            "Large gap between audio n_frames(%d) and "
+            "target_length (%d). Is the audio_target_length "
+            "setting correct?",
+            n_frames,
+            target_length,
+        )
+    # cut and pad
+    if p > 0:
+        fbank = torch.nn.functional.pad(fbank, (0, p), mode="constant", value=0)
+    elif p < 0:
+        fbank = fbank[:, 0:target_length]
+    # Convert to [1, mel_bins, num_frames] shape, essentially like a 1
+    # channel image
+    fbank = fbank.unsqueeze(0)
+    return fbank
+
+
+def get_clip_timepoints(clip_sampler, duration):
+    # Read out all clips in this video
+    all_clips_timepoints = []
+    is_last_clip = False
+    end = 0.0
+    while not is_last_clip:
+        start, end, _, _, is_last_clip = clip_sampler(end, duration, annotation=None)
+        all_clips_timepoints.append((start, end))
+    return all_clips_timepoints
+
+def load_and_transform_vision_data_from_pil_image(img_list, device):
+    if img_list is None:
+        return None
+
+    image_ouputs = []
+    for image in img_list:
+        data_transform = transforms.Compose(
+            [
+                transforms.Resize(
+                    224, interpolation=transforms.InterpolationMode.BICUBIC
+                ),
+                transforms.CenterCrop(224),
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    mean=(0.48145466, 0.4578275, 0.40821073),
+                    std=(0.26862954, 0.26130258, 0.27577711),
+                ),
+            ]
+        )
+
+        image = data_transform(image).to(device)
+        image_ouputs.append(image)
+    return torch.stack(image_ouputs, dim=0)
+
+def load_and_transform_vision_data(image_paths, device):
+    if image_paths is None:
+        return None
+
+    image_ouputs = []
+    for image_path in image_paths:
+        data_transform = transforms.Compose(
+            [
+                transforms.Resize(
+                    224, interpolation=transforms.InterpolationMode.BICUBIC
+                ),
+                transforms.CenterCrop(224),
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    mean=(0.48145466, 0.4578275, 0.40821073),
+                    std=(0.26862954, 0.26130258, 0.27577711),
+                ),
+            ]
+        )
+        with open(image_path, "rb") as fopen:
+            image = Image.open(fopen).convert("RGB")
+
+        image = data_transform(image).to(device)
+        image_ouputs.append(image)
+    return torch.stack(image_ouputs, dim=0)
+
+
+def load_and_transform_text(text, device):
+    if text is None:
+        return None
+    tokenizer = SimpleTokenizer(bpe_path=BPE_PATH)
+    tokens = [tokenizer(t).unsqueeze(0).to(device) for t in text]
+    tokens = torch.cat(tokens, dim=0)
+    return tokens
+
+
+def load_and_transform_audio_data(
+    audio_paths,
+    device,
+    num_mel_bins=128,
+    target_length=204,
+    sample_rate=16000,
+    clip_duration=2,
+    clips_per_video=3,
+    mean=-4.268,
+    std=9.138,
+):
+    if audio_paths is None:
+        return None
+
+    audio_outputs = []
+    clip_sampler = ConstantClipsPerVideoSampler(
+        clip_duration=clip_duration, clips_per_video=clips_per_video
+    )
+
+    for audio_path in audio_paths:
+        waveform, sr = torchaudio.load(audio_path)
+        if sample_rate != sr:
+            waveform = torchaudio.functional.resample(
+                waveform, orig_freq=sr, new_freq=sample_rate
+            )
+        all_clips_timepoints = get_clip_timepoints(
+            clip_sampler, waveform.size(1) / sample_rate
+        )
+        all_clips = []
+        for clip_timepoints in all_clips_timepoints:
+            waveform_clip = waveform[
+                :,
+                int(clip_timepoints[0] * sample_rate) : int(
+                    clip_timepoints[1] * sample_rate
+                ),
+            ]
+            waveform_melspec = waveform2melspec(
+                waveform_clip, sample_rate, num_mel_bins, target_length
+            )
+            all_clips.append(waveform_melspec)
+
+        normalize = transforms.Normalize(mean=mean, std=std)
+        all_clips = [normalize(ac).to(device) for ac in all_clips]
+
+        all_clips = torch.stack(all_clips, dim=0)
+        audio_outputs.append(all_clips)
+
+    return torch.stack(audio_outputs, dim=0)
+
+
+def get_clip_timepoints(clip_sampler, duration):
+    # Read out all clips in this video
+    all_clips_timepoints = []
+    is_last_clip = False
+    end = 0.0
+    while not is_last_clip:
+        start, end, _, _, is_last_clip = clip_sampler(end, duration, annotation=None)
+        all_clips_timepoints.append((start, end))
+    return all_clips_timepoints
+
+
+def crop_boxes(boxes, x_offset, y_offset):
+    """
+    Peform crop on the bounding boxes given the offsets.
+    Args:
+        boxes (ndarray or None): bounding boxes to peform crop. The dimension
+            is `num boxes` x 4.
+        x_offset (int): cropping offset in the x axis.
+        y_offset (int): cropping offset in the y axis.
+    Returns:
+        cropped_boxes (ndarray or None): the cropped boxes with dimension of
+            `num boxes` x 4.
+    """
+    cropped_boxes = boxes.copy()
+    cropped_boxes[:, [0, 2]] = boxes[:, [0, 2]] - x_offset
+    cropped_boxes[:, [1, 3]] = boxes[:, [1, 3]] - y_offset
+
+    return cropped_boxes
+
+
+def uniform_crop(images, size, spatial_idx, boxes=None, scale_size=None):
+    """
+    Perform uniform spatial sampling on the images and corresponding boxes.
+    Args:
+        images (tensor): images to perform uniform crop. The dimension is
+            `num frames` x `channel` x `height` x `width`.
+        size (int): size of height and weight to crop the images.
+        spatial_idx (int): 0, 1, or 2 for left, center, and right crop if width
+            is larger than height. Or 0, 1, or 2 for top, center, and bottom
+            crop if height is larger than width.
+        boxes (ndarray or None): optional. Corresponding boxes to images.
+            Dimension is `num boxes` x 4.
+        scale_size (int): optinal. If not None, resize the images to scale_size before
+            performing any crop.
+    Returns:
+        cropped (tensor): images with dimension of
+            `num frames` x `channel` x `size` x `size`.
+        cropped_boxes (ndarray or None): the cropped boxes with dimension of
+            `num boxes` x 4.
+    """
+    assert spatial_idx in [0, 1, 2]
+    ndim = len(images.shape)
+    if ndim == 3:
+        images = images.unsqueeze(0)
+    height = images.shape[2]
+    width = images.shape[3]
+
+    if scale_size is not None:
+        if width <= height:
+            width, height = scale_size, int(height / width * scale_size)
+        else:
+            width, height = int(width / height * scale_size), scale_size
+        images = torch.nn.functional.interpolate(
+            images,
+            size=(height, width),
+            mode="bilinear",
+            align_corners=False,
+        )
+
+    y_offset = int(math.ceil((height - size) / 2))
+    x_offset = int(math.ceil((width - size) / 2))
+
+    if height > width:
+        if spatial_idx == 0:
+            y_offset = 0
+        elif spatial_idx == 2:
+            y_offset = height - size
+    else:
+        if spatial_idx == 0:
+            x_offset = 0
+        elif spatial_idx == 2:
+            x_offset = width - size
+    cropped = images[:, :, y_offset : y_offset + size, x_offset : x_offset + size]
+    cropped_boxes = crop_boxes(boxes, x_offset, y_offset) if boxes is not None else None
+    if ndim == 3:
+        cropped = cropped.squeeze(0)
+    return cropped, cropped_boxes
+
+
+class SpatialCrop(nn.Module):
+    """
+    Convert the video into 3 smaller clips spatially. Must be used after the
+        temporal crops to get spatial crops, and should be used with
+        -2 in the spatial crop at the slowfast augmentation stage (so full
+        frames are passed in here). Will return a larger list with the
+        3x spatial crops as well.
+    """
+
+    def __init__(self, crop_size: int = 224, num_crops: int = 3):
+        super().__init__()
+        self.crop_size = crop_size
+        if num_crops == 3:
+            self.crops_to_ext = [0, 1, 2]
+            self.flipped_crops_to_ext = []
+        elif num_crops == 1:
+            self.crops_to_ext = [1]
+            self.flipped_crops_to_ext = []
+        else:
+            raise NotImplementedError("Nothing else supported yet")
+
+    def forward(self, videos):
+        """
+        Args:
+            videos: A list of C, T, H, W videos.
+        Returns:
+            videos: A list with 3x the number of elements. Each video converted
+                to C, T, H', W' by spatial cropping.
+        """
+        assert isinstance(videos, list), "Must be a list of videos after temporal crops"
+        assert all([video.ndim == 4 for video in videos]), "Must be (C,T,H,W)"
+        res = []
+        for video in videos:
+            for spatial_idx in self.crops_to_ext:
+                res.append(uniform_crop(video, self.crop_size, spatial_idx)[0])
+            if not self.flipped_crops_to_ext:
+                continue
+            flipped_video = transforms.functional.hflip(video)
+            for spatial_idx in self.flipped_crops_to_ext:
+                res.append(uniform_crop(flipped_video, self.crop_size, spatial_idx)[0])
+        return res
+
+
+def load_and_transform_video_data(
+    video_paths,
+    device,
+    clip_duration=2,
+    clips_per_video=5,
+    sample_rate=16000,
+):
+    if video_paths is None:
+        return None
+
+    video_outputs = []
+    video_transform = transforms.Compose(
+        [
+            pv_transforms.ShortSideScale(224),
+            NormalizeVideo(
+                mean=(0.48145466, 0.4578275, 0.40821073),
+                std=(0.26862954, 0.26130258, 0.27577711),
+            ),
+        ]
+    )
+
+    clip_sampler = ConstantClipsPerVideoSampler(
+        clip_duration=clip_duration, clips_per_video=clips_per_video
+    )
+    frame_sampler = pv_transforms.UniformTemporalSubsample(num_samples=clip_duration)
+
+    for video_path in video_paths:
+        video = EncodedVideo.from_path(
+            video_path,
+            decoder="decord",
+            decode_audio=False,
+            **{"sample_rate": sample_rate},
+        )
+
+        all_clips_timepoints = get_clip_timepoints(clip_sampler, video.duration)
+
+        all_video = []
+        for clip_timepoints in all_clips_timepoints:
+            # Read the clip, get frames
+            clip = video.get_clip(clip_timepoints[0], clip_timepoints[1])
+            if clip is None:
+                raise ValueError("No clip found")
+            video_clip = frame_sampler(clip["video"])
+            video_clip = video_clip / 255.0  # since this is float, need 0-1
+
+            all_video.append(video_clip)
+
+        all_video = [video_transform(clip) for clip in all_video]
+        all_video = SpatialCrop(224, num_crops=3)(all_video)
+
+        all_video = torch.stack(all_video, dim=0)
+        video_outputs.append(all_video)
+
+    return torch.stack(video_outputs, dim=0).to(device)

external/Grounded-Segment-Anything/playground/ImageBind_SAM/demo.py

@@ -0,0 +1,133 @@
+import data
+import cv2
+import torch
+import numpy as np
+from PIL import Image, ImageDraw
+from tqdm import tqdm
+from models import imagebind_model
+from models.imagebind_model import ModalityType
+
+from segment_anything import build_sam, SamAutomaticMaskGenerator
+
+from utils import (
+    segment_image, 
+    convert_box_xywh_to_xyxy,
+    get_indices_of_values_above_threshold,
+)
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+"""
+Step 1: Instantiate model
+"""
+# Segment Anything
+mask_generator = SamAutomaticMaskGenerator(
+    build_sam(checkpoint=".checkpoints/sam_vit_h_4b8939.pth").to(device),
+    points_per_side=16,
+)
+
+# ImageBind
+bind_model = imagebind_model.imagebind_huge(pretrained=True)
+bind_model.eval()
+bind_model.to(device)
+
+
+"""
+Step 2: Generate auto masks with SAM
+"""
+image_path = ".assets/car_image.jpg"
+image = cv2.imread(image_path)
+image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+masks = mask_generator.generate(image)
+
+
+"""
+Step 3: Get cropped images based on mask and box
+"""
+cropped_boxes = []
+image = Image.open(image_path)
+for mask in tqdm(masks):
+    cropped_boxes.append(segment_image(image, mask["segmentation"]).crop(convert_box_xywh_to_xyxy(mask["bbox"])))
+
+
+"""
+Step 4: Run ImageBind model to get similarity between cropped image and different modalities
+"""
+def retriev_vision_and_text(elements, text_list):
+    inputs = {
+        ModalityType.VISION: data.load_and_transform_vision_data_from_pil_image(elements, device),
+        ModalityType.TEXT: data.load_and_transform_text(text_list, device),
+    }
+    with torch.no_grad():
+        embeddings = bind_model(inputs)
+    vision_audio = torch.softmax(embeddings[ModalityType.VISION] @ embeddings[ModalityType.TEXT].T, dim=0),
+    return vision_audio  # [113, 1]
+
+def retriev_vision_and_audio(elements, audio_list):
+    inputs = {
+        ModalityType.VISION: data.load_and_transform_vision_data_from_pil_image(elements, device),
+        ModalityType.AUDIO: data.load_and_transform_audio_data(audio_list, device),
+    }
+    with torch.no_grad():
+        embeddings = bind_model(inputs)
+    vision_audio = torch.softmax(embeddings[ModalityType.VISION] @ embeddings[ModalityType.AUDIO].T, dim=0),
+    return vision_audio 
+
+vision_audio_result = retriev_vision_and_audio(cropped_boxes, [".assets/car_audio.wav"])
+vision_text_result = retriev_vision_and_text(cropped_boxes, ["A car"] )
+
+
+"""
+Step 5: Merge the top similarity masks to get the final mask and save the merged mask
+
+This is the audio retrival result
+"""
+
+# get highest similar mask with threshold
+# result[0] shape: [113, 1]
+threshold = 0.025
+index = get_indices_of_values_above_threshold(vision_audio_result[0], threshold)
+
+segmentation_masks = []
+for seg_idx in index:
+    segmentation_mask_image = Image.fromarray(masks[seg_idx]["segmentation"].astype('uint8') * 255)
+    segmentation_masks.append(segmentation_mask_image)
+
+original_image = Image.open(image_path)
+overlay_image = Image.new('RGBA', image.size, (0, 0, 0, 255))
+overlay_color = (255, 255, 255, 0)
+
+draw = ImageDraw.Draw(overlay_image)
+for segmentation_mask_image in segmentation_masks:
+    draw.bitmap((0, 0), segmentation_mask_image, fill=overlay_color)
+
+# return Image.alpha_composite(original_image.convert('RGBA'), overlay_image) 
+mask_image = overlay_image.convert("RGB")
+mask_image.save("./audio_sam_merged_mask.jpg")
+
+"""
+Image / Text mask
+"""
+# get highest similar mask with threshold
+# result[0] shape: [113, 1]
+threshold = 0.05
+index = get_indices_of_values_above_threshold(vision_text_result[0], threshold)
+
+segmentation_masks = []
+for seg_idx in index:
+    segmentation_mask_image = Image.fromarray(masks[seg_idx]["segmentation"].astype('uint8') * 255)
+    segmentation_masks.append(segmentation_mask_image)
+
+original_image = Image.open(image_path)
+overlay_image = Image.new('RGBA', image.size, (0, 0, 0, 255))
+overlay_color = (255, 255, 255, 0)
+
+draw = ImageDraw.Draw(overlay_image)
+for segmentation_mask_image in segmentation_masks:
+    draw.bitmap((0, 0), segmentation_mask_image, fill=overlay_color)
+
+# return Image.alpha_composite(original_image.convert('RGBA'), overlay_image) 
+mask_image = overlay_image.convert("RGB")
+mask_image.save("./text_sam_merged_mask.jpg")

external/Grounded-Segment-Anything/playground/ImageBind_SAM/image_referring_seg_demo.py

@@ -0,0 +1,110 @@
+import data
+import cv2
+import torch
+from PIL import Image, ImageDraw
+from tqdm import tqdm
+from models import imagebind_model
+from models.imagebind_model import ModalityType
+
+from segment_anything import build_sam, SamAutomaticMaskGenerator
+
+from utils import (
+    segment_image, 
+    convert_box_xywh_to_xyxy,
+    get_indices_of_values_above_threshold,
+)
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+"""
+Step 1: Instantiate model
+"""
+# Segment Anything
+mask_generator = SamAutomaticMaskGenerator(
+    build_sam(checkpoint=".checkpoints/sam_vit_h_4b8939.pth").to(device),
+    points_per_side=16,
+)
+
+# ImageBind
+bind_model = imagebind_model.imagebind_huge(pretrained=True)
+bind_model.eval()
+bind_model.to(device)
+
+
+"""
+Step 2: Generate auto masks with SAM
+"""
+image_path = ".assets/car_image.jpg"
+image = cv2.imread(image_path)
+image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+masks = mask_generator.generate(image)
+
+
+"""
+Step 3: Get cropped images based on mask and box
+"""
+cropped_boxes = []
+image = Image.open(image_path)
+for mask in tqdm(masks):
+    cropped_boxes.append(segment_image(image, mask["segmentation"]).crop(convert_box_xywh_to_xyxy(mask["bbox"])))
+
+
+"""
+Step 4: Run ImageBind model to get similarity between cropped image and different modalities
+"""
+# load referring image
+referring_image_path = ".assets/referring_car_image.jpg"
+referring_image = Image.open(referring_image_path)
+
+image_list = []
+image_list += cropped_boxes
+image_list.append(referring_image)
+
+def retriev_vision_and_vision(elements):
+    inputs = {
+        ModalityType.VISION: data.load_and_transform_vision_data_from_pil_image(elements, device),
+    }
+    with torch.no_grad():
+        embeddings = bind_model(inputs)
+
+    # cropped box region embeddings
+    cropped_box_embeddings = embeddings[ModalityType.VISION][:-1, :]
+    referring_image_embeddings = embeddings[ModalityType.VISION][-1, :]
+
+    vision_referring_result = torch.softmax(cropped_box_embeddings @ referring_image_embeddings.T, dim=0),
+    return vision_referring_result  # [113, 1]
+
+
+vision_referring_result = retriev_vision_and_vision(image_list)
+
+
+"""
+Step 5: Merge the top similarity masks to get the final mask and save the merged mask
+
+Image / Text mask
+"""
+
+# get highest similar mask with threshold
+# result[0] shape: [113, 1]
+threshold = 0.017
+index = get_indices_of_values_above_threshold(vision_referring_result[0], threshold)
+
+
+segmentation_masks = []
+for seg_idx in index:
+    segmentation_mask_image = Image.fromarray(masks[seg_idx]["segmentation"].astype('uint8') * 255)
+    segmentation_masks.append(segmentation_mask_image)
+
+original_image = Image.open(image_path)
+overlay_image = Image.new('RGBA', image.size, (0, 0, 0, 255))
+overlay_color = (255, 255, 255, 0)
+
+draw = ImageDraw.Draw(overlay_image)
+for segmentation_mask_image in segmentation_masks:
+    draw.bitmap((0, 0), segmentation_mask_image, fill=overlay_color)
+
+# return Image.alpha_composite(original_image.convert('RGBA'), overlay_image) 
+mask_image = overlay_image.convert("RGB")
+mask_image.save("./image_referring_sam_merged_mask.jpg")

external/Grounded-Segment-Anything/playground/ImageBind_SAM/text_referring_seg_demo.py

@@ -0,0 +1,97 @@
+import data
+import cv2
+import torch
+from PIL import Image, ImageDraw
+from tqdm import tqdm
+from models import imagebind_model
+from models.imagebind_model import ModalityType
+
+from segment_anything import build_sam, SamAutomaticMaskGenerator
+
+from utils import (
+    segment_image, 
+    convert_box_xywh_to_xyxy,
+    get_indices_of_values_above_threshold,
+)
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+"""
+Step 1: Instantiate model
+"""
+# Segment Anything
+mask_generator = SamAutomaticMaskGenerator(
+    build_sam(checkpoint=".checkpoints/sam_vit_h_4b8939.pth").to(device),
+    points_per_side=16,
+)
+
+# ImageBind
+bind_model = imagebind_model.imagebind_huge(pretrained=True)
+bind_model.eval()
+bind_model.to(device)
+
+
+"""
+Step 2: Generate auto masks with SAM
+"""
+image_path = ".assets/car_image.jpg"
+image = cv2.imread(image_path)
+image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+masks = mask_generator.generate(image)
+
+
+"""
+Step 3: Get cropped images based on mask and box
+"""
+cropped_boxes = []
+image = Image.open(image_path)
+for mask in tqdm(masks):
+    cropped_boxes.append(segment_image(image, mask["segmentation"]).crop(convert_box_xywh_to_xyxy(mask["bbox"])))
+
+
+"""
+Step 4: Run ImageBind model to get similarity between cropped image and different modalities
+"""
+def retriev_vision_and_text(elements, text_list):
+    inputs = {
+        ModalityType.VISION: data.load_and_transform_vision_data_from_pil_image(elements, device),
+        ModalityType.TEXT: data.load_and_transform_text(text_list, device),
+    }
+    with torch.no_grad():
+        embeddings = bind_model(inputs)
+    vision_audio = torch.softmax(embeddings[ModalityType.VISION] @ embeddings[ModalityType.TEXT].T, dim=0),
+    return vision_audio  # [113, 1]
+
+
+vision_text_result = retriev_vision_and_text(cropped_boxes, ["A car"] )
+
+
+"""
+Step 5: Merge the top similarity masks to get the final mask and save the merged mask
+
+Image / Text mask
+"""
+
+# get highest similar mask with threshold
+# result[0] shape: [113, 1]
+threshold = 0.05
+index = get_indices_of_values_above_threshold(vision_text_result[0], threshold)
+
+segmentation_masks = []
+for seg_idx in index:
+    segmentation_mask_image = Image.fromarray(masks[seg_idx]["segmentation"].astype('uint8') * 255)
+    segmentation_masks.append(segmentation_mask_image)
+
+original_image = Image.open(image_path)
+overlay_image = Image.new('RGBA', image.size, (0, 0, 0, 255))
+overlay_color = (255, 255, 255, 0)
+
+draw = ImageDraw.Draw(overlay_image)
+for segmentation_mask_image in segmentation_masks:
+    draw.bitmap((0, 0), segmentation_mask_image, fill=overlay_color)
+
+# return Image.alpha_composite(original_image.convert('RGBA'), overlay_image) 
+mask_image = overlay_image.convert("RGB")
+mask_image.save("./text_sam_merged_mask.jpg")

external/Grounded-Segment-Anything/playground/ImageBind_SAM/utils.py

@@ -0,0 +1,26 @@
+from PIL import Image
+import numpy as np
+
+def segment_image(image, segmentation_mask):
+    image_array = np.array(image)
+    segmented_image_array = np.zeros_like(image_array)
+    segmented_image_array[segmentation_mask] = image_array[segmentation_mask]
+    segmented_image = Image.fromarray(segmented_image_array)
+    black_image = Image.new("RGB", image.size, (0, 0, 0))
+    transparency_mask = np.zeros_like(segmentation_mask, dtype=np.uint8)
+    transparency_mask[segmentation_mask] = 255
+    transparency_mask_image = Image.fromarray(transparency_mask, mode='L')
+    black_image.paste(segmented_image, mask=transparency_mask_image)
+    return black_image
+
+
+def convert_box_xywh_to_xyxy(box):
+    x1 = box[0]
+    y1 = box[1]
+    x2 = box[0] + box[2]
+    y2 = box[1] + box[3]
+    return [x1, y1, x2, y2]
+
+
+def get_indices_of_values_above_threshold(values, threshold):
+    return [i for i, v in enumerate(values) if v > threshold]

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

@@ -0,0 +1,87 @@
+## LaMa: Resolution-robust Large Mask Inpainting with Fourier Convolutions
+
+:grapes: [[Official Project Page](https://advimman.github.io/lama-project/)]   :apple:[[LaMa Cleaner](https://github.com/Sanster/lama-cleaner)]
+
+We use the highly organized code [lama-cleaner](https://github.com/Sanster/lama-cleaner) to simplify the demo code for users.
+
+<div align="center">
+
+![](https://raw.githubusercontent.com/senya-ashukha/senya-ashukha.github.io/master/projects/lama_21/ezgif-4-0db51df695a8.gif)
+
+</div>
+
+## Abstract
+
+> Modern image inpainting systems, despite the significant progress, often struggle with large missing areas, complex geometric structures, and high-resolution images. We find that one of the main reasons for that is the lack of an ef-fective receptive field in both the inpainting network andthe loss function. To alleviate this issue, we propose anew method called large mask inpainting (LaMa). LaM ais based on: a new inpainting network architecture that uses fast Fourier convolutions, which have the image-widereceptive field
+a high receptive field perceptual loss; large training masks, which unlocks the potential ofthe first two components. Our inpainting network improves the state-of-the-art across a range of datasets and achieves excellent performance even in challenging scenarios, e.g.completion of periodic structures. Our model generalizes surprisingly well to resolutions that are higher than thoseseen at train time, and achieves this at lower parameter & compute costs than the competitive baselines.
+
+## Table of Contents
+- [Installation](#installation)
+- [LaMa Demos](#paint-by-example-demos)
+  - [Diffuser Demo](#paintbyexample-diffuser-demos)
+  - [PaintByExample with SAM](#paintbyexample-with-sam)
+
+
+## TODO
+- [x] LaMa Demo with lama-cleaner
+- [x] LaMa with SAM
+- [ ] LaMa with GroundingDINO
+- [ ] LaMa with Grounded-SAM
+
+
+## Installation
+We're using lama-cleaner for this demo, install it as follows:
+```bash
+pip install lama-cleaner
+```
+Please refer to [lama-cleaner](https://github.com/Sanster/lama-cleaner) for more details. 
+
+Then install Grounded-SAM follows [Grounded-SAM Installation](https://github.com/IDEA-Research/Grounded-Segment-Anything#installation) for some extension demos.
+
+## LaMa Demos
+Here we provide the demos for `LaMa`
+
+### LaMa Demo with lama-cleaner
+
+```bash
+cd playground/LaMa
+python lama_inpaint_demo.py
+```
+with the highly organized code lama-cleaner, this demo can be done in about 20 lines of code. The result will be saved as `lama_inpaint_demo.jpg`:
+
+<div align="center">
+
+| Input Image | Mask | Inpaint Output |
+|:----:|:----:|:----:|
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/example.jpg?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/mask.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/lama_inpaint_demo.jpg?raw=true) |
+
+</div>
+
+### LaMa with SAM
+
+```bash
+cd playground/LaMa
+python sam_lama.py
+```
+
+**Tips** 
+To make it better for inpaint, we should **dilate the mask first** to make it a bit larger to cover the whole region (Thanks a lot for [Inpaint-Anything](https://github.com/geekyutao/Inpaint-Anything) and [Tao Yu](https://github.com/geekyutao) for this)
+
+
+The `original mask` and `dilated mask` are shown as follows:
+
+<div align="center">
+
+| Mask | Dilated Mask |
+|:---:|:---:|
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/sam_demo_mask.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/dilated_mask.png?raw=true) |
+
+</div>
+
+
+And the inpaint result will be saved as `sam_lama_demo.jpg`:
+
+| Input Image | SAM Output | Dilated Mask | LaMa Inpaint |
+|:---:|:---:|:---:|:---:|
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/demo_with_point_prompt.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/dilated_mask.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/lama/sam_lama_demo.jpg?raw=true) |
+

external/Grounded-Segment-Anything/playground/LaMa/lama_inpaint_demo.py

@@ -0,0 +1,25 @@
+import cv2
+import PIL
+import requests
+import numpy as np
+from lama_cleaner.model.lama import LaMa
+from lama_cleaner.schema import Config
+
+
+def download_image(url):
+    image = PIL.Image.open(requests.get(url, stream=True).raw)
+    image = PIL.ImageOps.exif_transpose(image)
+    image = image.convert("RGB")
+    return image
+
+
+img_url = "https://raw.githubusercontent.com/Sanster/lama-cleaner/main/assets/dog.jpg"
+mask_url = "https://user-images.githubusercontent.com/3998421/202105351-9fcc4bf8-129d-461a-8524-92e4caad431f.png"
+
+image = np.asarray(download_image(img_url))
+mask = np.asarray(download_image(mask_url).convert("L"))
+
+# set to GPU for faster inference
+model = LaMa("cpu")
+result = model(image, mask, Config(hd_strategy="Original", ldm_steps=20, hd_strategy_crop_margin=128, hd_strategy_crop_trigger_size=800, hd_strategy_resize_limit=800))
+cv2.imwrite("lama_inpaint_demo.jpg", result)

external/Grounded-Segment-Anything/playground/LaMa/sam_lama.py

@@ -0,0 +1,96 @@
+# !pip install diffusers transformers
+
+import requests
+import cv2
+import numpy as np
+import PIL
+from PIL import Image
+from io import BytesIO
+
+from segment_anything import sam_model_registry, SamPredictor
+
+from lama_cleaner.model.lama import LaMa
+from lama_cleaner.schema import Config
+
+"""
+Step 1: Download and preprocess demo images
+"""
+def download_image(url):
+    image = PIL.Image.open(requests.get(url, stream=True).raw)
+    image = PIL.ImageOps.exif_transpose(image)
+    image = image.convert("RGB")
+    return image
+
+
+img_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true"
+
+
+init_image = download_image(img_url)
+init_image = np.asarray(init_image)
+
+
+"""
+Step 2: Initialize SAM and LaMa models
+"""
+
+DEVICE = "cuda:1"
+
+# SAM
+SAM_ENCODER_VERSION = "vit_h"
+SAM_CHECKPOINT_PATH = "/comp_robot/rentianhe/code/Grounded-Segment-Anything/sam_vit_h_4b8939.pth"
+sam = sam_model_registry[SAM_ENCODER_VERSION](checkpoint=SAM_CHECKPOINT_PATH).to(device=DEVICE)
+sam_predictor = SamPredictor(sam)
+sam_predictor.set_image(init_image)
+
+# LaMa
+model = LaMa(DEVICE)
+
+
+"""
+Step 3: Get masks with SAM by prompt (box or point) and inpaint the mask region by example image.
+"""
+
+input_point = np.array([[350, 256]])
+input_label = np.array([1])  # positive label
+
+masks, _, _ = sam_predictor.predict(
+    point_coords=input_point,
+    point_labels=input_label,
+    multimask_output=False
+)
+masks = masks.astype(np.uint8) * 255
+# mask_pil = Image.fromarray(masks[0])  # simply save the first mask
+
+
+"""
+Step 4: Dilate Mask to make it more suitable for LaMa inpainting
+
+The idea behind dilate mask is to mask a larger region which will be better for inpainting.
+
+Borrowed from Inpaint-Anything: https://github.com/geekyutao/Inpaint-Anything/blob/main/utils/utils.py#L18
+"""
+
+def dilate_mask(mask, dilate_factor=15):
+    mask = mask.astype(np.uint8)
+    mask = cv2.dilate(
+        mask,
+        np.ones((dilate_factor, dilate_factor), np.uint8),
+        iterations=1
+    )
+    return mask
+
+def save_array_to_img(img_arr, img_p):
+    Image.fromarray(img_arr.astype(np.uint8)).save(img_p)
+
+# [1, 512, 512] to [512, 512] and save mask
+save_array_to_img(masks[0], "./mask.png")
+
+mask = dilate_mask(masks[0], dilate_factor=15)
+
+save_array_to_img(mask, "./dilated_mask.png")
+
+"""
+Step 5: Run LaMa inpaint model
+"""
+result = model(init_image, mask, Config(hd_strategy="Original", ldm_steps=20, hd_strategy_crop_margin=128, hd_strategy_crop_trigger_size=800, hd_strategy_resize_limit=800))
+cv2.imwrite("sam_lama_demo.jpg", result)

external/Grounded-Segment-Anything/playground/PaintByExample/sam_paint_by_example.py

@@ -0,0 +1,78 @@
+# !pip install diffusers transformers
+
+import requests
+import torch
+import numpy as np
+from PIL import Image
+from io import BytesIO
+from diffusers import DiffusionPipeline
+
+from segment_anything import sam_model_registry, SamPredictor
+
+
+"""
+Step 1: Download and preprocess example demo images
+"""
+def download_image(url):
+    response = requests.get(url)
+    return Image.open(BytesIO(response.content)).convert("RGB")
+
+
+img_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true"
+# example_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/pomeranian_example.jpg?raw=True"
+# example_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/example_image.jpg?raw=true"
+example_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/labrador_example.jpg?raw=true"
+
+init_image = download_image(img_url).resize((512, 512))
+example_image = download_image(example_url).resize((512, 512))
+
+
+"""
+Step 2: Initialize SAM and PaintByExample models
+"""
+
+DEVICE = "cuda:1"
+
+# SAM
+SAM_ENCODER_VERSION = "vit_h"
+SAM_CHECKPOINT_PATH = "/comp_robot/rentianhe/code/Grounded-Segment-Anything/sam_vit_h_4b8939.pth"
+sam = sam_model_registry[SAM_ENCODER_VERSION](checkpoint=SAM_CHECKPOINT_PATH).to(device=DEVICE)
+sam_predictor = SamPredictor(sam)
+sam_predictor.set_image(np.array(init_image))
+
+# PaintByExample Pipeline
+CACHE_DIR = "/comp_robot/rentianhe/weights/diffusers/"
+pipe = DiffusionPipeline.from_pretrained(
+    "Fantasy-Studio/Paint-by-Example",
+    torch_dtype=torch.float16,
+    cache_dir=CACHE_DIR,
+)
+pipe = pipe.to(DEVICE)
+
+
+"""
+Step 3: Get masks with SAM by prompt (box or point) and inpaint the mask region by example image.
+"""
+
+input_point = np.array([[350, 256]])
+input_label = np.array([1])  # positive label
+
+masks, _, _ = sam_predictor.predict(
+    point_coords=input_point,
+    point_labels=input_label,
+    multimask_output=False
+)
+mask = masks[0]  # [1, 512, 512] to [512, 512] np.ndarray
+mask_pil = Image.fromarray(mask)
+
+mask_pil.save("./mask.jpg")
+
+image = pipe(
+    image=init_image, 
+    mask_image=mask_pil, 
+    example_image=example_image, 
+    num_inference_steps=500, 
+    guidance_scale=9.0
+).images[0]
+
+image.save("./paint_by_example_demo.jpg")

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

@@ -0,0 +1,55 @@
+## RePaint: Inpainting using Denoising Diffusion Probabilistic Models
+
+:grapes: [[Official Project Page](https://github.com/andreas128/RePaint)]
+
+<div align="center">
+
+![](https://user-images.githubusercontent.com/11280511/150803812-a4729ef8-6ad4-46aa-ae99-8c27fbb2ea2e.png)
+
+</div>
+
+## Abstract
+
+> Free-form inpainting is the task of adding new content to an image in the regions specified by an arbitrary binary mask. Most existing approaches train for a certain distribution of masks, which limits their generalization capabilities to unseen mask types. Furthermore, training with pixel-wise and perceptual losses often leads to simple textural extensions towards the missing areas instead of semantically meaningful generation. In this work, we propose RePaint: A Denoising Diffusion Probabilistic Model (DDPM) based inpainting approach that is applicable to even extreme masks. We employ a pretrained unconditional DDPM as the generative prior. To condition the generation process, we only alter the reverse diffusion iterations by sampling the unmasked regions using the given image information. Since this technique does not modify or condition the original DDPM network itself, the model produces highquality and diverse output images for any inpainting form. We validate our method for both faces and general-purpose image inpainting using standard and extreme masks. RePaint outperforms state-of-the-art Autoregressive, and GAN approaches for at least five out of six mask distributions.
+
+
+## Table of Contents
+- [Installation](#installation)
+- [Repaint Demos](#repaint-demos)
+  - [Diffuser Demo](#repaint-diffuser-demos)
+
+
+## TODO
+- [x] RePaint Diffuser Demo
+- [ ] RePaint with SAM
+- [ ] RePaint with GroundingDINO
+- [ ] RePaint with Grounded-SAM
+
+## Installation
+We're using PaintByExample with diffusers, install diffusers as follows:
+```bash
+pip install diffusers==0.16.1
+```
+Then install Grounded-SAM follows [Grounded-SAM Installation](https://github.com/IDEA-Research/Grounded-Segment-Anything#installation) for some extension demos.
+
+## RePaint Demos
+Here we provide the demos for `RePaint`
+
+
+### RePaint Diffuser Demos
+```python
+cd playground/RePaint
+python repaint.py
+```
+**Notes:** set `cache_dir` to save the pretrained weights to specific folder. The paint result will be save as `repaint_demo.jpg`:
+
+<div align="center">
+
+| Input Image | Mask | Inpaint Result |
+|:----:|:----:|:----:|
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/repaint/celeba_hq_256.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/repaint/mask_256.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/repaint/repaint_demo.jpg?raw=true) |
+
+
+</div>
+
+

external/Grounded-Segment-Anything/playground/RePaint/repaint.py

@@ -0,0 +1,40 @@
+from io import BytesIO
+
+import torch
+
+import PIL
+import requests
+from diffusers import RePaintPipeline, RePaintScheduler
+
+
+def download_image(url):
+    response = requests.get(url)
+    return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+img_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/celeba_hq_256.png"
+mask_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"
+
+# Load the original image and the mask as PIL images
+original_image = download_image(img_url).resize((256, 256))
+mask_image = download_image(mask_url).resize((256, 256))
+
+# Load the RePaint scheduler and pipeline based on a pretrained DDPM model
+DEVICE = "cuda:1"
+CACHE_DIR = "/comp_robot/rentianhe/weights/diffusers/"
+scheduler = RePaintScheduler.from_pretrained("google/ddpm-ema-celebahq-256", cache_dir=CACHE_DIR)
+pipe = RePaintPipeline.from_pretrained("google/ddpm-ema-celebahq-256", scheduler=scheduler, cache_dir=CACHE_DIR)
+pipe = pipe.to(DEVICE)
+
+generator = torch.Generator(device=DEVICE).manual_seed(0)
+output = pipe(
+    image=original_image,
+    mask_image=mask_image,
+    num_inference_steps=250,
+    eta=0.0,
+    jump_length=10,
+    jump_n_sample=10,
+    generator=generator,
+)
+inpainted_image = output.images[0]
+inpainted_image.save("./repaint_demo.jpg")

external/Grounded-Segment-Anything/recognize-anything/datasets/hico/hico_600_taglist.txt

@@ -0,0 +1,600 @@
+person board airplane
+person direct airplane
+person exit airplane
+person fly airplane
+person inspect airplane
+person load airplane
+person ride airplane
+person sit_on airplane
+person wash airplane
+person no_interaction airplane
+person carry bicycle
+person hold bicycle
+person inspect bicycle
+person jump bicycle
+person hop_on bicycle
+person park bicycle
+person push bicycle
+person repair bicycle
+person ride bicycle
+person sit_on bicycle
+person straddle bicycle
+person walk bicycle
+person wash bicycle
+person no_interaction bicycle
+person chase bird
+person feed bird
+person hold bird
+person pet bird
+person release bird
+person watch bird
+person no_interaction bird
+person board boat
+person drive boat
+person exit boat
+person inspect boat
+person jump boat
+person launch boat
+person repair boat
+person ride boat
+person row boat
+person sail boat
+person sit_on boat
+person stand_on boat
+person tie boat
+person wash boat
+person no_interaction boat
+person carry bottle
+person drink_with bottle
+person hold bottle
+person inspect bottle
+person lick bottle
+person open bottle
+person pour bottle
+person no_interaction bottle
+person board bus
+person direct bus
+person drive bus
+person exit bus
+person inspect bus
+person load bus
+person ride bus
+person sit_on bus
+person wash bus
+person wave bus
+person no_interaction bus
+person board car
+person direct car
+person drive car
+person hose car
+person inspect car
+person jump car
+person load car
+person park car
+person ride car
+person wash car
+person no_interaction car
+person dry cat
+person feed cat
+person hold cat
+person hug cat
+person kiss cat
+person pet cat
+person scratch cat
+person wash cat
+person chase cat
+person no_interaction cat
+person carry chair
+person hold chair
+person lie_on chair
+person sit_on chair
+person stand_on chair
+person no_interaction chair
+person carry couch
+person lie_on couch
+person sit_on couch
+person no_interaction couch
+person feed cow
+person herd cow
+person hold cow
+person hug cow
+person kiss cow
+person lasso cow
+person milk cow
+person pet cow
+person ride cow
+person walk cow
+person no_interaction cow
+person clean dining_table
+person eat_at dining_table
+person sit_at dining_table
+person no_interaction dining_table
+person carry dog
+person dry dog
+person feed dog
+person groom dog
+person hold dog
+person hose dog
+person hug dog
+person inspect dog
+person kiss dog
+person pet dog
+person run dog
+person scratch dog
+person straddle dog
+person train dog
+person walk dog
+person wash dog
+person chase dog
+person no_interaction dog
+person feed horse
+person groom horse
+person hold horse
+person hug horse
+person jump horse
+person kiss horse
+person load horse
+person hop_on horse
+person pet horse
+person race horse
+person ride horse
+person run horse
+person straddle horse
+person train horse
+person walk horse
+person wash horse
+person no_interaction horse
+person hold motorcycle
+person inspect motorcycle
+person jump motorcycle
+person hop_on motorcycle
+person park motorcycle
+person push motorcycle
+person race motorcycle
+person ride motorcycle
+person sit_on motorcycle
+person straddle motorcycle
+person turn motorcycle
+person walk motorcycle
+person wash motorcycle
+person no_interaction motorcycle
+person carry person
+person greet person
+person hold person
+person hug person
+person kiss person
+person stab person
+person tag person
+person teach person
+person lick person
+person no_interaction person
+person carry potted_plant
+person hold potted_plant
+person hose potted_plant
+person no_interaction potted_plant
+person carry sheep
+person feed sheep
+person herd sheep
+person hold sheep
+person hug sheep
+person kiss sheep
+person pet sheep
+person ride sheep
+person shear sheep
+person walk sheep
+person wash sheep
+person no_interaction sheep
+person board train
+person drive train
+person exit train
+person load train
+person ride train
+person sit_on train
+person wash train
+person no_interaction train
+person control tv
+person repair tv
+person watch tv
+person no_interaction tv
+person buy apple
+person cut apple
+person eat apple
+person hold apple
+person inspect apple
+person peel apple
+person pick apple
+person smell apple
+person wash apple
+person no_interaction apple
+person carry backpack
+person hold backpack
+person inspect backpack
+person open backpack
+person wear backpack
+person no_interaction backpack
+person buy banana
+person carry banana
+person cut banana
+person eat banana
+person hold banana
+person inspect banana
+person peel banana
+person pick banana
+person smell banana
+person no_interaction banana
+person break baseball_bat
+person carry baseball_bat
+person hold baseball_bat
+person sign baseball_bat
+person swing baseball_bat
+person throw baseball_bat
+person wield baseball_bat
+person no_interaction baseball_bat
+person hold baseball_glove
+person wear baseball_glove
+person no_interaction baseball_glove
+person feed bear
+person hunt bear
+person watch bear
+person no_interaction bear
+person clean bed
+person lie_on bed
+person sit_on bed
+person no_interaction bed
+person inspect bench
+person lie_on bench
+person sit_on bench
+person no_interaction bench
+person carry book
+person hold book
+person open book
+person read book
+person no_interaction book
+person hold bowl
+person stir bowl
+person wash bowl
+person lick bowl
+person no_interaction bowl
+person cut broccoli
+person eat broccoli
+person hold broccoli
+person smell broccoli
+person stir broccoli
+person wash broccoli
+person no_interaction broccoli
+person blow cake
+person carry cake
+person cut cake
+person eat cake
+person hold cake
+person light cake
+person make cake
+person pick_up cake
+person no_interaction cake
+person carry carrot
+person cook carrot
+person cut carrot
+person eat carrot
+person hold carrot
+person peel carrot
+person smell carrot
+person stir carrot
+person wash carrot
+person no_interaction carrot
+person carry cell_phone
+person hold cell_phone
+person read cell_phone
+person repair cell_phone
+person talk_on cell_phone
+person text_on cell_phone
+person no_interaction cell_phone
+person check clock
+person hold clock
+person repair clock
+person set clock
+person no_interaction clock
+person carry cup
+person drink_with cup
+person hold cup
+person inspect cup
+person pour cup
+person sip cup
+person smell cup
+person fill cup
+person wash cup
+person no_interaction cup
+person buy donut
+person carry donut
+person eat donut
+person hold donut
+person make donut
+person pick_up donut
+person smell donut
+person no_interaction donut
+person feed elephant
+person hold elephant
+person hose elephant
+person hug elephant
+person kiss elephant
+person hop_on elephant
+person pet elephant
+person ride elephant
+person walk elephant
+person wash elephant
+person watch elephant
+person no_interaction elephant
+person hug fire_hydrant
+person inspect fire_hydrant
+person open fire_hydrant
+person paint fire_hydrant
+person no_interaction fire_hydrant
+person hold fork
+person lift fork
+person stick fork
+person lick fork
+person wash fork
+person no_interaction fork
+person block frisbee
+person catch frisbee
+person hold frisbee
+person spin frisbee
+person throw frisbee
+person no_interaction frisbee
+person feed giraffe
+person kiss giraffe
+person pet giraffe
+person ride giraffe
+person watch giraffe
+person no_interaction giraffe
+person hold hair_drier
+person operate hair_drier
+person repair hair_drier
+person no_interaction hair_drier
+person carry handbag
+person hold handbag
+person inspect handbag
+person no_interaction handbag
+person carry hot_dog
+person cook hot_dog
+person cut hot_dog
+person eat hot_dog
+person hold hot_dog
+person make hot_dog
+person no_interaction hot_dog
+person carry keyboard
+person clean keyboard
+person hold keyboard
+person type_on keyboard
+person no_interaction keyboard
+person assemble kite
+person carry kite
+person fly kite
+person hold kite
+person inspect kite
+person launch kite
+person pull kite
+person no_interaction kite
+person cut_with knife
+person hold knife
+person stick knife
+person wash knife
+person wield knife
+person lick knife
+person no_interaction knife
+person hold laptop
+person open laptop
+person read laptop
+person repair laptop
+person type_on laptop
+person no_interaction laptop
+person clean microwave
+person open microwave
+person operate microwave
+person no_interaction microwave
+person control mouse
+person hold mouse
+person repair mouse
+person no_interaction mouse
+person buy orange
+person cut orange
+person eat orange
+person hold orange
+person inspect orange
+person peel orange
+person pick orange
+person squeeze orange
+person wash orange
+person no_interaction orange
+person clean oven
+person hold oven
+person inspect oven
+person open oven
+person repair oven
+person operate oven
+person no_interaction oven
+person check parking_meter
+person pay parking_meter
+person repair parking_meter
+person no_interaction parking_meter
+person buy pizza
+person carry pizza
+person cook pizza
+person cut pizza
+person eat pizza
+person hold pizza
+person make pizza
+person pick_up pizza
+person slide pizza
+person smell pizza
+person no_interaction pizza
+person clean refrigerator
+person hold refrigerator
+person move refrigerator
+person open refrigerator
+person no_interaction refrigerator
+person hold remote
+person point remote
+person swing remote
+person no_interaction remote
+person carry sandwich
+person cook sandwich
+person cut sandwich
+person eat sandwich
+person hold sandwich
+person make sandwich
+person no_interaction sandwich
+person cut_with scissors
+person hold scissors
+person open scissors
+person no_interaction scissors
+person clean sink
+person repair sink
+person wash sink
+person no_interaction sink
+person carry skateboard
+person flip skateboard
+person grind skateboard
+person hold skateboard
+person jump skateboard
+person pick_up skateboard
+person ride skateboard
+person sit_on skateboard
+person stand_on skateboard
+person no_interaction skateboard
+person adjust skis
+person carry skis
+person hold skis
+person inspect skis
+person jump skis
+person pick_up skis
+person repair skis
+person ride skis
+person stand_on skis
+person wear skis
+person no_interaction skis
+person adjust snowboard
+person carry snowboard
+person grind snowboard
+person hold snowboard
+person jump snowboard
+person ride snowboard
+person stand_on snowboard
+person wear snowboard
+person no_interaction snowboard
+person hold spoon
+person lick spoon
+person wash spoon
+person sip spoon
+person no_interaction spoon
+person block sports_ball
+person carry sports_ball
+person catch sports_ball
+person dribble sports_ball
+person hit sports_ball
+person hold sports_ball
+person inspect sports_ball
+person kick sports_ball
+person pick_up sports_ball
+person serve sports_ball
+person sign sports_ball
+person spin sports_ball
+person throw sports_ball
+person no_interaction sports_ball
+person hold stop_sign
+person stand_under stop_sign
+person stop_at stop_sign
+person no_interaction stop_sign
+person carry suitcase
+person drag suitcase
+person hold suitcase
+person hug suitcase
+person load suitcase
+person open suitcase
+person pack suitcase
+person pick_up suitcase
+person zip suitcase
+person no_interaction suitcase
+person carry surfboard
+person drag surfboard
+person hold surfboard
+person inspect surfboard
+person jump surfboard
+person lie_on surfboard
+person load surfboard
+person ride surfboard
+person stand_on surfboard
+person sit_on surfboard
+person wash surfboard
+person no_interaction surfboard
+person carry teddy_bear
+person hold teddy_bear
+person hug teddy_bear
+person kiss teddy_bear
+person no_interaction teddy_bear
+person carry tennis_racket
+person hold tennis_racket
+person inspect tennis_racket
+person swing tennis_racket
+person no_interaction tennis_racket
+person adjust tie
+person cut tie
+person hold tie
+person inspect tie
+person pull tie
+person tie tie
+person wear tie
+person no_interaction tie
+person hold toaster
+person operate toaster
+person repair toaster
+person no_interaction toaster
+person clean toilet
+person flush toilet
+person open toilet
+person repair toilet
+person sit_on toilet
+person stand_on toilet
+person wash toilet
+person no_interaction toilet
+person brush_with toothbrush
+person hold toothbrush
+person wash toothbrush
+person no_interaction toothbrush
+person install traffic_light
+person repair traffic_light
+person stand_under traffic_light
+person stop_at traffic_light
+person no_interaction traffic_light
+person direct truck
+person drive truck
+person inspect truck
+person load truck
+person repair truck
+person ride truck
+person sit_on truck
+person wash truck
+person no_interaction truck
+person carry umbrella
+person hold umbrella
+person lose umbrella
+person open umbrella
+person repair umbrella
+person set umbrella
+person stand_under umbrella
+person no_interaction umbrella
+person hold vase
+person make vase
+person paint vase
+person no_interaction vase
+person fill wine_glass
+person hold wine_glass
+person sip wine_glass
+person toast wine_glass
+person lick wine_glass
+person wash wine_glass
+person no_interaction wine_glass
+person feed zebra
+person hold zebra
+person pet zebra
+person watch zebra
+person no_interaction zebra

external/Grounded-Segment-Anything/recognize-anything/datasets/imagenet_multi/imagenet_multi_1000_taglist.txt

@@ -0,0 +1,1000 @@
+tench
+goldfish
+great white shark
+tiger shark
+hammerhead shark
+electric ray
+stingray
+rooster
+hen
+ostrich
+brambling
+goldfinch
+house finch
+junco
+indigo bunting
+American robin
+bulbul
+jay
+magpie
+chickadee
+American dipper
+kite (bird of prey)
+bald eagle
+vulture
+great grey owl
+fire salamander
+smooth newt
+newt
+spotted salamander
+axolotl
+American bullfrog
+tree frog
+tailed frog
+loggerhead sea turtle
+leatherback sea turtle
+mud turtle
+terrapin
+box turtle
+banded gecko
+green iguana
+Carolina anole
+desert grassland whiptail lizard
+agama
+frilled-necked lizard
+alligator lizard
+Gila monster
+European green lizard
+chameleon
+Komodo dragon
+Nile crocodile
+American alligator
+triceratops
+worm snake
+ring-necked snake
+eastern hog-nosed snake
+smooth green snake
+kingsnake
+garter snake
+water snake
+vine snake
+night snake
+boa constrictor
+African rock python
+Indian cobra
+green mamba
+sea snake
+Saharan horned viper
+eastern diamondback rattlesnake
+sidewinder rattlesnake
+trilobite
+harvestman
+scorpion
+yellow garden spider
+barn spider
+European garden spider
+southern black widow
+tarantula
+wolf spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse
+prairie grouse
+peafowl
+quail
+partridge
+african grey parrot
+macaw
+sulphur-crested cockatoo
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+duck
+red-breasted merganser
+goose
+black swan
+tusker
+echidna
+platypus
+wallaby
+koala
+wombat
+jellyfish
+sea anemone
+brain coral
+flatworm
+nematode
+conch
+snail
+slug
+sea slug
+chiton
+chambered nautilus
+Dungeness crab
+rock crab
+fiddler crab
+red king crab
+American lobster
+spiny lobster
+crayfish
+hermit crab
+isopod
+white stork
+black stork
+spoonbill
+flamingo
+little blue heron
+great egret
+bittern bird
+crane bird
+limpkin
+common gallinule
+American coot
+bustard
+ruddy turnstone
+dunlin
+common redshank
+dowitcher
+oystercatcher
+pelican
+king penguin
+albatross
+grey whale
+killer whale
+dugong
+sea lion
+Chihuahua
+Japanese Chin
+Maltese
+Pekingese
+Shih Tzu
+King Charles Spaniel
+Papillon
+toy terrier
+Rhodesian Ridgeback
+Afghan Hound
+Basset Hound
+Beagle
+Bloodhound
+Bluetick Coonhound
+Black and Tan Coonhound
+Treeing Walker Coonhound
+English foxhound
+Redbone Coonhound
+borzoi
+Irish Wolfhound
+Italian Greyhound
+Whippet
+Ibizan Hound
+Norwegian Elkhound
+Otterhound
+Saluki
+Scottish Deerhound
+Weimaraner
+Staffordshire Bull Terrier
+American Staffordshire Terrier
+Bedlington Terrier
+Border Terrier
+Kerry Blue Terrier
+Irish Terrier
+Norfolk Terrier
+Norwich Terrier
+Yorkshire Terrier
+Wire Fox Terrier
+Lakeland Terrier
+Sealyham Terrier
+Airedale Terrier
+Cairn Terrier
+Australian Terrier
+Dandie Dinmont Terrier
+Boston Terrier
+Miniature Schnauzer
+Giant Schnauzer
+Standard Schnauzer
+Scottish Terrier
+Tibetan Terrier
+Australian Silky Terrier
+Soft-coated Wheaten Terrier
+West Highland White Terrier
+Lhasa Apso
+Flat-Coated Retriever
+Curly-coated Retriever
+Golden Retriever
+Labrador Retriever
+Chesapeake Bay Retriever
+German Shorthaired Pointer
+Vizsla
+English Setter
+Irish Setter
+Gordon Setter
+Brittany dog
+Clumber Spaniel
+English Springer Spaniel
+Welsh Springer Spaniel
+Cocker Spaniel
+Sussex Spaniel
+Irish Water Spaniel
+Kuvasz
+Schipperke
+Groenendael dog
+Malinois
+Briard
+Australian Kelpie
+Komondor
+Old English Sheepdog
+Shetland Sheepdog
+collie
+Border Collie
+Bouvier des Flandres dog
+Rottweiler
+German Shepherd Dog
+Dobermann
+Miniature Pinscher
+Greater Swiss Mountain Dog
+Bernese Mountain Dog
+Appenzeller Sennenhund
+Entlebucher Sennenhund
+Boxer
+Bullmastiff
+Tibetan Mastiff
+French Bulldog
+Great Dane
+St. Bernard
+husky
+Alaskan Malamute
+Siberian Husky
+Dalmatian
+Affenpinscher
+Basenji
+pug
+Leonberger
+Newfoundland dog
+Great Pyrenees dog
+Samoyed
+Pomeranian
+Chow Chow
+Keeshond
+brussels griffon
+Pembroke Welsh Corgi
+Cardigan Welsh Corgi
+Toy Poodle
+Miniature Poodle
+Standard Poodle
+Mexican hairless dog (xoloitzcuintli)
+grey wolf
+Alaskan tundra wolf
+red wolf or maned wolf
+coyote
+dingo
+dhole
+African wild dog
+hyena
+red fox
+kit fox
+Arctic fox
+grey fox
+tabby cat
+tiger cat
+Persian cat
+Siamese cat
+Egyptian Mau
+cougar
+lynx
+leopard
+snow leopard
+jaguar
+lion
+tiger
+cheetah
+brown bear
+American black bear
+polar bear
+sloth bear
+mongoose
+meerkat
+tiger beetle
+ladybug
+ground beetle
+longhorn beetle
+leaf beetle
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant
+grasshopper
+cricket insect
+stick insect
+cockroach
+praying mantis
+cicada
+leafhopper
+lacewing
+dragonfly
+damselfly
+red admiral butterfly
+ringlet butterfly
+monarch butterfly
+small white butterfly
+sulphur butterfly
+gossamer-winged butterfly
+starfish
+sea urchin
+sea cucumber
+cottontail rabbit
+hare
+Angora rabbit
+hamster
+porcupine
+fox squirrel
+marmot
+beaver
+guinea pig
+common sorrel horse
+zebra
+pig
+wild boar
+warthog
+hippopotamus
+ox
+water buffalo
+bison
+ram (adult male sheep)
+bighorn sheep
+Alpine ibex
+hartebeest
+impala (antelope)
+gazelle
+arabian camel
+llama
+weasel
+mink
+European polecat
+black-footed ferret
+otter
+skunk
+badger
+armadillo
+three-toed sloth
+orangutan
+gorilla
+chimpanzee
+gibbon
+siamang
+guenon
+patas monkey
+baboon
+macaque
+langur
+black-and-white colobus
+proboscis monkey
+marmoset
+white-headed capuchin
+howler monkey
+titi monkey
+Geoffroy's spider monkey
+common squirrel monkey
+ring-tailed lemur
+indri
+Asian elephant
+African bush elephant
+red panda
+giant panda
+snoek fish
+eel
+silver salmon
+rock beauty fish
+clownfish
+sturgeon
+gar fish
+lionfish
+pufferfish
+abacus
+abaya
+academic gown
+accordion
+acoustic guitar
+aircraft carrier
+airliner
+airship
+altar
+ambulance
+amphibious vehicle
+analog clock
+apiary
+apron
+trash can
+assault rifle
+backpack
+bakery
+balance beam
+balloon
+ballpoint pen
+Band-Aid
+banjo
+baluster / handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel
+wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+swimming cap
+bath towel
+bathtub
+station wagon
+lighthouse
+beaker
+military hat (bearskin or shako)
+beer bottle
+beer glass
+bell tower
+baby bib
+tandem bicycle
+bikini
+ring binder
+binoculars
+birdhouse
+boathouse
+bobsleigh
+bolo tie
+poke bonnet
+bookcase
+bookstore
+bottle cap
+hunting bow
+bow tie
+brass memorial plaque
+bra
+breakwater
+breastplate
+broom
+bucket
+buckle
+bulletproof vest
+high-speed train
+butcher shop
+taxicab
+cauldron
+candle
+cannon
+canoe
+can opener
+cardigan
+car mirror
+carousel
+tool kit
+cardboard box / carton
+car wheel
+automated teller machine
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello
+mobile phone
+chain
+chain-link fence
+chain mail
+chainsaw
+storage chest
+chiffonier
+bell or wind chime
+china cabinet
+Christmas stocking
+church
+movie theater
+cleaver
+cliff dwelling
+cloak
+clogs
+cocktail shaker
+coffee mug
+coffeemaker
+spiral or coil
+combination lock
+computer keyboard
+candy store
+container ship
+convertible
+corkscrew
+cornet
+cowboy boot
+cowboy hat
+cradle
+construction crane
+crash helmet
+crate
+infant bed
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam
+desk
+desktop computer
+rotary dial telephone
+diaper
+digital clock
+digital watch
+dining table
+dishcloth
+dishwasher
+disc brake
+dock
+dog sled
+dome
+doormat
+drilling rig
+drum
+drumstick
+dumbbell
+Dutch oven
+electric fan
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso machine
+face powder
+feather boa
+filing cabinet
+fireboat
+fire truck
+fire screen
+flagpole
+flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster bed
+freight car
+French horn
+frying pan
+fur coat
+garbage truck
+gas mask or respirator
+gas pump
+goblet
+go-kart
+golf ball
+golf cart
+gondola
+gong
+gown
+grand piano
+greenhouse
+radiator grille
+grocery store
+guillotine
+hair clip
+hair spray
+half-track
+hammer
+hamper
+hair dryer
+hand-held computer
+handkerchief
+hard disk drive
+harmonica
+harp
+combine harvester
+hatchet
+holster
+home theater
+honeycomb
+hook
+hoop skirt
+gymnastic horizontal bar
+horse-drawn vehicle
+hourglass
+iPod
+clothes iron
+carved pumpkin
+jeans
+jeep
+T-shirt
+jigsaw puzzle
+rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat
+ladle
+lampshade
+laptop computer
+lawn mower
+lens cap
+letter opener
+library
+lifeboat
+lighter
+limousine
+ocean liner
+lipstick
+slip-on shoe
+lotion
+music speaker
+loupe magnifying glass
+sawmill
+magnetic compass
+messenger bag
+mailbox
+tights
+one-piece bathing suit
+manhole cover
+maraca
+marimba
+mask
+matchstick
+maypole
+maze
+measuring cup
+medicine cabinet
+megalith
+microphone
+microwave oven
+military uniform
+milk can
+minibus
+miniskirt
+minivan
+missile
+mitten
+mixing bowl
+mobile home
+ford model t
+modem
+monastery
+monitor
+moped
+mortar and pestle
+graduation cap
+mosque
+mosquito net
+vespa
+mountain bike
+tent
+computer mouse
+mousetrap
+moving van
+muzzle
+metal nail
+neck brace
+necklace
+baby pacifier
+notebook computer
+obelisk
+oboe
+ocarina
+odometer
+oil filter
+pipe organ
+oscilloscope
+overskirt
+bullock cart
+oxygen mask
+product packet / packaging
+paddle
+paddle wheel
+padlock
+paintbrush
+pajamas
+palace
+pan flute
+paper towel
+parachute
+parallel bars
+park bench
+parking meter
+railroad car
+patio
+payphone
+pedestal
+pencil case
+pencil sharpener
+perfume
+Petri dish
+photocopier
+plectrum
+Pickelhaube
+picket fence
+pickup truck
+pier
+piggy bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate ship
+drink pitcher
+block plane
+planetarium
+plastic bag
+plate rack
+farm plow
+plunger
+Polaroid camera
+pole
+police van
+poncho
+pool table
+soda bottle
+plant pot
+potter's wheel
+power drill
+prayer rug
+printer
+prison
+missile
+projector
+hockey puck
+punching bag
+purse
+quill
+quilt
+race car
+racket
+radiator
+radio
+radio telescope
+rain barrel
+recreational vehicle
+fishing casting reel
+reflex camera
+refrigerator
+remote control
+restaurant
+revolver
+rifle
+rocking chair
+rotisserie
+eraser
+rugby ball
+ruler measuring stick
+sneaker
+safe
+safety pin
+salt shaker
+sandal
+sarong
+saxophone
+scabbard
+weighing scale
+school bus
+schooner
+scoreboard
+CRT monitor
+screw
+screwdriver
+seat belt
+sewing machine
+shield
+shoe store
+shoji screen / room divider
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+balaclava ski mask
+sleeping bag
+slide rule
+sliding door
+slot machine
+snorkel
+snowmobile
+snowplow
+soap dispenser
+soccer ball
+sock
+solar thermal collector
+sombrero
+soup bowl
+keyboard space bar
+space heater
+space shuttle
+spatula
+motorboat
+spider web
+spindle
+sports car
+spotlight
+stage
+steam locomotive
+through arch bridge
+steel drum
+stethoscope
+scarf
+stone wall
+stopwatch
+stove
+strainer
+tram
+stretcher
+couch
+stupa
+submarine
+suit
+sundial
+sunglasses
+sunglasses
+sunscreen
+suspension bridge
+mop
+sweatshirt
+swim trunks / shorts
+swing
+electrical switch
+syringe
+table lamp
+tank
+tape player
+teapot
+teddy bear
+television
+tennis ball
+thatched roof
+front curtain
+thimble
+threshing machine
+throne
+tile roof
+toaster
+tobacco shop
+toilet seat
+torch
+totem pole
+tow truck
+toy store
+tractor
+semi-trailer truck
+tray
+trench coat
+tricycle
+trimaran
+tripod
+triumphal arch
+trolleybus
+trombone
+hot tub
+turnstile
+typewriter keyboard
+umbrella
+unicycle
+upright piano
+vacuum cleaner
+vase
+vaulted or arched ceiling
+velvet fabric
+vending machine
+vestment
+viaduct
+violin
+volleyball
+waffle iron
+wall clock
+wallet
+wardrobe
+military aircraft
+sink
+washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+hair wig
+window screen
+window shade
+Windsor tie
+wine bottle
+airplane wing
+wok
+wooden spoon
+wool
+split-rail fence
+shipwreck
+sailboat
+yurt
+website
+comic book
+crossword
+traffic or street sign
+traffic light
+dust jacket
+menu
+plate
+guacamole
+consomme
+hot pot
+trifle
+ice cream
+popsicle
+baguette
+bagel
+pretzel
+cheeseburger
+hot dog
+mashed potatoes
+cabbage
+broccoli
+cauliflower
+zucchini
+spaghetti squash
+acorn squash
+butternut squash
+cucumber
+artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith apple
+strawberry
+orange
+lemon
+fig
+pineapple
+banana
+jackfruit
+cherimoya (custard apple)
+pomegranate
+hay
+carbonara
+chocolate syrup
+dough
+meatloaf
+pizza
+pot pie
+burrito
+red wine
+espresso
+tea cup
+eggnog
+mountain
+bubble
+cliff
+coral reef
+geyser
+lakeshore
+promontory
+sandbar
+beach
+valley
+volcano
+baseball player
+bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper
+corn
+acorn
+rose hip
+horse chestnut seed
+coral fungus
+agaric
+gyromitra
+stinkhorn mushroom
+earth star fungus
+hen of the woods mushroom
+bolete
+corn cob
+toilet paper

external/Grounded-Segment-Anything/recognize-anything/datasets/openimages_common_214/openimages_common_214_ram_taglist.txt

@@ -0,0 +1,214 @@
+accident
+accordion
+plane
+airport
+antelope
+apple
+art gallery
+eggplant
+auditorium
+autumn
+baboon
+backpack
+bakery
+bamboo
+banana
+barbecue
+bed
+bedroom
+clock
+bicycle
+bikini
+birthday cake
+blackberry
+blueberry
+pig
+bookcase
+bridge
+broccoli
+bus
+butterfly
+calculator
+calendar
+camping
+candle
+candy
+cannon
+canyon
+car
+carousel
+cat
+cave
+ceiling
+cheese
+cheetah
+chef
+chicken
+christmas
+christmas tree
+clover
+coral
+corn
+courtyard
+crab
+lobster
+crocodile
+crosswalk
+crow
+cucumber
+cup
+currency
+dachshund
+deer
+desert
+die
+dinosaur
+dog
+dolphin
+doodle
+dragonfly
+drum
+duck
+dumbbell
+easter egg
+egg
+elephant
+faucet
+ferris wheel
+fire
+fireman
+firework
+flamingo
+flower
+football
+fountain
+fox
+fridge
+frog
+ham
+gas stove
+giraffe
+glacier
+glove
+goat
+goose
+gorilla
+grape
+guitar
+gull
+gym
+halloween
+hamburger
+hamster
+handbag
+hedgehog
+helicopter
+horse
+hummingbird
+jellyfish
+kangaroo
+kimono
+kite
+ladybird
+laptop
+leg
+mailbox
+library
+lightning
+lily
+lion
+lizard
+luggage
+mannequin
+map
+mask
+mattress
+microphone
+microwave
+monkey
+moon
+mosque
+mouse
+mushroom
+nebula
+sea
+ostrich
+palm tree
+paper
+pasta
+patient
+pavilion
+pear
+pebble
+penguin
+pet
+piano
+picture frame
+pine
+pineapple
+pizza
+police car
+pomegranate
+poodle
+popcorn
+stamp
+power station
+printer
+pumpkin
+raccoon
+rainbow
+rat
+restroom
+ring
+run
+salad
+sandwich
+sausage
+shark
+sheet music
+shrine
+snowboard
+snake
+sparrow
+squirrel
+stage
+starfish
+statue
+steering wheel
+stream
+street art
+street light
+submarine
+suite
+surfboard
+sushi
+swan
+tattoo
+teddy
+tennis court
+tennis racket
+tiger
+toast
+toilet bowl
+toy
+tractor
+train
+trampoline
+treadmill
+truck
+tunnel
+turkey
+vending machine
+waffle
+walnut
+washing machine
+water buffalo
+waterfall
+watermelon
+wheat
+wheelchair
+windmill
+winter
+wolf
+woodpecker
+zebra

external/Grounded-Segment-Anything/recognize-anything/datasets/openimages_common_214/openimages_common_214_tag2text_tagidlist.txt

@@ -0,0 +1,214 @@
+3
+8
+16
+19
+21
+33
+44
+50
+58
+61
+71
+77
+84
+96
+117
+139
+142
+147
+180
+200
+202
+206
+244
+267
+317
+321
+347
+361
+380
+387
+398
+407
+471
+486
+489
+509
+514
+530
+568
+590
+595
+612
+622
+626
+654
+658
+664
+684
+699
+704
+717
+720
+727
+760
+773
+786
+787
+812
+814
+817
+843
+855
+856
+907
+950
+955
+957
+1023
+1042
+1056
+1066
+1091
+1094
+1108
+1141
+1148
+1152
+1168
+1174
+1187
+1231
+1235
+1246
+1276
+1277
+1305
+1308
+1344
+1359
+1362
+1393
+1394
+1410
+1411
+1468
+1504
+1524
+1536
+1540
+1542
+1546
+1553
+1572
+1574
+1606
+1610
+1615
+1655
+1672
+1680
+1682
+1687
+1691
+1692
+1711
+1712
+1713
+1719
+1727
+1733
+1761
+1770
+1782
+1784
+1786
+1803
+1812
+1816
+1820
+1829
+1831
+1841
+1845
+1878
+1882
+1931
+1940
+1944
+1947
+1974
+1975
+1977
+2009
+2031
+2035
+2052
+2065
+2110
+2113
+2138
+2149
+2154
+2157
+2174
+2178
+2184
+2185
+2202
+2222
+2233
+2291
+2301
+2302
+2317
+2320
+2351
+2354
+2373
+2383
+2393
+2403
+2413
+2415
+2417
+2423
+2449
+2454
+2455
+2472
+2494
+2495
+2528
+2541
+2543
+2553
+2563
+2589
+2603
+2654
+2656
+2658
+2676
+2690
+2693
+2700
+2708
+2720
+2721
+2729
+2732
+2734
+2756
+2786
+2792
+2801
+2821
+2851
+2887
+2906
+2909
+2924
+2929
+2966
+2980

external/Grounded-Segment-Anything/recognize-anything/datasets/openimages_rare_200/openimages_rare_200_ram_taglist.txt

@@ -0,0 +1,200 @@
+Aerial photography
+Aircraft engine
+Ale
+Aloe
+Amphibian
+Angling
+Anole
+Antique car
+Arcade game
+Arthropod
+Assault rifle
+Athletic shoe
+Auto racing
+Backlighting
+Bagpipes
+Ball game
+Barbecue chicken
+Barechested
+Barquentine
+Beef tenderloin
+Billiard room
+Billiards
+Bird of prey
+Black swan
+Black-and-white
+Blond
+Boating
+Bonbon
+Bottled water
+Bouldering
+Bovine
+Bratwurst
+Breadboard
+Briefs
+Brisket
+Brochette
+Calabaza
+Camera operator
+Canola
+Childbirth
+Chordophone
+Church bell
+Classical sculpture
+Close-up
+Cobblestone
+Coca-cola
+Combat sport
+Comics
+Compact car
+Computer speaker
+Cookies and crackers
+Coral reef fish
+Corn on the cob
+Cosmetics
+Crocodilia
+Digital camera
+Dishware
+Divemaster
+Dobermann
+Dog walking
+Domestic rabbit
+Domestic short-haired cat
+Double-decker bus
+Drums
+Electric guitar
+Electric piano
+Electronic instrument
+Equestrianism
+Equitation
+Erinaceidae
+Extreme sport
+Falafel
+Figure skating
+Filling station
+Fire apparatus
+Firearm
+Flatbread
+Floristry
+Forklift truck
+Freight transport
+Fried food
+Fried noodles
+Frigate
+Frozen yogurt
+Frying
+Full moon
+Galleon
+Glacial landform
+Gliding
+Go-kart
+Goats
+Grappling
+Great white shark
+Gumbo
+Gun turret
+Hair coloring
+Halter
+Headphones
+Heavy cruiser
+Herding
+High-speed rail
+Holding hands
+Horse and buggy
+Horse racing
+Hound
+Hunting knife
+Hurdling
+Inflatable
+Jackfruit
+Jeans
+Jiaozi
+Junk food
+Khinkali
+Kitesurfing
+Lawn game
+Leaf vegetable
+Lechon
+Lifebuoy
+Locust
+Lumpia
+Luxury vehicle
+Machine tool
+Medical imaging
+Melee weapon
+Microcontroller
+Middle ages
+Military person
+Military vehicle
+Milky way
+Miniature Poodle
+Modern dance
+Molluscs
+Monoplane
+Motorcycling
+Musical theatre
+Narcissus
+Nest box
+Newsagent's shop
+Nile crocodile
+Nordic skiing
+Nuclear power plant
+Orator
+Outdoor shoe
+Parachuting
+Pasta salad
+Peafowl
+Pelmeni
+Perching bird
+Performance car
+Personal water craft
+Pit bull
+Plant stem
+Pork chop
+Portrait photography
+Primate
+Procyonidae
+Prosciutto
+Public speaking
+Racewalking
+Ramen
+Rear-view mirror
+Residential area
+Ribs
+Rice ball
+Road cycling
+Roller skating
+Roman temple
+Rowing
+Rural area
+Sailboat racing
+Scaled reptile
+Scuba diving
+Senior citizen
+Shallot
+Shinto shrine
+Shooting range
+Siberian husky
+Sledding
+Soba
+Solar energy
+Sport climbing
+Sport utility vehicle
+Steamed rice
+Stemware
+Sumo
+Surfing Equipment
+Team sport
+Touring car
+Toy block
+Trampolining
+Underwater diving
+Vegetarian food
+Wallaby
+Water polo
+Watercolor paint
+Whiskers
+Wind wave
+Woodwind instrument
+Yakitori
+Zeppelin

external/Grounded-Segment-Anything/recognize-anything/ram.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: ram
+Version: 0.0.1
+Summary: Recognize Anything Plus Model, Recognize Anything Model and Tag2Text Model
+License-File: LICENSE
+License-File: NOTICE.txt
+Dynamic: license-file

external/Grounded-Segment-Anything/recognize-anything/ram.egg-info/SOURCES.txt

@@ -0,0 +1,39 @@
+LICENSE
+MANIFEST.in
+NOTICE.txt
+README.md
+setup.cfg
+setup.py
+ram/__init__.py
+ram/inference.py
+ram/transform.py
+ram.egg-info/PKG-INFO
+ram.egg-info/SOURCES.txt
+ram.egg-info/dependency_links.txt
+ram.egg-info/top_level.txt
+ram/configs/med_config.json
+ram/configs/q2l_config.json
+ram/configs/swin/config_swinB_224.json
+ram/configs/swin/config_swinB_384.json
+ram/configs/swin/config_swinL_224.json
+ram/configs/swin/config_swinL_384.json
+ram/data/__init__.py
+ram/data/dataset.py
+ram/data/ram_tag_list.txt
+ram/data/ram_tag_list_chinese.txt
+ram/data/ram_tag_list_threshold.txt
+ram/data/randaugment.py
+ram/data/tag2text_ori_tag_list.txt
+ram/data/tag_list.txt
+ram/data/utils.py
+ram/models/__init__.py
+ram/models/bert.py
+ram/models/ram.py
+ram/models/ram_plus.py
+ram/models/swin_transformer.py
+ram/models/tag2text.py
+ram/models/utils.py
+ram/models/vit.py
+ram/utils/__init__.py
+ram/utils/metrics.py
+ram/utils/openset_utils.py

external/Grounded-Segment-Anything/recognize-anything/ram.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

external/Grounded-Segment-Anything/recognize-anything/ram.egg-info/top_level.txt

@@ -0,0 +1 @@
+ram

external/Grounded-Segment-Anything/recognize-anything/ram/__init__.py

@@ -0,0 +1,2 @@
+from .inference import inference_tag2text, inference_ram, inference_ram_openset
+from .transform import get_transform

external/Grounded-Segment-Anything/recognize-anything/ram/configs/finetune.yaml

@@ -0,0 +1,22 @@
+train_file: [
+            'datasets/train/coco_train_rmcocodev_ram.json',
+             ]
+image_path_root: ""
+
+# size of vit model; base or large
+vit: 'swin_l'
+vit_grad_ckpt: False
+vit_ckpt_layer: 0
+
+image_size: 384
+batch_size: 26
+
+# optimizer
+weight_decay: 0.05
+init_lr: 5e-06
+min_lr: 0
+max_epoch: 2
+warmup_steps: 3000
+
+class_num: 4585
+

external/Grounded-Segment-Anything/recognize-anything/ram/configs/finetune_tag2text.yaml

@@ -0,0 +1,22 @@
+train_file: [
+            'datasets/train/coco_train_rmcocodev_ram.json',
+             ]
+image_path_root: ""
+
+# size of vit model; base or large
+vit: 'swin_b'
+vit_grad_ckpt: False
+vit_ckpt_layer: 0
+
+image_size: 384
+batch_size: 36
+
+# optimizer
+weight_decay: 0.05
+init_lr: 5e-06
+min_lr: 0
+max_epoch: 2
+warmup_steps: 3000
+
+class_num: 4585
+

external/Grounded-Segment-Anything/recognize-anything/ram/configs/med_config.json

@@ -0,0 +1,21 @@
+{
+    "architectures": [
+      "BertModel"
+    ],
+    "attention_probs_dropout_prob": 0.1,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.1,
+    "hidden_size": 768,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "layer_norm_eps": 1e-12,
+    "max_position_embeddings": 512,
+    "model_type": "bert",
+    "num_attention_heads": 12,
+    "num_hidden_layers": 12,
+    "pad_token_id": 0,
+    "type_vocab_size": 2,
+    "vocab_size": 30524,
+    "encoder_width": 768,
+    "add_cross_attention": true   
+  }

external/Grounded-Segment-Anything/recognize-anything/ram/configs/pretrain.yaml

@@ -0,0 +1,29 @@
+train_file: [
+            'datasets/train/coco_train_rmcocodev_ram.json',
+            'datasets/train/vg_ram.json',
+            'datasets/train/sbu_ram.json',
+            'datasets/train/cc3m_train_ram.json',
+            'datasets/train/cc3m_val_ram.json',
+            'datasets/train/cc12m_ram.json',
+             ]
+image_path_root: ""
+
+# size of vit model; base or large
+vit: 'swin_l'
+vit_grad_ckpt: False
+vit_ckpt_layer: 0
+
+image_size: 224
+batch_size: 52
+
+# optimizer
+weight_decay: 0.05
+init_lr: 1e-4
+min_lr: 5e-7
+warmup_lr: 5e-7
+lr_decay_rate: 0.9
+max_epoch: 5
+warmup_steps: 3000
+
+class_num: 4585
+

external/Grounded-Segment-Anything/recognize-anything/ram/configs/pretrain_tag2text.yaml

@@ -0,0 +1,29 @@
+train_file: [
+            'datasets/train/coco_train_rmcocodev_ram.json',
+            'datasets/train/vg_ram.json',
+            'datasets/train/sbu_ram.json',
+            'datasets/train/cc3m_train_ram.json',
+            'datasets/train/cc3m_val_ram.json',
+            'datasets/train/cc12m_ram.json',
+             ]
+image_path_root: ""
+
+# size of vit model; base or large
+vit: 'swin_b'
+vit_grad_ckpt: False
+vit_ckpt_layer: 0
+
+image_size: 224
+batch_size: 80
+
+# optimizer
+weight_decay: 0.05
+init_lr: 1e-4
+min_lr: 5e-7
+warmup_lr: 5e-7
+lr_decay_rate: 0.9
+max_epoch: 5
+warmup_steps: 3000
+
+class_num: 4585
+

external/Grounded-Segment-Anything/recognize-anything/ram/configs/q2l_config.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "BertModel"
+    ],
+    "attention_probs_dropout_prob": 0.1,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.1,
+    "hidden_size": 768,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "layer_norm_eps": 1e-12,
+    "max_position_embeddings": 512,
+    "model_type": "bert",
+    "num_attention_heads": 4,
+    "num_hidden_layers": 2,
+    "pad_token_id": 0,
+    "type_vocab_size": 2,
+    "vocab_size": 30522,
+    "encoder_width": 768,
+    "add_cross_attention": true,
+    "add_tag_cross_attention": false
+  }

external/Grounded-Segment-Anything/recognize-anything/ram/configs/swin/config_swinB_224.json

@@ -0,0 +1,9 @@
+{
+    "ckpt": "pretrain_model/swin_base_patch4_window7_224_22k.pth",
+    "vision_width": 1024,
+    "image_res": 224,
+    "window_size": 7,
+    "embed_dim": 128,
+    "depths": [ 2, 2, 18, 2 ],
+    "num_heads": [ 4, 8, 16, 32 ]
+  }