joonmyung 1.5.13__tar.gz → 1.5.14__tar.gz

{joonmyung-1.5.13 → joonmyung-1.5.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: joonmyung
-Version: 1.5.13
+Version: 1.5.14
 Summary: JoonMyung's Library
 Home-page: https://github.com/pizard/JoonMyung.git
 Author: JoonMyung Choi

{joonmyung-1.5.13 → joonmyung-1.5.14}/joonmyung/draw.py

@@ -241,28 +241,22 @@ def saliency(attentions=None, gradients=None, head_fusion="mean",
 
 
 
+
 def data2PIL(datas):
-    if type(datas) == torch.Tensor: # MAKE TO (..., H, W, 3)
-        if datas.shape[-1] == 3:
-            pils = datas
-        elif len(datas.shape) == 2:
+    if type(datas) == torch.Tensor:
+        if len(datas.shape) == 2:
             pils = datas.unsqueeze(-1).detach().cpu()
-        elif len(datas.shape) == 3:
+        if len(datas.shape) == 3:
             pils = datas.permute(1, 2, 0).detach().cpu()
         elif len(datas.shape) == 4:
             pils = datas.permute(0, 2, 3, 1).detach().cpu()
     elif type(datas) == np.ndarray:
-        if len(datas.shape) == 2:
-            datas = np.expand_dims(datas, axis=-1)
-        # TODO NEED TO CHECK
-        # if datas.max() <= 1:
-        #     pils = cv2.cvtColor(datas, cv2.COLOR_BGR2RGB)  # 0.29ms
-        # else:
-        #     pils = datas
-
-        # image = Image.fromarray(image)                 # 0.32ms
-        pils = cv2.cvtColor(datas, cv2.COLOR_BGR2RGB)  # 0.29ms
-
+        if len(datas.shape) == 3: datas = np.expand_dims(datas, axis=0)
+        if datas.max() <= 1:
+            # image = Image.fromarray(image)                 # 0.32ms
+            pils = cv2.cvtColor(datas, cv2.COLOR_BGR2RGB)   # 0.29ms
+        else:
+            pils = datas
     elif type(datas) == PIL.JpegImagePlugin.JpegImageFile \
          or type(datas) == PIL.Image.Image:
         pils = datas

{joonmyung-1.5.13 → joonmyung-1.5.14}/joonmyung.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: joonmyung
-Version: 1.5.13
+Version: 1.5.14
 Summary: JoonMyung's Library
 Home-page: https://github.com/pizard/JoonMyung.git
 Author: JoonMyung Choi

{joonmyung-1.5.13 → joonmyung-1.5.14}/joonmyung.egg-info/SOURCES.txt

@@ -29,17 +29,4 @@ joonmyung/meta_data/__init__.py
 joonmyung/meta_data/label.py
 joonmyung/meta_data/utils.py
 joonmyung/models/__init__.py
-joonmyung/models/tome.py
-models/__init__.py
-models/deit.py
-models/evit.py
-models/pvt.py
-models/pvt_v2.py
-models/tome.py
-models/SA/MHSA.py
-models/SA/PVTSA.py
-models/SA/TMSA.py
-models/SA/__init__.py
-models/modules/PE.py
-models/modules/__init__.py
-models/modules/blocks.py
+joonmyung/models/tome.py

{joonmyung-1.5.13 → joonmyung-1.5.14}/joonmyung.egg-info/top_level.txt

@@ -1,2 +1 @@
 joonmyung
-models

{joonmyung-1.5.13 → joonmyung-1.5.14}/setup.py

@@ -3,7 +3,7 @@ from setuptools import find_packages
 
 setuptools.setup(
     name="joonmyung",
-    version="1.5.13",
+    version="1.5.14",
     author="JoonMyung Choi",
     author_email="pizard@korea.ac.kr",
     description="JoonMyung's Library",

joonmyung-1.5.13/models/SA/MHSA.py

@@ -1,37 +0,0 @@
-import torch.nn as nn
-class MHSA(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0.,
-                 talking_head=False):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = head_dim ** -0.5
-
-        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)
-
-
-        self.proj_l = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-        self.proj_w = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-
-
-    def forward(self, x):
-        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)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale # (B, H, T, D)
-        # attn = self.proj_l(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_l(attn.transpose(1, -1)).transpose(1, -1)
-
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        # attn = self.proj_w(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_w(attn.transpose(1, -1)).transpose(1, -1)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x

joonmyung-1.5.13/models/SA/PVTSA.py

@@ -1,90 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from functools import partial
-
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-from timm.models.registry import register_model
-from timm.models.vision_transformer import _cfg
-import math
-
-class PVTSA(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1, linear=False,
-                 talking_head=False):
-        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 = qk_scale or head_dim ** -0.5
-
-        self.q = nn.Linear(dim, dim, bias=qkv_bias)
-        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-        self.proj_l = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-        self.proj_w = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-
-        self.linear = linear
-        self.sr_ratio = sr_ratio
-        if not linear:
-            if sr_ratio > 1:
-                self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
-                self.norm = nn.LayerNorm(dim)
-        else:
-            self.pool = nn.AdaptiveAvgPool2d(7)
-            self.sr = nn.Conv2d(dim, dim, kernel_size=1, stride=1)
-            self.norm = nn.LayerNorm(dim)
-            self.act = nn.GELU()
-        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)
-        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(self, x, H, W):
-        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 not self.linear:
-            if self.sr_ratio > 1:
-                x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
-                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)
-            else:
-                kv = self.kv(x).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        else:
-            x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
-            x_ = self.sr(self.pool(x_)).reshape(B, C, -1).permute(0, 2, 1)
-            x_ = self.norm(x_)
-            x_ = self.act(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[0], kv[1]
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale
-
-        attn = self.proj_l(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        attn = self.proj_w(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-
-        return x

joonmyung-1.5.13/models/SA/TMSA.py

@@ -1,37 +0,0 @@
-import torch.nn as nn
-class MHSA(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0.,
-                 talking_head=False):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = head_dim ** -0.5
-
-        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)
-
-
-        self.proj_l = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-        self.proj_w = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-
-
-    def forward(self, x):
-        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)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale # (B, H, T, D)
-        # attn = self.proj_l(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_l(attn.transpose(1, -1)).transpose(1, -1)
-
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        # attn = self.proj_w(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_w(attn.transpose(1, -1)).transpose(1, -1)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x, k.mean(dim=1)

joonmyung-1.5.13/models/deit.py

@@ -1,372 +0,0 @@
-""" Vision Transformer (ViT) in PyTorch
-
-A PyTorch implement of Vision Transformers as described in:
-
-'An Image Is Worth 16 x 16 Words: Transformers for Image Recognition at Scale'
-    - https://arxiv.org/abs/2010.11929
-
-`How to train your ViT? Data, Augmentation, and Regularization in Vision Transformers`
-    - https://arxiv.org/abs/2106.10270
-
-The official jax code is released and available at https://github.com/google-research/vision_transformer
-
-DeiT model defs and weights from https://github.com/facebookresearch/deit,
-paper `DeiT: Data-efficient Image Transformers` - https://arxiv.org/abs/2012.12877
-
-Acknowledgments:
-* The paper authors for releasing code and weights, thanks!
-* I fixed my class token impl based on Phil Wang's https://github.com/lucidrains/vit-pytorch ... check it out
-for some einops/einsum fun
-* Simple transformer style inspired by Andrej Karpathy's https://github.com/karpathy/minGPT
-* Bert reference code checks against Huggingface Transformers and Tensorflow Bert
-
-Hacked together by / Copyright 2021 Ross Wightman
-"""
-import math
-import logging
-from functools import partial
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from timm.models.helpers import named_apply, adapt_input_conv
-from timm.models.layers import PatchEmbed, trunc_normal_, lecun_normal_
-from timm.models.registry import register_model
-
-from models.modules.PE import PositionalEncodingFourier, get_2d_sincos_pos_embed
-from models.modules.blocks import Block_DEIT
-
-_logger = logging.getLogger(__name__)
-
-class VisionTransformer(nn.Module):
-    """ Vision Transformer
-
-    A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
-        - https://arxiv.org/abs/2010.11929
-
-    Includes distillation token & head support for `DeiT: Data-efficient Image Transformers`
-        - https://arxiv.org/abs/2012.12877
-    """
-
-    def __init__(self, input_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
-                 num_heads=12, mlp_ratio=4., qkv_bias=True,
-                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., embed_layer=PatchEmbed, norm_layer=None,
-                 act_layer=None, weight_init='', **kwargs):
-        super().__init__()
-        self.num_classes = num_classes
-        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
-        self.cls_token_num     = kwargs["token_nums"][0]
-        self.dist_token_num = kwargs["token_nums"][1]
-
-        self.patch_embed_type         = kwargs["embed_type"][0]
-        self.pos_embed_type           = kwargs["embed_type"][1]
-        self.pos_embed_applied_type   = kwargs["embed_type"][2]
-
-
-        self.layer_scale   = kwargs["model_type"][0]
-        self.talking_head  = kwargs["model_type"][1]
-
-        self.num_tokens = self.cls_token_num + self.dist_token_num
-
-        act_layer = act_layer or nn.GELU
-
-        img_size = input_size
-        if self.patch_embed_type == 0:
-            self.patch_embed = embed_layer(
-                img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
-        else:
-            raise ValueError
-        num_patches = self.patch_embed.num_patches
-
-        if self.cls_token_num:  self.cls_token = nn.Parameter(torch.zeros(1, self.cls_token_num, embed_dim))
-        if self.dist_token_num: self.dist_token = nn.Parameter(torch.zeros(1, self.dist_token_num, embed_dim))
-
-        pos_embed_token_num = num_patches + self.num_tokens if self.pos_embed_applied_type == 0 else num_patches
-        if self.pos_embed_type == 0:
-            self.pos_embed = nn.Parameter(torch.zeros(1, pos_embed_token_num, embed_dim))
-        elif self.pos_embed_type == 1:
-            self.pos_embed = nn.Parameter(torch.zeros(1, pos_embed_token_num, embed_dim), requires_grad=False)
-            pos_embed = get_2d_sincos_pos_embed(embed_dim, int(pos_embed_token_num **.5))
-            self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
-        elif self.pos_embed_type == 2:
-            self.pos_embed = PositionalEncodingFourier(dim=embed_dim)
-        else:
-            raise ValueError
-        self.pos_drop = nn.Dropout(p=drop_rate)
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
-        self.blocks = nn.Sequential(*[
-            Block_DEIT(
-                dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, drop=drop_rate,
-                attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, act_layer=act_layer,
-                # OURS
-                layer_scale=self.layer_scale, talking_head=self.talking_head)
-            for i in range(depth)])
-        self.norm = norm_layer(embed_dim)
-        self.pre_logits = nn.Identity()
-
-        # Classifier head(s)
-        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
-        if self.dist_token_num:
-            self.head_dist = nn.Linear(self.embed_dim, self.num_classes) if num_classes > 0 else nn.Identity()
-        else:
-            self.head_dist = None
-
-        self.init_weights(weight_init)
-
-    def init_weights(self, mode=''):
-        assert mode in ('jax', 'jax_nlhb', 'nlhb', '')
-        head_bias = -math.log(self.num_classes) if 'nlhb' in mode else 0.
-
-        if self.pos_embed_type not in  [1,2]: trunc_normal_(self.pos_embed, std=.02)
-        if self.dist_token_num:
-            trunc_normal_(self.dist_token, std=.02)
-        if mode.startswith('jax'):
-            # leave cls token as zeros to match jax impl
-            named_apply(partial(_init_vit_weights, head_bias=head_bias, jax_impl=True), self)
-        else:
-            if self.cls_token_num:
-                trunc_normal_(self.cls_token, std=.02)
-            self.apply(_init_vit_weights)
-
-    def _init_weights(self, m):
-        # this fn left here for compat with downstream users
-        _init_vit_weights(m)
-
-    @torch.jit.ignore()
-    def load_pretrained(self, checkpoint_path, prefix=''):
-        _load_weights(self, checkpoint_path, prefix)
-
-    @torch.jit.ignore
-    def no_weight_decay(self):
-        return {'pos_embed', 'cls_token', 'dist_token'}
-
-    def get_classifier(self):
-        if self.dist_token is None:
-            return self.head
-        else:
-            return self.head, self.head_dist
-
-    def reset_classifier(self, num_classes, global_pool=''):
-        self.num_classes = num_classes
-        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
-        if self.dist_token_num:
-            self.head_dist = nn.Linear(self.embed_dim, self.num_classes) if num_classes > 0 else nn.Identity()
-
-    def forward_features(self, x):
-
-        x = self.patch_embed(x)
-        B, T, D = x.shape
-        cls_token = self.cls_token.expand(B, -1, -1)
-
-        pos_embed = self.pos_embed if self.pos_embed_type not in [2] else self.pos_embed(B, int(T**0.5), int(T**0.5)).reshape(B, -1, T).transpose(1, 2)
-        if self.pos_embed_applied_type == 0:
-            x = torch.cat((cls_token, x), dim=1)
-            x = self.pos_drop(x + pos_embed)
-        else:
-            x = torch.cat((cls_token, x + pos_embed), dim=1)
-            x = self.pos_drop(x)
-
-        x = self.blocks(x)
-        x = self.norm(x)
-        return self.pre_logits(x[:, :self.cls_token_num].mean(dim=1))
-
-    def forward(self, x):
-        x = self.forward_features(x)
-        x = self.head(x)
-        return x
-
-
-def _init_vit_weights(module: nn.Module, name: str = '', head_bias: float = 0., jax_impl: bool = False):
-    """ ViT weight initialization
-    * When called without n, head_bias, jax_impl args it will behave exactly the same
-      as my original init for compatibility with prev hparam / downstream use cases (ie DeiT).
-    * When called w/ valid n (module name) and jax_impl=True, will (hopefully) match JAX impl
-    """
-    if isinstance(module, nn.Linear):
-        if name.startswith('head'):
-            nn.init.zeros_(module.weight)
-            nn.init.constant_(module.bias, head_bias)
-        elif name.startswith('pre_logits'):
-            lecun_normal_(module.weight)
-            nn.init.zeros_(module.bias)
-        else:
-            if jax_impl:
-                nn.init.xavier_uniform_(module.weight)
-                if module.bias is not None:
-                    if 'mlp' in name:
-                        nn.init.normal_(module.bias, std=1e-6)
-                    else:
-                        nn.init.zeros_(module.bias)
-            else:
-                trunc_normal_(module.weight, std=.02)
-                if module.bias is not None:
-                    nn.init.zeros_(module.bias)
-    elif jax_impl and isinstance(module, nn.Conv2d):
-        # NOTE conv was left to pytorch default in my original init
-        lecun_normal_(module.weight)
-        if module.bias is not None:
-            nn.init.zeros_(module.bias)
-    elif isinstance(module, (nn.LayerNorm, nn.GroupNorm, nn.BatchNorm2d)):
-        nn.init.zeros_(module.bias)
-        nn.init.ones_(module.weight)
-
-
-@torch.no_grad()
-def _load_weights(model: VisionTransformer, checkpoint_path: str, prefix: str = ''):
-    """ Load weights from .npz checkpoints for official Google Brain Flax implementation
-    """
-    import numpy as np
-
-    def _n2p(w, t=True):
-        if w.ndim == 4 and w.shape[0] == w.shape[1] == w.shape[2] == 1:
-            w = w.flatten()
-        if t:
-            if w.ndim == 4:
-                w = w.transpose([3, 2, 0, 1])
-            elif w.ndim == 3:
-                w = w.transpose([2, 0, 1])
-            elif w.ndim == 2:
-                w = w.transpose([1, 0])
-        return torch.from_numpy(w)
-
-    w = np.load(checkpoint_path)
-    if not prefix and 'opt/target/embedding/kernel' in w:
-        prefix = 'opt/target/'
-
-    if hasattr(model.patch_embed, 'backbone'):
-        # hybrid
-        backbone = model.patch_embed.backbone
-        stem_only = not hasattr(backbone, 'stem')
-        stem = backbone if stem_only else backbone.stem
-        stem.conv.weight.copy_(adapt_input_conv(stem.conv.weight.shape[1], _n2p(w[f'{prefix}conv_root/kernel'])))
-        stem.norm.weight.copy_(_n2p(w[f'{prefix}gn_root/scale']))
-        stem.norm.bias.copy_(_n2p(w[f'{prefix}gn_root/bias']))
-        if not stem_only:
-            for i, stage in enumerate(backbone.stages):
-                for j, block in enumerate(stage.blocks):
-                    bp = f'{prefix}block{i + 1}/unit{j + 1}/'
-                    for r in range(3):
-                        getattr(block, f'conv{r + 1}').weight.copy_(_n2p(w[f'{bp}conv{r + 1}/kernel']))
-                        getattr(block, f'norm{r + 1}').weight.copy_(_n2p(w[f'{bp}gn{r + 1}/scale']))
-                        getattr(block, f'norm{r + 1}').bias.copy_(_n2p(w[f'{bp}gn{r + 1}/bias']))
-                    if block.downsample is not None:
-                        block.downsample.conv.weight.copy_(_n2p(w[f'{bp}conv_proj/kernel']))
-                        block.downsample.norm.weight.copy_(_n2p(w[f'{bp}gn_proj/scale']))
-                        block.downsample.norm.bias.copy_(_n2p(w[f'{bp}gn_proj/bias']))
-        embed_conv_w = _n2p(w[f'{prefix}embedding/kernel'])
-    else:
-        embed_conv_w = adapt_input_conv(
-            model.patch_embed.proj.weight.shape[1], _n2p(w[f'{prefix}embedding/kernel']))
-    model.patch_embed.proj.weight.copy_(embed_conv_w)
-    model.patch_embed.proj.bias.copy_(_n2p(w[f'{prefix}embedding/bias']))
-    model.cls_token.copy_(_n2p(w[f'{prefix}cls'], t=False))
-    pos_embed_w = _n2p(w[f'{prefix}Transformer/posembed_input/pos_embedding'], t=False)
-    if pos_embed_w.shape != model.pos_embed.shape:
-        pos_embed_w = resize_pos_embed(  # resize pos embedding when different size from pretrained weights
-            pos_embed_w, model.pos_embed, getattr(model, 'num_tokens', 1), model.patch_embed.grid_size)
-    model.pos_embed.copy_(pos_embed_w)
-    model.norm.weight.copy_(_n2p(w[f'{prefix}Transformer/encoder_norm/scale']))
-    model.norm.bias.copy_(_n2p(w[f'{prefix}Transformer/encoder_norm/bias']))
-    if isinstance(model.head, nn.Linear) and model.head.bias.shape[0] == w[f'{prefix}head/bias'].shape[-1]:
-        model.head.weight.copy_(_n2p(w[f'{prefix}head/kernel']))
-        model.head.bias.copy_(_n2p(w[f'{prefix}head/bias']))
-    if isinstance(getattr(model.pre_logits, 'fc', None), nn.Linear) and f'{prefix}pre_logits/bias' in w:
-        model.pre_logits.fc.weight.copy_(_n2p(w[f'{prefix}pre_logits/kernel']))
-        model.pre_logits.fc.bias.copy_(_n2p(w[f'{prefix}pre_logits/bias']))
-    for i, block in enumerate(model.blocks.children()):
-        block_prefix = f'{prefix}Transformer/encoderblock_{i}/'
-        mha_prefix = block_prefix + 'MultiHeadDotProductAttention_1/'
-        block.norm1.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/scale']))
-        block.norm1.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/bias']))
-        block.attn.qkv.weight.copy_(torch.cat([
-            _n2p(w[f'{mha_prefix}{n}/kernel'], t=False).flatten(1).T for n in ('query', 'key', 'value')]))
-        block.attn.qkv.bias.copy_(torch.cat([
-            _n2p(w[f'{mha_prefix}{n}/bias'], t=False).reshape(-1) for n in ('query', 'key', 'value')]))
-        block.attn.proj.weight.copy_(_n2p(w[f'{mha_prefix}out/kernel']).flatten(1))
-        block.attn.proj.bias.copy_(_n2p(w[f'{mha_prefix}out/bias']))
-        for r in range(2):
-            getattr(block.mlp, f'fc{r + 1}').weight.copy_(_n2p(w[f'{block_prefix}MlpBlock_3/Dense_{r}/kernel']))
-            getattr(block.mlp, f'fc{r + 1}').bias.copy_(_n2p(w[f'{block_prefix}MlpBlock_3/Dense_{r}/bias']))
-        block.norm2.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_2/scale']))
-        block.norm2.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_2/bias']))
-
-
-def resize_pos_embed(posemb, posemb_new, num_tokens=1, gs_new=()):
-    # Rescale the grid of position embeddings when loading from state_dict. Adapted from
-    # https://github.com/google-research/vision_transformer/blob/00883dd691c63a6830751563748663526e811cee/vit_jax/checkpoint.py#L224
-    _logger.info('Resized position embedding: %s to %s', posemb.shape, posemb_new.shape)
-    ntok_new = posemb_new.shape[1]
-    if num_tokens:
-        posemb_tok, posemb_grid = posemb[:, :num_tokens], posemb[0, num_tokens:]
-        ntok_new -= num_tokens
-    else:
-        posemb_tok, posemb_grid = posemb[:, :0], posemb[0]
-    gs_old = int(math.sqrt(len(posemb_grid)))
-    if not len(gs_new):  # backwards compatibility
-        gs_new = [int(math.sqrt(ntok_new))] * 2
-    assert len(gs_new) >= 2
-    _logger.info('Position embedding grid-size from %s to %s', [gs_old, gs_old], gs_new)
-    posemb_grid = posemb_grid.reshape(1, gs_old, gs_old, -1).permute(0, 3, 1, 2)
-    posemb_grid = F.interpolate(posemb_grid, size=gs_new, mode='bilinear')
-    posemb_grid = posemb_grid.permute(0, 2, 3, 1).reshape(1, gs_new[0] * gs_new[1], -1)
-    posemb = torch.cat([posemb_tok, posemb_grid], dim=1)
-    return posemb
-
-
-def checkpoint_filter_fn(state_dict, model):
-    """ convert patch embedding weight from manual patchify + linear proj to conv"""
-    out_dict = {}
-    if 'model' in state_dict:
-        # For deit models
-        state_dict = state_dict['model']
-    for k, v in state_dict.items():
-        if 'patch_embed.proj.weight' in k and len(v.shape) < 4:
-            # For old models that I trained prior to conv based patchification
-            O, I, H, W = model.patch_embed.proj.weight.shape
-            v = v.reshape(O, -1, H, W)
-        elif k == 'pos_embed' and v.shape != model.pos_embed.shape:
-            # To resize pos embedding when using model at different size from pretrained weights
-            v = resize_pos_embed(
-                v, model.pos_embed, getattr(model, 'num_tokens', 1), model.patch_embed.grid_size)
-        out_dict[k] = v
-    return out_dict
-
-@register_model
-def deit_tiny(pretrained=False, **kwargs):
-    model_kwargs = dict(patch_size=16, embed_dim=192, depth=12, num_heads=3,
-                        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model = VisionTransformer(**model_kwargs)
-    if pretrained:
-        checkpoint = torch.hub.load_state_dict_from_url(
-            url="https://dl.fbaipublicfiles.com/deit/deit_tiny_patch16_224-a1311bcf.pth",
-            map_location="cpu", check_hash=True
-        )
-        model.load_state_dict(checkpoint["model"])
-    return model
-
-@register_model
-def deit_small(pretrained=False, **kwargs):
-    model_kwargs = dict(patch_size=16, embed_dim=384, depth=12, num_heads=6,
-                        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model = VisionTransformer(**model_kwargs)
-    if pretrained:
-        checkpoint = torch.hub.load_state_dict_from_url(
-            url="https://dl.fbaipublicfiles.com/deit/deit_small_patch16_224-cd65a155.pth",
-            map_location="cpu", check_hash=True
-        )
-        model.load_state_dict(checkpoint["model"])
-    return model
-
-@register_model
-def deit_base(pretrained=False, **kwargs):
-    model_kwargs = dict(patch_size=16, embed_dim=768, depth=12, num_heads=12,
-                        norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
-    model = VisionTransformer(**model_kwargs)
-    if pretrained:
-        checkpoint = torch.hub.load_state_dict_from_url(
-            url="https://dl.fbaipublicfiles.com/deit/deit_base_patch16_224-b5f2ef4d.pth",
-            map_location="cpu", check_hash=True
-        )
-        model.load_state_dict(checkpoint["model"])
-    return model