

import inspect
import unittest

from transformers import YolosConfig
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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import YolosForObjectDetection, YolosModel
					from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor







class 				lowercase       :




				def __init__(      self   ,     snake_case   ,     snake_case=13   ,     snake_case=[30, 30]   ,     snake_case=2   ,     snake_case=3   ,     snake_case=True   ,     snake_case=True   ,     snake_case=32   ,     snake_case=5   ,     snake_case=4   ,     snake_case=37   ,     snake_case="gelu"   ,     snake_case=0.1   ,     snake_case=0.1   ,     snake_case=10   ,     snake_case=0.02   ,     snake_case=3   ,     snake_case=None   ,     snake_case=8   ,     snake_case=10   ,     ):
											snake_case_           =					parent
											snake_case_           =					batch_size
											snake_case_           =					image_size
											snake_case_           =					patch_size
											snake_case_           =					num_channels
											snake_case_           =					is_training
											snake_case_           =					use_labels
											snake_case_           =					hidden_size
											snake_case_           =					num_hidden_layers
											snake_case_           =					num_attention_heads
											snake_case_           =					intermediate_size
											snake_case_           =					hidden_act
											snake_case_           =					hidden_dropout_prob
											snake_case_           =					attention_probs_dropout_prob
											snake_case_           =					type_sequence_label_size
											snake_case_           =					initializer_range
											snake_case_           =					num_labels
											snake_case_           =					scope
											snake_case_           =					n_targets
											snake_case_           =					num_detection_tokens
											# we set the expected sequence length (which is used in several tests)
											# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
											snake_case_           =					(image_size[1] // patch_size) * (image_size[0] // patch_size)
											snake_case_           =					num_patches + 1 + self.num_detection_tokens




				def 					a							(      self ):
											snake_case_           =					floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]] )

											snake_case_           =					None
											if self.use_labels:
																		# labels is a list of Dict (each Dict being the labels for a given example in the batch)
																		snake_case_           =					[]
																		for i in range(self.batch_size ):
																									snake_case_           =					{}
																									snake_case_           =					torch.randint(
																									    high=self.num_labels   ,     size=(self.n_targets,)   ,     device=snake_case )
																									snake_case_           =					torch.rand(self.n_targets   ,     4   ,     device=snake_case )
																									labels.append(snake_case )

											snake_case_           =					self.get_config()

											return config, pixel_values, labels




				def 					a							(      self ):
											return YolosConfig(
											    image_size=self.image_size   ,     patch_size=self.patch_size   ,     num_channels=self.num_channels   ,     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   ,     is_decoder=snake_case   ,     initializer_range=self.initializer_range   ,     num_detection_tokens=self.num_detection_tokens   ,     num_labels=self.num_labels   ,     )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					YolosModel(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )
											self.parent.assertEqual(
											    result.last_hidden_state.shape   ,     (self.batch_size, self.expected_seq_len, self.hidden_size) )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					YolosForObjectDetection(snake_case )
											model.to(snake_case )
											model.eval()

											snake_case_           =					model(pixel_values=snake_case )
											snake_case_           =					model(snake_case )

											self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, self.num_detection_tokens, self.num_labels + 1) )
											self.parent.assertEqual(result.pred_boxes.shape   ,     (self.batch_size, self.num_detection_tokens, 4) )

											snake_case_           =					model(pixel_values=snake_case   ,     labels=snake_case )

											self.parent.assertEqual(result.loss.shape   ,     () )
											self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, self.num_detection_tokens, self.num_labels + 1) )
											self.parent.assertEqual(result.pred_boxes.shape   ,     (self.batch_size, self.num_detection_tokens, 4) )




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







