



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	:       Union[str, Any]			,     lowercase	:       List[Any]			,     lowercase	:       List[Any]=13			,     lowercase	:       Tuple=10			,     lowercase	:       List[str]=3			,     lowercase	:       Dict=2			,     lowercase	:       Any=2			,     lowercase	:       Optional[int]=True			,     lowercase	:       Optional[int]=True			,     lowercase	:       Union[str, Any]=32			,     lowercase	:       Any=5			,     lowercase	:       Optional[Any]=4			,     lowercase	:       Union[str, Any]=37			,     lowercase	:       int="gelu"			,     lowercase	:       Optional[int]=0.1			,     lowercase	:       int=0.1			,     lowercase	:       List[str]=10			,     lowercase	:       int=0.02			,     lowercase	:       int="divided_space_time"			,     lowercase	:       int=None			,     )						->					Tuple:
									"""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 		snake_case__			(				self	:       Union[str, Any]   )						->					List[Any]:
									"""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 		snake_case__			(				self	:       Optional[int]   )						->					Optional[int]:
									"""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 		snake_case__			(				self	:       Dict			,     lowercase	:       str			,     lowercase	:       Tuple			,     lowercase	:       str   )						->					Union[str, Any]:
									"""simple docstring"""







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





			def 		snake_case__			(				self	:       str			,     lowercase	:       List[str]			,     lowercase	:       List[Any]			,     lowercase	:       Optional[int]   )						->					Any:
									"""simple docstring"""







									__lowercase					=				TimesformerForVideoClassification(lowercase   )
									model.to(lowercase   )
									model.eval()

									__lowercase					=				model(lowercase   )

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







			def 		snake_case__			(				self	:       Tuple   )						->					Tuple:
									"""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 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  str      =			(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
			lowercase__      :  Any      =			(
			    {"""feature-extraction""": TimesformerModel, """video-classification""": TimesformerForVideoClassification}
			    if is_torch_available()
			    else {}
			)

			lowercase__      :  List[str]      =			False
			lowercase__      :  Any      =			False
			lowercase__      :  Union[str, Any]      =			False
			lowercase__      :  Optional[int]      =			False





			def 		snake_case__			(				self	:       Dict   )						->					Dict:
									"""simple docstring"""







									__lowercase					=				TimesformerModelTester(self   )
									__lowercase					=				ConfigTester(
									    self			,     config_class=lowercase			,     has_text_modality=lowercase			,     hidden_size=37   )





			def 		snake_case__			(				self	:       Optional[int]			,     lowercase	:       Union[str, Any]			,     lowercase	:       Union[str, Any]			,     lowercase	:       Tuple=False   )						->					Optional[Any]:
									"""simple docstring"""







									__lowercase					=				copy.deepcopy(lowercase   )

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

									return inputs_dict





			def 		snake_case__			(				self	:       List[Any]   )						->					int:
									"""simple docstring"""







									self.config_tester.run_common_tests()





			@unittest.skip(reason="""TimeSformer does not use inputs_embeds"""   )
			def 		snake_case__			(				self	:       List[str]   )						->					Any:
									"""simple docstring"""







									pass





			def 		snake_case__			(				self	:       int   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()

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





			def 		snake_case__			(				self	:       str   )						->					Tuple:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															__lowercase					=				model_class(lowercase   )
															__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]			,     lowercase   )





			def 		snake_case__			(				self	:       Tuple   )						->					Dict:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowercase   )





			def 		snake_case__			(				self	:       Union[str, Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_video_classification(*lowercase   )





			@slow
			def 		snake_case__			(				self	:       Optional[int]   )						->					Optional[Any]:
									"""simple docstring"""







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





			def 		snake_case__			(				self	:       Dict   )						->					Union[str, 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(lowercase   )
																					model.to(lowercase   )
																					model.eval()
																					with torch.no_grad():
																											__lowercase					=				model(**self._prepare_for_class(lowercase			,     lowercase   )   )
																					__lowercase					=				outputs.attentions
																					self.assertEqual(len(lowercase   )			,     self.model_tester.num_hidden_layers   )

																					# check that output_attentions also work using config
																					del inputs_dict["output_attentions"]
																					__lowercase					=				True
																					__lowercase					=				model_class(lowercase   )
																					model.to(lowercase   )
																					model.eval()
																					with torch.no_grad():
																											__lowercase					=				model(**self._prepare_for_class(lowercase			,     lowercase   )   )
																					__lowercase					=				outputs.attentions
																					self.assertEqual(len(lowercase   )			,     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(lowercase   )

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

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

																					__lowercase					=				outputs.attentions

																					self.assertEqual(len(lowercase   )			,     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	:       Dict   )						->					List[Any]:
									"""simple docstring"""







									def check_hidden_states_output(lowercase	:       List[Any]			,     lowercase	:       Dict			,     lowercase	:       Union[str, Any]   ):
															__lowercase					=				model_class(lowercase   )
															model.to(lowercase   )
															model.eval()

															with torch.no_grad():
																					__lowercase					=				model(**self._prepare_for_class(lowercase			,     lowercase   )   )

															__lowercase					=				outputs.hidden_states
															__lowercase					=				self.model_tester.num_hidden_layers + 1
															self.assertEqual(len(lowercase   )			,     lowercase   )

															__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(lowercase			,     lowercase			,     lowercase   )

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

															check_hidden_states_output(lowercase			,     lowercase			,     lowercase   )






def  UpperCAmelCase__    (    ) ->      List[Any]:
						__lowercase					=				hf_hub_download(
						    repo_id="""hf-internal-testing/spaghetti-video"""						,       filename="""eating_spaghetti.npy"""						,       repo_type="""dataset"""   )
						__lowercase					=				np.load(lowercase__   )
						return list(lowercase__   )







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






			"""simple docstring"""





			@cached_property
			def 		snake_case__			(				self	:       Dict   )						->					Union[str, Any]:
									"""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 		snake_case__			(				self	:       Tuple   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase					=				TimesformerForVideoClassification.from_pretrained("""facebook/timesformer-base-finetuned-k400"""   ).to(
									    lowercase   )

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

									# forward pass
									with torch.no_grad():
															__lowercase					=				model(**lowercase   )

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

									__lowercase					=				torch.tensor([-0.3016, -0.7713, -0.4205]   ).to(lowercase   )

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










from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCamelCase__ =						logging.get_logger(__name__)

UpperCamelCase__ =						{
    "hustvl/yolos-small": "https://huggingface.co/hustvl/yolos-small/resolve/main/config.json",
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}
class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  Union[str, Any]      =			"""yolos"""





			def __init__(				self	:       Optional[int]			,     lowercase	:       Any=768			,     lowercase	:       Tuple=12			,     lowercase	:       Tuple=12			,     lowercase	:       str=3_072			,     lowercase	:       Optional[Any]="gelu"			,     lowercase	:       Union[str, Any]=0.0			,     lowercase	:       Dict=0.0			,     lowercase	:       Optional[int]=0.02			,     lowercase	:       Optional[Any]=1E-1_2			,     lowercase	:       Tuple=[512, 864]			,     lowercase	:       Optional[int]=16			,     lowercase	:       Dict=3			,     lowercase	:       Optional[Any]=True			,     lowercase	:       Optional[int]=100			,     lowercase	:       Optional[int]=True			,     lowercase	:       Any=False			,     lowercase	:       Any=1			,     lowercase	:       Any=5			,     lowercase	:       List[str]=2			,     lowercase	:       Union[str, Any]=5			,     lowercase	:       str=2			,     lowercase	:       Tuple=0.1			,     **lowercase	:       str			,     )						->					Optional[Any]:
									"""simple docstring"""







									super().__init__(**lowercase   )

									__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					=				initializer_range
									__lowercase					=				layer_norm_eps
									__lowercase					=				image_size
									__lowercase					=				patch_size
									__lowercase					=				num_channels
									__lowercase					=				qkv_bias
									__lowercase					=				num_detection_tokens
									__lowercase					=				use_mid_position_embeddings
									__lowercase					=				auxiliary_loss
									# Hungarian matcher
									__lowercase					=				class_cost
									__lowercase					=				bbox_cost
									__lowercase					=				giou_cost
									# Loss coefficients
									__lowercase					=				bbox_loss_coefficient
									__lowercase					=				giou_loss_coefficient
									__lowercase					=				eos_coefficient





class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  Dict      =			version.parse("""1.11"""			)





			@property
			def 		snake_case__			(				self	:       List[str]   )						->					Mapping[str, Mapping[int, str]]:
									"""simple docstring"""







									return OrderedDict(
									    [
									        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
									    ]   )





			@property
			def 		snake_case__			(				self	:       int   )						->					float:
									"""simple docstring"""







									return 1E-4







			@property
			def 		snake_case__			(				self	:       Optional[Any]   )						->					int:
									"""simple docstring"""







									return 12





