third_party/TinyCLIP/src/open_clip/model.py

""" CLIP Model

Adapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI.
"""

import functools
import inspect
from copy import deepcopy
import os
import random
import copy
from contextlib import nullcontext
from argparse import Namespace

from dataclasses import dataclass
import functools
import logging
import math
from typing import Tuple, Union, Callable, Optional

import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from torch.utils.checkpoint import checkpoint
# apply the non-reentrant variant of checkpoint
if 'use_reentrant' in inspect.signature(checkpoint).parameters:
    checkpoint = functools.partial(checkpoint, use_reentrant=False)

from .timm_model import TimmModel
from .utils import freeze_batch_norm_2d, to_2tuple
from .resnet import ModifiedResNet
from .l0module import L0Module


def load_state_dict(model, state_dict):
    model.load_state_dict(state_dict, strict=True)


class LayerNorm(nn.LayerNorm):
    """Subclass torch's LayerNorm to handle fp16."""

    def forward(self, x: torch.Tensor, hidden_z=None):
        '''
        x: (N, L, C)
        hidden_z: (C,)
        '''
        self.hidden_z = hidden_z
        orig_type = x.dtype

        if hidden_z is None:
            x = F.layer_norm(x, self.normalized_shape,
                             self.weight, self.bias, self.eps)
        else:
            assert len(self.normalized_shape) == 1
            # [TODO] weighted layer norm
            remaining_index = torch.where(hidden_z != 0)[0]
            compressed_input = torch.index_select(
                x, dim=-1, index=remaining_index)
            compressed_weight = self.weight[remaining_index]
            compressed_bias = self.bias[remaining_index]
            normalized_shape = len(remaining_index)
            normed_input = F.layer_norm(
                compressed_input, [normalized_shape], compressed_weight, compressed_bias, self.eps)
            x = x.new_zeros(x.shape)
            x[..., remaining_index] = normed_input.to(orig_type)

        return x.to(orig_type)

    def prune(self):
        if self.hidden_z is None:
            return self
        hidden_z = self.hidden_z
        assert len(self.normalized_shape) == 1
        remaining_index = torch.where(hidden_z != 0)[0]
        compressed_weight = self.weight[remaining_index]
        compressed_bias = self.bias[remaining_index]
        # m = self
        m = LayerNorm(remaining_index.shape[0]).to(self.weight.device)
        m.normalized_shape = (len(remaining_index),)
        m.weight.data = compressed_weight.contiguous()
        m.bias.data = compressed_bias.contiguous()
        return m

    def prune_mul_hidden(self):
        if self.hidden_z is None:
            return self
        hidden_z = self.hidden_z
        assert len(self.normalized_shape) == 1
        remaining_index = torch.where(hidden_z != 0)[0]
        compressed_weight = self.weight[remaining_index] * \
            hidden_z[remaining_index]
        compressed_bias = self.bias[remaining_index] * \
            hidden_z[remaining_index]
        m = self
        m.normalized_shape = (len(remaining_index),)
        m.weight.data = compressed_weight.contiguous()
        m.bias.data = compressed_bias.contiguous()
        return m


class QuickGELU(nn.Module):
    # NOTE This is slower than nn.GELU or nn.SiLU and uses more GPU memory
    def forward(self, x: torch.Tensor):
        return x * torch.sigmoid(1.702 * x)


class Mlp(nn.Module):
    def __init__(self, d_model, mlp_width, act_layer=nn.GELU, scale_fc=False):
        super().__init__()
        self.d_model = d_model
        self.mlp_width = mlp_width
        self.c_fc = nn.Linear(d_model, mlp_width)
        assert not scale_fc
        # self.ln = LayerNorm(mlp_width) if scale_fc else nn.Identity()
        self.act_layer = act_layer
        self.scale_fc = scale_fc
        self.gelu = act_layer()
        self.c_proj = nn.Linear(mlp_width, d_model)

    def forward(self, x, hidden_z=None, intermediate_z=None):
        '''
        x: (N, L, C)
        intermediate_z: (mlp_width,) or (1, 1, mlp_width)
        hidden_z: (embed_dim,) or (1, 1, embed_dim)
        '''
        self.hidden_z = hidden_z
        self.intermediate_z = intermediate_z

        x = self.c_fc(x)
        x = self.gelu(x)
        if intermediate_z is not None:
            x = torch.mul(x, intermediate_z)
        x = self.c_proj(x)
        if hidden_z is not None:
            x = torch.mul(x, hidden_z)
        return x

    def prune(self):
        device = self.c_fc.weight.device
        if self.hidden_z is None:
            self.hidden_z = torch.ones(
                (self.d_model,), dtype=torch.bool, device=device)
        if self.intermediate_z is None:
            self.intermediate_z = torch.ones(
                (self.mlp_width,), dtype=torch.bool, device=device)
        hidden_r = torch.where(self.hidden_z != 0)[0]
        intermediate_r = torch.where(self.intermediate_z != 0)[0]
        d_model = len(hidden_r)
        mlp_width = len(intermediate_r)
        # m = self
        m = copy.deepcopy(self)
        m.c_fc = nn.Linear(hidden_r.shape[0], intermediate_r.shape[0])
        m.c_proj = nn.Linear(intermediate_r.shape[0], hidden_r.shape[0])
        m.d_model = d_model
        m.mlp_width = mlp_width
        m.c_fc.weight = nn.Parameter(
            (self.c_fc.weight[intermediate_r][:, hidden_r]).contiguous())
        m.c_fc.bias = nn.Parameter(
            (self.c_fc.bias[intermediate_r]).contiguous())

        m.c_proj.weight = nn.Parameter(((self.c_proj.weight *
                                         self.intermediate_z.view(1, -1) * self.hidden_z.view(-1, 1))[hidden_r][:, intermediate_r]).contiguous())
        m.c_proj.bias = nn.Parameter(
            ((self.c_proj.bias * self.hidden_z)[hidden_r]).contiguous())
        return m


