



"""simple docstring"""
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    SCREAMING_SNAKE_CASE__ :

				def __init__(				self			:				str ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				str=1_3 ,  lowerCAmelCase_			:				Union[str, Any]=1_0 ,  lowerCAmelCase_			:				Optional[Any]=3 ,  lowerCAmelCase_			:				List[str]=2 ,  lowerCAmelCase_			:				int=2 ,  lowerCAmelCase_			:				List[Any]=True ,  lowerCAmelCase_			:				Dict=True ,  lowerCAmelCase_			:				List[str]=3_2 ,  lowerCAmelCase_			:				Optional[Any]=5 ,  lowerCAmelCase_			:				Union[str, Any]=4 ,  lowerCAmelCase_			:				Tuple=3_7 ,  lowerCAmelCase_			:				Any="gelu" ,  lowerCAmelCase_			:				Tuple=0.1 ,  lowerCAmelCase_			:				str=0.1 ,  lowerCAmelCase_			:				Optional[int]=1_0 ,  lowerCAmelCase_			:				str=0.02 ,  lowerCAmelCase_			:				Optional[Any]="divided_space_time" ,  lowerCAmelCase_			:				str=None ,  ):







						"""simple docstring"""







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

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

				def 					_UpperCAmelCase	(				self			:				Tuple):







						"""simple docstring"""







						lowercase_								= floats_tensor(
						    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

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

						lowercase_								= self.get_config()

						return config, pixel_values, labels

				def 					_UpperCAmelCase	(				self			:				List[str]):







						"""simple docstring"""







						lowercase_								= 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 ,  )
						lowercase_								= self.num_labels
						return config

				def 					_UpperCAmelCase	(				self			:				Optional[int] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				str):







						"""simple docstring"""







						lowercase_								= TimesformerModel(config=lowerCAmelCase_)
						model.to(lowerCAmelCase_)
						model.eval()
						lowercase_								= model(lowerCAmelCase_)
						self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size))

				def 					_UpperCAmelCase	(				self			:				List[str] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Any):







						"""simple docstring"""







						lowercase_								= TimesformerForVideoClassification(lowerCAmelCase_)
						model.to(lowerCAmelCase_)
						model.eval()

						lowercase_								= model(lowerCAmelCase_)

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




				def 					_UpperCAmelCase	(				self			:				Optional[int]):







						"""simple docstring"""







						lowercase_								= self.prepare_config_and_inputs()
						lowercase_					,    lowercase_					,    lowercase_								= config_and_inputs
						lowercase_								= {"""pixel_values""": pixel_values}
						return config, inputs_dict







