



'''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  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:str										=      TimesformerConfig()

		if "large" in model_name:
				SCREAMING_SNAKE_CASE_						:Optional[Any]										=      96

		if "hr" in model_name:
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      16
				SCREAMING_SNAKE_CASE_						:Tuple										=      448

		SCREAMING_SNAKE_CASE_						:Optional[Any]										=      'huggingface/label-files'
		if "k400" in model_name:
				SCREAMING_SNAKE_CASE_						:int										=      400
				SCREAMING_SNAKE_CASE_						:List[str]										=      'kinetics400-id2label.json'
		elif "k600" in model_name:
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      600
				SCREAMING_SNAKE_CASE_						:Tuple										=      'kinetics600-id2label.json'
		elif "ssv2" in model_name:
				SCREAMING_SNAKE_CASE_						:List[Any]										=      174
				SCREAMING_SNAKE_CASE_						:str										=      'something-something-v2-id2label.json'
		else:
				raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'     )
		SCREAMING_SNAKE_CASE_						:str										=      json.load(open(hf_hub_download(_UpperCamelCase ,		_UpperCamelCase ,		repo_type='dataset'     ) ,		'r'     )     )
		SCREAMING_SNAKE_CASE_						:Tuple										=      {int(_UpperCamelCase     ): v for k, v in idalabel.items()}
		SCREAMING_SNAKE_CASE_						:List[Any]										=      idalabel
		SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      {v: k for k, v in idalabel.items()}

		return config







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):







		if "encoder." in name:
				SCREAMING_SNAKE_CASE_						:int										=      name.replace('encoder.' ,		''     )
		if "cls_token" in name:
				SCREAMING_SNAKE_CASE_						:Any										=      name.replace('cls_token' ,		'timesformer.embeddings.cls_token'     )
		if "pos_embed" in name:
				SCREAMING_SNAKE_CASE_						:List[str]										=      name.replace('pos_embed' ,		'timesformer.embeddings.position_embeddings'     )
		if "time_embed" in name:
				SCREAMING_SNAKE_CASE_						:Tuple										=      name.replace('time_embed' ,		'timesformer.embeddings.time_embeddings'     )
		if "patch_embed.proj" in name:
				SCREAMING_SNAKE_CASE_						:Optional[Any]										=      name.replace('patch_embed.proj' ,		'timesformer.embeddings.patch_embeddings.projection'     )
		if "patch_embed.norm" in name:
				SCREAMING_SNAKE_CASE_						:Optional[Any]										=      name.replace('patch_embed.norm' ,		'timesformer.embeddings.norm'     )
		if "blocks" in name:
				SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      name.replace('blocks' ,		'timesformer.encoder.layer'     )
		if "attn.proj" in name:
				SCREAMING_SNAKE_CASE_						:Tuple										=      name.replace('attn.proj' ,		'attention.output.dense'     )
		if "attn" in name and "bias" not in name and "temporal" not in name:
				SCREAMING_SNAKE_CASE_						:List[str]										=      name.replace('attn' ,		'attention.self'     )
		if "attn" in name and "temporal" not in name:
				SCREAMING_SNAKE_CASE_						:str										=      name.replace('attn' ,		'attention.attention'     )
		if "temporal_norm1" in name:
				SCREAMING_SNAKE_CASE_						:Optional[Any]										=      name.replace('temporal_norm1' ,		'temporal_layernorm'     )
		if "temporal_attn.proj" in name:
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      name.replace('temporal_attn' ,		'temporal_attention.output.dense'     )
		if "temporal_fc" in name:
				SCREAMING_SNAKE_CASE_						:Any										=      name.replace('temporal_fc' ,		'temporal_dense'     )
		if "norm1" in name and "temporal" not in name:
				SCREAMING_SNAKE_CASE_						:List[Any]										=      name.replace('norm1' ,		'layernorm_before'     )
		if "norm2" in name:
				SCREAMING_SNAKE_CASE_						:str										=      name.replace('norm2' ,		'layernorm_after'     )
		if "mlp.fc1" in name:
				SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      name.replace('mlp.fc1' ,		'intermediate.dense'     )
		if "mlp.fc2" in name:
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      name.replace('mlp.fc2' ,		'output.dense'     )
		if "norm.weight" in name and "fc" not in name and "temporal" not in name:
				SCREAMING_SNAKE_CASE_						:Tuple										=      name.replace('norm.weight' ,		'timesformer.layernorm.weight'     )
		if "norm.bias" in name and "fc" not in name and "temporal" not in name:
				SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      name.replace('norm.bias' ,		'timesformer.layernorm.bias'     )
		if "head" in name:
				SCREAMING_SNAKE_CASE_						:List[str]										=      name.replace('head' ,		'classifier'     )

		return name







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):







		for key in orig_state_dict.copy().keys():
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      orig_state_dict.pop(_UpperCamelCase     )

				if key.startswith('model.'     ):
						SCREAMING_SNAKE_CASE_						:Optional[Any]										=      key.replace('model.' ,		''     )

				if "qkv" in key:
						SCREAMING_SNAKE_CASE_						:Dict										=      key.split('.'     )
						SCREAMING_SNAKE_CASE_						:Optional[Any]										=      int(key_split[1]     )
						SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      'timesformer.encoder.layer.'
						if "temporal" in key:
								SCREAMING_SNAKE_CASE_						:Any										=      '.temporal_attention.attention.qkv.'
						else:
								SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      '.attention.attention.qkv.'
						if "weight" in key:
								SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      val
						else:
								SCREAMING_SNAKE_CASE_						:str										=      val
				else:
						SCREAMING_SNAKE_CASE_						:Optional[int]										=      val

		return orig_state_dict







def  SCREAMING_SNAKE_CASE__ (				):
		SCREAMING_SNAKE_CASE_						:Dict										=      hf_hub_download(
		    repo_id='hf-internal-testing/spaghetti-video' ,		filename='eating_spaghetti.npy' ,		repo_type='dataset'     )
		SCREAMING_SNAKE_CASE_						:Tuple										=      np.load(_UpperCamelCase     )
		return list(_UpperCamelCase     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:int										=      get_timesformer_config(_UpperCamelCase     )

		SCREAMING_SNAKE_CASE_						:Optional[Any]										=      TimesformerForVideoClassification(_UpperCamelCase     )

		# download original checkpoint, hosted on Google Drive
		SCREAMING_SNAKE_CASE_						:str										=      'pytorch_model.bin'
		gdown.cached_download(_UpperCamelCase ,		_UpperCamelCase ,		quiet=_UpperCamelCase     )
		SCREAMING_SNAKE_CASE_						:str										=      torch.load(_UpperCamelCase ,		map_location='cpu'     )
		if "model" in files:
				SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      files['model']
		elif "module" in files:
				SCREAMING_SNAKE_CASE_						:List[Any]										=      files['module']
		else:
				SCREAMING_SNAKE_CASE_						:List[Any]										=      files['model_state']
		SCREAMING_SNAKE_CASE_						:Optional[int]										=      convert_state_dict(_UpperCamelCase ,		_UpperCamelCase     )

		model.load_state_dict(_UpperCamelCase     )
		model.eval()

		# verify model on basic input
		SCREAMING_SNAKE_CASE_						:Optional[int]										=      VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] ,		image_std=[0.5, 0.5, 0.5]     )
		SCREAMING_SNAKE_CASE_						:Optional[Any]										=      prepare_video()
		SCREAMING_SNAKE_CASE_						:List[Any]										=      image_processor(video[:8] ,		return_tensors='pt'     )

		SCREAMING_SNAKE_CASE_						:Tuple										=      model(**_UpperCamelCase     )
		SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      outputs.logits

		SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      [
		    # 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":
				SCREAMING_SNAKE_CASE_						:Tuple										=      torch.Size([1, 400]     )
				SCREAMING_SNAKE_CASE_						:Any										=      torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5]     )
		elif model_name == "timesformer-base-finetuned-k600":
				SCREAMING_SNAKE_CASE_						:List[str]										=      torch.Size([1, 600]     )
				SCREAMING_SNAKE_CASE_						:int										=      torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]     )
		elif model_name == "timesformer-base-finetuned-ssv2":
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      torch.Size([1, 174]     )
				SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]     )
		elif model_name == "timesformer-large-finetuned-k400":
				SCREAMING_SNAKE_CASE_						:Dict										=      torch.Size([1, 400]     )
				SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.tensor([0, 0, 0]     )
		elif model_name == "timesformer-large-finetuned-k600":
				SCREAMING_SNAKE_CASE_						:List[str]										=      torch.Size([1, 600]     )
				SCREAMING_SNAKE_CASE_						:str										=      torch.tensor([0, 0, 0]     )
		elif model_name == "timesformer-large-finetuned-ssv2":
				SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.Size([1, 174]     )
				SCREAMING_SNAKE_CASE_						:List[str]										=      torch.tensor([0, 0, 0]     )
		elif model_name == "timesformer-hr-finetuned-k400":
				SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.Size([1, 400]     )
				SCREAMING_SNAKE_CASE_						:str										=      torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]     )
		elif model_name == "timesformer-hr-finetuned-k600":
				SCREAMING_SNAKE_CASE_						:Optional[Any]										=      torch.Size([1, 600]     )
				SCREAMING_SNAKE_CASE_						:int										=      torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8]     )
		elif model_name == "timesformer-hr-finetuned-ssv2":
				SCREAMING_SNAKE_CASE_						:Optional[int]										=      torch.Size([1, 174]     )
				SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.tensor([-3.6_7_5_6, -0.7_5_1_3, 0.7_1_8_0]     )
		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__":
							SCREAMING_SNAKE_CASE__     : str				=   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."""
							)

							SCREAMING_SNAKE_CASE__     : Optional[int]				=   parser.parse_args()
							convert_timesformer_checkpoint(
							    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
							)




'''simple docstring'''

from __future__ import annotations



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					list[list[int]]     ,		_UpperCamelCase   :					list[list[int]] )		->       list[int]:





   '''simple docstring'''







   assert len(_UpperCamelCase ) == len(_UpperCamelCase )

   UpperCamelCase__			    =    len(_UpperCamelCase )
   UpperCamelCase__			    =    list(range(_UpperCamelCase ) )
   UpperCamelCase__			    =    [-1] * n  # who the donor has donated to
   UpperCamelCase__			    =    [-1] * n  # who the recipient has received from
   UpperCamelCase__			    =    [0] * n

   while unmatched_donors:
      UpperCamelCase__			    =    unmatched_donors[0]
      UpperCamelCase__			    =    donor_pref[donor]
      UpperCamelCase__			    =    donor_preference[num_donations[donor]]
      num_donations[donor] += 1
      UpperCamelCase__			    =    recipient_pref[recipient]
      UpperCamelCase__			    =    rec_record[recipient]

      if prev_donor != -1:
         if rec_preference.index(_UpperCamelCase ) > rec_preference.index(_UpperCamelCase ):
            UpperCamelCase__			    =    donor
            UpperCamelCase__			    =    recipient
            unmatched_donors.append(_UpperCamelCase )
            unmatched_donors.remove(_UpperCamelCase )
      else:
         UpperCamelCase__			    =    donor
         UpperCamelCase__			    =    recipient
         unmatched_donors.remove(_UpperCamelCase )
   return donor_record