push unicl demo

README.md

@@ -1,5 +1,5 @@
 ---
-title: Unicl Img Recognition Demo
+title: Unicl Image Recognition Demo
 emoji: 🏢
 colorFrom: red
 colorTo: purple

app.py

@@ -0,0 +1,143 @@
+import argparse
+import requests
+import gradio as gr
+import numpy as np
+import cv2
+import torch
+import torch.nn as nn
+from PIL import Image
+from torchvision import transforms
+from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from timm.data import create_transform
+from config import get_config
+from model import build_model
+
+# Download human-readable labels for ImageNet.
+response = requests.get("https://git.io/JJkYN")
+labels = response.text.split("\n")
+
+def parse_option():
+    parser = argparse.ArgumentParser('UniCL demo script', add_help=False)
+    parser.add_argument('--cfg', type=str, default="configs/unicl_swin_base.yaml", metavar="FILE", help='path to config file', )
+    args, unparsed = parser.parse_known_args()
+
+    config = get_config(args)
+
+    return args, config
+
+def build_transforms(img_size, center_crop=True):
+    t = [transforms.ToPILImage()]
+    if center_crop:
+        size = int((256 / 224) * img_size)
+        t.append(
+            transforms.Resize(size)
+        )
+        t.append(
+            transforms.CenterCrop(img_size)    
+        )
+    else:
+        t.append(
+            transforms.Resize(img_size)
+        )        
+    t.append(transforms.ToTensor())
+    t.append(transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD))
+    return transforms.Compose(t)
+
+def build_transforms4display(img_size, center_crop=True):
+    t = [transforms.ToPILImage()]
+    if center_crop:
+        size = int((256 / 224) * img_size)
+        t.append(
+            transforms.Resize(size)
+        )
+        t.append(
+            transforms.CenterCrop(img_size)    
+        )
+    else:
+        t.append(
+            transforms.Resize(img_size)
+        )  
+    t.append(transforms.ToTensor())
+    return transforms.Compose(t)
+
+args, config = parse_option()
+
+'''
+build model
+'''
+model = build_model(config)
+
+url = './in21k_yfcc14m_gcc15m_swin_base.pth'
+checkpoint = torch.load(url, map_location="cpu")
+model.load_state_dict(checkpoint["model"])
+model.eval()
+
+'''
+build data transform
+'''
+eval_transforms = build_transforms(224, center_crop=True)
+display_transforms = build_transforms4display(224, center_crop=True)
+
+'''
+build upsampler
+'''
+# upsampler = nn.Upsample(scale_factor=16, mode='bilinear')
+
+'''
+borrow code from here: https://github.com/jacobgil/pytorch-grad-cam/blob/master/pytorch_grad_cam/utils/image.py
+'''
+def show_cam_on_image(img: np.ndarray,
+                      mask: np.ndarray,
+                      use_rgb: bool = False,
+                      colormap: int = cv2.COLORMAP_JET) -> np.ndarray:
+    """ This function overlays the cam mask on the image as an heatmap.
+    By default the heatmap is in BGR format.
+    :param img: The base image in RGB or BGR format.
+    :param mask: The cam mask.
+    :param use_rgb: Whether to use an RGB or BGR heatmap, this should be set to True if 'img' is in RGB format.
+    :param colormap: The OpenCV colormap to be used.
+    :returns: The default image with the cam overlay.
+    """
+    heatmap = cv2.applyColorMap(np.uint8(255 * mask), colormap)
+    if use_rgb:
+        heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
+    heatmap = np.float32(heatmap) / 255
+
+    if np.max(img) > 1:
+        raise Exception(
+            "The input image should np.float32 in the range [0, 1]")
+
+    cam = 0.7*heatmap + 0.3*img
+    # cam = cam / np.max(cam)
+    return np.uint8(255 * cam)
+
+def recognize_image(image, texts):
+    img_t = eval_transforms(image) 
+    img_d = display_transforms(image).permute(1, 2, 0).numpy()
+
+    text_embeddings = model.get_text_embeddings(texts.split(';'))
+
+    # compute output
+    feat_img = model.encode_image(img_t.unsqueeze(0))
+    output = model.logit_scale.exp() * feat_img @ text_embeddings.t()
+    prediction = output.softmax(-1).flatten()
+
+    return {texts.split(';')[i]: float(prediction[i]) for i in range(len(texts.split(';')))}
+
+
+image = gr.inputs.Image()
+label = gr.outputs.Label(num_top_classes=100)
+
+gr.Interface(
+    description="UniCL for Zero-shot Image Recognition Demo (https://github.com/microsoft/unicl)",
+    fn=recognize_image,
+    inputs=["image", "text"],
+    outputs=[                   
+        label,
+    ],
+    examples=[
+    ["./elephants.png", "an elephant; an elephant walking in the river; four elephants walking in the river"], 
+    ["./apple_with_ipod.jpg", "an ipod; an apple with a write note 'ipod'; an apple"], 
+    ["./crowd2.jpg", "a street; a street with a woman walking in the middle; a street with a man walking in the  middle"],
+    ],
+).launch()

config.py

