


'''simple docstring'''

import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase							:   str  						=	logging.get_logger(__name__)

def _SCREAMING_SNAKE_CASE      (A  , A=False       )       ->       Optional[Any]:






       """simple docstring"""







       lowercase__      			= []

       # fmt: off
       # stem:
       rename_keys.append(('''cls_token''', '''vit.embeddings.cls_token''')       )
       rename_keys.append(('''pos_embed''', '''vit.embeddings.position_embeddings''')       )

       rename_keys.append(('''patch_embed.proj.weight''', '''vit.embeddings.patch_embeddings.projection.weight''')       )
       rename_keys.append(('''patch_embed.proj.bias''', '''vit.embeddings.patch_embeddings.projection.bias''')       )

       # backbone
       rename_keys.append(('''patch_embed.backbone.stem.conv.weight''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight''')       )
       rename_keys.append(('''patch_embed.backbone.stem.norm.weight''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight''')       )
       rename_keys.append(('''patch_embed.backbone.stem.norm.bias''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias''')       )

       for stage_idx in range(len(config.backbone_config.depths       )       ):
              for layer_idx in range(config.backbone_config.depths[stage_idx]       ):
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight")       )
                     rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias")       )

              rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight")       )
              rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight")       )
              rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias")       )

       # transformer encoder
       for i in range(config.num_hidden_layers       ):
              # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
              rename_keys.append((f"blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight")       )
              rename_keys.append((f"blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias")       )
              rename_keys.append((f"blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight")       )
              rename_keys.append((f"blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias")       )
              rename_keys.append((f"blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight")       )
              rename_keys.append((f"blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias")       )
              rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight")       )
              rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias")       )
              rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight")       )
              rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias")       )

       if base_model:
              # layernorm + pooler
              rename_keys.extend(
                  [
                      ('''norm.weight''', '''layernorm.weight'''),
                      ('''norm.bias''', '''layernorm.bias'''),
                      ('''pre_logits.fc.weight''', '''pooler.dense.weight'''),
                      ('''pre_logits.fc.bias''', '''pooler.dense.bias'''),
                  ]       )

              # if just the base model, we should remove "vit" from all keys that start with "vit"
              lowercase__      			= [(pair[0], pair[1][4:]) if pair[1].startswith('''vit'''       ) else pair for pair in rename_keys]
       else:
              # layernorm + classification head
              rename_keys.extend(
                  [
                      ('''norm.weight''', '''vit.layernorm.weight'''),
                      ('''norm.bias''', '''vit.layernorm.bias'''),
                      ('''head.weight''', '''classifier.weight'''),
                      ('''head.bias''', '''classifier.bias'''),
                  ]       )
       # fmt: on

       return rename_keys

def _SCREAMING_SNAKE_CASE      (A  , A  , A=False       )       ->       Tuple:






       """simple docstring"""







       for i in range(config.num_hidden_layers       ):
              if base_model:
                     lowercase__      			= ''''''
              else:
                     lowercase__      			= '''vit.'''
              # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
              lowercase__      			= state_dict.pop(f"blocks.{i}.attn.qkv.weight"       )
              lowercase__      			= state_dict.pop(f"blocks.{i}.attn.qkv.bias"       )
              # next, add query, keys and values (in that order) to the state dict
              lowercase__      			= in_proj_weight[
                  : config.hidden_size, :
              ]
              lowercase__      			= in_proj_bias[: config.hidden_size]
              lowercase__      			= in_proj_weight[
                  config.hidden_size : config.hidden_size * 2, :
              ]
              lowercase__      			= in_proj_bias[
                  config.hidden_size : config.hidden_size * 2
              ]
              lowercase__      			= in_proj_weight[
                  -config.hidden_size :, :
              ]
              lowercase__      			= in_proj_bias[-config.hidden_size :]

def _SCREAMING_SNAKE_CASE      (A       )       ->       List[Any]:






       """simple docstring"""







       lowercase__      			= ['''head.weight''', '''head.bias''']
       for k in ignore_keys:
              state_dict.pop(A  , A       )

def _SCREAMING_SNAKE_CASE      (A  , A  , A       )       ->       Optional[Any]:






       """simple docstring"""







       lowercase__      			= dct.pop(A       )
       lowercase__      			= val

def _SCREAMING_SNAKE_CASE      ()       ->       Optional[Any]:






       """simple docstring"""







       lowercase__      			= '''http://images.cocodataset.org/val2017/000000039769.jpg'''
       lowercase__      			= Image.open(requests.get(A  , stream=A       ).raw       )
       return im

