





"""simple docstring"""




import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling





def 			a_							(				_lowercase  ):
						_UpperCamelCase     :   List[Any]      =       '''https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint'''

						with open(_lowerCAmelCase			,		'''wb'''  ) as f:
												with requests.get(_lowerCAmelCase			,		stream=_lowerCAmelCase  ) as req:
																		for chunk in req.iter_content(chunk_size=2048  ):
																								f.write(_lowerCAmelCase  )





def 			a_							(				):
						_UpperCamelCase     :   List[Any]      =       VivitConfig()

						_UpperCamelCase     :   List[Any]      =       400
						_UpperCamelCase     :   Optional[Any]      =       '''huggingface/label-files'''
						_UpperCamelCase     :   Dict      =       '''kinetics400-id2label.json'''

						_UpperCamelCase     :   str      =       json.load(open(hf_hub_download(_lowerCAmelCase			,		_lowerCAmelCase			,		repo_type='''dataset'''  )			,		'''r'''  )  )
						_UpperCamelCase     :   Optional[Any]      =       {int(_lowerCAmelCase  ): v for k, v in idalabel.items()}
						_UpperCamelCase     :   Any      =       idalabel
						_UpperCamelCase     :   List[str]      =       {v: k for k, v in idalabel.items()}
						return config





def 			a_							(				):
						_UpperCamelCase     :   Dict      =       hf_hub_download(
						    repo_id='''hf-internal-testing/spaghetti-video'''			,		filename='''eating_spaghetti_32_frames.npy'''			,		repo_type='''dataset'''  )
						_UpperCamelCase     :   List[str]      =       np.load(_lowerCAmelCase  )
						return list(_lowerCAmelCase  )





def 			a_							(				_lowercase  ):
						if np.ndim(_lowerCAmelCase  ) == 2:
												return transform_attention_bias(_lowerCAmelCase  )

						elif np.ndim(_lowerCAmelCase  ) == 3:
												return transform_attention_kernel(_lowerCAmelCase  )

						else:
												raise Exception(F"""Invalid number of dimesions: {np.ndim(_lowerCAmelCase  )}"""  )





def 			a_							(				_lowercase  ):
						return current.flatten()





def 			a_							(				_lowercase  ):
						return np.reshape(_lowerCAmelCase			,		(current.shape[0], current.shape[1] * current.shape[2])  ).T





def 			a_							(				_lowercase  ):
						return np.reshape(_lowerCAmelCase			,		(current.shape[0] * current.shape[1], current.shape[2])  ).T





def 			a_							(				_lowercase			,		_lowercase  ):
						_UpperCamelCase     :   int      =       state_dict['''optimizer''']['''target''']['''Transformer'''][F"""encoderblock_{i}"""]

						_UpperCamelCase     :   Union[str, Any]      =       F"""encoder.layer.{i}."""
						_UpperCamelCase     :   int      =       {
						    prefix + '''intermediate.dense.bias''': state['''MlpBlock_0''']['''Dense_0''']['''bias'''],
						    prefix + '''intermediate.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_0''']['''kernel''']  ),
						    prefix + '''output.dense.bias''': state['''MlpBlock_0''']['''Dense_1''']['''bias'''],
						    prefix + '''output.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_1''']['''kernel''']  ),
						    prefix + '''layernorm_before.bias''': state['''LayerNorm_0''']['''bias'''],
						    prefix + '''layernorm_before.weight''': state['''LayerNorm_0''']['''scale'''],
						    prefix + '''layernorm_after.bias''': state['''LayerNorm_1''']['''bias'''],
						    prefix + '''layernorm_after.weight''': state['''LayerNorm_1''']['''scale'''],
						    prefix
						    + '''attention.attention.query.bias''': transform_attention(
						        state['''MultiHeadDotProductAttention_0''']['''query''']['''bias''']  ),
						    prefix
						    + '''attention.attention.query.weight''': transform_attention(
						        state['''MultiHeadDotProductAttention_0''']['''query''']['''kernel''']  ),
						    prefix
						    + '''attention.attention.key.bias''': transform_attention(state['''MultiHeadDotProductAttention_0''']['''key''']['''bias''']  ),
						    prefix
						    + '''attention.attention.key.weight''': transform_attention(
						        state['''MultiHeadDotProductAttention_0''']['''key''']['''kernel''']  ),
						    prefix
						    + '''attention.attention.value.bias''': transform_attention(
						        state['''MultiHeadDotProductAttention_0''']['''value''']['''bias''']  ),
						    prefix
						    + '''attention.attention.value.weight''': transform_attention(
						        state['''MultiHeadDotProductAttention_0''']['''value''']['''kernel''']  ),
						    prefix + '''attention.output.dense.bias''': state['''MultiHeadDotProductAttention_0''']['''out''']['''bias'''],
						    prefix
						    + '''attention.output.dense.weight''': transform_attention_output_weight(
						        state['''MultiHeadDotProductAttention_0''']['''out''']['''kernel''']  ),
						}

						return new_state





def 			a_							(				_lowercase  ):
						return sum([1 if '''encoderblock_''' in k else 0 for k in state_dict['''optimizer''']['''target''']['''Transformer'''].keys()]  )





