code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  import argparse
  import json
  
  import gdown
  import numpy as np
  import torch
  from huggingface_hub import hf_hub_download
  
  from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_       )      ->Any:
  	snake_case__  					=      TimesformerConfig()
  
  	if "large" in model_name:
  		snake_case__  					=      96
  
  	if "hr" in model_name:
  		snake_case__  					=      16
  		snake_case__  					=      4_48
  
  	snake_case__  					=      'huggingface/label-files'
  	if "k400" in model_name:
  		snake_case__  					=      4_00
  		snake_case__  					=      'kinetics400-id2label.json'
  	elif "k600" in model_name:
  		snake_case__  					=      6_00
  		snake_case__  					=      'kinetics600-id2label.json'
  	elif "ssv2" in model_name:
  		snake_case__  					=      1_74
  		snake_case__  					=      'something-something-v2-id2label.json'
  	else:
  		raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'       )
  	snake_case__  					=      json.load(open(hf_hub_download(UpperCAmelCase_				,							UpperCAmelCase_				,							repo_type='dataset'       )				,							'r'       )       )
  	snake_case__  					=      {int(UpperCAmelCase_       ): v for k, v in idalabel.items()}
  	snake_case__  					=      idalabel
  	snake_case__  					=      {v: k for k, v in idalabel.items()}
  
  	return config
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_       )      ->int:
  	if "encoder." in name:
  		snake_case__  					=      name.replace('encoder.'				,							''       )
  	if "cls_token" in name:
  		snake_case__  					=      name.replace('cls_token'				,							'timesformer.embeddings.cls_token'       )
  	if "pos_embed" in name:
  		snake_case__  					=      name.replace('pos_embed'				,							'timesformer.embeddings.position_embeddings'       )
  	if "time_embed" in name:
  		snake_case__  					=      name.replace('time_embed'				,							'timesformer.embeddings.time_embeddings'       )
  	if "patch_embed.proj" in name:
  		snake_case__  					=      name.replace('patch_embed.proj'				,							'timesformer.embeddings.patch_embeddings.projection'       )
  	if "patch_embed.norm" in name:
  		snake_case__  					=      name.replace('patch_embed.norm'				,							'timesformer.embeddings.norm'       )
  	if "blocks" in name:
  		snake_case__  					=      name.replace('blocks'				,							'timesformer.encoder.layer'       )
  	if "attn.proj" in name:
  		snake_case__  					=      name.replace('attn.proj'				,							'attention.output.dense'       )
  	if "attn" in name and "bias" not in name and "temporal" not in name:
  		snake_case__  					=      name.replace('attn'				,							'attention.self'       )
  	if "attn" in name and "temporal" not in name:
  		snake_case__  					=      name.replace('attn'				,							'attention.attention'       )
  	if "temporal_norm1" in name:
  		snake_case__  					=      name.replace('temporal_norm1'				,							'temporal_layernorm'       )
  	if "temporal_attn.proj" in name:
  		snake_case__  					=      name.replace('temporal_attn'				,							'temporal_attention.output.dense'       )
  	if "temporal_fc" in name:
  		snake_case__  					=      name.replace('temporal_fc'				,							'temporal_dense'       )
  	if "norm1" in name and "temporal" not in name:
  		snake_case__  					=      name.replace('norm1'				,							'layernorm_before'       )
  	if "norm2" in name:
  		snake_case__  					=      name.replace('norm2'				,							'layernorm_after'       )
  	if "mlp.fc1" in name:
  		snake_case__  					=      name.replace('mlp.fc1'				,							'intermediate.dense'       )
  	if "mlp.fc2" in name:
  		snake_case__  					=      name.replace('mlp.fc2'				,							'output.dense'       )
  	if "norm.weight" in name and "fc" not in name and "temporal" not in name:
  		snake_case__  					=      name.replace('norm.weight'				,							'timesformer.layernorm.weight'       )
  	if "norm.bias" in name and "fc" not in name and "temporal" not in name:
  		snake_case__  					=      name.replace('norm.bias'				,							'timesformer.layernorm.bias'       )
  	if "head" in name:
  		snake_case__  					=      name.replace('head'				,							'classifier'       )
  
  	return name
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_       )      ->Tuple:
  	for key in orig_state_dict.copy().keys():
  		snake_case__  					=      orig_state_dict.pop(UpperCAmelCase_       )
  
  		if key.startswith('model.'       ):
  			snake_case__  					=      key.replace('model.'				,							''       )
  
  		if "qkv" in key:
  			snake_case__  					=      key.split('.'       )
  			snake_case__  					=      int(key_split[1]       )
  			snake_case__  					=      'timesformer.encoder.layer.'
  			if "temporal" in key:
  				snake_case__  					=      '.temporal_attention.attention.qkv.'
  			else:
  				snake_case__  					=      '.attention.attention.qkv.'
  			if "weight" in key:
  				snake_case__  					=      val
  			else:
  				snake_case__  					=      val
  		else:
  			snake_case__  					=      val
  
  	return orig_state_dict
  
  
  
  
  def 	__lowerCamelCase (  )      ->List[str]:
  	snake_case__  					=      hf_hub_download(
  	    repo_id='hf-internal-testing/spaghetti-video'				,							filename='eating_spaghetti.npy'				,							repo_type='dataset'       )
  	snake_case__  					=      np.load(UpperCAmelCase_       )
  	return list(UpperCAmelCase_       )
  
  
  
  
  def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_       )      ->Dict:
  	snake_case__  					=      get_timesformer_config(UpperCAmelCase_       )
  
  	snake_case__  					=      TimesformerForVideoClassification(UpperCAmelCase_       )
  
  	# download original checkpoint, hosted on Google Drive
  	snake_case__  					=      'pytorch_model.bin'
  	gdown.cached_download(UpperCAmelCase_				,							UpperCAmelCase_				,							quiet=UpperCAmelCase_       )
  	snake_case__  					=      torch.load(UpperCAmelCase_				,							map_location='cpu'       )
  	if "model" in files:
  		snake_case__  					=      files['model']
  	elif "module" in files:
  		snake_case__  					=      files['module']
  	else:
  		snake_case__  					=      files['model_state']
  	snake_case__  					=      convert_state_dict(UpperCAmelCase_				,							UpperCAmelCase_       )
  
  	model.load_state_dict(UpperCAmelCase_       )
  	model.eval()
  
  	# verify model on basic input
  	snake_case__  					=      VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]				,							image_std=[0.5, 0.5, 0.5]       )
  	snake_case__  					=      prepare_video()
  	snake_case__  					=      image_processor(video[:8]				,							return_tensors='pt'       )
  
  	snake_case__  					=      model(**UpperCAmelCase_       )
  	snake_case__  					=      outputs.logits
  
  	snake_case__  					=      [
  	    # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
  	    'timesformer-base-finetuned-k400',
  	    'timesformer-large-finetuned-k400',
  	    'timesformer-hr-finetuned-k400',
  	    # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
  	    'timesformer-base-finetuned-k600',
  	    'timesformer-large-finetuned-k600',
  	    'timesformer-hr-finetuned-k600',
  	    # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
  	    'timesformer-base-finetuned-ssv2',
  	    'timesformer-large-finetuned-ssv2',
  	    'timesformer-hr-finetuned-ssv2',
  	]
  
  	# NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
  	if model_name == "timesformer-base-finetuned-k400":
  		snake_case__  					=      torch.Size([1, 4_00]       )
  		snake_case__  					=      torch.tensor([-0.3016, -0.7713, -0.4205]       )
  	elif model_name == "timesformer-base-finetuned-k600":
  		snake_case__  					=      torch.Size([1, 6_00]       )
  		snake_case__  					=      torch.tensor([-0.7267, -0.7466, 3.2404]       )
  	elif model_name == "timesformer-base-finetuned-ssv2":
  		snake_case__  					=      torch.Size([1, 1_74]       )
  		snake_case__  					=      torch.tensor([-0.9059, 0.6433, -3.1457]       )
  	elif model_name == "timesformer-large-finetuned-k400":
  		snake_case__  					=      torch.Size([1, 4_00]       )
  		snake_case__  					=      torch.tensor([0, 0, 0]       )
  	elif model_name == "timesformer-large-finetuned-k600":
  		snake_case__  					=      torch.Size([1, 6_00]       )
  		snake_case__  					=      torch.tensor([0, 0, 0]       )
  	elif model_name == "timesformer-large-finetuned-ssv2":
  		snake_case__  					=      torch.Size([1, 1_74]       )
  		snake_case__  					=      torch.tensor([0, 0, 0]       )
  	elif model_name == "timesformer-hr-finetuned-k400":
  		snake_case__  					=      torch.Size([1, 4_00]       )
  		snake_case__  					=      torch.tensor([-0.9617, -3.7311, -3.7708]       )
  	elif model_name == "timesformer-hr-finetuned-k600":
  		snake_case__  					=      torch.Size([1, 6_00]       )
  		snake_case__  					=      torch.tensor([2.5273, 0.7127, 1.8848]       )
  	elif model_name == "timesformer-hr-finetuned-ssv2":
  		snake_case__  					=      torch.Size([1, 1_74]       )
  		snake_case__  					=      torch.tensor([-3.6756, -0.7513, 0.7180]       )
  	else:
  		raise ValueError(f'''Model name not supported. Should be one of {model_names}'''       )
  
  	# verify logits
  	assert logits.shape == expected_shape
  	assert torch.allclose(logits[0, :3]				,							UpperCAmelCase_				,							atol=1E-4       )
  	print('Logits ok!'       )
  
  	if pytorch_dump_folder_path is not None:
  		print(f'''Saving model and image processor to {pytorch_dump_folder_path}'''       )
  		image_processor.save_pretrained(UpperCAmelCase_       )
  		model.save_pretrained(UpperCAmelCase_       )
  
  	if push_to_hub:
  		print('Pushing to the hub...'       )
  		model.push_to_hub(f'''fcakyon/{model_name}'''       )
  
  
  if __name__ == "__main__":
  			a__				: int									=    argparse.ArgumentParser()
  			# Required parameters
  			parser.add_argument(
  			    '''--checkpoint_url''',
  			    default='''https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download''',
  			    type=str,
  			    help=(
  			        '''URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'''
  			        ''' download link.'''
  			    ),
  			)
  			parser.add_argument(
  			    '''--pytorch_dump_folder_path''',
  			    default='''''',
  			    type=str,
  			    help='''Path to the output PyTorch model directory.''',
  			)
  			parser.add_argument('''--model_name''', default='''timesformer-base-finetuned-k400''', type=str, help='''Name of the model.''')
  			parser.add_argument(
  			    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
  			)
  
  			a__				: Union[str, Any]									=    parser.parse_args()
  			convert_timesformer_checkpoint(
  			    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
  			)
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import is_detectrona_available, logging
  
  
  a__				: Optional[Any]									=    logging.get_logger(__name__)
  
  a__				: List[str]									=    {
      '''layoutlmv2-base-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-base-uncased/resolve/main/config.json''',
      '''layoutlmv2-large-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-large-uncased/resolve/main/config.json''',
      # See all LayoutLMv2 models at https://huggingface.co/models?filter=layoutlmv2
  }
  
  # soft dependency
  if is_detectrona_available():
  			import detectrona
  
  
  
  
  
  
  class 							__snake_case    (				__magic_name__       ):
  	__lowerCAmelCase						=     '''layoutlmv2'''
  
  
  
  
  
  	def __init__(		self			,					UpperCamelCase_=3_0522			,					UpperCamelCase_=768			,					UpperCamelCase_=12			,					UpperCamelCase_=12			,					UpperCamelCase_=3072			,					UpperCamelCase_="gelu"			,					UpperCamelCase_=0.1			,					UpperCamelCase_=0.1			,					UpperCamelCase_=512			,					UpperCamelCase_=2			,					UpperCamelCase_=0.0_2			,					UpperCamelCase_=1E-1_2			,					UpperCamelCase_=0			,					UpperCamelCase_=1024			,					UpperCamelCase_=128			,					UpperCamelCase_=32			,					UpperCamelCase_=True			,					UpperCamelCase_=256			,					UpperCamelCase_=64			,					UpperCamelCase_=True			,					UpperCamelCase_=[7, 7, 256]			,					UpperCamelCase_=128			,					UpperCamelCase_=128			,					UpperCamelCase_=True			,					UpperCamelCase_=True			,					UpperCamelCase_=False			,					UpperCamelCase_=None			,					**UpperCamelCase_			,					)			->		Tuple:
  		super().__init__(
  		    vocab_size=UpperCamelCase_			,					hidden_size=UpperCamelCase_			,					num_hidden_layers=UpperCamelCase_			,					num_attention_heads=UpperCamelCase_			,					intermediate_size=UpperCamelCase_			,					hidden_act=UpperCamelCase_			,					hidden_dropout_prob=UpperCamelCase_			,					attention_probs_dropout_prob=UpperCamelCase_			,					max_position_embeddings=UpperCamelCase_			,					type_vocab_size=UpperCamelCase_			,					initializer_range=UpperCamelCase_			,					layer_norm_eps=UpperCamelCase_			,					pad_token_id=UpperCamelCase_			,					**UpperCamelCase_			,					)
  		snake_case__  					=      max_ad_position_embeddings
  		snake_case__  					=      max_rel_pos
  		snake_case__  					=      rel_pos_bins
  		snake_case__  					=      fast_qkv
  		snake_case__  					=      max_rel_ad_pos
  		snake_case__  					=      rel_ad_pos_bins
  		snake_case__  					=      convert_sync_batchnorm
  		snake_case__  					=      image_feature_pool_shape
  		snake_case__  					=      coordinate_size
  		snake_case__  					=      shape_size
  		snake_case__  					=      has_relative_attention_bias
  		snake_case__  					=      has_spatial_attention_bias
  		snake_case__  					=      has_visual_segment_embedding
  		snake_case__  					=      (
  		    detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
  		)
  
  
  
  
  
  	@classmethod
  	def      _snake_case      (		self		)			->		Dict:
  		return {
  		    "MODEL.MASK_ON": True,
  		    "MODEL.PIXEL_STD": [5_7.3_7_5, 5_7.1_2_0, 5_8.3_9_5],
  		    "MODEL.BACKBONE.NAME": "build_resnet_fpn_backbone",
  		    "MODEL.FPN.IN_FEATURES": ["res2", "res3", "res4", "res5"],
  		    "MODEL.ANCHOR_GENERATOR.SIZES": [[32], [64], [128], [256], [512]],
  		    "MODEL.RPN.IN_FEATURES": ["p2", "p3", "p4", "p5", "p6"],
  		    "MODEL.RPN.PRE_NMS_TOPK_TRAIN": 2000,
  		    "MODEL.RPN.PRE_NMS_TOPK_TEST": 1000,
  		    "MODEL.RPN.POST_NMS_TOPK_TRAIN": 1000,
  		    "MODEL.POST_NMS_TOPK_TEST": 1000,
  		    "MODEL.ROI_HEADS.NAME": "StandardROIHeads",
  		    "MODEL.ROI_HEADS.NUM_CLASSES": 5,
  		    "MODEL.ROI_HEADS.IN_FEATURES": ["p2", "p3", "p4", "p5"],
  		    "MODEL.ROI_BOX_HEAD.NAME": "FastRCNNConvFCHead",
  		    "MODEL.ROI_BOX_HEAD.NUM_FC": 2,
  		    "MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION": 14,
  		    "MODEL.ROI_MASK_HEAD.NAME": "MaskRCNNConvUpsampleHead",
  		    "MODEL.ROI_MASK_HEAD.NUM_CONV": 4,
  		    "MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION": 7,
  		    "MODEL.RESNETS.DEPTH": 101,
  		    "MODEL.RESNETS.SIZES": [[32], [64], [128], [256], [512]],
  		    "MODEL.RESNETS.ASPECT_RATIOS": [[0.5, 1.0, 2.0]],
  		    "MODEL.RESNETS.OUT_FEATURES": ["res2", "res3", "res4", "res5"],
  		    "MODEL.RESNETS.NUM_GROUPS": 32,
  		    "MODEL.RESNETS.WIDTH_PER_GROUP": 8,
  		    "MODEL.RESNETS.STRIDE_IN_1X1": False,
  		}
  
  
  
  
  
  	def      _snake_case      (		self		)			->		Optional[Any]:
  		snake_case__  					=      detectrona.config.get_cfg()
  		for k, v in self.detectrona_config_args.items():
  			snake_case__  					=      k.split('.'		)
  			snake_case__  					=      detectrona_config
  			for attribute in attributes[:-1]:
  				snake_case__  					=      getattr(UpperCamelCase_			,					UpperCamelCase_		)
  			setattr(UpperCamelCase_			,					attributes[-1]			,					UpperCamelCase_		)
  
  		return detectrona_config
  
  
  
  