@@ -0,0 +1,245 @@
+# --------------------------------------------------------
+# Unified Contrastive Learning (UniCL)
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Jianwei Yang ([email protected])
+# Based on Swin Transformer written by Zhe Liu
+# --------------------------------------------------------
+
+import os
+import yaml
+from yacs.config import CfgNode as CN
+
+_C = CN()
+_C.VERBOSE = False
+
+# Base config files
+_C.BASE = ['']
+
+# -----------------------------------------------------------------------------
+# Data settings
+# -----------------------------------------------------------------------------
+_C.DATA = CN()
+# Batch size for a single GPU, could be overwritten by command line argument
+_C.DATA.BATCH_SIZE = 128
+# Path to dataset, could be overwritten by command line argument
+_C.DATA.DATA_PATH = ''
+# Dataset name
+_C.DATA.DATASET = 'imagenet'
+# Input image size
+_C.DATA.IMG_SIZE = 224
+# Interpolation to resize image (random, bilinear, bicubic)
+_C.DATA.INTERPOLATION = 'bicubic'
+# Use zipped dataset instead of folder dataset
+# could be overwritten by command line argument
+_C.DATA.ZIP_MODE = False
+# Cache Data in Memory, could be overwritten by command line argument
+_C.DATA.CACHE_MODE = 'part'
+# Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.
+_C.DATA.PIN_MEMORY = True
+# Number of data loading threads
+_C.DATA.NUM_WORKERS = 8
+
+# -----------------------------------------------------------------------------
+# Model settings
+# -----------------------------------------------------------------------------
+_C.MODEL = CN()
+# Model name
+_C.MODEL.NAME = ''
+# Checkpoint to resume, could be overwritten by command line argument
+_C.MODEL.RESUME = ''
+# Number of classes, overwritten in data preparation
+_C.MODEL.NUM_CLASSES = 0
+# Label Smoothing
+_C.MODEL.LABEL_SMOOTHING = 0.1
+# Whether load pretrained model
+_C.MODEL.PRETRAINED = ''
+# Projection dimension
+_C.MODEL.DIM_PROJECTION = 512
+# Mode specific
+_C.MODEL.SPEC = CN(new_allowed=True)
+# -----------------------------------------------------------------------------
+# Build Image Encoder
+# -----------------------------------------------------------------------------
+_C.MODEL.IMAGE_ENCODER = CN()
+# Image encoder type
+_C.MODEL.IMAGE_ENCODER.TYPE = 'swin'
+# Input image size
+_C.MODEL.IMAGE_ENCODER.IMG_SIZE = 224
+# Dropout rate
+_C.MODEL.IMAGE_ENCODER.DROP_RATE = 0.0
+# Drop path rate
+_C.MODEL.IMAGE_ENCODER.DROP_PATH_RATE = 0.1
+
+# Swin Transformer parameters
+_C.MODEL.IMAGE_ENCODER.SWIN = CN()
+_C.MODEL.IMAGE_ENCODER.SWIN.PATCH_SIZE = 4
+_C.MODEL.IMAGE_ENCODER.SWIN.IN_CHANS = 3
+_C.MODEL.IMAGE_ENCODER.SWIN.EMBED_DIM = 96
+_C.MODEL.IMAGE_ENCODER.SWIN.DEPTHS = [2, 2, 6, 2]
+_C.MODEL.IMAGE_ENCODER.SWIN.NUM_HEADS = [3, 6, 12, 24]
+_C.MODEL.IMAGE_ENCODER.SWIN.WINDOW_SIZE = 7
+_C.MODEL.IMAGE_ENCODER.SWIN.MLP_RATIO = 4.
+_C.MODEL.IMAGE_ENCODER.SWIN.QKV_BIAS = True
+_C.MODEL.IMAGE_ENCODER.SWIN.QK_SCALE = None
+_C.MODEL.IMAGE_ENCODER.SWIN.APE = False
+_C.MODEL.IMAGE_ENCODER.SWIN.PATCH_NORM = True
+
+# FocalNet parameters
+_C.MODEL.IMAGE_ENCODER.FOCAL = CN()
+_C.MODEL.IMAGE_ENCODER.FOCAL.PATCH_SIZE = 4
+_C.MODEL.IMAGE_ENCODER.FOCAL.IN_CHANS = 3
+_C.MODEL.IMAGE_ENCODER.FOCAL.EMBED_DIM = 96
+_C.MODEL.IMAGE_ENCODER.FOCAL.DEPTHS = [2, 2, 6, 2]
+_C.MODEL.IMAGE_ENCODER.FOCAL.MLP_RATIO = 4.
+_C.MODEL.IMAGE_ENCODER.FOCAL.PATCH_NORM = True
+_C.MODEL.IMAGE_ENCODER.FOCAL.FOCAL_LEVELS = [2, 2, 2, 2]
+_C.MODEL.IMAGE_ENCODER.FOCAL.FOCAL_WINDOWS = [3, 3, 3, 3]
+_C.MODEL.IMAGE_ENCODER.FOCAL.FOCAL_FACTORS = [2, 2, 2, 2]
+_C.MODEL.IMAGE_ENCODER.FOCAL.USE_CONV_EMBED = False
+_C.MODEL.IMAGE_ENCODER.FOCAL.USE_LAYERSCALE = False
+_C.MODEL.IMAGE_ENCODER.FOCAL.USE_POSTLN = False
+
+# -----------------------------------------------------------------------------
+# Build Text Encoder
+# -----------------------------------------------------------------------------
+_C.MODEL.TEXT_ENCODER = CN()
+
+_C.MODEL.TEXT_ENCODER.NAME = 'transformer'
+_C.MODEL.TEXT_ENCODER.LOAD_PRETRAINED = False
+_C.MODEL.TEXT_ENCODER.PRETRAINED = ''
+_C.MODEL.TEXT_ENCODER.TOKENIZER = 'clip'
+_C.MODEL.TEXT_ENCODER.CONTEXT_LENGTH = 77
+_C.MODEL.TEXT_ENCODER.WIDTH = 1024
+_C.MODEL.TEXT_ENCODER.HEADS = 16
+_C.MODEL.TEXT_ENCODER.LAYERS = 12
+_C.MODEL.TEXT_ENCODER.AUTOGRESSIVE = True
+
+# -----------------------------------------------------------------------------
+# Training settings
+# -----------------------------------------------------------------------------
+_C.TRAIN = CN()
+_C.TRAIN.START_EPOCH = 0
+_C.TRAIN.EPOCHS = 32
+_C.TRAIN.WARMUP_EPOCHS = 5
+_C.TRAIN.WEIGHT_DECAY = 0.1
+_C.TRAIN.BASE_LR = 5e-4
+_C.TRAIN.WARMUP_LR = 5e-7
+_C.TRAIN.MIN_LR = 5e-6
+# Clip gradient norm
+_C.TRAIN.CLIP_GRAD = 5.0
+# Auto resume from latest checkpoint
+_C.TRAIN.AUTO_RESUME = True
+# Gradient accumulation steps
+# could be overwritten by command line argument
+_C.TRAIN.ACCUMULATION_STEPS = 0
+# Whether to use gradient checkpointing to save memory
+# could be overwritten by command line argument
+_C.TRAIN.USE_CHECKPOINT = False
+
+# LR scheduler
+_C.TRAIN.LR_SCHEDULER = CN()
+_C.TRAIN.LR_SCHEDULER.NAME = 'cosine'
+# Epoch interval to decay LR, used in StepLRScheduler
+_C.TRAIN.LR_SCHEDULER.DECAY_EPOCHS = 30
+# LR decay rate, used in StepLRScheduler
+_C.TRAIN.LR_SCHEDULER.DECAY_RATE = 0.1
+
+# Optimizer
+_C.TRAIN.OPTIMIZER = CN()
+_C.TRAIN.OPTIMIZER.NAME = 'adamw'
+# Optimizer Epsilon
+_C.TRAIN.OPTIMIZER.EPS = 1e-8
+# Optimizer Betas
+_C.TRAIN.OPTIMIZER.BETAS = (0.9, 0.999)
+# SGD momentum
+_C.TRAIN.OPTIMIZER.MOMENTUM = 0.9
+
+# -----------------------------------------------------------------------------
+# Augmentation settings
+# -----------------------------------------------------------------------------
+_C.AUG = CN()
+# Color jitter factor
+_C.AUG.COLOR_JITTER = 0.4
+# Use AutoAugment policy. "v0" or "original"
+_C.AUG.AUTO_AUGMENT = 'rand-m9-mstd0.5-inc1'
+# Random erase prob
+_C.AUG.REPROB = 0.25
+# Random erase mode
+_C.AUG.REMODE = 'pixel'
+# Random erase count
+_C.AUG.RECOUNT = 1
+# Mixup alpha, mixup enabled if > 0
+_C.AUG.MIXUP = 0.8
+# Cutmix alpha, cutmix enabled if > 0
+_C.AUG.CUTMIX = 1.0
+# Cutmix min/max ratio, overrides alpha and enables cutmix if set
+_C.AUG.CUTMIX_MINMAX = None
+# Probability of performing mixup or cutmix when either/both is enabled
+_C.AUG.MIXUP_PROB = 1.0
+# Probability of switching to cutmix when both mixup and cutmix enabled
+_C.AUG.MIXUP_SWITCH_PROB = 0.5
+# How to apply mixup/cutmix params. Per "batch", "pair", or "elem"
+_C.AUG.MIXUP_MODE = 'batch'
+
+# -----------------------------------------------------------------------------
+# Testing settings
+# -----------------------------------------------------------------------------
+_C.TEST = CN()
+# Whether to use center crop when testing
+_C.TEST.CROP = True
+
+# -----------------------------------------------------------------------------
+# Misc
+# -----------------------------------------------------------------------------
+# Mixed precision opt level, if O0, no amp is used ('O0', 'O1', 'O2')
+# overwritten by command line argument
+_C.AMP_OPT_LEVEL = ''
+# Path to output folder, overwritten by command line argument
+_C.OUTPUT = ''
+# Tag of experiment, overwritten by command line argument
+_C.TAG = 'default'
+# Frequency to save checkpoint
+_C.SAVE_FREQ = 1
+# Frequency to logging info
+_C.PRINT_FREQ = 100
+# Fixed random seed
+_C.SEED = 0
+# Perform evaluation only, overwritten by command line argument
+_C.EVAL_MODE = False
+# Test throughput only, overwritten by command line argument
+_C.THROUGHPUT_MODE = False
+# Debug only so that skip dataloader initialization, overwritten by command line argument
+_C.DEBUG_MODE = False
+# local rank for DistributedDataParallel, given by command line argument
+_C.LOCAL_RANK = 0
+
+
+def _update_config_from_file(config, cfg_file):
+    config.defrost()
+    with open(cfg_file, 'r') as f:
+        yaml_cfg = yaml.load(f, Loader=yaml.FullLoader)
+
+    for cfg in yaml_cfg.setdefault('BASE', ['']):
+        if cfg:
+            _update_config_from_file(
+                config, os.path.join(os.path.dirname(cfg_file), cfg)
+            )
+    print('=> merge config from {}'.format(cfg_file))
+    config.merge_from_file(cfg_file)
+    config.freeze()
+
+
+def update_config(config, args):
+    _update_config_from_file(config, args.cfg)
+    config.freeze()
+
+
+def get_config(args):
+    """Get a yacs CfgNode object with default values."""
+    # Return a clone so that the defaults will not be altered
+    # This is for the "local variable" use pattern
+    config = _C.clone()
+    update_config(config, args)
+
+    return config

configs/unicl_focalnet_giant.yaml

@@ -0,0 +1,16 @@
+MODEL:
+  NAME: unicl_focalnet_giant
+  DIM_PROJECTION: 1024 
+  IMAGE_ENCODER:
+    TYPE: focalnet_giant_lrf
+    DROP_PATH_RATE: 0.5
+    FOCAL:
+      USE_POSTLN: False
+      USE_CONV_EMBED: False    
+      EMBED_DIM: 512
+      USE_LAYERSCALE: True
+  TEXT_ENCODER:
+    NAME: 'transformer'
+    WIDTH: 1024
+    HEADS: 16
+    LAYERS: 16   

configs/unicl_swin_base.yaml

@@ -0,0 +1,16 @@
+MODEL:
+  NAME: unicl_swin_base
+  DIM_PROJECTION: 512  
+  IMAGE_ENCODER:
+    TYPE: swin
+    DROP_PATH_RATE: 0.5
+    SWIN:
+      EMBED_DIM: 128
+      DEPTHS: [ 2, 2, 18, 2 ]
+      NUM_HEADS: [ 4, 8, 16, 32 ]
+      WINDOW_SIZE: 7
+  TEXT_ENCODER:
+    NAME: 'transformer'
+    WIDTH: 512
+    HEADS: 8
+    LAYERS: 12  

