


'''simple docstring'''



import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   str   ):
					__a			:       List[Any]					    =  VideoMAEConfig()

					set_architecture_configs(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )

					if "finetuned" not in model_name:
										__a			:       List[Any]					    =  False

					if "finetuned" in model_name:
										__a			:       Tuple					    =  'huggingface/label-files'
										if "kinetics" in model_name:
															__a			:       List[str]					    =  400
															__a			:       Optional[int]					    =  'kinetics400-id2label.json'
										elif "ssv2" in model_name:
															__a			:       Tuple					    =  174
															__a			:       Optional[int]					    =  'something-something-v2-id2label.json'
										else:
															raise ValueError('Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned.'   )
										__a			:       List[str]					    =  json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      repo_type='dataset'   )						,      'r'   )   )
										__a			:       List[Any]					    =  {int(_SCREAMING_SNAKE_CASE   ): v for k, v in idalabel.items()}
										__a			:       List[str]					    =  idalabel
										__a			:       Optional[Any]					    =  {v: k for k, v in idalabel.items()}

					return config






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[str]						,      _SCREAMING_SNAKE_CASE      :   List[Any]   ):
					if "small" in model_name:
										__a			:       Any					    =  384
										__a			:       List[str]					    =  1_536
										__a			:       Optional[Any]					    =  12
										__a			:       List[Any]					    =  16
										__a			:       Optional[int]					    =  12
										__a			:       List[Any]					    =  3
										__a			:       int					    =  192
										__a			:       Dict					    =  768
					elif "large" in model_name:
										__a			:       Optional[Any]					    =  1_024
										__a			:       List[Any]					    =  4_096
										__a			:       List[Any]					    =  24
										__a			:       Any					    =  16
										__a			:       Dict					    =  12
										__a			:       List[Any]					    =  8
										__a			:       Optional[int]					    =  512
										__a			:       int					    =  2_048
					elif "huge" in model_name:
										__a			:       Union[str, Any]					    =  1_280
										__a			:       Optional[int]					    =  5_120
										__a			:       Tuple					    =  32
										__a			:       Union[str, Any]					    =  16
										__a			:       Any					    =  12
										__a			:       str					    =  8
										__a			:       List[str]					    =  640
										__a			:       Dict					    =  2_560
					elif "base" not in model_name:
										raise ValueError('Model name should include either "small", "base", "large", or "huge"'   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict   ):
					if "encoder." in name:
										__a			:       List[Any]					    =  name.replace('encoder.'						,      ''   )
					if "cls_token" in name:
										__a			:       str					    =  name.replace('cls_token'						,      'videomae.embeddings.cls_token'   )
					if "decoder_pos_embed" in name:
										__a			:       Optional[int]					    =  name.replace('decoder_pos_embed'						,      'decoder.decoder_pos_embed'   )
					if "pos_embed" in name and "decoder" not in name:
										__a			:       str					    =  name.replace('pos_embed'						,      'videomae.embeddings.position_embeddings'   )
					if "patch_embed.proj" in name:
										__a			:       Optional[int]					    =  name.replace('patch_embed.proj'						,      'videomae.embeddings.patch_embeddings.projection'   )
					if "patch_embed.norm" in name:
										__a			:       Dict					    =  name.replace('patch_embed.norm'						,      'videomae.embeddings.norm'   )
					if "decoder.blocks" in name:
										__a			:       Tuple					    =  name.replace('decoder.blocks'						,      'decoder.decoder_layers'   )
					if "blocks" in name:
										__a			:       Any					    =  name.replace('blocks'						,      'videomae.encoder.layer'   )
					if "attn.proj" in name:
										__a			:       Optional[int]					    =  name.replace('attn.proj'						,      'attention.output.dense'   )
					if "attn" in name and "bias" not in name:
										__a			:       List[Any]					    =  name.replace('attn'						,      'attention.self'   )
					if "attn" in name:
										__a			:       Optional[Any]					    =  name.replace('attn'						,      'attention.attention'   )
					if "norm1" in name:
										__a			:       Union[str, Any]					    =  name.replace('norm1'						,      'layernorm_before'   )
					if "norm2" in name:
										__a			:       List[Any]					    =  name.replace('norm2'						,      'layernorm_after'   )
					if "mlp.fc1" in name:
										__a			:       List[str]					    =  name.replace('mlp.fc1'						,      'intermediate.dense'   )
					if "mlp.fc2" in name:
										__a			:       Union[str, Any]					    =  name.replace('mlp.fc2'						,      'output.dense'   )
					if "decoder_embed" in name:
										__a			:       str					    =  name.replace('decoder_embed'						,      'decoder.decoder_embed'   )
					if "decoder_norm" in name:
										__a			:       str					    =  name.replace('decoder_norm'						,      'decoder.decoder_norm'   )
					if "decoder_pred" in name:
										__a			:       List[Any]					    =  name.replace('decoder_pred'						,      'decoder.decoder_pred'   )
					if "norm.weight" in name and "decoder" not in name and "fc" not in name:
										__a			:       List[str]					    =  name.replace('norm.weight'						,      'videomae.layernorm.weight'   )
					if "norm.bias" in name and "decoder" not in name and "fc" not in name:
										__a			:       Dict					    =  name.replace('norm.bias'						,      'videomae.layernorm.bias'   )
					if "head" in name and "decoder" not in name:
										__a			:       str					    =  name.replace('head'						,      'classifier'   )

					return name






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Optional[int]						,      _SCREAMING_SNAKE_CASE      :   Any   ):
					for key in orig_state_dict.copy().keys():
										__a			:       List[Any]					    =  orig_state_dict.pop(_SCREAMING_SNAKE_CASE   )

										if key.startswith('encoder.'   ):
															__a			:       str					    =  key.replace('encoder.'						,      ''   )

										if "qkv" in key:
															__a			:       Tuple					    =  key.split('.'   )
															if key.startswith('decoder.blocks'   ):
																				__a			:       Optional[Any]					    =  config.decoder_hidden_size
																				__a			:       Optional[int]					    =  int(key_split[2]   )
																				__a			:       Union[str, Any]					    =  'decoder.decoder_layers.'
																				if "weight" in key:
																									__a			:       List[Any]					    =  val[:dim, :]
																									__a			:       Optional[Any]					    =  val[dim : dim * 2, :]
																									__a			:       Union[str, Any]					    =  val[-dim:, :]
															else:
																				__a			:       Dict					    =  config.hidden_size
																				__a			:       Any					    =  int(key_split[1]   )
																				__a			:       Optional[int]					    =  'videomae.encoder.layer.'
																				if "weight" in key:
																									__a			:       List[Any]					    =  val[:dim, :]
																									__a			:       List[Any]					    =  val[dim : dim * 2, :]
																									__a			:       Any					    =  val[-dim:, :]
										else:
															__a			:       Optional[Any]					    =  val

					return orig_state_dict