@require_torch
class 				lowercase       ( lowercase_			,						lowercase_			,						unittest.TestCase    ):
				__SCREAMING_SNAKE_CASE      :				Any     =    (YolosModel, YolosForObjectDetection) if is_torch_available() else ()
				__SCREAMING_SNAKE_CASE      :				Dict     =    (
				    {'''feature-extraction''': YolosModel, '''object-detection''': YolosForObjectDetection} if is_torch_available() else {}
				)

				__SCREAMING_SNAKE_CASE      :				Optional[Any]     =    False
				__SCREAMING_SNAKE_CASE      :				Dict     =    False
				__SCREAMING_SNAKE_CASE      :				List[str]     =    False
				__SCREAMING_SNAKE_CASE      :				Optional[int]     =    False




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case=False ):
											snake_case_           =					super()._prepare_for_class(snake_case   ,     snake_case   ,     return_labels=snake_case )

											if return_labels:
																		if model_class.__name__ == "YolosForObjectDetection":
																									snake_case_           =					[]
																									for i in range(self.model_tester.batch_size ):
																																snake_case_           =					{}
																																snake_case_           =					torch.ones(
																																    size=(self.model_tester.n_targets,)   ,     device=snake_case   ,     dtype=torch.long )
																																snake_case_           =					torch.ones(
																																    self.model_tester.n_targets   ,     4   ,     device=snake_case   ,     dtype=torch.float )
																																labels.append(snake_case )
																									snake_case_           =					labels

											return inputs_dict




				def 					a							(      self ):
											snake_case_           =					YolosModelTester(self )
											snake_case_           =					ConfigTester(self   ,     config_class=snake_case   ,     has_text_modality=snake_case   ,     hidden_size=37 )




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




				def 					a							(      self ):
											# YOLOS does not use inputs_embeds
											pass




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

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




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

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

																		snake_case_           =					['pixel_values']
																		self.assertListEqual(arg_names[:1]   ,     snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case )




				def 					a							(      self ):
											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_           =					True

											# in YOLOS, the seq_len is different
											snake_case_           =					self.model_tester.expected_seq_len
											for model_class in self.all_model_classes:
																		snake_case_           =					True
																		snake_case_           =					False
																		snake_case_           =					True
																		snake_case_           =					model_class(snake_case )
																		model.to(snake_case )
																		model.eval()
																		with torch.no_grad():
																									snake_case_           =					model(**self._prepare_for_class(snake_case   ,     snake_case ) )
																		snake_case_           =					outputs.attentions
																		self.assertEqual(len(snake_case )   ,     self.model_tester.num_hidden_layers )

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

																		self.assertListEqual(
																		    list(attentions[0].shape[-3:] )   ,     [self.model_tester.num_attention_heads, seq_len, seq_len]   ,     )
																		snake_case_           =					len(snake_case )

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

																		snake_case_           =					1
																		self.assertEqual(out_len + added_hidden_states   ,     len(snake_case ) )

																		snake_case_           =					outputs.attentions

																		self.assertEqual(len(snake_case )   ,     self.model_tester.num_hidden_layers )
																		self.assertListEqual(
																		    list(self_attentions[0].shape[-3:] )   ,     [self.model_tester.num_attention_heads, seq_len, seq_len]   ,     )




				def 					a							(      self ):
											def check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case ):
																		snake_case_           =					model_class(snake_case )
																		model.to(snake_case )
																		model.eval()

																		with torch.no_grad():
																									snake_case_           =					model(**self._prepare_for_class(snake_case   ,     snake_case ) )

																		snake_case_           =					outputs.hidden_states

																		snake_case_           =					getattr(
																		    self.model_tester   ,     'expected_num_hidden_layers'   ,     self.model_tester.num_hidden_layers + 1 )
																		self.assertEqual(len(snake_case )   ,     snake_case )

																		# YOLOS has a different seq_length
																		snake_case_           =					self.model_tester.expected_seq_len

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

											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		snake_case_           =					True
																		check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case )

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

																		check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_object_detection(*snake_case )




				@slow
				def 					a							(      self ):
											for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		snake_case_           =					YolosModel.from_pretrained(snake_case )
																		self.assertIsNotNone(snake_case )





def       __lowerCamelCase			(				):







							'''simple docstring'''






							snake_case_           =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
							return image







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




				@cached_property
				def 					a							(      self ):
											return AutoImageProcessor.from_pretrained('hustvl/yolos-small' ) if is_vision_available() else None




				@slow
				def 					a							(      self ):
											snake_case_           =					YolosForObjectDetection.from_pretrained('hustvl/yolos-small' ).to(snake_case )

											snake_case_           =					self.default_image_processor
											snake_case_           =					prepare_img()
											snake_case_           =					image_processor(images=snake_case   ,     return_tensors='pt' ).to(snake_case )

											# forward pass
											with torch.no_grad():
																		snake_case_           =					model(inputs.pixel_values )

											# verify outputs
											snake_case_           =					torch.Size((1, 100, 92) )
											self.assertEqual(outputs.logits.shape   ,     snake_case )

											snake_case_           =					torch.tensor(
											    [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]]   ,     device=snake_case   ,     )
											snake_case_           =					torch.tensor(
											    [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]]   ,     device=snake_case )
											self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]   ,     snake_case   ,     atol=1e-4 ) )
											self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3]   ,     snake_case   ,     atol=1e-4 ) )

											# verify postprocessing
											snake_case_           =					image_processor.post_process_object_detection(
											    snake_case   ,     threshold=0.3   ,     target_sizes=[image.size[::-1]] )[0]
											snake_case_           =					torch.tensor([0.99_94, 0.97_90, 0.99_64, 0.99_72, 0.98_61] ).to(snake_case )
											snake_case_           =					[75, 75, 17, 63, 17]
											snake_case_           =					torch.tensor([3_35.06_09, 79.38_48, 3_75.42_16, 1_87.24_95] ).to(snake_case )

											self.assertEqual(len(results['scores'] )   ,     5 )
											self.assertTrue(torch.allclose(results['scores']   ,     snake_case   ,     atol=1e-4 ) )
											self.assertSequenceEqual(results['labels'].tolist()   ,     snake_case )
											self.assertTrue(torch.allclose(results['boxes'][0, :]   ,     snake_case ) )







import warnings

from ...utils import logging
from .image_processing_deformable_detr import DeformableDetrImageProcessor


_UpperCAmelCase	:     Any		       = logging.get_logger(__name__)







class 				lowercase       ( lowercase_    ):




				def __init__(      self   ,     *snake_case   ,     **snake_case ):
											warnings.warn(
											    'The class DeformableDetrFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
											    ' Please use DeformableDetrImageProcessor instead.'   ,     snake_case   ,     )
											super().__init__(*snake_case   ,     **snake_case )