class MultiheadAttention(nn.MultiheadAttention):
    def prune(self):
        device = self.in_proj_weight.device
        if self.hidden_z is None:
            self.hidden_z = torch.ones(
                (self.embed_dim,), dtype=torch.bool, device=device)
        if self.head_z is None:
            self.head_z = torch.ones(
                (self.num_heads,), dtype=torch.bool, device=device)
        hidden_r = torch.where(self.hidden_z != 0)[0]
        head_r = torch.where(self.head_z != 0)[0]
        d_model = len(hidden_r)
        d_head = len(head_r)
        org_num_heads = self.num_heads
        org_head_dim = self.head_dim
        org_embed_dim = self.embed_dim
        mod = self
        mod.use_naive_compute = True
        mod.embed_dim = d_model
        mod.head_dim = self.head_dim
        mod.num_heads = d_head
        inter_dim = d_head * self.head_dim
        mod.in_proj_weight = nn.Parameter(self.in_proj_weight.view(
            3, org_num_heads, org_head_dim, org_embed_dim)[:, head_r][..., hidden_r].reshape(-1, d_model))
        if self.in_proj_bias is not None:
            mod.in_proj_bias = nn.Parameter(self.in_proj_bias.view(
                3, org_num_heads, org_head_dim)[:, head_r].reshape(-1))
        mod.out_proj.weight = nn.Parameter(
            ((self.out_proj.weight * self.hidden_z.view(-1, 1)).
             view(org_embed_dim, org_num_heads, org_head_dim) * self.head_z.view(1, org_num_heads, 1))[hidden_r][:, head_r].reshape(d_model, -1)
        )
        if self.out_proj.bias is not None:
            mod.out_proj.bias = nn.Parameter(
                (self.out_proj.bias * self.hidden_z.view(-1,)).
                view(org_embed_dim)[hidden_r].reshape(-1)
            )
        return mod


class ResidualAttentionBlock(nn.Module):
    def __init__(
            self,
            d_model: int,
            n_head: int,
            mlp_ratio: float = 4.0,
            act_layer: Callable = nn.GELU,
            scale_cosine_attn: bool = False,
            scale_heads: bool = False,
            scale_attn: bool = False,
            scale_fc: bool = False,
    ):
        super().__init__()

        self.ln_1 = LayerNorm(d_model)
        # FIXME torchscript issues need to be resolved for custom attention
        # if scale_cosine_attn or scale_heads:
        #     self.attn = Attention(
        #        d_model, n_head,
        #        scaled_cosine=scale_cosine_attn,
        #        scale_heads=scale_heads,
        #     )
        self.attn = MultiheadAttention(d_model, n_head)
        assert not scale_attn
        self.ln_attn = LayerNorm(d_model) if scale_attn else nn.Identity()

        self.ln_2 = LayerNorm(d_model)
        mlp_width = int(d_model * mlp_ratio)
        self.mlp = Mlp(d_model, mlp_width, act_layer, scale_fc)

    def attention(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None,
                  *,
                  head_z: Optional[torch.Tensor] = None,
                  hidden_z: Optional[torch.Tensor] = None,
                  ):

        self.attn.head_z = head_z
        self.attn.hidden_z = hidden_z

        if (head_z is None and hidden_z is None and
                not getattr(self.attn, 'use_naive_compute', False)):
            return self.attn(x, x, x, need_weights=False, attn_mask=attn_mask)[0]
        else:
            # the following code does not support `attn_mask`
            # x: (length, batch_size, embed_dim)
            n_head = self.attn.num_heads
            length, batch_size, d_model = x.shape
            ws = self.attn.in_proj_weight.chunk(3)
            bs = self.attn.in_proj_bias.chunk(3)
            dim_per_head = len(ws[0]) // n_head
            # (length, batch_size, n_head * dim_per_head)
            q, k, v = [F.linear(x, w, b) for w, b in zip(ws, bs)]
            # (batch_size * n_head, length, d_head)
            q = q.reshape(length, batch_size * n_head, -1).transpose(0, 1)
            k = k.reshape(length, batch_size * n_head, -1).transpose(0, 1)
            v = v.reshape(length, batch_size * n_head, -1).transpose(0, 1)
            scale = dim_per_head ** -0.5
            q *= scale
            # (batch_size * n_head, length, length)
            sim = q @ k.transpose(1, 2)
            if attn_mask is not None:
                sim += attn_mask
            sim = torch.softmax(sim, -1)
            # (batch_size * n_head, length, head_dim)
            out = sim @ v
            if head_z is not None:
                out = out.view(batch_size, n_head, length, dim_per_head)
                # head_z: (1, n_head, 1, 1)
                out *= head_z.view(1, -1, 1, 1)
                out = out.view(batch_size * n_head, length, dim_per_head)
            out = out.transpose(0, 1).reshape(length, batch_size, -1)
            out = F.linear(out, self.attn.out_proj.weight,
                           self.attn.out_proj.bias)
            if hidden_z is not None:
                out = torch.mul(out, hidden_z)
            return out

    def forward(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None,
                hidden_z: Optional[torch.Tensor] = None,
                heads_z: Optional[torch.Tensor] = None,
                mha_z: Optional[torch.Tensor] = None,
                intermediate_z: Optional[torch.Tensor] = None,
                ffn_z: Optional[torch.Tensor] = None):

        self.hidden_z = hidden_z
        self.heads_z = heads_z
        self.mha_z = mha_z
        self.intermediate_z = intermediate_z
        self.ffn_z = ffn_z

        # x: (length, batch_size, embed_dim) e.g. 50, 128, 768 for vision
        if self.attention is not None:
            attn_out = self.attention(self.ln_1(x, hidden_z=hidden_z),
                                      attn_mask=attn_mask,
                                      head_z=heads_z, hidden_z=hidden_z)
            if mha_z is not None:  # a number
                attn_out = attn_out.mul(mha_z)
            x = x + attn_out
        if self.mlp is not None:
            ln_2_out = self.ln_2(x, hidden_z=hidden_z)

            mlp_out = self.mlp(ln_2_out,
                               intermediate_z=intermediate_z,
                               hidden_z=hidden_z)
            if ffn_z is not None:  # a number
                mlp_out = mlp_out.mul(ffn_z)
            x = x + mlp_out
        return x

    def prune(self):
        mod = self
        if (self.mha_z is not None and self.mha_z.item() == 0) or (self.heads_z).sum() == 0:
            mod.ln_1 = None
            mod.attn = None
            mod.attention = None
        else:
            mod.ln_1 = mod.ln_1.prune()
            mod.attn = mod.attn.prune()
            if self.mha_z is not None:
                mod.attn.out_proj.weight.data *= self.mha_z
                mod.attn.out_proj.bias.data *= self.mha_z

        if self.ffn_z is not None and self.ffn_z.item() == 0:
            mod.ln_2 = None
            mod.mlp = None
        else:
            mod.ln_2 = mod.ln_2.prune()
            mod.mlp = mod.mlp.prune()
            if self.ffn_z is not None:
                mod.mlp.c_proj.weight.data *= self.ffn_z
                mod.mlp.c_proj.bias.data *= self.ffn_z
        return mod


