
import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis_float32 (there's also the fix_lavis branch)
# also note: to convert Vicuna checkpoints, we had to include /home/niels/python_projects/checkpoints/FastChat/vicuna-7b in lavis/configs/models/blip2/blip2_instruct_vicuna7b.yaml
# same for Vicuna-13b
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipImageProcessor,
    InstructBlipConfig,
    InstructBlipForConditionalGeneration,
    InstructBlipProcessor,
    InstructBlipQFormerConfig,
    InstructBlipVisionConfig,
    LlamaConfig,
    LlamaTokenizerFast,
    TaConfig,
    TaTokenizerFast,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD






def 							UpperCAmelCase_		(							):
	lowercase       =    'https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg'
	lowercase       =    Image.open(requests.get(UpperCamelCase__ ,							stream=UpperCamelCase__							).raw							).convert('RGB'							)

	return image






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	lowercase       =    []
	# fmt: off

	# vision encoder
	rename_keys.append(('visual_encoder.cls_token', 'vision_model.embeddings.class_embedding')							)
	rename_keys.append(('visual_encoder.pos_embed', 'vision_model.embeddings.position_embedding')							)
	rename_keys.append(('visual_encoder.patch_embed.proj.weight', 'vision_model.embeddings.patch_embedding.weight')							)
	rename_keys.append(('visual_encoder.patch_embed.proj.bias', 'vision_model.embeddings.patch_embedding.bias')							)
	rename_keys.append(('ln_vision.weight', 'vision_model.post_layernorm.weight')							)
	rename_keys.append(('ln_vision.bias', 'vision_model.post_layernorm.bias')							)

	for i in range(config.vision_config.num_hidden_layers							):
		rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.weight''', F'''vision_model.encoder.layers.{i}.layer_norm1.weight''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.bias''', F'''vision_model.encoder.layers.{i}.layer_norm1.bias''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.weight''', F'''vision_model.encoder.layers.{i}.layer_norm2.weight''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.bias''', F'''vision_model.encoder.layers.{i}.layer_norm2.bias''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.attn.qkv.weight''', F'''vision_model.encoder.layers.{i}.self_attn.qkv.weight''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.weight''', F'''vision_model.encoder.layers.{i}.self_attn.projection.weight''',)							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.bias''', F'''vision_model.encoder.layers.{i}.self_attn.projection.bias''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc1.weight''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc1.bias''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc2.weight''')							)
		rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc2.bias''')							)

	# QFormer
	rename_keys.append(('Qformer.bert.embeddings.LayerNorm.weight', 'qformer.embeddings.layernorm.weight')							)
	rename_keys.append(('Qformer.bert.embeddings.LayerNorm.bias', 'qformer.embeddings.layernorm.bias')							)

	# fmt: on
	return rename_keys






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							):
	lowercase       =    dct.pop(UpperCamelCase__							)
	lowercase       =    val






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							):


	for i in range(config.vision_config.num_hidden_layers							):
		# read in original q and v biases
		lowercase       =    state_dict.pop(F'''visual_encoder.blocks.{i}.attn.q_bias'''							)
		lowercase       =    state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''							)

		# next, set bias in the state dict
		lowercase       =    torch.cat((q_bias, torch.zeros_like(UpperCamelCase__ ,							requires_grad=UpperCamelCase__							), v_bias)							)
		lowercase       =    qkv_bias






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	lowercase       =    364 if 'coco' in model_name else 224
	lowercase       =    InstructBlipVisionConfig(image_size=UpperCamelCase__							).to_dict()

	# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
	# seems like flan-T5 models don't have bos_token_id properly set?
	if "t5-xl" in model_name:
		lowercase       =    TaConfig.from_pretrained('google/flan-t5-xl' ,							dense_act_fn='gelu' ,							bos_token_id=1							).to_dict()
	elif "t5-xxl" in model_name:
		lowercase       =    TaConfig.from_pretrained('google/flan-t5-xxl' ,							dense_act_fn='gelu' ,							bos_token_id=1							).to_dict()
	elif "vicuna-7b" in model_name:
		lowercase       =    LlamaConfig.from_pretrained('decapoda-research/llama-7b-hf' ,							vocab_size=3_2001							).to_dict()
	elif "vicuna-13b" in model_name:
		lowercase       =    LlamaConfig.from_pretrained('decapoda-research/llama-13b-hf' ,							vocab_size=3_2001							).to_dict()
	else:
		raise ValueError('Model name not supported'							)

	# the authors add one special "[DEC]" token to the vocab of Q-Former, hence vocab size = 30522 + 1
	lowercase       =    InstructBlipQFormerConfig(vocab_size=3_0523							).to_dict()
	lowercase       =    InstructBlipConfig(vision_config=UpperCamelCase__ ,							text_config=UpperCamelCase__ ,							qformer_config=UpperCamelCase__							)

	return config, image_size






@torch.no_grad()
def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE=None ,							__SCREAMING_SNAKE_CASE=False							):
	lowercase       =    AutoTokenizer.from_pretrained('bert-base-uncased' ,							truncation_side='left'							)
	qformer_tokenizer.add_special_tokens({'bos_token': '[DEC]'}							)

	if "t5" in model_name:
		lowercase       =    TaTokenizerFast.from_pretrained('google/flan-t5-xl' ,							truncation_side='left'							)
	elif "vicuna" in model_name:
		# the following was used in the original implementation:
		# tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", use_fast=False, truncation_side="left")
		# tokenizer.add_special_tokens({"pad_token": "[PAD]"})
		# tokenizer.add_special_tokens({"bos_token": "</s>"})
		# tokenizer.add_special_tokens({"eos_token": "</s>"})
		# tokenizer.add_special_tokens({"unk_token": "</s>"})
		lowercase       =    LlamaTokenizerFast.from_pretrained(
		    'huggyllama/llama-7b' ,							truncation_side='left' ,							bos_token='</s>' ,							unk_token='</s>'							)
		tokenizer.add_special_tokens({'pad_token': '[PAD]'}							)

	lowercase  ,					lowercase       =    get_blipa_config(UpperCamelCase__							)
	lowercase       =    InstructBlipForConditionalGeneration(UpperCamelCase__							).eval()

	lowercase       =    {
	    'instructblip-vicuna-7b': ('blip2_vicuna_instruct', 'vicuna7b'),
	    'instructblip-vicuna-13b': ('blip2_vicuna_instruct', 'vicuna13b'),
	    'instructblip-flan-t5-xl': ('blip2_t5_instruct', 'flant5xl'),
	    'instructblip-flan-t5-xxl': ('blip2_t5_instruct', 'flant5xxl'),
	}

	lowercase  ,					lowercase       =    model_name_to_original[model_name]

	# load original model
	print('Loading original model...'							)
	lowercase       =    'cuda:1' if torch.cuda.is_available() else 'cpu'
	lowercase       =    'cuda:2' if torch.cuda.is_available() else 'cpu'
	lowercase  ,					lowercase  ,					lowercase       =    load_model_and_preprocess(
	    name=UpperCamelCase__ ,							model_type=UpperCamelCase__ ,							is_eval=UpperCamelCase__ ,							device=UpperCamelCase__							)
	original_model.eval()
	print('Done!'							)

	# update state dict keys
	lowercase       =    original_model.state_dict()
	lowercase       =    create_rename_keys(UpperCamelCase__							)
	for src, dest in rename_keys:
		rename_key(UpperCamelCase__ ,							UpperCamelCase__ ,							UpperCamelCase__							)

	# some keys can be renamed efficiently
	for key, val in state_dict.copy().items():
		lowercase       =    state_dict.pop(UpperCamelCase__							)
		if key.startswith('Qformer.bert'							):
			lowercase       =    key.replace('Qformer.bert' ,							'qformer'							)
		if "attention.self" in key:
			lowercase       =    key.replace('self' ,							'attention'							)
		if "llm_proj" in key:
			lowercase       =    key.replace('llm_proj' ,							'language_projection'							)
		if "t5_proj" in key:
			lowercase       =    key.replace('t5_proj' ,							'language_projection'							)
		if key.startswith('llm_model'							):
			lowercase       =    key.replace('llm_model' ,							'language_model'							)
		if key.startswith('t5'							):
			lowercase       =    key.replace('t5' ,							'language'							)
		lowercase       =    val

	# read in qv biases
	read_in_q_v_bias(UpperCamelCase__ ,							UpperCamelCase__							)

	# note: weights get loaded in torch.float32 by default
	hf_model.load_state_dict(UpperCamelCase__ ,							strict=UpperCamelCase__							)

	lowercase       =    load_demo_image()
	lowercase       =    'What is unusual about this image?'

	# create processor
	lowercase       =    BlipImageProcessor(
	    size={'height': image_size, 'width': image_size} ,							image_mean=UpperCamelCase__ ,							image_std=UpperCamelCase__							)
	lowercase       =    InstructBlipProcessor(
	    image_processor=UpperCamelCase__ ,							tokenizer=UpperCamelCase__ ,							qformer_tokenizer=UpperCamelCase__ ,							)
	lowercase       =    processor(images=UpperCamelCase__ ,							text=UpperCamelCase__ ,							return_tensors='pt'							).to(UpperCamelCase__							)

	# make sure processor creates exact same pixel values
	lowercase       =    vis_processors['eval'](UpperCamelCase__							).unsqueeze(0							).to(UpperCamelCase__							)
	lowercase       =    inputs.pixel_values
	assert torch.allclose(original_pixel_values.to(pixel_values.device							) ,							UpperCamelCase__							)

	original_model.to(UpperCamelCase__							)
	hf_model.to(UpperCamelCase__							)
	with torch.no_grad():
		if "vicuna" in model_name:
			lowercase       =    original_model({'image': original_pixel_values, 'text_input': [prompt]}							).logits
			lowercase       =    hf_model(**UpperCamelCase__							).logits
		else:
			lowercase       =    original_model(
			    {'image': original_pixel_values, 'text_input': [prompt], 'text_output': ['\n']}							).logits
			lowercase       =    tokenizer('\n' ,							return_tensors='pt'							).input_ids.to(UpperCamelCase__							)
			lowercase       =    label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id ,							-100							)
			lowercase       =    hf_model(**UpperCamelCase__ ,							labels=UpperCamelCase__							).logits

	print('First values of original logits:' ,							original_logits[0, :3, :3]							)
	print('First values of HF logits:' ,							logits[0, :3, :3]							)

	# assert values
	assert original_logits.shape == logits.shape
	lowercase       =    1e-4 if 'vicuna' in model_name else 1e-5
	assert torch.allclose(original_logits.to(logits.device							) ,							UpperCamelCase__ ,							atol=UpperCamelCase__							)
	print('Looks ok!'							)

	print('Generating with original model...'							)
	lowercase       =    original_model.generate({'image': original_pixel_values, 'prompt': prompt} ,							num_beams=5							)

	# important: we need to cast the weights of the HF model to the appropriate type
	print('Generating with HF model...'							)
	lowercase       =    hf_model.generate(
	    **UpperCamelCase__ ,							do_sample=UpperCamelCase__ ,							num_beams=5 ,							max_length=256 ,							min_length=1 ,							top_p=0.9 ,							repetition_penalty=1.5 ,							length_penalty=1.0 ,							temperature=1 ,							)
	if "vicuna" in model_name:
		# convert output id 0 to 2 (eos_token_id)
		# TODO add this in the generate method?
		lowercase       =    2
	print('Original generation:' ,							UpperCamelCase__							)
	lowercase       =    processor.batch_decode(UpperCamelCase__ ,							skip_special_tokens=UpperCamelCase__							)
	lowercase       =    [text.strip() for text in output_text]
	print('HF generation:' ,							UpperCamelCase__							)

	if pytorch_dump_folder_path is not None:
		processor.save_pretrained(UpperCamelCase__							)
		hf_model.save_pretrained(UpperCamelCase__							)

	if push_to_hub:
		processor.push_to_hub(F'''Salesforce/{model_name}'''							)
		hf_model.push_to_hub(F'''Salesforce/{model_name}'''							)


if __name__ == "__main__":
	UpperCAmelCase	      = argparse.ArgumentParser()
	UpperCAmelCase	      = [
	    '''instructblip-vicuna-7b''',
	    '''instructblip-vicuna-13b''',
	    '''instructblip-flan-t5-xl''',
	    '''instructblip-flan-t5-xxl''',
	]
	parser.add_argument(
	    '''--model_name''',
	    default='''instructblip-flan-t5-xl''',
	    choices=choices,
	    type=str,
	    help='''Path to hf config.json of model to convert''',
	)
	parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
	parser.add_argument(
	    '''--push_to_hub''',
	    action='''store_true''',
	    help='''Whether to push the model and processor to the hub after converting''',
	)

	UpperCAmelCase	      = parser.parse_args()

	convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import (
					    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
					    TimesformerForVideoClassification,
					    TimesformerModel,
					)
					from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from transformers import VideoMAEImageProcessor







class     __lowerCAmelCase :

			"""simple docstring"""







			def __init__(      self			,						lowerCamelCase__			,						lowerCamelCase__=13			,						lowerCamelCase__=10			,						lowerCamelCase__=3			,						lowerCamelCase__=2			,						lowerCamelCase__=2			,						lowerCamelCase__=True			,						lowerCamelCase__=True			,						lowerCamelCase__=32			,						lowerCamelCase__=5			,						lowerCamelCase__=4			,						lowerCamelCase__=37			,						lowerCamelCase__="gelu"			,						lowerCamelCase__=0.1			,						lowerCamelCase__=0.1			,						lowerCamelCase__=10			,						lowerCamelCase__=0.02			,						lowerCamelCase__="divided_space_time"			,						lowerCamelCase__=None			,						)    ->      Any:



							'''simple docstring'''
							__lowerCamelCase		       =    parent
							__lowerCamelCase		       =    batch_size
							__lowerCamelCase		       =    image_size
							__lowerCamelCase		       =    num_channels
							__lowerCamelCase		       =    patch_size
							__lowerCamelCase		       =    num_frames
							__lowerCamelCase		       =    is_training
							__lowerCamelCase		       =    use_labels
							__lowerCamelCase		       =    hidden_size
							__lowerCamelCase		       =    num_hidden_layers
							__lowerCamelCase		       =    num_attention_heads
							__lowerCamelCase		       =    intermediate_size
							__lowerCamelCase		       =    hidden_act
							__lowerCamelCase		       =    hidden_dropout_prob
							__lowerCamelCase		       =    attention_probs_dropout_prob
							__lowerCamelCase		       =    attention_type
							__lowerCamelCase		       =    initializer_range
							__lowerCamelCase		       =    scope
							__lowerCamelCase		       =    num_labels

							# in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
							__lowerCamelCase		       =    (image_size // patch_size) ** 2
							__lowerCamelCase		       =    (num_frames) * self.num_patches_per_frame + 1


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



							'''simple docstring'''
							__lowerCamelCase		       =    floats_tensor(
							    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]							)

							__lowerCamelCase		       =    None
							if self.use_labels:
											__lowerCamelCase		       =    ids_tensor([self.batch_size]			,						self.num_labels							)

							__lowerCamelCase		       =    self.get_config()

							return config, pixel_values, labels


			def       lowercase_    (      self							)    ->      Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    TimesformerConfig(
							    image_size=self.image_size			,						patch_size=self.patch_size			,						num_channels=self.num_channels			,						num_frames=self.num_frames			,						hidden_size=self.hidden_size			,						num_hidden_layers=self.num_hidden_layers			,						num_attention_heads=self.num_attention_heads			,						intermediate_size=self.intermediate_size			,						hidden_act=self.hidden_act			,						hidden_dropout_prob=self.hidden_dropout_prob			,						attention_probs_dropout_prob=self.attention_probs_dropout_prob			,						initializer_range=self.initializer_range			,						attention_type=self.attention_type			,						)
							__lowerCamelCase		       =    self.num_labels
							return config


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase		       =    TimesformerModel(config=lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()
							__lowerCamelCase		       =    model(lowerCamelCase__							)
							self.parent.assertEqual(result.last_hidden_state.shape			,						(self.batch_size, self.seq_length, self.hidden_size)							)


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    TimesformerForVideoClassification(lowerCamelCase__							)
							model.to(lowerCamelCase__							)
							model.eval()

							__lowerCamelCase		       =    model(lowerCamelCase__							)

							# verify the logits shape
							__lowerCamelCase		       =    torch.Size((self.batch_size, self.num_labels)							)
							self.parent.assertEqual(result.logits.shape			,						lowerCamelCase__							)






			def       lowercase_    (      self							)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase		       =    self.prepare_config_and_inputs()
							__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    config_and_inputs
							__lowerCamelCase		       =    {'pixel_values': pixel_values}
							return config, inputs_dict







@require_torch
class     __lowerCAmelCase (       __magic_name__			,				__magic_name__			,				unittest.TestCase ):

			"""simple docstring"""







			snake_case_   		=       (TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
			snake_case_   		=       (
			    {'''feature-extraction''': TimesformerModel, '''video-classification''': TimesformerForVideoClassification}
			    if is_torch_available()
			    else {}
			)

			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False
			snake_case_   		=       False


			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							__lowerCamelCase		       =    TimesformerModelTester(self							)
							__lowerCamelCase		       =    ConfigTester(
							    self			,						config_class=lowerCamelCase__			,						has_text_modality=lowerCamelCase__			,						hidden_size=37							)


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__=False							)    ->      int:



							'''simple docstring'''
							__lowerCamelCase		       =    copy.deepcopy(lowerCamelCase__							)

							if return_labels:
											if model_class in get_values(lowerCamelCase__							):
															__lowerCamelCase		       =    torch.zeros(
															    self.model_tester.batch_size			,						dtype=torch.long			,						device=lowerCamelCase__							)

							return inputs_dict


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



							'''simple docstring'''
							self.config_tester.run_common_tests()


			@unittest.skip(reason='TimeSformer does not use inputs_embeds'							)
			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							pass


			def       lowercase_    (      self							)    ->      Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											self.assertIsInstance(model.get_input_embeddings()			,						(nn.Module)							)
											__lowerCamelCase		       =    model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(lowerCamelCase__			,						nn.Linear							)							)


			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											__lowerCamelCase		       =    inspect.signature(model.forward							)
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											__lowerCamelCase		       =    [*signature.parameters.keys()]

											__lowerCamelCase		       =    ['pixel_values']
											self.assertListEqual(arg_names[:1]			,						lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      str:



							'''simple docstring'''
							__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_video_classification(*lowerCamelCase__							)


			@slow
			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowerCamelCase		       =    TimesformerModel.from_pretrained(lowerCamelCase__							)
											self.assertIsNotNone(lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      List[Any]:



							'''simple docstring'''
							if not self.has_attentions:
											pass

							else:
											__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()
											__lowerCamelCase		       =    True

											for model_class in self.all_model_classes:
															__lowerCamelCase		       =    self.model_tester.seq_length
															__lowerCamelCase		       =    self.model_tester.num_frames

															__lowerCamelCase		       =    True
															__lowerCamelCase		       =    False
															__lowerCamelCase		       =    True
															__lowerCamelCase		       =    model_class(lowerCamelCase__							)
															model.to(lowerCamelCase__							)
															model.eval()
															with torch.no_grad():
																			__lowerCamelCase		       =    model(**self._prepare_for_class(lowerCamelCase__			,						lowerCamelCase__							)							)
															__lowerCamelCase		       =    outputs.attentions
															self.assertEqual(len(lowerCamelCase__							)			,						self.model_tester.num_hidden_layers							)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															__lowerCamelCase		       =    True
															__lowerCamelCase		       =    model_class(lowerCamelCase__							)
															model.to(lowerCamelCase__							)
															model.eval()
															with torch.no_grad():
																			__lowerCamelCase		       =    model(**self._prepare_for_class(lowerCamelCase__			,						lowerCamelCase__							)							)
															__lowerCamelCase		       =    outputs.attentions
															self.assertEqual(len(lowerCamelCase__							)			,						self.model_tester.num_hidden_layers							)

															# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
															self.assertListEqual(
															    list(attentions[0].shape[-3:]							)			,						[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]			,						)
															__lowerCamelCase		       =    len(lowerCamelCase__							)

															# Check attention is always last and order is fine
															__lowerCamelCase		       =    True
															__lowerCamelCase		       =    True
															__lowerCamelCase		       =    model_class(lowerCamelCase__							)
															model.to(lowerCamelCase__							)
															model.eval()
															with torch.no_grad():
																			__lowerCamelCase		       =    model(**self._prepare_for_class(lowerCamelCase__			,						lowerCamelCase__							)							)

															self.assertEqual(out_len + 1			,						len(lowerCamelCase__							)							)

															__lowerCamelCase		       =    outputs.attentions

															self.assertEqual(len(lowerCamelCase__							)			,						self.model_tester.num_hidden_layers							)

															# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
															self.assertListEqual(
															    list(self_attentions[0].shape[-3:]							)			,						[self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]			,						)






			def       lowercase_    (      self							)    ->      Tuple:



							'''simple docstring'''
							def check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							):
											__lowerCamelCase		       =    model_class(lowerCamelCase__							)
											model.to(lowerCamelCase__							)
											model.eval()

											with torch.no_grad():
															__lowerCamelCase		       =    model(**self._prepare_for_class(lowerCamelCase__			,						lowerCamelCase__							)							)

											__lowerCamelCase		       =    outputs.hidden_states
											__lowerCamelCase		       =    self.model_tester.num_hidden_layers + 1
											self.assertEqual(len(lowerCamelCase__							)			,						lowerCamelCase__							)

											__lowerCamelCase		       =    self.model_tester.seq_length

											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]							)			,						[seq_length, self.model_tester.hidden_size]			,						)

							__lowerCamelCase       ,						__lowerCamelCase		       =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowerCamelCase		       =    True
											check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__lowerCamelCase		       =    True

											check_hidden_states_output(lowerCamelCase__			,						lowerCamelCase__			,						lowerCamelCase__							)







def 			lowerCamelCase_		(       )     ->       Any:





				"""simple docstring"""


				__lowerCamelCase		       =    hf_hub_download(
				    repo_id='hf-internal-testing/spaghetti-video' ,     filename='eating_spaghetti.npy' ,     repo_type='dataset'      )
				__lowerCamelCase		       =    np.load(UpperCamelCase__      )
				return list(UpperCamelCase__      )







@require_torch
@require_vision
class     __lowerCAmelCase (       unittest.TestCase ):

			"""simple docstring"""







			@cached_property
			def       lowercase_    (      self							)    ->      List[Any]:



							'''simple docstring'''
							# logits were tested with a different mean and std, so we use the same here
							return (
							    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]			,						image_std=[0.5, 0.5, 0.5]							)
							    if is_vision_available()
							    else None
							)






			@slow
			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							__lowerCamelCase		       =    TimesformerForVideoClassification.from_pretrained('facebook/timesformer-base-finetuned-k400'							).to(
							    lowerCamelCase__							)

							__lowerCamelCase		       =    self.default_image_processor
							__lowerCamelCase		       =    prepare_video()
							__lowerCamelCase		       =    image_processor(video[:8]			,						return_tensors='pt'							).to(lowerCamelCase__							)

							# forward pass
							with torch.no_grad():
											__lowerCamelCase		       =    model(**lowerCamelCase__							)

							# verify the logits
							__lowerCamelCase		       =    torch.Size((1, 400)							)
							self.assertEqual(outputs.logits.shape			,						lowerCamelCase__							)

							__lowerCamelCase		       =    torch.tensor([-0.30_16, -0.77_13, -0.42_05]							).to(lowerCamelCase__							)

							self.assertTrue(torch.allclose(outputs.logits[0, :3]			,						lowerCamelCase__			,						atol=1e-4							)							)