configs/unicl_swin_tiny.yaml

@@ -0,0 +1,16 @@
+MODEL:
+  NAME: unicl_swin_tiny
+  DIM_PROJECTION: 512  
+  IMAGE_ENCODER:
+    TYPE: swin
+    DROP_PATH_RATE: 0.2
+    SWIN:
+      EMBED_DIM: 96
+      DEPTHS: [ 2, 2, 6, 2 ]
+      NUM_HEADS: [ 3, 6, 12, 24 ]
+      WINDOW_SIZE: 7
+  TEXT_ENCODER:
+    NAME: 'transformer'
+    WIDTH: 512
+    HEADS: 8
+    LAYERS: 12  

model/__init__.py

@@ -0,0 +1 @@
+from .model import build_unicl_model as build_model

model/image_encoder/__init__.py

@@ -0,0 +1 @@
+from .build import build_model as build_image_encoder

model/image_encoder/build.py

@@ -0,0 +1,59 @@
+from timm.models import create_model
+from .swin_transformer import SwinTransformer
+from . import focalnet
+
+def build_model(config):
+    model_type = config.TYPE
+    print(f"Creating model: {model_type}")
+    
+    if "swin" in model_type:
+        model = SwinTransformer(
+            num_classes=0,
+            img_size=config.IMG_SIZE,
+            patch_size=config.SWIN.PATCH_SIZE,
+            in_chans=config.SWIN.IN_CHANS,
+            embed_dim=config.SWIN.EMBED_DIM,
+            depths=config.SWIN.DEPTHS,
+            num_heads=config.SWIN.NUM_HEADS,
+            window_size=config.SWIN.WINDOW_SIZE,
+            mlp_ratio=config.SWIN.MLP_RATIO,
+            qkv_bias=config.SWIN.QKV_BIAS,
+            qk_scale=config.SWIN.QK_SCALE,
+            drop_rate=config.DROP_RATE,
+            drop_path_rate=config.DROP_PATH_RATE,
+            ape=config.SWIN.APE,
+            patch_norm=config.SWIN.PATCH_NORM,
+            use_checkpoint=False
+            ) 
+    elif "focal" in model_type:
+        model = create_model(
+            model_type, 
+            pretrained=False, 
+            img_size=config.IMG_SIZE,
+            num_classes=0,
+            drop_path_rate=config.DROP_PATH_RATE,
+            use_conv_embed=config.FOCAL.USE_CONV_EMBED, 
+            use_layerscale=config.FOCAL.USE_LAYERSCALE,
+            use_postln=config.FOCAL.USE_POSTLN
+        )  
+
+    elif "vit" in model_type:
+        model = create_model(
+            model_type,
+            pretrained=is_pretrained,
+            img_size=config.DATA.IMG_SIZE,
+            num_classes=config.MODEL.NUM_CLASSES,
+        )
+    elif "resnet" in model_type:
+        model = create_model(
+            model_type,
+            pretrained=is_pretrained,
+            num_classes=config.MODEL.NUM_CLASSES
+        )
+    else:
+        model = create_model(
+            model_type,
+            pretrained=is_pretrained,
+            num_classes=config.MODEL.NUM_CLASSES
+        )        
+    return model

model/image_encoder/focalnet.py