class Transformer(nn.Module):
    def __init__(self, width: int, layers: int, heads: int, mlp_ratio: float = 4.0,
                 act_layer: Callable = nn.GELU):
        super().__init__()
        self.width = width
        self.layers = layers
        self.grad_checkpointing = False

        assert width % heads == 0
        self.head_dim = width // heads
        self.num_heads = heads
        self.mlp_ratio = mlp_ratio

        self.resblocks = nn.ModuleList([
            ResidualAttentionBlock(
                width, heads, mlp_ratio, act_layer=act_layer)
            for _ in range(layers)
        ])

    def forward(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None,
                hidden_z: Optional[torch.Tensor] = None,
                heads_z: Optional[torch.Tensor] = None,
                mha_z: Optional[torch.Tensor] = None,
                intermediate_z: Optional[torch.Tensor] = None,
                ffn_z: Optional[torch.Tensor] = None):

        return self.infer_blocks(x, attn_mask,
                                 hidden_z=hidden_z,
                                 heads_z=heads_z,
                                 mha_z=mha_z,
                                 intermediate_z=intermediate_z,
                                 ffn_z=ffn_z)

    def infer_blocks(self, x: torch.Tensor, attn_mask: Optional[torch.Tensor] = None, block_idxs=None,
                     hidden_z: Optional[torch.Tensor] = None,
                     heads_z: Optional[torch.Tensor] = None,
                     mha_z: Optional[torch.Tensor] = None,
                     intermediate_z: Optional[torch.Tensor] = None,
                     ffn_z: Optional[torch.Tensor] = None):

        num_layers = self.layers
        if hidden_z is not None:
            assert hidden_z.shape == (self.width,)
        if heads_z is not None:
            if heads_z.ndim == 5:
                heads_z = heads_z.view(num_layers, self.num_heads)
            assert heads_z.shape in [(num_layers, self.num_heads), (self.num_heads,)], (
                heads_z.shape, (num_layers, self.num_heads))
        if mha_z is not None:
            assert mha_z.shape == (num_layers,), mha_z.shape
        if intermediate_z is not None:
            if intermediate_z.ndim == 4:
                intermediate_z = intermediate_z.view(num_layers, -1)
            assert intermediate_z.shape in [
                (num_layers, self.mlp_ratio * self.width), (self.mlp_ratio * self.width,)], intermediate_z.shape
        if ffn_z is not None:
            assert ffn_z.shape == (num_layers,), ffn_z.shape

        def _get_zi(z, i, ndim=2):
            if z is None:
                return None
            if z.ndim == ndim:
                return z[i]
            return z

        block_idxs = block_idxs or list(range(self.layers))
        for i in block_idxs:
            r = self.resblocks[i]

            if self.grad_checkpointing and not torch.jit.is_scripting():
                x = checkpoint(r, x, attn_mask,
                               hidden_z,
                               _get_zi(heads_z, i),
                               _get_zi(mha_z, i, ndim=1),
                               _get_zi(intermediate_z, i),
                               _get_zi(ffn_z, i, ndim=1))
            else:
                x = r(x, attn_mask=attn_mask,
                      hidden_z=hidden_z,
                      heads_z=_get_zi(heads_z, i),
                      mha_z=_get_zi(mha_z, i, ndim=1),
                      intermediate_z=_get_zi(intermediate_z, i),
                      ffn_z=_get_zi(ffn_z, i, ndim=1))

        return x

    @torch.jit.ignore
    def set_grad_checkpointing(self, enable=True):
        self.grad_checkpointing = enable

    def extra_repr(self):
        return f'grad_checkpointing={self.grad_checkpointing}'

    def prune(self):
        mod = self
        for i in range(len(self.resblocks)):
            self.resblocks[i] = self.resblocks[i].prune()
        return mod


class VisualTransformer(nn.Module):
    def __init__(
            self,
            image_size: int,
            patch_size: int,
            width: int,
            layers: int,
            heads: int,
            mlp_ratio: float,
            output_dim: int,
            act_layer: Callable = nn.GELU,
            teacher_width: int = -1,
    ):
        super().__init__()
        self.image_size = to_2tuple(image_size)
        self.patch_size = to_2tuple(patch_size)
        self.grid_size = (
            self.image_size[0] // self.patch_size[0], self.image_size[1] // self.patch_size[1])
        self.output_dim = output_dim
        self.embed_dim = width
        self.layers = layers
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width,
                               kernel_size=patch_size, stride=patch_size, bias=False)

        scale = width ** -0.5
        self.class_embedding = nn.Parameter(scale * torch.randn(width))
        self.positional_embedding = nn.Parameter(
            scale * torch.randn(self.grid_size[0] * self.grid_size[1] + 1, width))
        self.ln_pre = LayerNorm(width)

        self.transformer = Transformer(
            width, layers, heads, mlp_ratio, act_layer=act_layer)
        self.head_dim = width // heads

        self.ln_post = LayerNorm(width)
        # image proj
        if teacher_width > 0:
            self.proj = nn.Parameter(torch.empty(
                teacher_width, output_dim), requires_grad=False)
        else:
            self.proj = nn.Parameter(scale * torch.randn(width, output_dim))

    def lock(self, unlocked_groups=0, freeze_bn_stats=False):
        assert unlocked_groups == 0, 'partial locking not currently supported for this model'
        for param in self.parameters():
            param.requires_grad = False

    @torch.jit.ignore
    def set_grad_checkpointing(self, enable=True):
        self.transformer.set_grad_checkpointing(enable)

    def forward(self, x: torch.Tensor,
                hidden_z: Optional[torch.Tensor] = None,
                heads_z: Optional[torch.Tensor] = None,
                mha_z: Optional[torch.Tensor] = None,
                intermediate_z: Optional[torch.Tensor] = None,
                ffn_z: Optional[torch.Tensor] = None,
                embed_dim_z: Optional[torch.Tensor] = None):

        self.hidden_z = hidden_z
        self.embed_dim_z = embed_dim_z

        x = x.to(self.conv1.weight.device)
        x = self.conv1(x)  # shape = [*, width, grid, grid]
        # shape = [*, width, grid ** 2]
        x = x.reshape(x.shape[0], x.shape[1], -1)
        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
        # the first token is the class token.
        x = torch.cat(
            [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),
             x], dim=1)  # shape = [*, 1 + grid ** 2, width]
        x = x + self.positional_embedding.to(x.dtype)  # 128, 50, 768

        if hidden_z is not None:
            x = torch.mul(x, hidden_z)
        x = self.ln_pre(x, hidden_z=hidden_z)

        x = x.permute(1, 0, 2)  # NLD -> LND 50, 128, 768
        x = self.transformer(x,
                             hidden_z=hidden_z,
                             heads_z=heads_z,
                             mha_z=mha_z,
                             intermediate_z=intermediate_z,
                             ffn_z=ffn_z)

        x = x.permute(1, 0, 2)  # LND -> NLD

        # select class token
        x = self.ln_post(x[:, 0, :], hidden_z=hidden_z)

        if self.proj is not None:
            x = self.get_proj_feature(x)

        return x

    def get_proj_feature(self, x):
        if self.proj is not None:
            x = x @ self.proj
        return x

    def extra_repr(self):
        return 'image_size={}, output_dim={}'.format(self.image_size, self.output_dim)

    def prune(self):
        hidden_r = torch.where(self.hidden_z != 0)[0]
        self.conv1.weight = nn.Parameter(
            (self.conv1.weight.data * self.hidden_z.view(-1, 1, 1, 1))[hidden_r])
        if self.conv1.bias is not None:
            self.conv1.bias = nn.Parameter(
                (self.conv1.bias * self.hidden_z.view(-1,))[hidden_r])
        self.class_embedding = nn.Parameter(
            (self.class_embedding * self.hidden_z.view(-1,))[hidden_r])
        self.positional_embedding = nn.Parameter(
            (self.positional_embedding * self.hidden_z.view(1, -1))[:, hidden_r])
        self.ln_pre = self.ln_pre.prune()
        self.transformer = self.transformer.prune()
        self.ln_post = self.ln_post.prune()
        if self.embed_dim_z is not None:
            embed_dim_r = self.embed_dim_z > 0
            self.proj = nn.Parameter((self.proj * self.hidden_z.view(-1, 1)
                                     * self.embed_dim_z.view(1, -1))[hidden_r][:, embed_dim_r])
        else:
            self.proj = nn.Parameter(
                (self.proj * self.hidden_z.view(-1, 1))[hidden_r])
        return self