@torch.no_grad()
def _SCREAMING_SNAKE_CASE      (A  , A  , A=False       )       ->       Dict:






       """simple docstring"""







       lowercase__      			= BitConfig(
           global_padding='''same'''  , layer_type='''bottleneck'''  , depths=(3, 4, 9)  , out_features=['''stage3''']  , embedding_dynamic_padding=A  , )
       lowercase__      			= ViTHybridConfig(backbone_config=A  , image_size=384  , num_labels=1_000       )
       lowercase__      			= False

       # load original model from timm
       lowercase__      			= timm.create_model(A  , pretrained=A       )
       timm_model.eval()

       # load state_dict of original model, remove and rename some keys
       lowercase__      			= timm_model.state_dict()
       if base_model:
              remove_classification_head_(A       )
       lowercase__      			= create_rename_keys(A  , A       )
       for src, dest in rename_keys:
              rename_key(A  , A  , A       )
       read_in_q_k_v(A  , A  , A       )

       lowercase__      			= '''huggingface/label-files'''
       lowercase__      			= '''imagenet-1k-id2label.json'''
       lowercase__      			= json.load(open(hf_hub_download(A  , A  , repo_type='''dataset'''       )  , '''r'''       )       )
       lowercase__      			= {int(A       ): v for k, v in idalabel.items()}
       lowercase__      			= idalabel
       lowercase__      			= {v: k for k, v in idalabel.items()}

       # load HuggingFace model
       if vit_name[-5:] == "in21k":
              lowercase__      			= ViTHybridModel(A       ).eval()
       else:
              lowercase__      			= ViTHybridForImageClassification(A       ).eval()
       model.load_state_dict(A       )

       # create image processor
       lowercase__      			= create_transform(**resolve_data_config({}  , model=A       )       )
       lowercase__      			= transform.transforms

       lowercase__      			= {
           '''bilinear''': PILImageResampling.BILINEAR,
           '''bicubic''': PILImageResampling.BICUBIC,
           '''nearest''': PILImageResampling.NEAREST,
       }

       lowercase__      			= ViTHybridImageProcessor(
           do_resize=A  , size={'''shortest_edge''': timm_transforms[0].size}  , resample=pillow_resamplings[timm_transforms[0].interpolation.value]  , do_center_crop=A  , crop_size={'''height''': timm_transforms[1].size[0], '''width''': timm_transforms[1].size[1]}  , do_normalize=A  , image_mean=timm_transforms[-1].mean.tolist()  , image_std=timm_transforms[-1].std.tolist()  , )

       lowercase__      			= prepare_img()
       lowercase__      			= transform(A       ).unsqueeze(0       )
       lowercase__      			= processor(A  , return_tensors='''pt'''       ).pixel_values

       # verify pixel values
       assert torch.allclose(A  , A       )

       # verify logits
       with torch.no_grad():
              lowercase__      			= model(A       )
              lowercase__      			= outputs.logits

       print('''Predicted class:'''  , logits.argmax(-1       ).item()       )
       if base_model:
              lowercase__      			= timm_model.forward_features(A       )
              assert timm_pooled_output.shape == outputs.pooler_output.shape
              assert torch.allclose(A  , outputs.pooler_output  , atol=1E-3       )
       else:
              lowercase__      			= timm_model(A       )
              assert timm_logits.shape == outputs.logits.shape
              assert torch.allclose(A  , outputs.logits  , atol=1E-3       )
       print('''Looks ok!'''       )

       if pytorch_dump_folder_path is not None:
              Path(A       ).mkdir(exist_ok=A       )
              print(f"Saving model {vit_name} to {pytorch_dump_folder_path}"       )
              model.save_pretrained(A       )
              print(f"Saving processor to {pytorch_dump_folder_path}"       )
              processor.save_pretrained(A       )

       if push_to_hub:
              print(f"Pushing model and processor to the hub {vit_name}"       )
              model.push_to_hub(f"ybelkada/{vit_name}"       )
              processor.push_to_hub(f"ybelkada/{vit_name}"       )


if __name__ == "__main__":
 lowerCamelCase							:   int  						=	argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--vit_name',
     default='vit_base_r50_s16_384',
     type=str,
     help='Name of the hybrid ViT timm model you\'d like to convert.',
 )
 parser.add_argument(
     '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
 )
 parser.add_argument(
     '--push_to_hub', action='store_true', help='Whether to upload the model to the HuggingFace hub.'
 )

 lowerCamelCase							:   Optional[Any]  						=	parser.parse_args()
 convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)








'''simple docstring'''

from __future__ import annotations

def _SCREAMING_SNAKE_CASE      (A  , A       )       ->       list[list[int]]:






       """simple docstring"""







       lowercase__      			= []
       create_all_state(1  , A  , A  , []  , A       )
       return result

def _SCREAMING_SNAKE_CASE      (A  , A  , A  , A  , A  , )       ->       None:






       """simple docstring"""







       if level == 0:
              total_list.append(current_list[:]       )
              return

       for i in range(A  , total_number - level + 2       ):
              current_list.append(A       )
              create_all_state(i + 1  , A  , level - 1  , A  , A       )
              current_list.pop()

def _SCREAMING_SNAKE_CASE      (A       )       ->       None:






       """simple docstring"""







       for i in total_list:
              print(*A       )


if __name__ == "__main__":
 lowerCamelCase							:   Tuple  						=	4
 lowerCamelCase							:   Union[str, Any]  						=	2
 lowerCamelCase							:   Dict  						=	generate_all_combinations(n, k)
 print_all_state(total_list)