def 			a_							(				_lowercase			,		_lowercase=False  ):
						_UpperCamelCase     :   Optional[int]      =       get_n_layers(_lowerCAmelCase  )

						_UpperCamelCase     :   List[str]      =       OrderedDict()

						_UpperCamelCase     :   Optional[int]      =       state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''bias''']
						_UpperCamelCase     :   str      =       state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''scale''']

						_UpperCamelCase     :   Union[str, Any]      =       np.transpose(
						    state_dict['''optimizer''']['''target''']['''embedding''']['''kernel''']			,		(4, 3, 0, 1, 2)  )
						_UpperCamelCase     :   int      =       state_dict['''optimizer''']['''target''']['''embedding''']['''bias''']

						_UpperCamelCase     :   List[str]      =       state_dict['''optimizer''']['''target''']['''cls''']
						_UpperCamelCase     :   Tuple      =       state_dict['''optimizer''']['''target''']['''Transformer''']['''posembed_input'''][
						    '''pos_embedding'''
						]

						for i in range(_lowerCAmelCase  ):
												new_state.update(transform_state_encoder_block(_lowerCAmelCase			,		_lowerCAmelCase  )  )

						if classification_head:
												_UpperCamelCase     :   Any      =       {'''vivit.''' + k: v for k, v in new_state.items()}
												_UpperCamelCase     :   str      =       np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''kernel''']  )
												_UpperCamelCase     :   List[str]      =       np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''bias''']  )

						return {k: torch.tensor(_lowerCAmelCase  ) for k, v in new_state.items()}





def 			a_							(				):
						_UpperCamelCase     :   List[str]      =       VivitImageProcessor()

						assert extractor.do_resize is True
						assert extractor.size == {"shortest_edge": 256}
						assert extractor.do_center_crop is True
						assert extractor.crop_size == {"width": 224, "height": 224}
						assert extractor.resample == PILImageResampling.BILINEAR

						# here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
						# one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
						# which effectively means no normalization (and ViViT does not overwrite those when calling this func)
						assert extractor.do_normalize is False
						assert extractor.do_rescale is True
						assert extractor.rescale_factor == 1 / 255

						# zero-centering = True in original implementation
						assert extractor.do_zero_centering is True

						return extractor





def 			a_							(				_lowercase  ):
						_UpperCamelCase     :   List[Any]      =       '''checkpoint'''

						if not os.path.exists(_lowerCAmelCase  ):
												download_checkpoint(_lowerCAmelCase  )

						_UpperCamelCase     :   List[Any]      =       restore_checkpoint(_lowerCAmelCase			,		_lowerCAmelCase  )
						_UpperCamelCase     :   Tuple      =       transform_state(_lowerCAmelCase			,		classification_head=_lowerCAmelCase  )

						_UpperCamelCase     :   Union[str, Any]      =       get_vivit_config()

						assert config.image_size == 224
						assert config.num_frames == 32

						_UpperCamelCase     :   Dict      =       VivitForVideoClassification(_lowerCAmelCase  )
						model.load_state_dict(_lowerCAmelCase  )
						model.eval()

						_UpperCamelCase     :   Any      =       get_processor()

						_UpperCamelCase     :   Tuple      =       prepare_video()
						_UpperCamelCase     :   int      =       extractor(_lowerCAmelCase			,		return_tensors='''pt'''  )

						_UpperCamelCase     :   List[str]      =       model(**_lowerCAmelCase  )

						_UpperCamelCase     :   Optional[Any]      =       torch.Size([1, 400]  )
						_UpperCamelCase     :   List[str]      =       torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]  )

						assert outputs.logits.shape == expected_shape
						assert torch.allclose(outputs.logits[0, :5]			,		_lowerCAmelCase			,		atol=1E-4  ), outputs.logits[0, :5]

						model.save_pretrained(_lowerCAmelCase  )
						extractor.save_pretrained(_lowerCAmelCase  )


if __name__ == "__main__":
						UpperCamelCase_	 =argparse.ArgumentParser()

						parser.add_argument("""--output_model_name""", """-o""", type=str, help="""Output path for the converted HuggingFace model""")

						UpperCamelCase_	 =parser.parse_args()
						convert(args.output_model_name)








import unittest

import pytest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    MBartaaTokenizerFast,
    MBartConfig,
    MBartForConditionalGeneration,
    TranslationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch, slow

from .test_pipelines_common import ANY