@dataclass
class CLIPVisionCfg:
    layers: Union[Tuple[int, int, int, int], int] = 12
    width: int = 768
    teacher_width: int = -1
    head_width: int = 64
    mlp_ratio: float = 4.0
    patch_size: int = 16
    image_size: Union[Tuple[int, int], int] = 224
    timm_model_name: str = None  # a valid model name overrides layers, width, patch_size
    # use (imagenet) pretrained weights for named model
    timm_model_pretrained: bool = False
    # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '')
    timm_pool: str = 'avg'
    # linear projection for timm model output ('linear', 'mlp', '')
    timm_proj: str = 'linear'


@dataclass
class CLIPTextCfg:
    context_length: int = 77
    vocab_size: int = 49408
    width: int = 512
    teacher_width: int = -1
    heads: int = 8
    layers: int = 12


class ImageEncoder(nn.Module):
    def __init__(self, embed_dim, vision_cfg, quick_gelu,
                 l0_module_image=False,
                 mask_cfg=None):
        super().__init__()
        act_layer = QuickGELU if quick_gelu else nn.GELU

        if vision_cfg.timm_model_name:
            self.visual = TimmModel(
                vision_cfg.timm_model_name,
                pretrained=vision_cfg.timm_model_pretrained,
                pool=vision_cfg.timm_pool,
                proj=vision_cfg.timm_proj,
                embed_dim=embed_dim,
                image_size=vision_cfg.image_size
            )
            act_layer = nn.GELU  # so that text transformer doesn't use QuickGELU w/ timm models
        elif isinstance(vision_cfg.layers, (tuple, list)):
            vision_heads = vision_cfg.width * 32 // vision_cfg.head_width
            self.visual = ModifiedResNet(
                layers=vision_cfg.layers,
                output_dim=embed_dim,
                heads=vision_heads,
                image_size=vision_cfg.image_size,
                width=vision_cfg.width
            )
        else:
            vision_heads = vision_cfg.width // vision_cfg.head_width
            self.visual = VisualTransformer(
                image_size=vision_cfg.image_size,
                patch_size=vision_cfg.patch_size,
                width=vision_cfg.width,
                layers=vision_cfg.layers,
                heads=vision_heads,
                mlp_ratio=vision_cfg.mlp_ratio,
                output_dim=embed_dim,
                act_layer=act_layer,
                teacher_width=vision_cfg.teacher_width,
            )
        self.init_parameters()

        if l0_module_image:
            logging.info('use l0_module_vision')
            config_mask = Namespace()
            config_mask.hidden_size = vision_cfg.width
            config_mask.intermediate_size = 4 * vision_cfg.width
            config_mask.num_attention_heads = vision_heads
            config_mask.num_hidden_layers = vision_cfg.layers
            config_mask.sparsity_warmup = mask_cfg.sparsity_warmup
            config_mask.sparsity = mask_cfg.sparsity
            config_mask.start_sparsity = mask_cfg.start_sparsity
            self.l0_module = L0Module(config_mask, lagrangian_warmup=config_mask.sparsity_warmup, start_sparsity=config_mask.start_sparsity,
                                      target_sparsity=config_mask.sparsity, pruning_type=["hidden", "heads", "intermediate"])
        else:
            self.l0_module = None

        self.mask = None

    def init_parameters(self):
        if hasattr(self.visual, 'init_parameters'):
            self.visual.init_parameters()

    def forward(self, image, normalized=False,
                **mask):

        if self.l0_module is not None:
            mask = self.l0_module.forward()

        self.mask = mask

        image_features = self.visual(image, **mask)

        embed_dim_z = mask.get('embed_dim_z', None)
        if embed_dim_z is not None:
            image_features = image_features.mul(embed_dim_z)

        if normalized:
            image_features = F.normalize(image_features, dim=-1)
        return image_features

    def prune(self):
        self.visual = self.visual.prune()
        return self