@require_torch
class    SCREAMING_SNAKE_CASE__ (							__UpperCAmelCase      ,  __UpperCAmelCase      ,  unittest.TestCase   ):
				lowercase__      =   (TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
				lowercase__      =   (
				    {"feature-extraction": TimesformerModel, "video-classification": TimesformerForVideoClassification}
				    if is_torch_available()
				    else {}
				)

				lowercase__      =   False
				lowercase__      =   False
				lowercase__      =   False
				lowercase__      =   False

				def 					_UpperCAmelCase	(				self			:				Tuple):







						"""simple docstring"""







						lowercase_								= TimesformerModelTester(self)
						lowercase_								= ConfigTester(
						    self ,  config_class=lowerCAmelCase_ ,  has_text_modality=lowerCAmelCase_ ,  hidden_size=3_7)

				def 					_UpperCAmelCase	(				self			:				List[str] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				List[Any]=False):







						"""simple docstring"""







						lowercase_								= copy.deepcopy(lowerCAmelCase_)

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

						return inputs_dict

				def 					_UpperCAmelCase	(				self			:				List[str]):







						"""simple docstring"""







						self.config_tester.run_common_tests()

				@unittest.skip(reason="""TimeSformer does not use inputs_embeds""")
				def 					_UpperCAmelCase	(				self			:				Tuple):







						"""simple docstring"""







						pass

				def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







						"""simple docstring"""







						lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

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

				def 					_UpperCAmelCase	(				self			:				str):







						"""simple docstring"""







						lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

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

								lowercase_								= ["""pixel_values"""]
								self.assertListEqual(arg_names[:1] ,  lowerCAmelCase_)

				def 					_UpperCAmelCase	(				self			:				int):







						"""simple docstring"""







						lowercase_								= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase_)

				def 					_UpperCAmelCase	(				self			:				Optional[Any]):







						"""simple docstring"""







						lowercase_								= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase_)

				@slow
				def 					_UpperCAmelCase	(				self			:				int):







						"""simple docstring"""







						for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								lowercase_								= TimesformerModel.from_pretrained(lowerCAmelCase_)
								self.assertIsNotNone(lowerCAmelCase_)

				def 					_UpperCAmelCase	(				self			:				List[Any]):







						"""simple docstring"""







						if not self.has_attentions:
								pass

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

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

										lowercase_								= True
										lowercase_								= False
										lowercase_								= True
										lowercase_								= model_class(lowerCAmelCase_)
										model.to(lowerCAmelCase_)
										model.eval()
										with torch.no_grad():
												lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))
										lowercase_								= 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"]
										lowercase_								= True
										lowercase_								= model_class(lowerCAmelCase_)
										model.to(lowerCAmelCase_)
										model.eval()
										with torch.no_grad():
												lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))
										lowercase_								= 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] ,  )
										lowercase_								= len(lowerCAmelCase_)

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

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

										lowercase_								= 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 					_UpperCAmelCase	(				self			:				List[str]):







						"""simple docstring"""







						def check_hidden_states_output(lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				List[Any]):
								lowercase_								= model_class(lowerCAmelCase_)
								model.to(lowerCAmelCase_)
								model.eval()

								with torch.no_grad():
										lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))

								lowercase_								= outputs.hidden_states
								lowercase_								= self.model_tester.num_hidden_layers + 1
								self.assertEqual(len(lowerCAmelCase_) ,  lowerCAmelCase_)

								lowercase_								= self.model_tester.seq_length

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

						lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
								lowercase_								= True
								check_hidden_states_output(lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_)

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

								check_hidden_states_output(lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_)







def 			_SCREAMING_SNAKE_CASE						() ->						List[str]:







		'''simple docstring'''


		lowercase_								= hf_hub_download(
		    repo_id="""hf-internal-testing/spaghetti-video""" ,  filename="""eating_spaghetti.npy""" ,  repo_type="""dataset"""							)
		lowercase_								= np.load(__lowerCAmelCase							)
		return list(__lowerCAmelCase							)


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

				@cached_property
				def 					_UpperCAmelCase	(				self			:				int):







						"""simple docstring"""







						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 					_UpperCAmelCase	(				self			:				List[Any]):







						"""simple docstring"""







						lowercase_								= TimesformerForVideoClassification.from_pretrained("""facebook/timesformer-base-finetuned-k400""").to(
						    lowerCAmelCase_)

						lowercase_								= self.default_image_processor
						lowercase_								= prepare_video()
						lowercase_								= image_processor(video[:8] ,  return_tensors="""pt""").to(lowerCAmelCase_)

						# forward pass
						with torch.no_grad():
								lowercase_								= model(**lowerCAmelCase_)

						# verify the logits
						lowercase_								= torch.Size((1, 4_0_0))
						self.assertEqual(outputs.logits.shape ,  lowerCAmelCase_)

						lowercase_								= torch.tensor([-0.3_016, -0.7_713, -0.4_205]).to(lowerCAmelCase_)

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






"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import _LazyModule


UpperCAmelCase						:		List[Any]			= {"tokenization_bertweet": ["BertweetTokenizer"]}


if TYPE_CHECKING:
       from .tokenization_bertweet import BertweetTokenizer

else:
       import sys

       UpperCAmelCase						:		Tuple			= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

