
"""simple docstring"""




import unittest

from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
@require_sentencepiece
@slow  # see https://github.com/huggingface/transformers/issues/11457
class 			__magic_name__       (       UpperCAmelCase__   ,					unittest.TestCase ):
							UpperCamelCase_   =		BarthezTokenizer
							UpperCamelCase_   =		BarthezTokenizerFast
							UpperCamelCase_   =		True
							UpperCamelCase_   =		True
							def 							lowercase_							(     self       )     ->	Tuple:





									"""simple docstring"""




									super().setUp()

									_lowercase:			Tuple       =     BarthezTokenizerFast.from_pretrained('''moussaKam/mbarthez'''       )
									tokenizer.save_pretrained(self.tmpdirname       )
									tokenizer.save_pretrained(self.tmpdirname ,				legacy_format=__lowerCAmelCase       )
									_lowercase:			Union[str, Any]       =     tokenizer
							def 							lowercase_							(     self       )     ->	List[str]:





									"""simple docstring"""




									_lowercase:			str       =     '''<pad>'''
									_lowercase:			Tuple       =     1

									self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCAmelCase       ) ,				__lowerCAmelCase       )
									self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCAmelCase       ) ,				__lowerCAmelCase       )
							def 							lowercase_							(     self       )     ->	List[str]:





									"""simple docstring"""




									_lowercase:			List[Any]       =     list(self.get_tokenizer().get_vocab().keys()       )

									self.assertEqual(vocab_keys[0] ,				'''<s>'''       )
									self.assertEqual(vocab_keys[1] ,				'''<pad>'''       )
									self.assertEqual(vocab_keys[-1] ,				'''<mask>'''       )
									self.assertEqual(len(__lowerCAmelCase       ) ,				10_1122       )
							def 							lowercase_							(     self       )     ->	List[Any]:





									"""simple docstring"""




									self.assertEqual(self.get_tokenizer().vocab_size ,				10_1122       )
							@require_torch
							def 							lowercase_							(     self       )     ->	Optional[int]:





									"""simple docstring"""




									_lowercase:			Optional[Any]       =     ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
									_lowercase:			List[str]       =     [0, 57, 3018, 7_0307, 91, 2]

									_lowercase:			Dict       =     self.tokenizer(
									    __lowerCAmelCase ,				max_length=len(__lowerCAmelCase       ) ,				padding=__lowerCAmelCase ,				truncation=__lowerCAmelCase ,				return_tensors='''pt'''       )
									self.assertIsInstance(__lowerCAmelCase ,				__lowerCAmelCase       )

									self.assertEqual((2, 6) ,				batch.input_ids.shape       )
									self.assertEqual((2, 6) ,				batch.attention_mask.shape       )
									_lowercase:			Union[str, Any]       =     batch.input_ids.tolist()[0]
									self.assertListEqual(__lowerCAmelCase ,				__lowerCAmelCase       )
							def 							lowercase_							(     self       )     ->	Union[str, Any]:





									"""simple docstring"""




									if not self.test_rust_tokenizer:
											return

									_lowercase:			Tuple       =     self.get_tokenizer()
									_lowercase:			Optional[int]       =     self.get_rust_tokenizer()

									_lowercase:			List[str]       =     '''I was born in 92000, and this is falsé.'''

									_lowercase:			Union[str, Any]       =     tokenizer.tokenize(__lowerCAmelCase       )
									_lowercase:			Any       =     rust_tokenizer.tokenize(__lowerCAmelCase       )
									self.assertListEqual(__lowerCAmelCase ,				__lowerCAmelCase       )

									_lowercase:			Any       =     tokenizer.encode(__lowerCAmelCase ,				add_special_tokens=__lowerCAmelCase       )
									_lowercase:			Dict       =     rust_tokenizer.encode(__lowerCAmelCase ,				add_special_tokens=__lowerCAmelCase       )
									self.assertListEqual(__lowerCAmelCase ,				__lowerCAmelCase       )

									_lowercase:			List[str]       =     self.get_rust_tokenizer()
									_lowercase:			str       =     tokenizer.encode(__lowerCAmelCase       )
									_lowercase:			Optional[Any]       =     rust_tokenizer.encode(__lowerCAmelCase       )
									self.assertListEqual(__lowerCAmelCase ,				__lowerCAmelCase       )



							@slow
							def 							lowercase_							(     self       )     ->	Optional[int]:





									"""simple docstring"""




									_lowercase:			str       =     {'''input_ids''': [[0, 490, 1_4328, 4507, 354, 47, 4_3669, 95, 25, 7_8117, 2_0215, 1_9779, 190, 22, 400, 4, 3_5343, 8_0310, 603, 86, 2_4937, 105, 3_3438, 9_4762, 196, 3_9642, 7, 15, 1_5933, 173, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1_0534, 87, 25, 66, 3358, 196, 5_5289, 8, 8_2961, 81, 2204, 7_5203, 7, 15, 763, 1_2956, 216, 178, 1_4328, 9595, 1377, 6_9693, 7, 448, 7_1021, 196, 1_8106, 1437, 1_3974, 108, 9083, 4, 4_9315, 7, 39, 86, 1326, 2793, 4_6333, 4, 448, 196, 7_4588, 7, 4_9315, 7, 39, 21, 822, 3_8470, 74, 21, 6_6723, 6_2480, 8, 2_2050, 5, 2]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
									# fmt: on

									# moussaKam/mbarthez is a french model. So we also use french texts.
									_lowercase:			Tuple       =     [
									    '''Le transformeur est un modèle d\'apprentissage profond introduit en 2017, '''
									    '''utilisé principalement dans le domaine du traitement automatique des langues (TAL).''',
									    '''À l\'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus '''
									    '''pour gérer des données séquentielles, telles que le langage naturel, pour des tâches '''
									    '''telles que la traduction et la synthèse de texte.''',
									]

									self.tokenizer_integration_test_util(
									    expected_encoding=__lowerCAmelCase ,				model_name='''moussaKam/mbarthez''' ,				revision='''c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6''' ,				sequences=__lowerCAmelCase ,				)


"""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		(		_UpperCamelCase						):






  """simple docstring"""



  _lowercase:			List[str]       =     VideoMAEConfig()

  set_architecture_configs(_UpperCamelCase ,				_UpperCamelCase						)

  if "finetuned" not in model_name:
    _lowercase:			Optional[Any]       =     False

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

  return config




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



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




def  _lowerCAmelCase		(		_UpperCamelCase						):






  """simple docstring"""



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

  return name




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  for key in orig_state_dict.copy().keys():
    _lowercase:			Any       =     orig_state_dict.pop(_UpperCamelCase						)

    if key.startswith('''encoder.'''						):
      _lowercase:			Any       =     key.replace('''encoder.''' ,				''''''						)

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

  return orig_state_dict




def  _lowerCAmelCase		(		):






  """simple docstring"""



  _lowercase:			Union[str, Any]       =     hf_hub_download(
      repo_id='''hf-internal-testing/spaghetti-video''' ,				filename='''eating_spaghetti.npy''' ,				repo_type='''dataset'''						)
  _lowercase:			List[Any]       =     np.load(_UpperCamelCase						)
  return list(_UpperCamelCase						)




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase ,				_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  _lowercase:			int       =     get_videomae_config(_UpperCamelCase						)

  if "finetuned" in model_name:
    _lowercase:			Optional[int]       =     VideoMAEForVideoClassification(_UpperCamelCase						)
  else:
    _lowercase:			Union[str, Any]       =     VideoMAEForPreTraining(_UpperCamelCase						)

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

  model.load_state_dict(_UpperCamelCase						)
  model.eval()

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

  if "finetuned" not in model_name:
    _lowercase:			Optional[int]       =     hf_hub_download(repo_id='''hf-internal-testing/bool-masked-pos''' ,				filename='''bool_masked_pos.pt'''						)
    _lowercase:			Union[str, Any]       =     torch.load(_UpperCamelCase						)

  _lowercase:			int       =     model(**_UpperCamelCase						)
  _lowercase:			List[Any]       =     outputs.logits

  _lowercase:			str       =     [
      '''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":
    _lowercase:			Union[str, Any]       =     torch.Size([1, 400]						)
    _lowercase:			Any       =     torch.tensor([-0.9_291, -0.4_061, -0.9_307]						)
  elif model_name == "videomae-small-finetuned-ssv2":
    _lowercase:			Union[str, Any]       =     torch.Size([1, 174]						)
    _lowercase:			Union[str, Any]       =     torch.tensor([0.2_671, -0.4_689, -0.8_235]						)
  elif model_name == "videomae-base":
    _lowercase:			str       =     torch.Size([1, 1_408, 1_536]						)
    _lowercase:			List[str]       =     torch.tensor([[0.7_739, 0.7_968, 0.7_089], [0.6_701, 0.7_487, 0.6_209], [0.4_287, 0.5_158, 0.4_773]]						)
  elif model_name == "videomae-base-short":
    _lowercase:			Tuple       =     torch.Size([1, 1_408, 1_536]						)
    _lowercase:			Optional[int]       =     torch.tensor([[0.7_994, 0.9_612, 0.8_508], [0.7_401, 0.8_958, 0.8_302], [0.5_862, 0.7_468, 0.7_325]]						)
    # we verified the loss both for normalized and unnormalized targets for this one
    _lowercase:			str       =     torch.tensor([0.5_142]						) if config.norm_pix_loss else torch.tensor([0.6_469]						)
  elif model_name == "videomae-large":
    _lowercase:			Tuple       =     torch.Size([1, 1_408, 1_536]						)
    _lowercase:			List[str]       =     torch.tensor([[0.7_149, 0.7_997, 0.6_966], [0.6_768, 0.7_869, 0.6_948], [0.5_139, 0.6_221, 0.5_605]]						)
  elif model_name == "videomae-large-finetuned-kinetics":
    _lowercase:			Dict       =     torch.Size([1, 400]						)
    _lowercase:			Dict       =     torch.tensor([0.0_771, 0.0_011, -0.3_625]						)
  elif model_name == "videomae-huge-finetuned-kinetics":
    _lowercase:			Union[str, Any]       =     torch.Size([1, 400]						)
    _lowercase:			str       =     torch.tensor([0.2_433, 0.1_632, -0.4_894]						)
  elif model_name == "videomae-base-short-finetuned-kinetics":
    _lowercase:			List[str]       =     torch.Size([1, 400]						)
    _lowercase:			Union[str, Any]       =     torch.tensor([0.6_588, 0.0_990, -0.2_493]						)
  elif model_name == "videomae-base-finetuned-kinetics":
    _lowercase:			Tuple       =     torch.Size([1, 400]						)
    _lowercase:			Any       =     torch.tensor([0.3_669, -0.0_688, -0.2_421]						)
  elif model_name == "videomae-base-short-ssv2":
    _lowercase:			int       =     torch.Size([1, 1_408, 1_536]						)
    _lowercase:			str       =     torch.tensor([[0.4_712, 0.5_296, 0.5_786], [0.2_278, 0.2_729, 0.4_026], [0.0_352, 0.0_730, 0.2_506]]						)
  elif model_name == "videomae-base-short-finetuned-ssv2":
    _lowercase:			Dict       =     torch.Size([1, 174]						)
    _lowercase:			Optional[Any]       =     torch.tensor([-0.0_537, -0.1_539, -0.3_266]						)
  elif model_name == "videomae-base-ssv2":
    _lowercase:			str       =     torch.Size([1, 1_408, 1_536]						)
    _lowercase:			str       =     torch.tensor([[0.8_131, 0.8_727, 0.8_546], [0.7_366, 0.9_377, 0.8_870], [0.5_935, 0.8_874, 0.8_564]]						)
  elif model_name == "videomae-base-finetuned-ssv2":
    _lowercase:			List[Any]       =     torch.Size([1, 174]						)
    _lowercase:			Tuple       =     torch.tensor([0.1_961, -0.8_337, -0.6_389]						)
  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] ,				_UpperCamelCase ,				atol=1e-4						)
  else:
    print('''Logits:''' ,				logits[0, :3, :3]						)
    assert torch.allclose(logits[0, :3, :3] ,				_UpperCamelCase ,				atol=1e-4						)
  print('''Logits ok!'''						)

  # verify loss, if applicable
  if model_name == "videomae-base-short":
    _lowercase:			List[str]       =     outputs.loss
    assert torch.allclose(_UpperCamelCase ,				_UpperCamelCase ,				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(_UpperCamelCase						)
    model.save_pretrained(_UpperCamelCase						)

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


if __name__ == "__main__":
  A__   :					Any							=   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.'
  )

  A__   :					Dict							=   parser.parse_args()
  convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