class TextEncoder(nn.Module):
    def __init__(self, embed_dim, text_cfg, quick_gelu,
                 l0_module_text, mask_cfg=None):
        super().__init__()

        act_layer = QuickGELU if quick_gelu else nn.GELU
        self.context_length = text_cfg.context_length

        if text_cfg.layers > 0:
            self.transformer = Transformer(
                width=text_cfg.width,
                layers=text_cfg.layers,
                heads=text_cfg.heads,
                act_layer=act_layer,
            )
        else:
            self.transformer = None

        self.text_projection = None
        if text_cfg.layers > 0:
            self.vocab_size = text_cfg.vocab_size
            self.token_embedding = nn.Embedding(
                text_cfg.vocab_size, text_cfg.width)
            self.positional_embedding = nn.Parameter(
                torch.empty(self.context_length, text_cfg.width))
            self.ln_final = LayerNorm(text_cfg.width)
            if text_cfg.teacher_width > 0:
                self.text_projection = nn.Parameter(torch.empty(
                    text_cfg.width, embed_dim), requires_grad=False)
            else:
                self.text_projection = nn.Parameter(
                    torch.empty(text_cfg.width, embed_dim))
            self.register_buffer(
                'attn_mask', self.build_attention_mask(), persistent=False)
        else:
            self.token_embedding = None
        self.init_parameters()

        if l0_module_text:
            logging.info('use l0_module_text')
            config_mask = Namespace()
            config_mask.hidden_size = text_cfg.width
            config_mask.intermediate_size = 4 * text_cfg.width
            config_mask.num_attention_heads = text_cfg.heads
            config_mask.num_hidden_layers = text_cfg.layers
            config_mask.sparsity_warmup = mask_cfg.sparsity_warmup
            config_mask.sparsity = mask_cfg.sparsity
            config_mask.start_sparsity = mask_cfg.start_sparsity
            self.l0_module = L0Module(config_mask, lagrangian_warmup=config_mask.sparsity_warmup, start_sparsity=config_mask.start_sparsity,
                                      target_sparsity=config_mask.sparsity, pruning_type=["hidden", "heads", "intermediate"])
        else:
            self.l0_module = None

        self.mask = None

    def init_parameters(self):
        if self.transformer is not None:
            nn.init.normal_(self.token_embedding.weight, std=0.02)
            nn.init.normal_(self.positional_embedding, std=0.01)

            proj_std = (self.transformer.width ** -0.5) * \
                ((2 * self.transformer.layers) ** -0.5)
            attn_std = self.transformer.width ** -0.5
            fc_std = (2 * self.transformer.width) ** -0.5
            for block in self.transformer.resblocks:
                nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
                nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
                nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
                nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)

            if self.text_projection is not None:
                nn.init.normal_(self.text_projection,
                                std=self.transformer.width ** -0.5)

    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 encode_text(self, text, normalized=False,
                    hidden_z: Optional[torch.Tensor] = None,
                    heads_z: Optional[torch.Tensor] = None,
                    mha_z: Optional[torch.Tensor] = None,
                    intermediate_z: Optional[torch.Tensor] = None,
                    ffn_z: Optional[torch.Tensor] = None,
                    embed_dim_z: Optional[torch.Tensor] = None,
                    ):
        self.hidden_z = hidden_z
        self.embed_dim_z = embed_dim_z

        text = text.to(self.token_embedding.weight.device)
        x = self.token_embedding(text)  # [batch_size, n_ctx, d_model]

        x = x + self.positional_embedding
        if hidden_z is not None:
            x = torch.mul(x, hidden_z)

        x = x.permute(1, 0, 2)  # NLD -> LND
        x = self.transformer(x, attn_mask=self.attn_mask,
                             hidden_z=hidden_z,
                             heads_z=heads_z,
                             mha_z=mha_z,
                             intermediate_z=intermediate_z,
                             ffn_z=ffn_z)
        x = x.permute(1, 0, 2)  # LND -> NLD
        x = self.ln_final(x, hidden_z)

        # if hidden_z is not None:
        #     x = torch.mul(x, hidden_z)

        x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)]

        # x.shape = [batch_size, n_ctx, transformer.width]
        # take features from the eot embedding (eot_token is the highest number in each sequence)
        x = self.get_proj_feature(x)
        if embed_dim_z is not None:
            x = x.mul(embed_dim_z)
        if normalized:
            x = F.normalize(x, dim=-1)

        return x

    def get_proj_feature(self, x):
        return x @ self.text_projection

    def forward(self, text, normalized=False):
        mask = dict()

        if self.l0_module is not None:
            mask = self.l0_module.forward()

        self.mask = mask

        return self.encode_text(text, normalized=normalized, **mask)

    def prune(self):
        device = self.token_embedding.weight.device
        if self.hidden_z is None:
            self.hidden_z = torch.ones(
                self.text_projection.size(0), device=device)
        if self.embed_dim_z is None:
            self.embed_dim_z = torch.ones(
                self.text_projection.size(1), device=device)
        mod = self
        self_copy = copy.deepcopy(self)
        hidden_r = self.hidden_z > 0
        mod.token_embedding = nn.Embedding(
            self_copy.token_embedding.weight.shape[0], hidden_r.sum())
        mod.positional_embedding = nn.Parameter(
            torch.empty(self_copy.context_length, hidden_r.sum()))
        mod.token_embedding.weight = nn.Parameter(
            (self_copy.token_embedding.weight * self_copy.hidden_z.view(1, -1))[:, hidden_r])
        mod.positional_embedding = nn.Parameter(
            (self_copy.positional_embedding * self_copy.hidden_z.view(1, -1))[:, hidden_r])
        mod.transformer = self.transformer.prune()
        mod.ln_final = self.ln_final.prune()
        embed_dim_r = self.embed_dim_z > 0
        mod.text_projection = nn.Parameter(
            (self.text_projection * self.hidden_z.view(-1, 1) * self.embed_dim_z.view(1, -1))[hidden_r][:, embed_dim_r])
        return mod


class LogitScale(nn.Module):
    def __init__(self):
        super().__init__()
        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))

    def forward(self, dummy):
        return self.logit_scale


class FNBlock(nn.Module):
    def __init__(self, fn):
        super().__init__()
        self.fn = fn

    def forward(self, *args, **kwargs):
        return self.fn(*args, **kwargs)


class FakeDDP(nn.Module):
    def __init__(self, module):
        super().__init__()
        self.module = module

    def forward(self, *args, **kwargs):
        return self.module(*args, **kwargs)


