
"""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_ :




		"""simple docstring"""





		def __init__(     self							,  lowerCAmelCase__							,  lowerCAmelCase__=1_3							,  lowerCAmelCase__=1_0							,  lowerCAmelCase__=3							,  lowerCAmelCase__=2							,  lowerCAmelCase__=2							,  lowerCAmelCase__=True							,  lowerCAmelCase__=True							,  lowerCAmelCase__=3_2							,  lowerCAmelCase__=5							,  lowerCAmelCase__=4							,  lowerCAmelCase__=3_7							,  lowerCAmelCase__="gelu"							,  lowerCAmelCase__=0.1							,  lowerCAmelCase__=0.1							,  lowerCAmelCase__=1_0							,  lowerCAmelCase__=0.02							,  lowerCAmelCase__="divided_space_time"							,  lowerCAmelCase__=None							,  ):
				__SCREAMING_SNAKE_CASE            = parent
				__SCREAMING_SNAKE_CASE            = batch_size
				__SCREAMING_SNAKE_CASE            = image_size
				__SCREAMING_SNAKE_CASE            = num_channels
				__SCREAMING_SNAKE_CASE            = patch_size
				__SCREAMING_SNAKE_CASE            = num_frames
				__SCREAMING_SNAKE_CASE            = is_training
				__SCREAMING_SNAKE_CASE            = use_labels
				__SCREAMING_SNAKE_CASE            = hidden_size
				__SCREAMING_SNAKE_CASE            = num_hidden_layers
				__SCREAMING_SNAKE_CASE            = num_attention_heads
				__SCREAMING_SNAKE_CASE            = intermediate_size
				__SCREAMING_SNAKE_CASE            = hidden_act
				__SCREAMING_SNAKE_CASE            = hidden_dropout_prob
				__SCREAMING_SNAKE_CASE            = attention_probs_dropout_prob
				__SCREAMING_SNAKE_CASE            = attention_type
				__SCREAMING_SNAKE_CASE            = initializer_range
				__SCREAMING_SNAKE_CASE            = scope
				__SCREAMING_SNAKE_CASE            = num_labels

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




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = floats_tensor(
				    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

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

				__SCREAMING_SNAKE_CASE            = self.get_config()

				return config, pixel_values, labels




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = 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							,  )
				__SCREAMING_SNAKE_CASE            = self.num_labels
				return config




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = TimesformerModel(config=lowerCAmelCase__)
				model.to(lowerCAmelCase__)
				model.eval()
				__SCREAMING_SNAKE_CASE            = model(lowerCAmelCase__)
				self.parent.assertEqual(result.last_hidden_state.shape							,  (self.batch_size, self.seq_length, self.hidden_size))




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = TimesformerForVideoClassification(lowerCAmelCase__)
				model.to(lowerCAmelCase__)
				model.eval()

				__SCREAMING_SNAKE_CASE            = model(lowerCAmelCase__)

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




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



@require_torch
class 						SCREAMING_SNAKE_CASE_ (						__a     ,				__a     ,				unittest.TestCase ):




		"""simple docstring"""





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

		__lowercase							:  Union[str, Any]						   =		False
		__lowercase							:  Dict						   =		False
		__lowercase							:  Optional[Any]						   =		False
		__lowercase							:  Union[str, Any]						   =		False




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = TimesformerModelTester(self)
				__SCREAMING_SNAKE_CASE            = ConfigTester(
				    self							,  config_class=lowerCAmelCase__							,  has_text_modality=lowerCAmelCase__							,  hidden_size=3_7)




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__=False):
				__SCREAMING_SNAKE_CASE            = copy.deepcopy(lowerCAmelCase__)

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

				return inputs_dict




		def 	snake_case_     (     self):
				self.config_tester.run_common_tests()




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




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

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




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

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

						__SCREAMING_SNAKE_CASE            = ["""pixel_values"""]
						self.assertListEqual(arg_names[:1]							,  lowerCAmelCase__)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCAmelCase__)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase__)




		@slow
		def 	snake_case_     (     self):
				for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						__SCREAMING_SNAKE_CASE            = TimesformerModel.from_pretrained(lowerCAmelCase__)
						self.assertIsNotNone(lowerCAmelCase__)




		def 	snake_case_     (     self):
				if not self.has_attentions:
						pass

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

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

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

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

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

								__SCREAMING_SNAKE_CASE            = 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 	snake_case_     (     self):
				def check_hidden_states_output(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE            = model_class(lowerCAmelCase__)
						model.to(lowerCAmelCase__)
						model.eval()

						with torch.no_grad():
								__SCREAMING_SNAKE_CASE            = model(**self._prepare_for_class(lowerCAmelCase__							,  lowerCAmelCase__))

						__SCREAMING_SNAKE_CASE            = outputs.hidden_states
						__SCREAMING_SNAKE_CASE            = self.model_tester.num_hidden_layers + 1
						self.assertEqual(len(lowerCAmelCase__)							,  lowerCAmelCase__)

						__SCREAMING_SNAKE_CASE            = self.model_tester.seq_length

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

				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						__SCREAMING_SNAKE_CASE            = True
						check_hidden_states_output(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__)

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

						check_hidden_states_output(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__)



def 						_lowerCAmelCase				(				):
		__SCREAMING_SNAKE_CASE            = hf_hub_download(
		    repo_id="""hf-internal-testing/spaghetti-video"""  ,				filename="""eating_spaghetti.npy"""  ,				repo_type="""dataset"""				)
		__SCREAMING_SNAKE_CASE            = np.load(UpperCamelCase_				)
		return list(UpperCamelCase_				)
@require_torch
@require_vision
class 						SCREAMING_SNAKE_CASE_ (						unittest.TestCase ):




		"""simple docstring"""





		@cached_property
		def 	snake_case_     (     self):
				# 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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = TimesformerForVideoClassification.from_pretrained("""facebook/timesformer-base-finetuned-k400""").to(
				    lowerCAmelCase__)

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

				# forward pass
				with torch.no_grad():
						__SCREAMING_SNAKE_CASE            = model(**lowerCAmelCase__)

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

				__SCREAMING_SNAKE_CASE            = 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))






"""simple docstring"""





def 						_lowerCAmelCase				(				UpperCamelCase_				):

		if isinstance(UpperCamelCase_  ,				UpperCamelCase_				):
				raise TypeError("""'float' object cannot be interpreted as an integer"""				)
		if isinstance(UpperCamelCase_  ,				UpperCamelCase_				):
				raise TypeError("""'str' object cannot be interpreted as an integer"""				)

		if num == 0:
				return "0b0"

		__SCREAMING_SNAKE_CASE            = False

		if num < 0:
				__SCREAMING_SNAKE_CASE            = True
				__SCREAMING_SNAKE_CASE            = -num

		__SCREAMING_SNAKE_CASE            = []
		while num > 0:
				binary.insert(0  ,				num % 2				)
				num >>= 1

		if negative:
				return "-0b" + "".join(str(UpperCamelCase_				) for e in binary				)

		return "0b" + "".join(str(UpperCamelCase_				) for e in binary				)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