def   lowerCamelCase							():
					__a			:       int					    =  hf_hub_download(
					    repo_id='hf-internal-testing/spaghetti-video'						,      filename='eating_spaghetti.npy'						,      repo_type='dataset'   )
					__a			:       Any					    =  np.load(_SCREAMING_SNAKE_CASE   )
					return list(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   str						,      _SCREAMING_SNAKE_CASE      :   List[Any]						,      _SCREAMING_SNAKE_CASE      :   Optional[Any]						,      _SCREAMING_SNAKE_CASE      :   Optional[Any]   ):
					__a			:       int					    =  get_videomae_config(_SCREAMING_SNAKE_CASE   )

					if "finetuned" in model_name:
										__a			:       str					    =  VideoMAEForVideoClassification(_SCREAMING_SNAKE_CASE   )
					else:
										__a			:       List[Any]					    =  VideoMAEForPreTraining(_SCREAMING_SNAKE_CASE   )

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

					model.load_state_dict(_SCREAMING_SNAKE_CASE   )
					model.eval()

					# verify model on basic input
					__a			:       Optional[Any]					    =  VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]						,      image_std=[0.5, 0.5, 0.5]   )
					__a			:       Tuple					    =  prepare_video()
					__a			:       Any					    =  image_processor(_SCREAMING_SNAKE_CASE						,      return_tensors='pt'   )

					if "finetuned" not in model_name:
										__a			:       Any					    =  hf_hub_download(repo_id='hf-internal-testing/bool-masked-pos'						,      filename='bool_masked_pos.pt'   )
										__a			:       Tuple					    =  torch.load(_SCREAMING_SNAKE_CASE   )

					__a			:       str					    =  model(**_SCREAMING_SNAKE_CASE   )
					__a			:       Optional[Any]					    =  outputs.logits

					__a			:       Optional[Any]					    =  [
					    'videomae-small-finetuned-kinetics',
					    'videomae-small-finetuned-ssv2',
					    # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
					    'videomae-base-short',
					    'videomae-base-short-finetuned-kinetics',
					    'videomae-base',
					    'videomae-base-finetuned-kinetics',
					    'videomae-large',
					    'videomae-large-finetuned-kinetics',
					    'videomae-huge-finetuned-kinetics',
					    # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
					    'videomae-base-short-ssv2',
					    'videomae-base-short-finetuned-ssv2',
					    'videomae-base-ssv2',
					    'videomae-base-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 == "videomae-small-finetuned-kinetics":
										__a			:       Any					    =  torch.Size([1, 400]   )
										__a			:       Optional[Any]					    =  torch.tensor([-0.9_2_9_1, -0.4_0_6_1, -0.9_3_0_7]   )
					elif model_name == "videomae-small-finetuned-ssv2":
										__a			:       Optional[int]					    =  torch.Size([1, 174]   )
										__a			:       Optional[Any]					    =  torch.tensor([0.2_6_7_1, -0.4_6_8_9, -0.8_2_3_5]   )
					elif model_name == "videomae-base":
										__a			:       int					    =  torch.Size([1, 1_408, 1_536]   )
										__a			:       Optional[int]					    =  torch.tensor([[0.7_7_3_9, 0.7_9_6_8, 0.7_0_8_9], [0.6_7_0_1, 0.7_4_8_7, 0.6_2_0_9], [0.4_2_8_7, 0.5_1_5_8, 0.4_7_7_3]]   )
					elif model_name == "videomae-base-short":
										__a			:       Tuple					    =  torch.Size([1, 1_408, 1_536]   )
										__a			:       Optional[Any]					    =  torch.tensor([[0.7_9_9_4, 0.9_6_1_2, 0.8_5_0_8], [0.7_4_0_1, 0.8_9_5_8, 0.8_3_0_2], [0.5_8_6_2, 0.7_4_6_8, 0.7_3_2_5]]   )
										# we verified the loss both for normalized and unnormalized targets for this one
										__a			:       str					    =  torch.tensor([0.5_1_4_2]   ) if config.norm_pix_loss else torch.tensor([0.6_4_6_9]   )
					elif model_name == "videomae-large":
										__a			:       Optional[Any]					    =  torch.Size([1, 1_408, 1_536]   )
										__a			:       str					    =  torch.tensor([[0.7_1_4_9, 0.7_9_9_7, 0.6_9_6_6], [0.6_7_6_8, 0.7_8_6_9, 0.6_9_4_8], [0.5_1_3_9, 0.6_2_2_1, 0.5_6_0_5]]   )
					elif model_name == "videomae-large-finetuned-kinetics":
										__a			:       List[str]					    =  torch.Size([1, 400]   )
										__a			:       Optional[int]					    =  torch.tensor([0.0_7_7_1, 0.0_0_1_1, -0.3_6_2_5]   )
					elif model_name == "videomae-huge-finetuned-kinetics":
										__a			:       Optional[Any]					    =  torch.Size([1, 400]   )
										__a			:       List[str]					    =  torch.tensor([0.2_4_3_3, 0.1_6_3_2, -0.4_8_9_4]   )
					elif model_name == "videomae-base-short-finetuned-kinetics":
										__a			:       Optional[int]					    =  torch.Size([1, 400]   )
										__a			:       List[Any]					    =  torch.tensor([0.6_5_8_8, 0.0_9_9_0, -0.2_4_9_3]   )
					elif model_name == "videomae-base-finetuned-kinetics":
										__a			:       str					    =  torch.Size([1, 400]   )
										__a			:       Any					    =  torch.tensor([0.3_6_6_9, -0.0_6_8_8, -0.2_4_2_1]   )
					elif model_name == "videomae-base-short-ssv2":
										__a			:       Any					    =  torch.Size([1, 1_408, 1_536]   )
										__a			:       int					    =  torch.tensor([[0.4_7_1_2, 0.5_2_9_6, 0.5_7_8_6], [0.2_2_7_8, 0.2_7_2_9, 0.4_0_2_6], [0.0_3_5_2, 0.0_7_3_0, 0.2_5_0_6]]   )
					elif model_name == "videomae-base-short-finetuned-ssv2":
										__a			:       str					    =  torch.Size([1, 174]   )
										__a			:       Any					    =  torch.tensor([-0.0_5_3_7, -0.1_5_3_9, -0.3_2_6_6]   )
					elif model_name == "videomae-base-ssv2":
										__a			:       int					    =  torch.Size([1, 1_408, 1_536]   )
										__a			:       int					    =  torch.tensor([[0.8_1_3_1, 0.8_7_2_7, 0.8_5_4_6], [0.7_3_6_6, 0.9_3_7_7, 0.8_8_7_0], [0.5_9_3_5, 0.8_8_7_4, 0.8_5_6_4]]   )
					elif model_name == "videomae-base-finetuned-ssv2":
										__a			:       str					    =  torch.Size([1, 174]   )
										__a			:       Tuple					    =  torch.tensor([0.1_9_6_1, -0.8_3_3_7, -0.6_3_8_9]   )
					else:
										raise ValueError(F"""Model name not supported. Should be one of {model_names}"""   )

					# verify logits
					assert logits.shape == expected_shape
					if "finetuned" in model_name:
										assert torch.allclose(logits[0, :3]						,      _SCREAMING_SNAKE_CASE						,      atol=1e-4   )
					else:
										print('Logits:'						,      logits[0, :3, :3]   )
										assert torch.allclose(logits[0, :3, :3]						,      _SCREAMING_SNAKE_CASE						,      atol=1e-4   )
					print('Logits ok!'   )

					# verify loss, if applicable
					if model_name == "videomae-base-short":
										__a			:       Tuple					    =  outputs.loss
										assert torch.allclose(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      atol=1e-4   )
										print('Loss 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(_SCREAMING_SNAKE_CASE   )
										model.save_pretrained(_SCREAMING_SNAKE_CASE   )

					if push_to_hub:
										print('Pushing to the hub...'   )
										model.push_to_hub(_SCREAMING_SNAKE_CASE						,      organization='nielsr'   )


if __name__ == "__main__":
	__lowercase	:						int       =	argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--checkpoint_url',
	    default='https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4',
	    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='/Users/nielsrogge/Documents/VideoMAE/Test',
	    type=str,
	    help='Path to the output PyTorch model directory.',
	)
	parser.add_argument('--model_name', default='videomae-base', 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.'
	)

	__lowercase	:						Union[str, Any]       =	parser.parse_args()
	convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)







'''simple docstring'''



import requests
from bsa import BeautifulSoup






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   str = "https://www.worldometers.info/coronavirus"   ):
					__a			:       List[Any]					    =  BeautifulSoup(requests.get(_SCREAMING_SNAKE_CASE   ).text						,      'html.parser'   )
					__a			:       Union[str, Any]					    =  soup.findAll('h1'   )
					__a			:       int					    =  soup.findAll('div'						,      {'class': 'maincounter-number'}   )
					keys += soup.findAll('span'						,      {'class': 'panel-title'}   )
					values += soup.findAll('div'						,      {'class': 'number-table-main'}   )
					return {key.text.strip(): value.text.strip() for key, value in zip(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )}


if __name__ == "__main__":
	print('\033[1m' + 'COVID-19 Status of the World' + '\033[0m\n')
	for key, value in world_covidaa_stats().items():
		print(f'''{key}\n{value}\n''')