class CLIPBase(nn.Module):
    def __init__(self, image_encoder, text_encoder):
        super().__init__()
        self._image_encoder = image_encoder
        self._text_encoder = text_encoder

        self._logit_scale = LogitScale()

        # autocast context
        self.image_autocast = nullcontext
        self.text_autocast = nullcontext
        self.logit_autocast = nullcontext

        # copy the module without ddp
        self._without_ddp = [self._image_encoder,
                             self._text_encoder, self._logit_scale]

        self.used_ddp = False

    def set_autocast(self, image_autocast, text_autocast, logit_autocast):
        self.image_autocast = image_autocast
        self.text_autocast = text_autocast
        self.logit_autocast = logit_autocast

    @property
    def image_encoder_without_ddp(self):
        return self._without_ddp[0]

    @image_encoder_without_ddp.setter
    def image_encoder_without_ddp(self, encoder):
        assert self.used_ddp is False
        self._image_encoder = encoder
        self._without_ddp[0] = self._image_encoder

    @property
    def text_encoder_without_ddp(self):
        return self._without_ddp[1]

    @text_encoder_without_ddp.setter
    def text_encoder_without_ddp(self, encoder):
        assert self.used_ddp is False
        self._text_encoder = encoder
        self._without_ddp[1] = self._text_encoder

    @property
    def logit_scale_without_ddp(self):
        return self._without_ddp[2]

    @logit_scale_without_ddp.setter
    def logit_scale_without_ddp(self, logit_scale):
        assert self.used_ddp is False
        self._logit_scale = logit_scale
        self._without_ddp[2] = self._logit_scale

    @property
    def visual(self):
        return self.image_encoder_without_ddp.visual

    @property
    def transformer(self):
        return self.text_encoder_without_ddp.transformer

    @property
    def text_encoder_without_ddp(self):
        return self._without_ddp[1]

    @property
    def logit_scale_without_ddp(self):
        return self._without_ddp[2]

    def get_teacher(self):
        return self.teacher[0]

    def use_teacher_image(self):
        def teacher_image_encoder_fn(image, normalized=False):
            teacher = self.get_teacher()
            with torch.no_grad():
                return teacher.encode_image(image, normalized=normalized)

        self._image_encoder = FNBlock(teacher_image_encoder_fn)

        class EmptyVisual(nn.Module):
            def __init__(self):
                super().__init__()
                self.layers = 0
        self._image_encoder.visual = EmptyVisual()
        self._without_ddp[0] = self._image_encoder

    def use_teacher_text(self):
        def teacher_text_encoder_fn(text, normalized=False):
            teacher = self.get_teacher()
            with torch.no_grad():
                return teacher.encode_text(text, normalized=normalized)
        self._text_encoder = FNBlock(teacher_text_encoder_fn)

        class EmptyTransformer(nn.Module):
            def __init__(self):
                super().__init__()
                self.layers = 0
        self._text_encoder.transformer = EmptyTransformer()
        self._text_encoder.token_embedding = None
        self._without_ddp[1] = self._text_encoder

    def ddpify(self, ddp_fn):
        def _ddp_fn(module):
            cnt = sum([p.numel()
                      for p in module.parameters() if p.requires_grad])
            if cnt > 0:
                return ddp_fn(module)
            return FakeDDP(module)
        self._image_encoder = _ddp_fn(self.image_encoder_without_ddp)
        self._text_encoder = _ddp_fn(self.text_encoder_without_ddp)
        self._logit_scale = _ddp_fn(self.logit_scale_without_ddp)

        self.used_ddp = True

    def forward(self, image, text, normalized=True):
        image_features = text_features = None
        if image is not None:
            with self.image_autocast():
                image_features = self._image_encoder(
                    image, normalized=normalized)
        if text is not None:
            with self.text_autocast():
                text_features = self._text_encoder(text, normalized=normalized)
        with self.logit_autocast():
            logit_scale = self._logit_scale(torch.tensor(0))
        return image_features, text_features, logit_scale.exp()

    def encode_image(self, image, normalized=False):
        with self.image_autocast():
            return self._image_encoder(image, normalized=normalized)

    def encode_text(self, text, normalized=False):
        with self.text_autocast():
            return self._text_encoder(text, normalized=normalized)

    @property
    def logit_scale(self):
        return self.logit_scale_without_ddp.logit_scale

    def lock_image_tower(self, unlocked_groups=0, freeze_bn_stats=False):
        assert unlocked_groups == 0, 'partial locking not currently supported for this model'
        tower = self.image_encoder_without_ddp
        for param in tower.parameters():
            param.requires_grad = False
        if freeze_bn_stats:
            freeze_batch_norm_2d(tower)

    def lock_text_tower(self, unlocked_groups=0, freeze_bn_stats=False):
        assert unlocked_groups == 0, 'partial locking not currently supported for this model'
        tower = self.text_encoder_without_ddp
        for param in tower.parameters():
            param.requires_grad = False
        if freeze_bn_stats:
            freeze_batch_norm_2d(tower)

    @torch.jit.ignore
    def set_grad_checkpointing(self, enable=True):
        visual = self.image_encoder_without_ddp.visual
        transformer = self.text_encoder_without_ddp.transformer
        if hasattr(visual, 'set_grad_checkpointing'):
            visual.set_grad_checkpointing(enable)
        if transformer is not None and hasattr(transformer, 'set_grad_checkpointing'):
            transformer.set_grad_checkpointing(enable)

    def image_named_params(self):
        return self._image_encoder.named_parameters()

    def text_named_params(self):
        return self._text_encoder.named_parameters()

    def joint_named_params(self):
        return self._logit_scale.named_parameters()

    def load_state_dict(self, state_dict, strict=True):
        state_dict = convert_to_new_checkpoint(state_dict, self.used_ddp)
        if not any(k.startswith('_image_encoder') for k in state_dict.keys()):
            self.use_teacher_image()

        for m in ['module.', '']:
            flag = f'_image_encoder.{m}visual.model.head.0.weight'
            if flag in state_dict:
                # LN
                state_dict[f'_image_encoder.{m}visual.ln_post.weight'] = state_dict.pop(
                    f'_image_encoder.{m}visual.model.head.0.weight')
                state_dict[f'_image_encoder.{m}visual.ln_post.bias'] = state_dict.pop(
                    f'_image_encoder.{m}visual.model.head.0.bias')
                # FC
                state_dict[f'_image_encoder.{m}visual.proj'] = state_dict.pop(
                    f'_image_encoder.{m}visual.model.head.1.weight').T
        new_state_dict = state_dict.copy()
        for k, v in new_state_dict.items():
            if '.module' in k:
                state_dict[k.replace('.module', '')] = v
                state_dict.pop(k)
        super().load_state_dict(state_dict, strict=strict)