@is_pipeline_test
class    _lowercase (unittest.TestCase   ):
				'''simple docstring'''







				lowercase__     =    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
				lowercase__     =    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									if isinstance(model.config  ,			snake_case__     ):
														UpperCamelCase_	,     UpperCamelCase_			= list(tokenizer.lang_code_to_id.keys()     )[:2]
														UpperCamelCase_			= TranslationPipeline(model=snake_case__  ,			tokenizer=snake_case__  ,			src_lang=snake_case__  ,			tgt_lang=snake_case__     )
									else:
														UpperCamelCase_			= TranslationPipeline(model=snake_case__  ,			tokenizer=snake_case__     )
									return translator, ["Some string", "Some other text"]

				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= translator("Some string"     )
									self.assertEqual(snake_case__  ,			[{"translation_text": ANY(snake_case__     )}]     )

									UpperCamelCase_			= translator(["Some string"]     )
									self.assertEqual(snake_case__  ,			[{"translation_text": ANY(snake_case__     )}]     )

									UpperCamelCase_			= translator(["Some string", "other string"]     )
									self.assertEqual(snake_case__  ,			[{"translation_text": ANY(snake_case__     )}, {"translation_text": ANY(snake_case__     )}]     )

				@require_torch
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= pipeline("translation_en_to_ro"  ,			model="patrickvonplaten/t5-tiny-random"  ,			framework="pt"     )
									UpperCamelCase_			= translator("This is a test string"  ,			max_length=20     )
									self.assertEqual(
									    snake_case__  ,			[
									        {
									            "translation_text": (
									                "Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"
									                " Beide Beide"
									            )
									        }
									    ]  ,			)

				@require_tf
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= pipeline("translation_en_to_ro"  ,			model="patrickvonplaten/t5-tiny-random"  ,			framework="tf"     )
									UpperCamelCase_			= translator("This is a test string"  ,			max_length=20     )
									self.assertEqual(
									    snake_case__  ,			[
									        {
									            "translation_text": (
									                "Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"
									                " Beide Beide"
									            )
									        }
									    ]  ,			)

				@require_torch
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= pipeline("translation_en_to_de"  ,			model="patrickvonplaten/t5-tiny-random"  ,			framework="pt"     )
									UpperCamelCase_			= translator("This is a test string"  ,			max_length=20     )
									self.assertEqual(
									    snake_case__  ,			[
									        {
									            "translation_text": (
									                "monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"
									                " urine urine urine urine urine urine urine"
									            )
									        }
									    ]  ,			)

				@require_tf
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= pipeline("translation_en_to_de"  ,			model="patrickvonplaten/t5-tiny-random"  ,			framework="tf"     )
									UpperCamelCase_			= translator("This is a test string"  ,			max_length=20     )
									self.assertEqual(
									    snake_case__  ,			[
									        {
									            "translation_text": (
									                "monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"
									                " urine urine urine urine urine urine urine"
									            )
									        }
									    ]  ,			)




class    _lowercase (unittest.TestCase   ):
				'''simple docstring'''







				@require_torch
				@slow
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									with self.assertRaises(snake_case__     ):
														pipeline(task="translation_cn_to_ar"     )

									# but we do for this one
									UpperCamelCase_			= pipeline(task="translation_en_to_de"     )
									self.assertEqual(translator._preprocess_params["src_lang"]  ,			"en"     )
									self.assertEqual(translator._preprocess_params["tgt_lang"]  ,			"de"     )

				@require_torch
				@slow
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-50-many-to-many-mmt"     )
									UpperCamelCase_			= MBartaaTokenizerFast.from_pretrained("facebook/mbart-large-50-many-to-many-mmt"     )

									UpperCamelCase_			= pipeline(task="translation"  ,			model=snake_case__  ,			tokenizer=snake_case__     )
									# Missing src_lang, tgt_lang
									with self.assertRaises(snake_case__     ):
														translator("This is a test"     )

									UpperCamelCase_			= translator("This is a test"  ,			src_lang="en_XX"  ,			tgt_lang="ar_AR"     )
									self.assertEqual(snake_case__  ,			[{"translation_text": "هذا إختبار"}]     )

									UpperCamelCase_			= translator("This is a test"  ,			src_lang="en_XX"  ,			tgt_lang="hi_IN"     )
									self.assertEqual(snake_case__  ,			[{"translation_text": "यह एक परीक्षण है"}]     )

									# src_lang, tgt_lang can be defined at pipeline call time
									UpperCamelCase_			= pipeline(task="translation"  ,			model=snake_case__  ,			tokenizer=snake_case__  ,			src_lang="en_XX"  ,			tgt_lang="ar_AR"     )
									UpperCamelCase_			= translator("This is a test"     )
									self.assertEqual(snake_case__  ,			[{"translation_text": "هذا إختبار"}]     )

				@require_torch
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= "patrickvonplaten/t5-tiny-random"
									UpperCamelCase_			= pipeline(task="translation_cn_to_ar"  ,			model=snake_case__     )
									self.assertEqual(translator._preprocess_params["src_lang"]  ,			"cn"     )
									self.assertEqual(translator._preprocess_params["tgt_lang"]  ,			"ar"     )

				@require_torch
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= "patrickvonplaten/t5-tiny-random"
									with pytest.warns(snake_case__  ,			match=R".*translation_en_to_de.*"     ):
														UpperCamelCase_			= pipeline(task="translation"  ,			model=snake_case__     )
									self.assertEqual(translator.task  ,			"translation_en_to_de"     )
									self.assertEqual(translator._preprocess_params["src_lang"]  ,			"en"     )
									self.assertEqual(translator._preprocess_params["tgt_lang"]  ,			"de"     )

				@require_torch
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									with self.assertRaises(snake_case__     ):
														pipeline(task="translation"     )
