582 lines
21 KiB
Python
582 lines
21 KiB
Python
""" Twins
|
|
A PyTorch impl of : `Twins: Revisiting the Design of Spatial Attention in Vision Transformers`
|
|
- https://arxiv.org/pdf/2104.13840.pdf
|
|
|
|
Code/weights from https://github.com/Meituan-AutoML/Twins, original copyright/license info below
|
|
|
|
"""
|
|
# --------------------------------------------------------
|
|
# Twins
|
|
# Copyright (c) 2021 Meituan
|
|
# Licensed under The Apache 2.0 License [see LICENSE for details]
|
|
# Written by Xinjie Li, Xiangxiang Chu
|
|
# --------------------------------------------------------
|
|
import math
|
|
from functools import partial
|
|
from typing import List, Optional, Tuple, Union
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
|
|
from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
|
|
from timm.layers import Mlp, DropPath, to_2tuple, trunc_normal_, use_fused_attn
|
|
from ._builder import build_model_with_cfg
|
|
from ._features import feature_take_indices
|
|
from ._features_fx import register_notrace_module
|
|
from ._registry import register_model, generate_default_cfgs
|
|
from .vision_transformer import Attention
|
|
|
|
__all__ = ['Twins'] # model_registry will add each entrypoint fn to this
|
|
|
|
Size_ = Tuple[int, int]
|
|
|
|
|
|
@register_notrace_module # reason: FX can't symbolically trace control flow in forward method
|
|
class LocallyGroupedAttn(nn.Module):
|
|
""" LSA: self attention within a group
|
|
"""
|
|
fused_attn: torch.jit.Final[bool]
|
|
|
|
def __init__(self, dim, num_heads=8, attn_drop=0., proj_drop=0., ws=1):
|
|
assert ws != 1
|
|
super(LocallyGroupedAttn, self).__init__()
|
|
assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
|
|
|
|
self.dim = dim
|
|
self.num_heads = num_heads
|
|
head_dim = dim // num_heads
|
|
self.scale = head_dim ** -0.5
|
|
self.fused_attn = use_fused_attn()
|
|
|
|
self.qkv = nn.Linear(dim, dim * 3, bias=True)
|
|
self.attn_drop = nn.Dropout(attn_drop)
|
|
self.proj = nn.Linear(dim, dim)
|
|
self.proj_drop = nn.Dropout(proj_drop)
|
|
self.ws = ws
|
|
|
|
def forward(self, x, size: Size_):
|
|
# There are two implementations for this function, zero padding or mask. We don't observe obvious difference for
|
|
# both. You can choose any one, we recommend forward_padding because it's neat. However,
|
|
# the masking implementation is more reasonable and accurate.
|
|
B, N, C = x.shape
|
|
H, W = size
|
|
x = x.view(B, H, W, C)
|
|
pad_l = pad_t = 0
|
|
pad_r = (self.ws - W % self.ws) % self.ws
|
|
pad_b = (self.ws - H % self.ws) % self.ws
|
|
x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
|
|
_, Hp, Wp, _ = x.shape
|
|
_h, _w = Hp // self.ws, Wp // self.ws
|
|
x = x.reshape(B, _h, self.ws, _w, self.ws, C).transpose(2, 3)
|
|
qkv = self.qkv(x).reshape(
|
|
B, _h * _w, self.ws * self.ws, 3, self.num_heads, C // self.num_heads).permute(3, 0, 1, 4, 2, 5)
|
|
q, k, v = qkv.unbind(0)
|
|
|
|
if self.fused_attn:
|
|
x = F.scaled_dot_product_attention(
|
|
q, k, v,
|
|
dropout_p=self.attn_drop.p if self.training else 0.,
|
|
)
|
|
else:
|
|
q = q * self.scale
|
|
attn = q @ k.transpose(-2, -1)
|
|
attn = attn.softmax(dim=-1)
|
|
attn = self.attn_drop(attn)
|
|
x = attn @ v
|
|
|
|
x = x.transpose(2, 3).reshape(B, _h, _w, self.ws, self.ws, C)
|
|
x = x.transpose(2, 3).reshape(B, _h * self.ws, _w * self.ws, C)
|
|
if pad_r > 0 or pad_b > 0:
|
|
x = x[:, :H, :W, :].contiguous()
|
|
x = x.reshape(B, N, C)
|
|
x = self.proj(x)
|
|
x = self.proj_drop(x)
|
|
return x
|
|
|
|
# def forward_mask(self, x, size: Size_):
|
|
# B, N, C = x.shape
|
|
# H, W = size
|
|
# x = x.view(B, H, W, C)
|
|
# pad_l = pad_t = 0
|
|
# pad_r = (self.ws - W % self.ws) % self.ws
|
|
# pad_b = (self.ws - H % self.ws) % self.ws
|
|
# x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
|
|
# _, Hp, Wp, _ = x.shape
|
|
# _h, _w = Hp // self.ws, Wp // self.ws
|
|
# mask = torch.zeros((1, Hp, Wp), device=x.device)
|
|
# mask[:, -pad_b:, :].fill_(1)
|
|
# mask[:, :, -pad_r:].fill_(1)
|
|
#
|
|
# x = x.reshape(B, _h, self.ws, _w, self.ws, C).transpose(2, 3) # B, _h, _w, ws, ws, C
|
|
# mask = mask.reshape(1, _h, self.ws, _w, self.ws).transpose(2, 3).reshape(1, _h * _w, self.ws * self.ws)
|
|
# attn_mask = mask.unsqueeze(2) - mask.unsqueeze(3) # 1, _h*_w, ws*ws, ws*ws
|
|
# attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-1000.0)).masked_fill(attn_mask == 0, float(0.0))
|
|
# qkv = self.qkv(x).reshape(
|
|
# B, _h * _w, self.ws * self.ws, 3, self.num_heads, C // self.num_heads).permute(3, 0, 1, 4, 2, 5)
|
|
# # n_h, B, _w*_h, nhead, ws*ws, dim
|
|
# q, k, v = qkv[0], qkv[1], qkv[2] # B, _h*_w, n_head, ws*ws, dim_head
|
|
# attn = (q @ k.transpose(-2, -1)) * self.scale # B, _h*_w, n_head, ws*ws, ws*ws
|
|
# attn = attn + attn_mask.unsqueeze(2)
|
|
# attn = attn.softmax(dim=-1)
|
|
# attn = self.attn_drop(attn) # attn @v -> B, _h*_w, n_head, ws*ws, dim_head
|
|
# attn = (attn @ v).transpose(2, 3).reshape(B, _h, _w, self.ws, self.ws, C)
|
|
# x = attn.transpose(2, 3).reshape(B, _h * self.ws, _w * self.ws, C)
|
|
# if pad_r > 0 or pad_b > 0:
|
|
# x = x[:, :H, :W, :].contiguous()
|
|
# x = x.reshape(B, N, C)
|
|
# x = self.proj(x)
|
|
# x = self.proj_drop(x)
|
|
# return x
|
|
|
|
|
|
class GlobalSubSampleAttn(nn.Module):
|
|
""" GSA: using a key to summarize the information for a group to be efficient.
|
|
"""
|
|
fused_attn: torch.jit.Final[bool]
|
|
|
|
def __init__(self, dim, num_heads=8, attn_drop=0., proj_drop=0., sr_ratio=1):
|
|
super().__init__()
|
|
assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
|
|
|
|
self.dim = dim
|
|
self.num_heads = num_heads
|
|
head_dim = dim // num_heads
|
|
self.scale = head_dim ** -0.5
|
|
self.fused_attn = use_fused_attn()
|
|
|
|
self.q = nn.Linear(dim, dim, bias=True)
|
|
self.kv = nn.Linear(dim, dim * 2, bias=True)
|
|
self.attn_drop = nn.Dropout(attn_drop)
|
|
self.proj = nn.Linear(dim, dim)
|
|
self.proj_drop = nn.Dropout(proj_drop)
|
|
|
|
self.sr_ratio = sr_ratio
|
|
if sr_ratio > 1:
|
|
self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
|
|
self.norm = nn.LayerNorm(dim)
|
|
else:
|
|
self.sr = None
|
|
self.norm = None
|
|
|
|
def forward(self, x, size: Size_):
|
|
B, N, C = x.shape
|
|
q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
|
|
|
|
if self.sr is not None:
|
|
x = x.permute(0, 2, 1).reshape(B, C, *size)
|
|
x = self.sr(x).reshape(B, C, -1).permute(0, 2, 1)
|
|
x = self.norm(x)
|
|
kv = self.kv(x).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
|
|
k, v = kv.unbind(0)
|
|
|
|
if self.fused_attn:
|
|
x = torch.nn.functional.scaled_dot_product_attention(
|
|
q, k, v,
|
|
dropout_p=self.attn_drop.p if self.training else 0.,
|
|
)
|
|
else:
|
|
q = q * self.scale
|
|
attn = q @ k.transpose(-2, -1)
|
|
attn = attn.softmax(dim=-1)
|
|
attn = self.attn_drop(attn)
|
|
x = attn @ v
|
|
|
|
x = x.transpose(1, 2).reshape(B, N, C)
|
|
x = self.proj(x)
|
|
x = self.proj_drop(x)
|
|
|
|
return x
|
|
|
|
|
|
class Block(nn.Module):
|
|
|
|
def __init__(
|
|
self,
|
|
dim,
|
|
num_heads,
|
|
mlp_ratio=4.,
|
|
proj_drop=0.,
|
|
attn_drop=0.,
|
|
drop_path=0.,
|
|
act_layer=nn.GELU,
|
|
norm_layer=nn.LayerNorm,
|
|
sr_ratio=1,
|
|
ws=None,
|
|
):
|
|
super().__init__()
|
|
self.norm1 = norm_layer(dim)
|
|
if ws is None:
|
|
self.attn = Attention(dim, num_heads, False, None, attn_drop, proj_drop)
|
|
elif ws == 1:
|
|
self.attn = GlobalSubSampleAttn(dim, num_heads, attn_drop, proj_drop, sr_ratio)
|
|
else:
|
|
self.attn = LocallyGroupedAttn(dim, num_heads, attn_drop, proj_drop, ws)
|
|
self.drop_path1 = DropPath(drop_path) if drop_path > 0. else nn.Identity()
|
|
|
|
self.norm2 = norm_layer(dim)
|
|
self.mlp = Mlp(
|
|
in_features=dim,
|
|
hidden_features=int(dim * mlp_ratio),
|
|
act_layer=act_layer,
|
|
drop=proj_drop,
|
|
)
|
|
self.drop_path2 = DropPath(drop_path) if drop_path > 0. else nn.Identity()
|
|
|
|
def forward(self, x, size: Size_):
|
|
x = x + self.drop_path1(self.attn(self.norm1(x), size))
|
|
x = x + self.drop_path2(self.mlp(self.norm2(x)))
|
|
return x
|
|
|
|
|
|
class PosConv(nn.Module):
|
|
# PEG from https://arxiv.org/abs/2102.10882
|
|
def __init__(self, in_chans, embed_dim=768, stride=1):
|
|
super(PosConv, self).__init__()
|
|
self.proj = nn.Sequential(
|
|
nn.Conv2d(in_chans, embed_dim, 3, stride, 1, bias=True, groups=embed_dim),
|
|
)
|
|
self.stride = stride
|
|
|
|
def forward(self, x, size: Size_):
|
|
B, N, C = x.shape
|
|
cnn_feat_token = x.transpose(1, 2).view(B, C, *size)
|
|
x = self.proj(cnn_feat_token)
|
|
if self.stride == 1:
|
|
x += cnn_feat_token
|
|
x = x.flatten(2).transpose(1, 2)
|
|
return x
|
|
|
|
def no_weight_decay(self):
|
|
return ['proj.%d.weight' % i for i in range(4)]
|
|
|
|
|
|
class PatchEmbed(nn.Module):
|
|
""" Image to Patch Embedding
|
|
"""
|
|
|
|
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
|
|
super().__init__()
|
|
img_size = to_2tuple(img_size)
|
|
patch_size = to_2tuple(patch_size)
|
|
|
|
self.img_size = img_size
|
|
self.patch_size = patch_size
|
|
assert img_size[0] % patch_size[0] == 0 and img_size[1] % patch_size[1] == 0, \
|
|
f"img_size {img_size} should be divided by patch_size {patch_size}."
|
|
self.H, self.W = img_size[0] // patch_size[0], img_size[1] // patch_size[1]
|
|
self.num_patches = self.H * self.W
|
|
self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
|
|
self.norm = nn.LayerNorm(embed_dim)
|
|
|
|
def forward(self, x) -> Tuple[torch.Tensor, Size_]:
|
|
B, C, H, W = x.shape
|
|
|
|
x = self.proj(x).flatten(2).transpose(1, 2)
|
|
x = self.norm(x)
|
|
out_size = (H // self.patch_size[0], W // self.patch_size[1])
|
|
|
|
return x, out_size
|
|
|
|
|
|
class Twins(nn.Module):
|
|
""" Twins Vision Transfomer (Revisiting Spatial Attention)
|
|
|
|
Adapted from PVT (PyramidVisionTransformer) class at https://github.com/whai362/PVT.git
|
|
"""
|
|
def __init__(
|
|
self,
|
|
img_size=224,
|
|
patch_size=4,
|
|
in_chans=3,
|
|
num_classes=1000,
|
|
global_pool='avg',
|
|
embed_dims=(64, 128, 256, 512),
|
|
num_heads=(1, 2, 4, 8),
|
|
mlp_ratios=(4, 4, 4, 4),
|
|
depths=(3, 4, 6, 3),
|
|
sr_ratios=(8, 4, 2, 1),
|
|
wss=None,
|
|
drop_rate=0.,
|
|
pos_drop_rate=0.,
|
|
proj_drop_rate=0.,
|
|
attn_drop_rate=0.,
|
|
drop_path_rate=0.,
|
|
norm_layer=partial(nn.LayerNorm, eps=1e-6),
|
|
block_cls=Block,
|
|
):
|
|
super().__init__()
|
|
self.num_classes = num_classes
|
|
self.global_pool = global_pool
|
|
self.depths = depths
|
|
self.embed_dims = embed_dims
|
|
self.num_features = embed_dims[-1]
|
|
self.grad_checkpointing = False
|
|
|
|
img_size = to_2tuple(img_size)
|
|
prev_chs = in_chans
|
|
self.patch_embeds = nn.ModuleList()
|
|
self.pos_drops = nn.ModuleList()
|
|
for i in range(len(depths)):
|
|
self.patch_embeds.append(PatchEmbed(img_size, patch_size, prev_chs, embed_dims[i]))
|
|
self.pos_drops.append(nn.Dropout(p=pos_drop_rate))
|
|
prev_chs = embed_dims[i]
|
|
img_size = tuple(t // patch_size for t in img_size)
|
|
patch_size = 2
|
|
|
|
self.blocks = nn.ModuleList()
|
|
self.feature_info = []
|
|
dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
|
|
cur = 0
|
|
for k in range(len(depths)):
|
|
_block = nn.ModuleList([block_cls(
|
|
dim=embed_dims[k],
|
|
num_heads=num_heads[k],
|
|
mlp_ratio=mlp_ratios[k],
|
|
proj_drop=proj_drop_rate,
|
|
attn_drop=attn_drop_rate,
|
|
drop_path=dpr[cur + i],
|
|
norm_layer=norm_layer,
|
|
sr_ratio=sr_ratios[k],
|
|
ws=1 if wss is None or i % 2 == 1 else wss[k]) for i in range(depths[k])],
|
|
)
|
|
self.blocks.append(_block)
|
|
self.feature_info += [dict(module=f'block.{k}', num_chs=embed_dims[k], reduction=2**(2+k))]
|
|
cur += depths[k]
|
|
|
|
self.pos_block = nn.ModuleList([PosConv(embed_dim, embed_dim) for embed_dim in embed_dims])
|
|
|
|
self.norm = norm_layer(self.num_features)
|
|
|
|
# classification head
|
|
self.head_drop = nn.Dropout(drop_rate)
|
|
self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
|
|
|
|
# init weights
|
|
self.apply(self._init_weights)
|
|
|
|
@torch.jit.ignore
|
|
def no_weight_decay(self):
|
|
return set(['pos_block.' + n for n, p in self.pos_block.named_parameters()])
|
|
|
|
@torch.jit.ignore
|
|
def group_matcher(self, coarse=False):
|
|
matcher = dict(
|
|
stem=r'^patch_embeds.0', # stem and embed
|
|
blocks=[
|
|
(r'^(?:blocks|patch_embeds|pos_block)\.(\d+)', None),
|
|
('^norm', (99999,))
|
|
] if coarse else [
|
|
(r'^blocks\.(\d+)\.(\d+)', None),
|
|
(r'^(?:patch_embeds|pos_block)\.(\d+)', (0,)),
|
|
(r'^norm', (99999,))
|
|
]
|
|
)
|
|
return matcher
|
|
|
|
@torch.jit.ignore
|
|
def set_grad_checkpointing(self, enable=True):
|
|
assert not enable, 'gradient checkpointing not supported'
|
|
|
|
@torch.jit.ignore
|
|
def get_classifier(self):
|
|
return self.head
|
|
|
|
def reset_classifier(self, num_classes, global_pool=None):
|
|
self.num_classes = num_classes
|
|
if global_pool is not None:
|
|
assert global_pool in ('', 'avg')
|
|
self.global_pool = global_pool
|
|
self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
|
|
|
|
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)
|
|
elif isinstance(m, nn.Conv2d):
|
|
fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
|
|
fan_out //= m.groups
|
|
m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
|
|
if m.bias is not None:
|
|
m.bias.data.zero_()
|
|
|
|
def forward_intermediates(
|
|
self,
|
|
x: torch.Tensor,
|
|
indices: Union[int, List[int], Tuple[int]] = None,
|
|
norm: bool = False,
|
|
stop_early: bool = False,
|
|
output_fmt: str = 'NCHW',
|
|
intermediates_only: bool = False,
|
|
) -> Union[List[torch.Tensor], Tuple[torch.Tensor, List[torch.Tensor]]]:
|
|
""" Forward features that returns intermediates.
|
|
Args:
|
|
x: Input image tensor
|
|
indices: Take last n blocks if int, all if None, select matching indices if sequence
|
|
norm: Apply norm layer to all intermediates
|
|
stop_early: Stop iterating over blocks when last desired intermediate hit
|
|
output_fmt: Shape of intermediate feature outputs
|
|
intermediates_only: Only return intermediate features
|
|
Returns:
|
|
|
|
"""
|
|
assert output_fmt == 'NCHW', 'Output shape for Twins must be NCHW.'
|
|
intermediates = []
|
|
take_indices, max_index = feature_take_indices(len(self.blocks), indices)
|
|
|
|
# FIXME slice block/pos_block if < max
|
|
|
|
# forward pass
|
|
B, _, height, width = x.shape
|
|
for i, (embed, drop, blocks, pos_blk) in enumerate(zip(
|
|
self.patch_embeds, self.pos_drops, self.blocks, self.pos_block)
|
|
):
|
|
x, size = embed(x)
|
|
x = drop(x)
|
|
for j, blk in enumerate(blocks):
|
|
x = blk(x, size)
|
|
if j == 0:
|
|
x = pos_blk(x, size) # PEG here
|
|
|
|
if i < len(self.depths) - 1:
|
|
x = x.reshape(B, *size, -1).permute(0, 3, 1, 2).contiguous()
|
|
if i in take_indices:
|
|
intermediates.append(x)
|
|
else:
|
|
if i in take_indices:
|
|
# only last feature can be normed
|
|
x_feat = self.norm(x) if norm else x
|
|
intermediates.append(x_feat.reshape(B, *size, -1).permute(0, 3, 1, 2).contiguous())
|
|
|
|
if intermediates_only:
|
|
return intermediates
|
|
|
|
x = self.norm(x)
|
|
|
|
return x, intermediates
|
|
|
|
def prune_intermediate_layers(
|
|
self,
|
|
indices: Union[int, List[int], Tuple[int]] = 1,
|
|
prune_norm: bool = False,
|
|
prune_head: bool = True,
|
|
):
|
|
""" Prune layers not required for specified intermediates.
|
|
"""
|
|
take_indices, max_index = feature_take_indices(len(self.blocks), indices)
|
|
# FIXME add block pruning
|
|
if prune_norm:
|
|
self.norm = nn.Identity()
|
|
if prune_head:
|
|
self.reset_classifier(0, '')
|
|
return take_indices
|
|
|
|
def forward_features(self, x):
|
|
B = x.shape[0]
|
|
for i, (embed, drop, blocks, pos_blk) in enumerate(
|
|
zip(self.patch_embeds, self.pos_drops, self.blocks, self.pos_block)):
|
|
x, size = embed(x)
|
|
x = drop(x)
|
|
for j, blk in enumerate(blocks):
|
|
x = blk(x, size)
|
|
if j == 0:
|
|
x = pos_blk(x, size) # PEG here
|
|
if i < len(self.depths) - 1:
|
|
x = x.reshape(B, *size, -1).permute(0, 3, 1, 2).contiguous()
|
|
x = self.norm(x)
|
|
return x
|
|
|
|
def forward_head(self, x, pre_logits: bool = False):
|
|
if self.global_pool == 'avg':
|
|
x = x.mean(dim=1)
|
|
x = self.head_drop(x)
|
|
return x if pre_logits else self.head(x)
|
|
|
|
def forward(self, x):
|
|
x = self.forward_features(x)
|
|
x = self.forward_head(x)
|
|
return x
|
|
|
|
|
|
def _create_twins(variant, pretrained=False, **kwargs):
|
|
out_indices = kwargs.pop('out_indices', 4)
|
|
model = build_model_with_cfg(
|
|
Twins, variant, pretrained,
|
|
feature_cfg=dict(out_indices=out_indices, feature_cls='getter'),
|
|
**kwargs,
|
|
)
|
|
return model
|
|
|
|
|
|
def _cfg(url='', **kwargs):
|
|
return {
|
|
'url': url,
|
|
'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': None,
|
|
'crop_pct': .9, 'interpolation': 'bicubic', 'fixed_input_size': True,
|
|
'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD,
|
|
'first_conv': 'patch_embeds.0.proj', 'classifier': 'head',
|
|
**kwargs
|
|
}
|
|
|
|
|
|
default_cfgs = generate_default_cfgs({
|
|
'twins_pcpvt_small.in1k': _cfg(hf_hub_id='timm/'),
|
|
'twins_pcpvt_base.in1k': _cfg(hf_hub_id='timm/'),
|
|
'twins_pcpvt_large.in1k': _cfg(hf_hub_id='timm/'),
|
|
'twins_svt_small.in1k': _cfg(hf_hub_id='timm/'),
|
|
'twins_svt_base.in1k': _cfg(hf_hub_id='timm/'),
|
|
'twins_svt_large.in1k': _cfg(hf_hub_id='timm/'),
|
|
})
|
|
|
|
|
|
@register_model
|
|
def twins_pcpvt_small(pretrained=False, **kwargs) -> Twins:
|
|
model_args = dict(
|
|
patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
|
|
depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1])
|
|
return _create_twins('twins_pcpvt_small', pretrained=pretrained, **dict(model_args, **kwargs))
|
|
|
|
|
|
@register_model
|
|
def twins_pcpvt_base(pretrained=False, **kwargs) -> Twins:
|
|
model_args = dict(
|
|
patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
|
|
depths=[3, 4, 18, 3], sr_ratios=[8, 4, 2, 1])
|
|
return _create_twins('twins_pcpvt_base', pretrained=pretrained, **dict(model_args, **kwargs))
|
|
|
|
|
|
@register_model
|
|
def twins_pcpvt_large(pretrained=False, **kwargs) -> Twins:
|
|
model_args = dict(
|
|
patch_size=4, embed_dims=[64, 128, 320, 512], num_heads=[1, 2, 5, 8], mlp_ratios=[8, 8, 4, 4],
|
|
depths=[3, 8, 27, 3], sr_ratios=[8, 4, 2, 1])
|
|
return _create_twins('twins_pcpvt_large', pretrained=pretrained, **dict(model_args, **kwargs))
|
|
|
|
|
|
@register_model
|
|
def twins_svt_small(pretrained=False, **kwargs) -> Twins:
|
|
model_args = dict(
|
|
patch_size=4, embed_dims=[64, 128, 256, 512], num_heads=[2, 4, 8, 16], mlp_ratios=[4, 4, 4, 4],
|
|
depths=[2, 2, 10, 4], wss=[7, 7, 7, 7], sr_ratios=[8, 4, 2, 1])
|
|
return _create_twins('twins_svt_small', pretrained=pretrained, **dict(model_args, **kwargs))
|
|
|
|
|
|
@register_model
|
|
def twins_svt_base(pretrained=False, **kwargs) -> Twins:
|
|
model_args = dict(
|
|
patch_size=4, embed_dims=[96, 192, 384, 768], num_heads=[3, 6, 12, 24], mlp_ratios=[4, 4, 4, 4],
|
|
depths=[2, 2, 18, 2], wss=[7, 7, 7, 7], sr_ratios=[8, 4, 2, 1])
|
|
return _create_twins('twins_svt_base', pretrained=pretrained, **dict(model_args, **kwargs))
|
|
|
|
|
|
@register_model
|
|
def twins_svt_large(pretrained=False, **kwargs) -> Twins:
|
|
model_args = dict(
|
|
patch_size=4, embed_dims=[128, 256, 512, 1024], num_heads=[4, 8, 16, 32], mlp_ratios=[4, 4, 4, 4],
|
|
depths=[2, 2, 18, 2], wss=[7, 7, 7, 7], sr_ratios=[8, 4, 2, 1])
|
|
return _create_twins('twins_svt_large', pretrained=pretrained, **dict(model_args, **kwargs))
|