class CLIP(CLIPBase):
    def __init__(
            self,
            embed_dim: int,
            vision_cfg: CLIPVisionCfg,
            text_cfg: CLIPTextCfg,
            quick_gelu: bool = False,
            mask_image: bool = False,
            mask_text: bool = False,
            sparsity_warmup: int = 1000,
            sparsity: float = 0.25,
            start_sparsity: float = 0.0,
    ):

        vision_ocfg = None
        text_ocfg = None

        if isinstance(vision_cfg, dict):
            vision_ocfg = vision_cfg.pop('configs', None)
            vision_cfg = CLIPVisionCfg(**vision_cfg)

        if isinstance(text_cfg, dict):
            text_ocfg = text_cfg.pop('configs', None)
            text_cfg = CLIPTextCfg(**text_cfg)

        mask_cfg = Namespace()
        mask_cfg.sparsity_warmup = sparsity_warmup
        mask_cfg.sparsity = sparsity
        mask_cfg.start_sparsity = start_sparsity

        if vision_ocfg is None:
            image_encoder = ImageEncoder(embed_dim, vision_cfg, quick_gelu,
                                         l0_module_image=mask_image,
                                         mask_cfg=mask_cfg)

        if text_ocfg is None:
            text_encoder = TextEncoder(embed_dim, text_cfg, quick_gelu,
                                       l0_module_text=mask_text, mask_cfg=mask_cfg)

        super().__init__(image_encoder, text_encoder)


def convert_to_new_checkpoint(state_dict, used_ddp=False):
    if '_logit_scale.module.logit_scale' in state_dict:
        if not used_ddp:
            new_checkpoint = dict()
            for k, v in state_dict.items():
                sp = k.split('.')
                assert sp[1] == 'module', (sp, state_dict.keys())
                k = '.'.join(sp[:1] + sp[2:])
                new_checkpoint[k] = v
            state_dict = new_checkpoint
        return state_dict
    if '_logit_scale.logit_scale' in state_dict:
        if used_ddp:
            new_checkpoint = dict()
            for k, v in state_dict.items():
                sp = k.split('.')
                k = '.'.join(sp[:1] + ['module'] + sp[1:])
                new_checkpoint[k] = v
            state_dict = new_checkpoint
        return state_dict
    image_prefix = '_image_encoder.'
    text_prefix = '_text_encoder.'
    logit_scale_prefix = '_logit_scale.'
    if used_ddp:
        image_prefix += 'module.'
        text_prefix += 'module.'
        logit_scale_prefix += 'module.'
    new_checkpoint = dict()
    if 'module.logit_scale' in state_dict:
        # remove the prefix module
        state_dict = {k[len('module.'):]: v for k, v in state_dict.items()}
    if 'logit_scale' in state_dict:
        # old CLIP checkpoint
        for k, v in state_dict.items():
            if k.startswith('visual.'):
                new_checkpoint[image_prefix + k] = v
            elif k == 'logit_scale':
                new_checkpoint[logit_scale_prefix + 'logit_scale'] = v
            else:
                new_checkpoint[text_prefix + k] = v
    else:
        new_checkpoint = state_dict
    return new_checkpoint


def convert_weights_to_fp16(model: nn.Module):
    """Convert applicable model parameters to fp16"""

    def _convert_weights_to_fp16(l):
        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
            l.weight.data = l.weight.data.half()
            if l.bias is not None:
                l.bias.data = l.bias.data.half()

        if isinstance(l, (nn.MultiheadAttention, )):
            for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
                tensor = getattr(l, attr)
                if tensor is not None:
                    tensor.data = tensor.data.half()

        for name in ["text_projection", "proj"]:
            if hasattr(l, name):
                attr = getattr(l, name)
                if attr is not None:
                    attr.data = attr.data.half()

    model.apply(_convert_weights_to_fp16)