@@ -0,0 +1,649 @@
+# --------------------------------------------------------
+# FocalNets -- Focal Modulation Networks
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Jianwei Yang ([email protected])
+# --------------------------------------------------------
+
+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, to_2tuple, trunc_normal_
+from timm.models.registry import register_model
+
+from torchvision import transforms
+from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from timm.data import create_transform
+from timm.data.transforms import _pil_interp
+
+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.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)     
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+class FocalModulation(nn.Module):
+    def __init__(self, dim, focal_window, focal_level, focal_factor=2, bias=True, proj_drop=0.):
+        super().__init__()
+
+        self.dim = dim
+        self.focal_window = focal_window
+        self.focal_level = focal_level
+        self.focal_factor = focal_factor
+
+        self.f = nn.Linear(dim, 2*dim + (self.focal_level+1), bias=bias)
+        self.h = nn.Conv2d(dim, dim, kernel_size=1, stride=1, bias=bias)
+
+        self.act = nn.GELU()
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+        self.focal_layers = nn.ModuleList()
+                
+        self.kernel_sizes = []
+        for k in range(self.focal_level):
+            kernel_size = self.focal_factor*k + self.focal_window
+            self.focal_layers.append(
+                nn.Sequential(
+                    nn.Conv2d(dim, dim, kernel_size=kernel_size, stride=1, 
+                    groups=dim, padding=kernel_size//2, bias=False),
+                    nn.GELU(),
+                    )
+                )              
+            self.kernel_sizes.append(kernel_size)          
+    def forward(self, x):
+        """
+        Args:
+            x: input features with shape of (B, H, W, C)
+        """
+        C = x.shape[-1]
+
+        # pre linear projection
+        x = self.f(x).permute(0, 3, 1, 2).contiguous()
+        q, ctx, self.gates = torch.split(x, (C, C, self.focal_level+1), 1)
+        
+        # context aggreation
+        ctx_all = 0 
+        for l in range(self.focal_level):         
+            ctx = self.focal_layers[l](ctx)
+            ctx_all = ctx_all + ctx*self.gates[:, l:l+1]
+        ctx_global = self.act(ctx.mean(2, keepdim=True).mean(3, keepdim=True))
+        ctx_all = ctx_all + ctx_global*self.gates[:,self.focal_level:]
+
+        # focal modulation
+        self.modulator = self.h(ctx_all)
+        x_out = q*self.modulator
+        x_out = x_out.permute(0, 2, 3, 1).contiguous()
+        
+        # post linear porjection
+        x_out = self.proj(x_out)
+        x_out = self.proj_drop(x_out)
+        return x_out
+
+    def extra_repr(self) -> str:
+        return f'dim={self.dim}'
+
+    def flops(self, N):
+        # calculate flops for 1 window with token length of N
+        flops = 0
+
+        flops += N * self.dim * (self.dim * 2 + (self.focal_level+1))
+
+        # focal convolution
+        for k in range(self.focal_level):
+            flops += N * (self.kernel_sizes[k]**2+1) * self.dim
+
+        # global gating
+        flops += N * 1 * self.dim 
+
+        #  self.linear
+        flops += N * self.dim * (self.dim + 1)
+
+        # x = self.proj(x)
+        flops += N * self.dim * self.dim
+        return flops
+
+class FocalNetBlock(nn.Module):
+    r""" Focal Modulation Network Block.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resulotion.
+        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
+        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+        focal_level (int): Number of focal levels. 
+        focal_window (int): Focal window size at first focal level
+        use_layerscale (bool): Whether use layerscale
+        layerscale_value (float): Initial layerscale value
+        use_postln (bool): Whether use layernorm after modulation
+    """
+
+    def __init__(self, dim, input_resolution, mlp_ratio=4., drop=0., drop_path=0., 
+                    act_layer=nn.GELU, norm_layer=nn.LayerNorm,
+                    focal_level=1, focal_window=3,
+                    use_layerscale=False, layerscale_value=1e-4, 
+                    use_postln=False):
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.mlp_ratio = mlp_ratio
+
+        self.focal_window = focal_window
+        self.focal_level = focal_level
+        self.use_postln = use_postln
+
+        self.norm1 = norm_layer(dim)
+        self.modulation = FocalModulation(dim, proj_drop=drop, focal_window=focal_window, focal_level=self.focal_level)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        self.alpha = 3.0 if self.use_postln else 1.0
+
+        self.gamma_1 = 1.0
+        self.gamma_2 = 1.0    
+        if use_layerscale:
+            self.gamma_1 = nn.Parameter(layerscale_value * torch.ones((dim)), requires_grad=True)
+            self.gamma_2 = nn.Parameter(layerscale_value * torch.ones((dim)), requires_grad=True)
+
+        self.H = None
+        self.W = None
+
+    def forward(self, x):
+        H, W = self.H, self.W
+        B, L, C = x.shape
+        shortcut = x
+
+        # Focal Modulation
+        if not self.use_postln:
+            x = self.norm1(x)
+        x = x.view(B, H, W, C)
+        x = self.modulation(x).view(B, H * W, C)
+
+        # FFN
+        x = shortcut*self.alpha + self.drop_path(self.gamma_1 * x)
+        if self.use_postln:
+            x = self.norm1(x)
+
+        if not self.use_postln:
+            x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x)))
+        else:
+            x = x*self.alpha + self.drop_path(self.gamma_2 * self.mlp(x))
+            x = self.norm2(x)
+
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, " \
+               f"mlp_ratio={self.mlp_ratio}"
+
+    def flops(self):
+        flops = 0
+        H, W = self.input_resolution
+        # norm1
+        flops += self.dim * H * W
+        
+        # W-MSA/SW-MSA
+        flops += self.modulation.flops(H*W)
+
+        # mlp
+        flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio
+        # norm2
+        flops += self.dim * H * W
+        return flops
+
+class BasicLayer(nn.Module):
+    """ A basic Focal Transformer layer for one stage.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resolution.
+        depth (int): Number of blocks.
+        window_size (int): Local window size.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        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.
+        focal_level (int): Number of focal levels
+        focal_window (int): Focal window size at first focal level
+        use_layerscale (bool): Whether use layerscale
+        layerscale_value (float): Initial layerscale value
+        use_postln (bool): Whether use layernorm after modulation
+    """
+
+    def __init__(self, dim, out_dim, input_resolution, depth,
+                 mlp_ratio=4., drop=0., drop_path=0., norm_layer=nn.LayerNorm, 
+                 downsample=None, use_checkpoint=False, 
+                 focal_level=1, focal_window=1, 
+                 use_conv_embed=False, 
+                 use_layerscale=False, layerscale_value=1e-4, use_postln=False):
+
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+        
+        # build blocks
+        self.blocks = nn.ModuleList([
+            FocalNetBlock(
+                dim=dim, 
+                input_resolution=input_resolution,
+                mlp_ratio=mlp_ratio, 
+                drop=drop, 
+                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                norm_layer=norm_layer,
+                focal_level=focal_level,
+                focal_window=focal_window, 
+                use_layerscale=use_layerscale, 
+                layerscale_value=layerscale_value,
+                use_postln=use_postln, 
+            )
+            for i in range(depth)])
+
+        if downsample is not None:
+            self.downsample = downsample(
+                img_size=input_resolution, 
+                patch_size=2, 
+                in_chans=dim, 
+                embed_dim=out_dim, 
+                use_conv_embed=use_conv_embed, 
+                norm_layer=norm_layer, 
+                is_stem=False
+            )
+        else:
+            self.downsample = None
+
+    def forward(self, x, H, W):
+        for blk in self.blocks:
+            blk.H, blk.W = H, W
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x)
+            else:
+                x = blk(x)
+
+        if self.downsample is not None:
+            x = x.transpose(1, 2).reshape(x.shape[0], -1, H, W)
+            x, Ho, Wo = self.downsample(x)
+        else:
+            Ho, Wo = H, W        
+        return x, Ho, Wo
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"
+
+    def flops(self):
+        flops = 0
+        for blk in self.blocks:
+            flops += blk.flops()
+        if self.downsample is not None:
+            flops += self.downsample.flops()
+        return flops
+
+class PatchEmbed(nn.Module):
+    r""" Image to Patch Embedding
+
+    Args:
+        img_size (int): Image size.  Default: 224.
+        patch_size (int): Patch token size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        norm_layer (nn.Module, optional): Normalization layer. Default: None
+    """
+
+    def __init__(self, img_size=(224, 224), patch_size=4, in_chans=3, embed_dim=96, use_conv_embed=False, norm_layer=None, is_stem=False):
+        super().__init__()
+        patch_size = to_2tuple(patch_size)
+        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.patches_resolution = patches_resolution
+        self.num_patches = patches_resolution[0] * patches_resolution[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        if use_conv_embed:
+            # if we choose to use conv embedding, then we treat the stem and non-stem differently
+            if is_stem:
+                kernel_size = 7; padding = 2; stride = 4
+            else:
+                kernel_size = 3; padding = 1; stride = 2
+            self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=kernel_size, stride=stride, padding=padding)
+        else:
+            self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+        
+        if norm_layer is not None:
+            self.norm = norm_layer(embed_dim)
+        else:
+            self.norm = None
+
+    def forward(self, x):
+        B, C, H, W = x.shape
+
+        x = self.proj(x)        
+        H, W = x.shape[2:]
+        x = x.flatten(2).transpose(1, 2)  # B Ph*Pw C
+        if self.norm is not None:
+            x = self.norm(x)
+        return x, H, W
+
+    def flops(self):
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops
+
+class FocalNet(nn.Module):
+    r""" Focal Modulation Networks (FocalNets)
+
+    Args:
+        img_size (int | tuple(int)): Input image size. Default 224
+        patch_size (int | tuple(int)): Patch size. Default: 4
+        in_chans (int): Number of input image channels. Default: 3
+        num_classes (int): Number of classes for classification head. Default: 1000
+        embed_dim (int): Patch embedding dimension. Default: 96
+        depths (tuple(int)): Depth of each Focal Transformer layer.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
+        drop_rate (float): Dropout rate. Default: 0
+        drop_path_rate (float): Stochastic depth rate. Default: 0.1
+        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+        patch_norm (bool): If True, add normalization after patch embedding. Default: True
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False 
+        focal_levels (list): How many focal levels at all stages. Note that this excludes the finest-grain level. Default: [1, 1, 1, 1] 
+        focal_windows (list): The focal window size at all stages. Default: [7, 5, 3, 1] 
+        use_conv_embed (bool): Whether use convolutional embedding. We noted that using convolutional embedding usually improve the performance, but we do not use it by default. Default: False 
+        use_layerscale (bool): Whether use layerscale proposed in CaiT. Default: False 
+        layerscale_value (float): Value for layer scale. Default: 1e-4 
+        use_postln (bool): Whether use layernorm after modulation (it helps stablize training of large models)
+    """
+    def __init__(self, 
+                img_size=224, 
+                patch_size=4, 
+                in_chans=3, 
+                num_classes=1000,
+                embed_dim=96, 
+                depths=[2, 2, 6, 2], 
+                mlp_ratio=4., 
+                drop_rate=0., 
+                drop_path_rate=0.1,
+                norm_layer=nn.LayerNorm, 
+                patch_norm=True,
+                use_checkpoint=False,                 
+                focal_levels=[2, 2, 2, 2], 
+                focal_windows=[3, 3, 3, 3], 
+                use_conv_embed=False, 
+                use_layerscale=False, 
+                layerscale_value=1e-4, 
+                use_postln=False, 
+                **kwargs):
+        super().__init__()
+
+        self.num_layers = len(depths)
+        embed_dim = [embed_dim * (2 ** i) for i in range(self.num_layers)]
+
+        self.num_classes = num_classes
+        self.embed_dim = embed_dim
+        self.patch_norm = patch_norm
+        self.num_features = embed_dim[-1]
+        self.mlp_ratio = mlp_ratio
+        
+        # split image into patches using either non-overlapped embedding or overlapped embedding
+        self.patch_embed = PatchEmbed(
+            img_size=to_2tuple(img_size), 
+            patch_size=patch_size, 
+            in_chans=in_chans, 
+            embed_dim=embed_dim[0], 
+            use_conv_embed=use_conv_embed, 
+            norm_layer=norm_layer if self.patch_norm else None, 
+            is_stem=True)
+
+        num_patches = self.patch_embed.num_patches
+        patches_resolution = self.patch_embed.patches_resolution
+        self.patches_resolution = patches_resolution
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        # 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):
+            layer = BasicLayer(dim=embed_dim[i_layer], 
+                               out_dim=embed_dim[i_layer+1] if (i_layer < self.num_layers - 1) else None,  
+                               input_resolution=(patches_resolution[0] // (2 ** i_layer),
+                                                 patches_resolution[1] // (2 ** i_layer)),
+                               depth=depths[i_layer],
+                               mlp_ratio=self.mlp_ratio,
+                               drop=drop_rate, 
+                               drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                               norm_layer=norm_layer, 
+                               downsample=PatchEmbed if (i_layer < self.num_layers - 1) else None,
+                               focal_level=focal_levels[i_layer], 
+                               focal_window=focal_windows[i_layer], 
+                               use_conv_embed=use_conv_embed,
+                               use_checkpoint=use_checkpoint, 
+                               use_layerscale=use_layerscale, 
+                               layerscale_value=layerscale_value, 
+                               use_postln=use_postln,
+                    )
+            self.layers.append(layer)
+
+        self.norm = norm_layer(self.num_features)
+        self.avgpool = nn.AdaptiveAvgPool1d(1)
+        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
+        self.dim_out = self.num_features
+
+        self.apply(self._init_weights)
+
+    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(self):
+        return {''}
+
+    @torch.jit.ignore
+    def no_weight_decay_keywords(self):
+        return {''}
+
+    def forward_features(self, x):
+        x, H, W = self.patch_embed(x)
+        x = self.pos_drop(x)
+
+        for layer in self.layers:
+            x, H, W = layer(x, H, W)
+        x = self.norm(x)  # B L C
+        x = self.avgpool(x.transpose(1, 2))  # B C 1
+        x = torch.flatten(x, 1)
+        return x
+
+    def forward(self, x):
+        x = self.forward_features(x)
+        x = self.head(x)
+        return x
+
+    def flops(self):
+        flops = 0
+        flops += self.patch_embed.flops()
+        for i, layer in enumerate(self.layers):
+            flops += layer.flops()
+        flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)
+        flops += self.num_features * self.num_classes
+        return flops
+
+def build_transforms(img_size, center_crop=False):
+    t = []
+    if center_crop:
+        size = int((256 / 224) * img_size)
+        t.append(
+            transforms.Resize(size, interpolation=_pil_interp('bicubic'))
+        )
+        t.append(
+            transforms.CenterCrop(img_size)    
+        )
+    else:
+        t.append(
+            transforms.Resize(img_size, interpolation=_pil_interp('bicubic'))
+        )        
+    t.append(transforms.ToTensor())
+    t.append(transforms.Normalize(IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD))
+    return transforms.Compose(t)
+
+def build_transforms4display(img_size, center_crop=False):
+    t = []
+    if center_crop:
+        size = int((256 / 224) * img_size)
+        t.append(
+            transforms.Resize(size, interpolation=_pil_interp('bicubic'))
+        )
+        t.append(
+            transforms.CenterCrop(img_size)    
+        )
+    else:
+        t.append(
+            transforms.Resize(img_size, interpolation=_pil_interp('bicubic'))
+        )  
+    t.append(transforms.ToTensor())
+    return transforms.Compose(t)
+
+model_urls = {
+    "focalnet_tiny_srf": "",
+    "focalnet_small_srf": "",
+    "focalnet_base_srf": "",
+    "focalnet_tiny_lrf": "",
+    "focalnet_small_lrf": "",
+    "focalnet_base_lrf": "",    
+}
+
+@register_model
+def focalnet_tiny_srf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 6, 2], embed_dim=96, **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_tiny_srf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", check_hash=True)
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_small_srf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 18, 2], embed_dim=96, **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_small_srf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_base_srf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 18, 2], embed_dim=128, **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_base_srf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_tiny_lrf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 6, 2], embed_dim=96, focal_levels=[3, 3, 3, 3], **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_tiny_lrf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", check_hash=True)
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_small_lrf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 18, 2], embed_dim=96, focal_levels=[3, 3, 3, 3], **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_small_lrf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_base_lrf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 18, 2], embed_dim=128, focal_levels=[3, 3, 3, 3], **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_base_lrf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_giant_lrf(pretrained=False, **kwargs):
+    model = FocalNet(depths=[2, 2, 42, 2], embed_dim=512, focal_levels=[3, 3, 3, 3], **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_giant_lrf']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_tiny_iso_16(pretrained=False, **kwargs):
+    model = FocalNet(depths=[12], patch_size=16, embed_dim=192, focal_levels=[3], focal_windows=[3], **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_tiny_iso_16']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", check_hash=True)
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_small_iso_16(pretrained=False, **kwargs):
+    model = FocalNet(depths=[12], patch_size=16, embed_dim=384, focal_levels=[3], focal_windows=[3], **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_small_iso_16']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+@register_model
+def focalnet_base_iso_16(pretrained=False, **kwargs):
+    model = FocalNet(depths=[12], patch_size=16, embed_dim=768, focal_levels=[3], focal_windows=[3], use_layerscale=True, use_postln=True, **kwargs)
+    if pretrained:
+        url = model_urls['focalnet_base_iso_16']
+        checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model.load_state_dict(checkpoint["model"])
+    return model
+
+if __name__ == '__main__':
+    img_size = 224
+    x = torch.rand(16, 3, img_size, img_size).cuda()
+    # model = FocalNet(depths=[2, 2, 6, 2], embed_dim=96)
+    # model = FocalNet(depths=[12], patch_size=16, embed_dim=768, focal_levels=[3], focal_windows=[3], focal_factors=[2])
+    model = FocalNet(depths=[2, 2, 6, 2], embed_dim=96, focal_levels=[3, 3, 3, 3]).cuda()
+    print(model); model(x)
+
+    flops = model.flops()
+    print(f"number of GFLOPs: {flops / 1e9}")
+
+    n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"number of params: {n_parameters}")

model/image_encoder/swin_transformer.py

@@ -0,0 +1,586 @@
+# --------------------------------------------------------
+# Swin Transformer
+# Copyright (c) 2021 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ze Liu
+# --------------------------------------------------------
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as checkpoint
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+
+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.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+def window_partition(x, window_size):
+    """
+    Args:
+        x: (B, H, W, C)
+        window_size (int): window size
+
+    Returns:
+        windows: (num_windows*B, window_size, window_size, C)
+    """
+    B, H, W, C = x.shape
+    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    return windows
+
+
+def window_reverse(windows, window_size, H, W):
+    """
+    Args:
+        windows: (num_windows*B, window_size, window_size, C)
+        window_size (int): Window size
+        H (int): Height of image
+        W (int): Width of image
+
+    Returns:
+        x: (B, H, W, C)
+    """
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+    return x
+
+
+class WindowAttention(nn.Module):
+    r""" Window based multi-head self attention (W-MSA) module with relative position bias.
+    It supports both of shifted and non-shifted window.
+
+    Args:
+        dim (int): Number of input channels.
+        window_size (tuple[int]): The height and width of the window.
+        num_heads (int): Number of attention heads.
+        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
+        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
+        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
+    """
+
+    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
+
+        super().__init__()
+        self.dim = dim
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = qk_scale or head_dim ** -0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(self.window_size[0])
+        coords_w = torch.arange(self.window_size[1])
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += self.window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        trunc_normal_(self.relative_position_bias_table, std=.02)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, mask=None):
+        """
+        Args:
+            x: input features with shape of (num_windows*B, N, C)
+            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
+        """
+        B_, N, C = x.shape
+        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+            attn = self.softmax(attn)
+        else:
+            attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+    def extra_repr(self) -> str:
+        return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'
+
+    def flops(self, N):
+        # calculate flops for 1 window with token length of N
+        flops = 0
+        # qkv = self.qkv(x)
+        flops += N * self.dim * 3 * self.dim
+        # attn = (q @ k.transpose(-2, -1))
+        flops += self.num_heads * N * (self.dim // self.num_heads) * N
+        #  x = (attn @ v)
+        flops += self.num_heads * N * N * (self.dim // self.num_heads)
+        # x = self.proj(x)
+        flops += N * self.dim * self.dim
+        return flops
+
+
+class SwinTransformerBlock(nn.Module):
+    r""" Swin Transformer Block.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resulotion.
+        num_heads (int): Number of attention heads.
+        window_size (int): Window size.
+        shift_size (int): Shift size for SW-MSA.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float, optional): Stochastic depth rate. Default: 0.0
+        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
+                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.shift_size = shift_size
+        self.mlp_ratio = mlp_ratio
+        if min(self.input_resolution) <= self.window_size:
+            # if window size is larger than input resolution, we don't partition windows
+            self.shift_size = 0
+            self.window_size = min(self.input_resolution)
+        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+        self.norm1 = norm_layer(dim)
+        self.attn = WindowAttention(
+            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
+            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        if self.shift_size > 0:
+            # calculate attention mask for SW-MSA
+            H, W = self.input_resolution
+            img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1
+            h_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size, -self.shift_size),
+                        slice(-self.shift_size, None))
+            w_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size, -self.shift_size),
+                        slice(-self.shift_size, None))
+            cnt = 0
+            for h in h_slices:
+                for w in w_slices:
+                    img_mask[:, h, w, :] = cnt
+                    cnt += 1
+
+            mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
+            mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+            attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+        else:
+            attn_mask = None
+
+        self.register_buffer("attn_mask", attn_mask)
+
+    def forward(self, x):
+        H, W = self.input_resolution
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+
+        shortcut = x
+        x = self.norm1(x)
+        x = x.view(B, H, W, C)
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+        else:
+            shifted_x = x
+
+        # partition windows
+        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
+        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
+
+        # W-MSA/SW-MSA
+        attn_windows = self.attn(x_windows, mask=self.attn_mask)  # nW*B, window_size*window_size, C
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
+        shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
+
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+        else:
+            x = shifted_x
+        x = x.view(B, H * W, C)
+
+        # FFN
+        x = shortcut + self.drop_path(x)
+        x = x + self.drop_path(self.mlp(self.norm2(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}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}"
+
+    def flops(self):
+        flops = 0
+        H, W = self.input_resolution
+        # norm1
+        flops += self.dim * H * W
+        # W-MSA/SW-MSA
+        nW = H * W / self.window_size / self.window_size
+        flops += nW * self.attn.flops(self.window_size * self.window_size)
+        # mlp
+        flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio
+        # norm2
+        flops += self.dim * H * W
+        return flops
+
+
+class PatchMerging(nn.Module):
+    r""" Patch Merging Layer.
+
+    Args:
+        input_resolution (tuple[int]): Resolution of input feature.
+        dim (int): Number of input channels.
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.input_resolution = input_resolution
+        self.dim = dim
+        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+        self.norm = norm_layer(4 * dim)
+
+    def forward(self, x):
+        """
+        x: B, H*W, C
+        """
+        H, W = self.input_resolution
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+        assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."
+
+        x = x.view(B, H, W, C)
+
+        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
+        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
+        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
+        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
+        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
+        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
+
+        x = self.norm(x)
+        x = self.reduction(x)
+
+        return x
+
+    def extra_repr(self) -> str:
+        return f"input_resolution={self.input_resolution}, dim={self.dim}"
+
+    def flops(self):
+        H, W = self.input_resolution
+        flops = H * W * self.dim
+        flops += (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim
+        return flops
+
+
+class BasicLayer(nn.Module):
+    """ A basic Swin Transformer 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.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        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.
+    """
+
+    def __init__(self, dim, input_resolution, depth, num_heads, window_size,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
+                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):
+
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            SwinTransformerBlock(dim=dim, input_resolution=input_resolution,
+                                 num_heads=num_heads, window_size=window_size,
+                                 shift_size=0 if (i % 2 == 0) else window_size // 2,
+                                 mlp_ratio=mlp_ratio,
+                                 qkv_bias=qkv_bias, qk_scale=qk_scale,
+                                 drop=drop, attn_drop=attn_drop,
+                                 drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                                 norm_layer=norm_layer)
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)
+        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}"
+
+    def flops(self):
+        flops = 0
+        for blk in self.blocks:
+            flops += blk.flops()
+        if self.downsample is not None:
+            flops += self.downsample.flops()
+        return flops
+
+
+class PatchEmbed(nn.Module):
+    r""" Image to Patch Embedding
+
+    Args:
+        img_size (int): Image size.  Default: 224.
+        patch_size (int): Patch token size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        norm_layer (nn.Module, optional): Normalization layer. Default: None
+    """
+
+    def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
+        super().__init__()
+        img_size = to_2tuple(img_size)
+        patch_size = to_2tuple(patch_size)
+        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.patches_resolution = patches_resolution
+        self.num_patches = patches_resolution[0] * patches_resolution[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+        if norm_layer is not None:
+            self.norm = norm_layer(embed_dim)
+        else:
+            self.norm = None
+
+    def forward(self, x):
+        B, C, H, W = x.shape
+        # FIXME look at relaxing size constraints
+        assert H == self.img_size[0] and W == self.img_size[1], \
+            f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
+        x = self.proj(x).flatten(2).transpose(1, 2)  # B Ph*Pw C
+        if self.norm is not None:
+            x = self.norm(x)
+        return x
+
+    def flops(self):
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops
+
+
+class SwinTransformer(nn.Module):
+    r""" Swin Transformer
+        A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows`  -
+          https://arxiv.org/pdf/2103.14030
+
+    Args:
+        img_size (int | tuple(int)): Input image size. Default 224
+        patch_size (int | tuple(int)): Patch size. Default: 4
+        in_chans (int): Number of input image channels. Default: 3
+        num_classes (int): Number of classes for classification head. Default: 1000
+        embed_dim (int): Patch embedding dimension. Default: 96
+        depths (tuple(int)): Depth of each Swin Transformer layer.
+        num_heads (tuple(int)): Number of attention heads in different layers.
+        window_size (int): Window size. Default: 7
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
+        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
+        drop_rate (float): Dropout rate. Default: 0
+        attn_drop_rate (float): Attention dropout rate. Default: 0
+        drop_path_rate (float): Stochastic depth rate. Default: 0.1
+        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
+        patch_norm (bool): If True, add normalization after patch embedding. Default: True
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False
+    """
+
+    def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,
+                 embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24],
+                 window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,
+                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
+                 norm_layer=nn.LayerNorm, ape=False, patch_norm=True,
+                 use_checkpoint=False, **kwargs):
+        super().__init__()
+
+        self.num_classes = num_classes
+        self.num_layers = len(depths)
+        self.embed_dim = embed_dim
+        self.ape = ape
+        self.patch_norm = patch_norm
+        self.num_features = int(embed_dim * 2 ** (self.num_layers - 1))
+        self.mlp_ratio = mlp_ratio
+
+        # split image into non-overlapping patches
+        self.patch_embed = PatchEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
+            norm_layer=norm_layer if self.patch_norm else None)
+        num_patches = self.patch_embed.num_patches
+        patches_resolution = self.patch_embed.patches_resolution
+        self.patches_resolution = patches_resolution
+
+        # absolute position embedding
+        if self.ape:
+            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
+            trunc_normal_(self.absolute_pos_embed, std=.02)
+
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        # 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):
+            layer = BasicLayer(dim=int(embed_dim * 2 ** i_layer),
+                               input_resolution=(patches_resolution[0] // (2 ** i_layer),
+                                                 patches_resolution[1] // (2 ** i_layer)),
+                               depth=depths[i_layer],
+                               num_heads=num_heads[i_layer],
+                               window_size=window_size,
+                               mlp_ratio=self.mlp_ratio,
+                               qkv_bias=qkv_bias, qk_scale=qk_scale,
+                               drop=drop_rate, attn_drop=attn_drop_rate,
+                               drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                               norm_layer=norm_layer,
+                               downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
+                               use_checkpoint=use_checkpoint)
+            self.layers.append(layer)
+
+        self.norm = norm_layer(self.num_features)
+        self.avgpool = nn.AdaptiveAvgPool1d(1)
+        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
+        self.dim_out = self.num_features
+        
+        self.apply(self._init_weights)
+
+    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(self):
+        return {'absolute_pos_embed'}
+
+    @torch.jit.ignore
+    def no_weight_decay_keywords(self):
+        return {'relative_position_bias_table'}
+
+    def forward_features(self, x):
+        x = self.patch_embed(x)
+        if self.ape:
+            x = x + self.absolute_pos_embed
+        x = self.pos_drop(x)
+
+        for layer in self.layers:
+            x = layer(x)
+
+        x = self.norm(x)  # B L C
+        x = self.avgpool(x.transpose(1, 2))  # B C 1
+        x = torch.flatten(x, 1)
+        return x
+
+    def forward(self, x):
+        x = self.forward_features(x)
+        x = self.head(x)
+        return x
+
+    def flops(self):
+        flops = 0
+        flops += self.patch_embed.flops()
+        for i, layer in enumerate(self.layers):
+            flops += layer.flops()
+        flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)
+        flops += self.num_features * self.num_classes
+        return flops

