



'''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__					(  UpperCAmelCase_							):
						_UpperCamelCase      :	Optional[int]				       =     '''https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint'''

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






def A__					(  ):
						_UpperCamelCase      :	int				       =     VivitConfig()

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

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






def A__					(  ):
						_UpperCamelCase      :	Optional[int]				       =     hf_hub_download(
						    repo_id='hf-internal-testing/spaghetti-video'						,						filename='eating_spaghetti_32_frames.npy'						,						repo_type='dataset'							)
						_UpperCamelCase      :	Any				       =     np.load(UpperCAmelCase_							)
						return list(UpperCAmelCase_							)






def A__					(  UpperCAmelCase_							):
						if np.ndim(UpperCAmelCase_							) == 2:
												return transform_attention_bias(UpperCAmelCase_							)

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

						else:
												raise Exception(f'Invalid number of dimesions: {np.ndim(UpperCAmelCase_							)}'							)






def A__					(  UpperCAmelCase_							):
						return current.flatten()






def A__					(  UpperCAmelCase_							):
						return np.reshape(UpperCAmelCase_						,						(current.shape[0], current.shape[1] * current.shape[2])							).T






def A__					(  UpperCAmelCase_							):
						return np.reshape(UpperCAmelCase_						,						(current.shape[0] * current.shape[1], current.shape[2])							).T






def A__					(  UpperCAmelCase_						,						UpperCAmelCase_							):
						_UpperCamelCase      :	Tuple				       =     state_dict['''optimizer''']['''target''']['''Transformer'''][f'encoderblock_{i}']

						_UpperCamelCase      :	List[str]				       =     f'encoder.layer.{i}.'
						_UpperCamelCase      :	Union[str, Any]				       =     {
						    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__					(  UpperCAmelCase_							):
						return sum([1 if 'encoderblock_' in k else 0 for k in state_dict['optimizer']['target']['Transformer'].keys()]							)






def A__					(  UpperCAmelCase_						,						UpperCAmelCase_=False							):
						_UpperCamelCase      :	str				       =     get_n_layers(UpperCAmelCase_							)

						_UpperCamelCase      :	List[Any]				       =     OrderedDict()

						_UpperCamelCase      :	Union[str, Any]				       =     state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''bias''']
						_UpperCamelCase      :	List[Any]				       =     state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''scale''']

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

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

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

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

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






def A__					(  ):
						_UpperCamelCase      :	Tuple				       =     VivitImageProcessor()

						assert extractor.do_resize is True
						assert extractor.size == {"shortest_edge": 2_5_6}
						assert extractor.do_center_crop is True
						assert extractor.crop_size == {"width": 2_2_4, "height": 2_2_4}
						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 / 2_5_5

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

						return extractor






def A__					(  UpperCAmelCase_							):
						_UpperCamelCase      :	Optional[int]				       =     '''checkpoint'''

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

						_UpperCamelCase      :	List[str]				       =     restore_checkpoint(UpperCAmelCase_						,						UpperCAmelCase_							)
						_UpperCamelCase      :	int				       =     transform_state(UpperCAmelCase_						,						classification_head=UpperCAmelCase_							)

						_UpperCamelCase      :	Optional[int]				       =     get_vivit_config()

						assert config.image_size == 2_2_4
						assert config.num_frames == 3_2

						_UpperCamelCase      :	Tuple				       =     VivitForVideoClassification(UpperCAmelCase_							)
						model.load_state_dict(UpperCAmelCase_							)
						model.eval()

						_UpperCamelCase      :	Tuple				       =     get_processor()

						_UpperCamelCase      :	Tuple				       =     prepare_video()
						_UpperCamelCase      :	Optional[int]				       =     extractor(UpperCAmelCase_						,						return_tensors='pt'							)

						_UpperCamelCase      :	Dict				       =     model(**UpperCAmelCase_							)

						_UpperCamelCase      :	Optional[Any]				       =     torch.Size([1, 4_0_0]							)
						_UpperCamelCase      :	Tuple				       =     torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]							)

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

						model.save_pretrained(UpperCAmelCase_							)
						extractor.save_pretrained(UpperCAmelCase_							)


if __name__ == "__main__":
					snake_case_				:			Optional[int]						 =						argparse.ArgumentParser()

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

					snake_case_				:			str						 =						parser.parse_args()
					convert(args.output_model_name)







'''simple docstring'''
import os

from ...utils import logging
from .utils import DataProcessor, InputExample


snake_case_				:			Any						 =						logging.get_logger(__name__)






class 							lowercase__			(							lowercase     ):





	def __init__(				self      :       Union[str, Any]				,lowerCamelCase__      :       Tuple				,lowerCamelCase__      :       Optional[int]=None				):







							'''simple docstring'''
							_UpperCamelCase      :	Any				       =     language
							_UpperCamelCase      :	int				       =     train_language





	def 			UpperCamelCase_						(				self      :       Optional[int]				,lowerCamelCase__      :       Dict				):







							'''simple docstring'''
							_UpperCamelCase      :	Tuple				       =     self.language if self.train_language is None else self.train_language
							_UpperCamelCase      :	List[Any]				       =     self._read_tsv(os.path.join(lowerCamelCase__				,F'XNLI-MT-1.0/multinli/multinli.train.{lg}.tsv'				)				)
							_UpperCamelCase      :	Union[str, Any]				       =     []
							for i, line in enumerate(lowerCamelCase__				):
													if i == 0:
																			continue
													_UpperCamelCase      :	Optional[Any]				       =     F'train-{i}'
													_UpperCamelCase      :	List[str]				       =     line[0]
													_UpperCamelCase      :	Union[str, Any]				       =     line[1]
													_UpperCamelCase      :	Tuple				       =     'contradiction' if line[2] == 'contradictory' else line[2]
													if not isinstance(lowerCamelCase__				,lowerCamelCase__				):
																			raise ValueError(F'Training input {text_a} is not a string'				)
													if not isinstance(lowerCamelCase__				,lowerCamelCase__				):
																			raise ValueError(F'Training input {text_b} is not a string'				)
													if not isinstance(lowerCamelCase__				,lowerCamelCase__				):
																			raise ValueError(F'Training label {label} is not a string'				)
													examples.append(InputExample(guid=lowerCamelCase__				,text_a=lowerCamelCase__				,text_b=lowerCamelCase__				,label=lowerCamelCase__				)				)
							return examples





	def 			UpperCamelCase_						(				self      :       Optional[Any]				,lowerCamelCase__      :       List[str]				):







							'''simple docstring'''
							_UpperCamelCase      :	Optional[int]				       =     self._read_tsv(os.path.join(lowerCamelCase__				,'XNLI-1.0/xnli.test.tsv'				)				)
							_UpperCamelCase      :	List[str]				       =     []
							for i, line in enumerate(lowerCamelCase__				):
													if i == 0:
																			continue
													_UpperCamelCase      :	Optional[int]				       =     line[0]
													if language != self.language:
																			continue
													_UpperCamelCase      :	Optional[int]				       =     F'test-{i}'
													_UpperCamelCase      :	Optional[int]				       =     line[6]
													_UpperCamelCase      :	List[str]				       =     line[7]
													_UpperCamelCase      :	str				       =     line[1]
													if not isinstance(lowerCamelCase__				,lowerCamelCase__				):
																			raise ValueError(F'Training input {text_a} is not a string'				)
													if not isinstance(lowerCamelCase__				,lowerCamelCase__				):
																			raise ValueError(F'Training input {text_b} is not a string'				)
													if not isinstance(lowerCamelCase__				,lowerCamelCase__				):
																			raise ValueError(F'Training label {label} is not a string'				)
													examples.append(InputExample(guid=lowerCamelCase__				,text_a=lowerCamelCase__				,text_b=lowerCamelCase__				,label=lowerCamelCase__				)				)
							return examples





	def 			UpperCamelCase_						(				self      :       str				):







							'''simple docstring'''
							return ["contradiction", "entailment", "neutral"]
snake_case_				:			int						 =						{
    'xnli': XnliProcessor,
}

snake_case_				:			Tuple						 =						{
    'xnli': 'classification',
}

snake_case_				:			Any						 =						{
    'xnli': 3,
}