def build_model_from_openai_state_dict(state_dict: dict):
    vit = "visual.proj" in state_dict

    if vit:
        vision_width = state_dict["visual.conv1.weight"].shape[0]
        vision_layers = len(
            [k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
        vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
        grid_size = round(
            (state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
        image_size = vision_patch_size * grid_size
    else:
        counts: list = [
            len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
        vision_layers = tuple(counts)
        vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
        output_width = round(
            (state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
        vision_patch_size = None
        assert output_width ** 2 + \
            1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
        image_size = output_width * 32

    embed_dim = state_dict["text_projection"].shape[1]
    context_length = state_dict["positional_embedding"].shape[0]
    vocab_size = state_dict["token_embedding.weight"].shape[0]
    transformer_width = state_dict["ln_final.weight"].shape[0]
    transformer_heads = transformer_width // 64
    transformer_layers = len(set(
        k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks")))

    vision_cfg = CLIPVisionCfg(
        layers=vision_layers,
        width=vision_width,
        patch_size=vision_patch_size,
        image_size=image_size,
    )
    text_cfg = CLIPTextCfg(
        context_length=context_length,
        vocab_size=vocab_size,
        width=transformer_width,
        heads=transformer_heads,
        layers=transformer_layers
    )
    model = CLIP(
        embed_dim,
        vision_cfg=vision_cfg,
        text_cfg=text_cfg,
        quick_gelu=True,  # OpenAI models were trained with QuickGELU
    )

    for key in ["input_resolution", "context_length", "vocab_size"]:
        state_dict.pop(key, None)

    convert_weights_to_fp16(model)
    model.load_state_dict(state_dict)
    return model.eval()


def trace_model(model, batch_size=256, device=torch.device('cpu')):
    model.eval()
    image_size = model.visual.image_size
    example_images = torch.ones(
        (batch_size, 3, image_size, image_size), device=device)
    example_text = torch.zeros(
        (batch_size, model.context_length), dtype=torch.int, device=device)
    model = torch.jit.trace_module(
        model,
        inputs=dict(
            forward=(example_images, example_text),
            encode_text=(example_text,),
            encode_image=(example_images,)
        ))
    model.visual.image_size = image_size
    return model


def resize_pos_embed(state_dict, model, interpolation: str = 'bicubic', seq_dim=1):
    # Rescale the grid of position embeddings when loading from state_dict
    old_pos_embed = state_dict.get('visual.positional_embedding', None)
    if old_pos_embed is None or not hasattr(model.visual, 'grid_size'):
        return
    grid_size = to_2tuple(model.visual.grid_size)
    # FIXME detect different token configs (ie no class token, or more)
    extra_tokens = 1
    new_seq_len = grid_size[0] * grid_size[1] + extra_tokens
    if new_seq_len == old_pos_embed.shape[0]:
        return

    if extra_tokens:
        pos_emb_tok, pos_emb_img = old_pos_embed[:
                                                 extra_tokens], old_pos_embed[extra_tokens:]
    else:
        pos_emb_tok, pos_emb_img = None, old_pos_embed
    old_grid_size = to_2tuple(int(math.sqrt(len(pos_emb_img))))

    logging.info('Resizing position embedding grid-size from %s to %s',
                 old_grid_size, grid_size)
    pos_emb_img = pos_emb_img.reshape(
        1, old_grid_size[0], old_grid_size[1], -1).permute(0, 3, 1, 2)
    pos_emb_img = F.interpolate(
        pos_emb_img,
        size=grid_size,
        mode=interpolation,
        align_corners=True,
    )
    pos_emb_img = pos_emb_img.permute(0, 2, 3, 1).reshape(
        1, grid_size[0] * grid_size[1], -1)[0]
    if pos_emb_tok is not None:
        new_pos_embed = torch.cat([pos_emb_tok, pos_emb_img], dim=0)
    else:
        new_pos_embed = pos_emb_img
    state_dict['visual.positional_embedding'] = new_pos_embed


@torch.no_grad()
def load_pruned_model(model, pruned_state_dict, strict=True):
    '''
    A full model loads the pruned state dict.

    Inputs:
        model_state_dict: the full model weights
        pruned_state_dict: the pruned model weights
    '''
    def _copy_to_full_weight(dst, src):
        assert dst.ndim == src.ndim, (dst.ndim, src.ndim)
        dst.zero_()
        dims = src.shape
        if len(dims) == 0:
            dst.copy_(src)
        else:
            slices = [slice(0, d) for d in dims]
            dst[slices].copy_(src)

    for _ in range(2):
        pruned_state_dict = {
            k.replace('module.', ''): v for k, v in pruned_state_dict.items()}

    lambda_init_value = 10.0
    model_state_dict = model.state_dict()
    head_dim = model.transformer.head_dim

    pruned_state_dict = {k.replace('image_encoder_without_ddp', '_image_encoder').
                         replace('text_encoder_without_ddp', '_text_encoder'): v for k, v in pruned_state_dict.items()}

    for name, dst in model_state_dict.items():
        # auto weight inheritance model weight prefix
        dst_shape = dst.shape

        # copy weights
        if name in pruned_state_dict:
            src = pruned_state_dict[name]
            if 'attn.in_proj_weight' in name:
                # reshape: (3 * num_heads * head_dim, embed_dim) -> (3, num_heads, head_dim, embed_dim)
                assert len(src.shape) == 2
                _copy_to_full_weight(dst.view(3, -1, head_dim, dst_shape[-1]),
                                     src.view(3, -1, head_dim, src.shape[-1]))
            elif 'attn.in_proj_bias' in name:
                # reshape: (3 * num_heads * head_dim,) -> (3, num_heads, head_dim)
                assert len(src.shape) == 1
                _copy_to_full_weight(dst.view(3, -1, head_dim),
                                     src.view(3, -1, head_dim))
            else:
                _copy_to_full_weight(dst, src)
        else:
            if '.resblocks.' in name:
                # the layer has been pruned.
                dst.zero_()

    model_state_dict['_logit_scale.logit_scale'] = pruned_state_dict['_logit_scale.logit_scale']

    # prune hidden dimensions
    encoder_names = ['_image_encoder', '_text_encoder']
    hidden_size_img = pruned_state_dict['_image_encoder.visual.ln_pre.weight'].shape[0]
    hidden_size_txt = pruned_state_dict['_text_encoder.positional_embedding'].shape[1]
    hidden_sizes = [hidden_size_img, hidden_size_txt]

    for ename, hidden_size in zip(encoder_names, hidden_sizes):
        # reset lambda in l0 module
        model_state_dict[f'{ename}.l0_module.lambda_1'].fill_(
            lambda_init_value)
        model_state_dict[f'{ename}.l0_module.lambda_2'].fill_(
            lambda_init_value)
        # prune the last dimensions
        model_state_dict[f'{ename}.l0_module.hidden_loga'][hidden_size:].fill_(
            -lambda_init_value)

    def _get_layer_id(name):
        return int(name.split('resblocks.')[1].split('.')[0])

    for ename in encoder_names:
        # get the depth of the encoder
        encoder_keys = list(k for k in model_state_dict.keys() if ename in k)
        encoder_depth = max(_get_layer_id(k)
                            for k in encoder_keys if 'resblocks' in k) + 1
        pruned_encoder_keys = list(
            k for k in pruned_state_dict.keys() if ename in k)
        in_proj_weight_shapes = [None for _ in range(encoder_depth)]
        mlp_c_fc_shapes = [None for _ in range(encoder_depth)]
        for k in pruned_encoder_keys:
            if 'in_proj_weight' in k:
                d = _get_layer_id(k)
                in_proj_weight_shapes[d] = pruned_state_dict[k].shape
            elif 'mlp.c_fc.weight' in k:
                d = _get_layer_id(k)
                mlp_c_fc_shapes[d] = pruned_state_dict[k].shape

        for d in range(encoder_depth):
            # set heads_loga
            if in_proj_weight_shapes[d] is not None:
                num_heads = in_proj_weight_shapes[d][0] // head_dim // 3
                model_state_dict[f'{ename}.l0_module.heads_loga'][d,
                                                                  num_heads:].fill_(-lambda_init_value)
            else:
                # all heads have been pruned
                model_state_dict[f'{ename}.l0_module.heads_loga'][d,
                                                                  :].fill_(-lambda_init_value)

            # set intermediate_loga
            if mlp_c_fc_shapes[d] is not None:
                inter_size = mlp_c_fc_shapes[d][0]
                model_state_dict[f'{ename}.l0_module.intermediate_loga'][d,
                                                                         inter_size:].fill_(-lambda_init_value)
            else:
                # all intermediate dimensions have been pruned
                model_state_dict[f'{ename}.l0_module.intermediate_loga'][d,
                                                                         :].fill_(-lambda_init_value)

    return model.load_state_dict(model_state_dict, strict=strict)


def prune_model(model):
    device = next(model.parameters()).device

    with torch.no_grad():
        model.image_encoder_without_ddp.eval()
        image_size = (1, 3) + model.image_encoder_without_ddp.visual.image_size
        image = torch.randn(image_size, device=device)
        model.image_encoder_without_ddp(image)
        model.image_encoder_without_ddp = model.image_encoder_without_ddp.prune()

    assert hasattr(model.image_encoder_without_ddp, 'l0_module')
    model.image_encoder_without_ddp.l0_module = None

    with torch.no_grad():
        model.text_encoder_without_ddp.eval()
        context_length = model.text_encoder_without_ddp.context_length
        text = torch.zeros((1, context_length), dtype=torch.long, device=device)
        model.text_encoder_without_ddp(text)
        model.text_encoder_without_ddp = model.text_encoder_without_ddp.prune()

    assert hasattr(model.text_encoder_without_ddp, 'l0_module')
    model.text_encoder_without_ddp.l0_module = None

    return model