model/model.py

@@ -0,0 +1,204 @@
+import pathlib
+import tempfile
+from collections import OrderedDict
+from typing import Tuple, Union
+import logging
+import os
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from timm.models.layers import DropPath, trunc_normal_
+
+from .image_encoder import build_image_encoder
+from .text_encoder import build_text_encoder
+from .text_encoder import build_tokenizer
+from .templates import DEFAULT_TEMPLATES
+
+logger = logging.getLogger(__name__)
+
+
+class UniCLModel(nn.Module):
+    def __init__(self, config: dict,):
+        super().__init__()
+
+        self.conf_lang_encoder = config['MODEL']['TEXT_ENCODER']
+        self.tokenizer = build_tokenizer(self.conf_lang_encoder)
+
+        self.text_encoder = build_text_encoder(self.conf_lang_encoder, self.tokenizer, config['VERBOSE'])
+
+        dim_projection = config['MODEL']['DIM_PROJECTION']
+        if hasattr(self.text_encoder, 'dim_out'):
+            dim_out = self.text_encoder.dim_out
+        else:
+            with torch.no_grad():
+                dim_out = self.text_encoder(
+                    torch.zeros(1,1).type(torch.LongTensor)
+                )['last_hidden_state'].size(2)
+
+        self.text_projection = nn.Parameter(torch.empty(dim_out, dim_projection))
+
+        self.conf_image_encoder = config['MODEL']['IMAGE_ENCODER']
+        self.image_encoder = build_image_encoder(self.conf_image_encoder)
+
+        self.image_projection = nn.Parameter(
+            torch.empty(self.image_encoder.dim_out, dim_projection)
+        )
+
+        self.logit_scale = nn.Parameter(torch.ones([]))
+
+        trunc_normal_(self.text_projection, std=.02)
+        trunc_normal_(self.image_projection, std=.02)
+
+    def _convert_old_weights(self, model_dict):
+        model_dict_updated = {}
+        for k, v in model_dict.items():
+            if k.startswith('visual.'):
+                model_dict_updated['image_encoder.'+k[7:]] = v
+            elif k.startswith('text.'):
+                model_dict_updated['lang_encoder.'+k[5:]] = v
+            elif k == 'vision_projection':
+                model_dict_updated['image_projection'] = v
+            elif k == 'text_projection':
+                model_dict_updated['text_projection'] = v
+            else:
+                model_dict_updated[k] = v
+
+        return model_dict_updated
+
+    def from_pretrained(self, pretrained='', pretrained_layers=[], verbose=True):
+        if not os.path.isfile(pretrained):
+            logger.warning(f'=> Pretrained model ({pretrained}) is not a file, skip init weight')
+            return
+
+        pretrained_dict = torch.load(pretrained, map_location='cpu')
+        logger.info(f'=> Loading pretrained model {pretrained}')
+        pretrained_dict = self._convert_old_weights(pretrained_dict)
+        model_dict = self.state_dict()
+        pretrained_dict = {
+            k: v for k, v in pretrained_dict.items()
+            if k in model_dict.keys()
+        }
+        need_init_state_dict = {}
+        image_encoder_state_dict = {}
+        for k, v in pretrained_dict.items():
+            need_init = (
+                k.split('.')[0] in pretrained_layers
+                or pretrained_layers[0] == '*'
+            )
+
+            if need_init:
+                if k.startswith('image_encoder.'):
+                    image_encoder_state_dict[k] = v
+                else:
+                    if verbose:
+                        logger.info(f'=> init {k} from {pretrained}')
+
+                    need_init_state_dict[k] = v
+        self.image_encoder.from_state_dict(image_encoder_state_dict, ['*'], verbose)
+        self.load_state_dict(need_init_state_dict, strict=False)
+
+    @torch.jit.ignore
+    def no_weight_decay(self):
+        no_weight_decay = {'logit_scale'}
+        if hasattr(self.text_encoder, 'no_weight_decay'):
+            for k in self.text_encoder.no_weight_decay():
+                no_weight_decay.add('lang_encoder.'+k)
+
+        if hasattr(self.image_encoder, 'no_weight_decay'):
+            for k in self.image_encoder.no_weight_decay():
+                no_weight_decay.add('image_encoder.'+k)
+
+        return no_weight_decay
+
+    @property
+    def dtype(self):
+        return self.logit_scale.dtype
+
+    def get_imnet_embeddings(self):
+        templates = IMAGENET_DEFAULT_TEMPLATES[:1]
+        clss_embeddings = []
+        for clss in IMAGENET_CLASSES:
+            txts = [template.format(clss) for template in templates]
+            
+            tokens = self.tokenizer(
+                txts, padding='max_length', truncation=True, max_length=77, return_tensors='pt'
+            )                
+            tokens = {key:(val.cuda() if next(self.parameters()).is_cuda else val) for key,val in tokens.items()}
+
+            clss_embedding = self.encode_text(tokens)
+            clss_embedding = clss_embedding.mean(dim=0)
+            clss_embedding /= clss_embedding.norm()
+            clss_embeddings.append(clss_embedding)
+        imnet_text_embeddings = torch.stack(clss_embeddings, dim=0)
+        return imnet_text_embeddings
+
+    def get_text_embeddings(self, texts):
+        templates = DEFAULT_TEMPLATES[:1]
+        clss_embeddings = []
+        for clss in texts:
+            txts = [template.format(clss) for template in templates]
+            
+            tokens = self.tokenizer(
+                txts, padding='max_length', truncation=True, max_length=77, return_tensors='pt'
+            )                
+            tokens = {key:(val.cuda() if next(self.parameters()).is_cuda else val) for key,val in tokens.items()}
+
+            clss_embedding = self.encode_text(tokens)
+            clss_embedding = clss_embedding.mean(dim=0)
+            clss_embedding /= clss_embedding.norm()
+            clss_embeddings.append(clss_embedding)
+        imnet_text_embeddings = torch.stack(clss_embeddings, dim=0)
+        return imnet_text_embeddings
+
+    def encode_image(self, image, norm=True):
+        x = self.image_encoder.forward_features(image)
+        x = x @ self.image_projection
+
+        if norm:
+            x = x / x.norm(dim=-1, keepdim=True)
+
+        return x
+
+    def encode_text(self, text, norm=True):
+        x = self.text_encoder(**text)
+        x = x['last_hidden_state']
+
+        if self.conf_lang_encoder['TOKENIZER'] == 'clip':
+            x = x[torch.arange(x.size(0)), text['input_ids'].argmax(dim=-1)]
+        else:
+            x = x[:, 0]
+
+        x = x @ self.text_projection
+
+        if norm:
+            x = x / x.norm(dim=-1, keepdim=True)
+
+        return x
+
+    def forward(self, image, text):
+        features_image = self.encode_image(image)
+        features_text = self.encode_text(text)
+
+        # cosine similarity as logits
+        T = self.logit_scale.exp()
+
+        return features_image, features_text, T
+
+
+def build_unicl_model(config, **kwargs):
+    model = UniCLModel(config)
+    if config['MODEL']['PRETRAINED'] != '':
+        pretrained_path = config['MODEL']['PRETRAINED']
+        from ..Utils.Utils import is_valid_url, download_file
+        if is_valid_url(pretrained_path):
+            with tempfile.TemporaryDirectory() as tmp_path:
+                file_local_path = pathlib.Path(tmp_path) / 'base_model.pt'
+                download_file(pretrained_path, file_local_path)
+                model.from_pretrained(str(file_local_path), config['MODEL']['PRETRAINED_LAYERS'], config['VERBOSE'])
+        else:
+            model.from_pretrained(pretrained_path, config['MODEL']['PRETRAINED_LAYERS'], config['VERBOSE'])
+
+    return model

model/templates.py

@@ -0,0 +1,83 @@
+DEFAULT_TEMPLATES = [
+    '{}.',
+    'a bad photo of a {}.',
+    'a photo of many {}.',
+    'a sculpture of a {}.',
+    'a photo of the hard to see {}.',
+    'a low resolution photo of the {}.',
+    'a rendering of a {}.',
+    'graffiti of a {}.',
+    'a bad photo of the {}.',
+    'a cropped photo of the {}.',
+    'a tattoo of a {}.',
+    'the embroidered {}.',
+    'a photo of a hard to see {}.',
+    'a bright photo of a {}.',
+    'a photo of a clean {}.',
+    'a photo of a dirty {}.',
+    'a dark photo of the {}.',
+    'a drawing of a {}.',
+    'a photo of my {}.',
+    'the plastic {}.',
+    'a photo of the cool {}.',
+    'a close-up photo of a {}.',
+    'a black and white photo of the {}.',
+    'a painting of the {}.',
+    'a painting of a {}.',
+    'a pixelated photo of the {}.',
+    'a sculpture of the {}.',
+    'a bright photo of the {}.',
+    'a cropped photo of a {}.',
+    'a plastic {}.',
+    'a photo of the dirty {}.',
+    'a jpeg corrupted photo of a {}.',
+    'a blurry photo of the {}.',
+    'a photo of the {}.',
+    'a good photo of the {}.',
+    'a rendering of the {}.',
+    'a {} in a video game.',
+    'a photo of one {}.',
+    'a doodle of a {}.',
+    'a close-up photo of the {}.',
+    'a photo of a {}.',
+    'the origami {}.',
+    'the {} in a video game.',
+    'a sketch of a {}.',
+    'a doodle of the {}.',
+    'a origami {}.',
+    'a low resolution photo of a {}.',
+    'the toy {}.',
+    'a rendition of the {}.',
+    'a photo of the clean {}.',
+    'a photo of a large {}.',
+    'a rendition of a {}.',
+    'a photo of a nice {}.',
+    'a photo of a weird {}.',
+    'a blurry photo of a {}.',
+    'a cartoon {}.',
+    'art of a {}.',
+    'a sketch of the {}.',
+    'a embroidered {}.',
+    'a pixelated photo of a {}.',
+    'itap of the {}.',
+    'a jpeg corrupted photo of the {}.',
+    'a good photo of a {}.',
+    'a plushie {}.',
+    'a photo of the nice {}.',
+    'a photo of the small {}.',
+    'a photo of the weird {}.',
+    'the cartoon {}.',
+    'art of the {}.',
+    'a drawing of the {}.',
+    'a photo of the large {}.',
+    'a black and white photo of a {}.',
+    'the plushie {}.',
+    'a dark photo of a {}.',
+    'itap of a {}.',
+    'graffiti of the {}.',
+    'a toy {}.',
+    'itap of my {}.',
+    'a photo of a cool {}.',
+    'a photo of a small {}.',
+    'a tattoo of the {}.',
+]

model/text_encoder/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from .build import build_lang_encoder as build_text_encoder
+from .build import build_tokenizer
+
+from .transformer import *
+from .hf_model import *

model/text_encoder/build.py

@@ -0,0 +1,31 @@
+import os
+
+from transformers import CLIPTokenizer
+from transformers import AutoTokenizer
+
+from .registry import lang_encoders
+from .registry import is_lang_encoder
+
+
+def build_lang_encoder(config_encoder, tokenizer, verbose, **kwargs):
+    model_name = config_encoder['NAME']
+
+    if not is_lang_encoder(model_name):
+        raise ValueError(f'Unknown model: {model_name}')
+
+    return lang_encoders(model_name)(config_encoder, tokenizer, verbose, **kwargs)
+
+
+def build_tokenizer(config_encoder):
+    tokenizer = None
+    os.environ['TOKENIZERS_PARALLELISM'] = 'true'
+    if config_encoder['TOKENIZER'] == 'clip':
+        pretrained_tokenizer = config_encoder.get(
+            'PRETRAINED_TOKENIZER', 'openai/clip-vit-base-patch32'
+        )
+        tokenizer = CLIPTokenizer.from_pretrained(pretrained_tokenizer)
+        tokenizer.add_special_tokens({'cls_token': tokenizer.eos_token})
+    else:
+        tokenizer = AutoTokenizer.from_pretrained(config_encoder['TOKENIZER'])
+
+    return tokenizer

model/text_encoder/hf_model.py

@@ -0,0 +1,27 @@
+import logging
+
+from transformers import AutoConfig
+from transformers import AutoModel
+
+from .registry import register_lang_encoder
+
+logger = logging.getLogger(__name__)
+
+
+@register_lang_encoder
+def lang_encoder(config_encoder, tokenizer, verbose, **kwargs):
+
+    hf_model = None
+    if config_encoder['LOAD_PRETRAINED']:
+        hf_model = AutoModel.from_pretrained(config_encoder['HF_MODEL'])
+    else:
+        hf_config = AutoConfig.from_pretrained(config_encoder['HF_MODEL'])
+
+        if 'CONFIG_OVERRIDE' in config_encoder:
+            logger.warning(f'Override config: {config_encoder["CONFIG_OVERRIDE"]}')
+            hf_config.update(config_encoder['CONFIG_OVERRIDE'])
+
+        logger.info(f'HF model config: {hf_config}')
+        hf_model = AutoModel.from_config(hf_config)
+
+    return hf_model

model/text_encoder/registry.py

@@ -0,0 +1,18 @@
+_lang_encoders = {}
+
+
+def register_lang_encoder(fn):
+    module_name_split = fn.__module__.split('.')
+    model_name = module_name_split[-1]
+
+    _lang_encoders[model_name] = fn
+
+    return fn
+
+
+def lang_encoders(model_name):
+    return _lang_encoders[model_name]
+
+
+def is_lang_encoder(model_name):
+    return model_name in _lang_encoders

model/text_encoder/transformer.py

@@ -0,0 +1,194 @@
+from collections import OrderedDict
+from typing import Tuple, Union
+import logging
+import os
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from timm.models.layers import DropPath, trunc_normal_
+
+from .registry import register_lang_encoder
+
+logger = logging.getLogger(__name__)
+
+class LayerNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-12):
+        """Construct a layernorm module in the TF style (epsilon inside the square root).
+        """
+        super(LayerNorm, self).__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.bias = nn.Parameter(torch.zeros(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, x):
+        pdtype = x.dtype
+        x = x.float()
+        u = x.mean(-1, keepdim=True)
+        s = (x - u).pow(2).mean(-1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.variance_epsilon)
+        return self.weight * x.to(pdtype) + self.bias
+
+
+class QuickGELU(nn.Module):
+    def forward(self, x: torch.Tensor):
+        return x * torch.sigmoid(1.702 * x)
+
+
+class ResidualAttentionBlock(nn.Module):
+    def __init__(self,
+                 d_model: int,
+                 n_head: int,
+                 attn_mask: torch.Tensor = None,
+                 drop_path: float = 0.0):
+        super().__init__()
+
+        self.attn = nn.MultiheadAttention(d_model, n_head)
+        self.ln_1 = LayerNorm(d_model)
+        self.mlp = nn.Sequential(OrderedDict([
+            ("c_fc", nn.Linear(d_model, d_model * 4)),
+            ("gelu", QuickGELU()),
+            ("c_proj", nn.Linear(d_model * 4, d_model))
+        ]))
+        self.ln_2 = LayerNorm(d_model)
+        self.attn_mask = attn_mask
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+
+    def attention(self, x: torch.Tensor, key_padding_mask: torch.Tensor = None):
+        self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) \
+            if self.attn_mask is not None else None
+
+
+        return self.attn(
+            x, x, x,
+            key_padding_mask=key_padding_mask,
+            need_weights=False,
+            attn_mask=self.attn_mask
+        )[0]
+
+    def forward(self, x: torch.Tensor, key_padding_mask: torch.Tensor = None):
+        x = x + self.drop_path(self.attention(self.ln_1(x), key_padding_mask=key_padding_mask))
+        x = x + self.drop_path(self.mlp(self.ln_2(x)))
+        return x
+
+
+class Transformer(nn.Module):
+    def __init__(self,
+                 context_length: int,
+                 vocab_size: int,
+                 width: int,
+                 layers: int,
+                 heads: int,
+                 drop_path: float = 0.0,
+                 autogressive: bool =True):
+        super().__init__()
+
+        self.token_embedding = nn.Embedding(vocab_size, width)
+
+        self.context_length = context_length
+        self.positional_embedding = nn.Parameter(
+            torch.empty(self.context_length, width)
+        )
+
+        self.width = width
+        self.layers = layers
+        self.autogressive = autogressive
+        attn_mask = self.build_attention_mask() if autogressive else None
+        dpr = [x.item() for x in torch.linspace(0, drop_path, layers)]  # stochastic depth decay rule
+        self.resblocks = nn.ModuleList(
+            [
+                ResidualAttentionBlock(width, heads, attn_mask, dpr[i])
+                for i in range(layers)
+            ]
+        )
+
+        self.ln_final = LayerNorm(width)
+
+        trunc_normal_(self.positional_embedding, std=.02)
+        # nn.init.normal_(self.token_embedding, std=.02)
+        trunc_normal_(self.token_embedding.weight, std=.02)
+        self.apply(self._init_weights)
+
+    @property
+    def dim_out(self):
+        return self.width
+
+    def build_attention_mask(self):
+        # lazily create causal attention mask, with full attention between the vision tokens
+        # pytorch uses additive attention mask; fill with -inf
+        mask = torch.empty(self.context_length, self.context_length)
+        mask.fill_(float("-inf"))
+        mask.triu_(1)  # zero out the lower diagonal
+        return mask
+
+    def _init_weights(self, m):
+        if isinstance(m, (nn.Linear, nn.Conv2d)):
+            logger.info('=> init weight of Linear/Conv2d from trunc norm')
+            trunc_normal_(m.weight, std=0.02)
+            if m.bias is not None:
+                logger.info('=> init bias of Linear/Conv2d to zeros')
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, (nn.LayerNorm, nn.BatchNorm2d)):
+            nn.init.constant_(m.bias, 0)
+
+    def load_pretrained(self, pretrained='', pretrained_layers=[], verbose=True):
+        if os.path.isfile(pretrained):
+            pretrained_dict = torch.load(pretrained, map_location='cpu')
+            logging.info(f'=> loading pretrained model {pretrained}')
+            model_dict = self.state_dict()
+            pretrained_dict = {
+                k: v for k, v in pretrained_dict.items()
+                if k in model_dict.keys()
+            }
+            need_init_state_dict = {}
+            for k, v in pretrained_dict.items():
+                need_init = (
+                    k.split('.')[0] in pretrained_layers
+                    or pretrained_layers[0] == '*'
+                )
+                if need_init:
+                    if verbose:
+                        logging.info(f'=> init {k} from {pretrained}')
+
+                    need_init_state_dict[k] = v
+            self.load_state_dict(need_init_state_dict, strict=False)
+
+
+    @torch.jit.ignore
+    def no_weight_decay(self):
+        return {
+            'positional_embedding',
+            'token_embedding',
+        }
+
+    def forward(self, input_ids, attention_mask=None):
+        key_padding_mask = (input_ids == 0) if not self.autogressive else None
+        x = self.token_embedding(input_ids)  # [batch_size, n_ctx, d_model]
+        x = x + self.positional_embedding
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        for block in self.resblocks:
+            x = block(x, key_padding_mask)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+
+        x = self.ln_final(x)
+
+        return {'last_hidden_state': x}
+
+
+@register_lang_encoder
+def lang_encoder(config_encoder, tokenizer, verbose, **kwargs):
+    transformer = Transformer(
+        context_length=config_encoder['CONTEXT_LENGTH'],
+        vocab_size=tokenizer.vocab_size,
+        width=config_encoder['WIDTH'],
+        layers=config_encoder['LAYERS'],
+        heads=config_encoder['HEADS'],
+        autogressive=config_encoder.get('AUTOGRESSIVE', True)
+    )
+
+    if config_encoder['LOAD_PRETRAINED']:
+        transformer.load_pretrained()
+
+    return transformer

requirements.txt

@@ -0,0 +1,7 @@
+torch==1.10.1
+torchvision==0.11.2
+opencv-python-headless==4.5.3.56
+timm==0.4.12
+numpy
+yacs
+transformers