





"""simple docstring"""





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      ,						lowercase      ,						lowercase=13      ,						lowercase=[30, 30]      ,						lowercase=2      ,						lowercase=3      ,						lowercase=True      ,						lowercase=True      ,						lowercase=32      ,						lowercase=5      ,						lowercase=4      ,						lowercase=37      ,						lowercase="gelu"      ,						lowercase=0.1      ,						lowercase=0.1      ,						lowercase=10      ,						lowercase=0.02      ,						lowercase=3      ,						lowercase=None      ,						lowercase=8      ,						lowercase=10      ,						)		->     Dict:
            lowerCAmelCase  						=       parent
            lowerCAmelCase  						=       batch_size
            lowerCAmelCase  						=       image_size
            lowerCAmelCase  						=       patch_size
            lowerCAmelCase  						=       num_channels
            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  						=       type_sequence_label_size
            lowerCAmelCase  						=       initializer_range
            lowerCAmelCase  						=       num_labels
            lowerCAmelCase  						=       scope
            lowerCAmelCase  						=       n_targets
            lowerCAmelCase  						=       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
            lowerCAmelCase  						=       (image_size[1] // patch_size) * (image_size[0] // patch_size)
            lowerCAmelCase  						=       num_patches + 1 + self.num_detection_tokens





      def     _snake_case			(       self )		->     Optional[int]:
            lowerCAmelCase  						=       floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]] )

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

            lowerCAmelCase  						=       self.get_config()

            return config, pixel_values, labels





      def     _snake_case			(       self )		->     List[Any]:
            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=lowercase      ,						initializer_range=self.initializer_range      ,						num_detection_tokens=self.num_detection_tokens      ,						num_labels=self.num_labels      ,						)





      def     _snake_case			(       self      ,						lowercase      ,						lowercase      ,						lowercase )		->     Any:
            lowerCAmelCase  						=       YolosModel(config=lowercase )
            model.to(lowercase )
            model.eval()
            lowerCAmelCase  						=       model(lowercase )
            self.parent.assertEqual(
                result.last_hidden_state.shape      ,						(self.batch_size, self.expected_seq_len, self.hidden_size) )





      def     _snake_case			(       self      ,						lowercase      ,						lowercase      ,						lowercase )		->     Tuple:
            lowerCAmelCase  						=       YolosForObjectDetection(lowercase )
            model.to(lowercase )
            model.eval()

            lowerCAmelCase  						=       model(pixel_values=lowercase )
            lowerCAmelCase  						=       model(lowercase )

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

            lowerCAmelCase  						=       model(pixel_values=lowercase      ,						labels=lowercase )

            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     _snake_case			(       self )		->     List[str]:
            lowerCAmelCase  						=       self.prepare_config_and_inputs()
            lowerCAmelCase						,		lowerCAmelCase						,		lowerCAmelCase  						=       config_and_inputs
            lowerCAmelCase  						=       {"""pixel_values""": pixel_values}
            return config, inputs_dict







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

      _SCREAMING_SNAKE_CASE					=      False
      _SCREAMING_SNAKE_CASE					=      False
      _SCREAMING_SNAKE_CASE					=      False
      _SCREAMING_SNAKE_CASE					=      False





      def     _snake_case			(       self      ,						lowercase      ,						lowercase      ,						lowercase=False )		->     Union[str, Any]:
            lowerCAmelCase  						=       super()._prepare_for_class(lowercase      ,						lowercase      ,						return_labels=lowercase )

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

            return inputs_dict





      def     _snake_case			(       self )		->     Union[str, Any]:
            lowerCAmelCase  						=       YolosModelTester(self )
            lowerCAmelCase  						=       ConfigTester(self      ,						config_class=lowercase      ,						has_text_modality=lowercase      ,						hidden_size=37 )





      def     _snake_case			(       self )		->     str:
            self.config_tester.run_common_tests()





      def     _snake_case			(       self )		->     Optional[Any]:
            # YOLOS does not use inputs_embeds
            pass





      def     _snake_case			(       self )		->     Optional[int]:
            lowerCAmelCase						,		lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs_for_common()

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





      def     _snake_case			(       self )		->     List[Any]:
            lowerCAmelCase						,		lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs_for_common()

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





      def     _snake_case			(       self )		->     Union[str, Any]:
            lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowercase )





      def     _snake_case			(       self )		->     Any:
            lowerCAmelCase						,		lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs_for_common()
            lowerCAmelCase  						=       True

            # in YOLOS, the seq_len is different
            lowerCAmelCase  						=       self.model_tester.expected_seq_len
            for model_class in self.all_model_classes:
                  lowerCAmelCase  						=       True
                  lowerCAmelCase  						=       False
                  lowerCAmelCase  						=       True
                  lowerCAmelCase  						=       model_class(lowercase )
                  model.to(lowercase )
                  model.eval()
                  with torch.no_grad():
                        lowerCAmelCase  						=       model(**self._prepare_for_class(lowercase      ,						lowercase ) )
                  lowerCAmelCase  						=       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"]
                  lowerCAmelCase  						=       True
                  lowerCAmelCase  						=       model_class(lowercase )
                  model.to(lowercase )
                  model.eval()
                  with torch.no_grad():
                        lowerCAmelCase  						=       model(**self._prepare_for_class(lowercase      ,						lowercase ) )
                  lowerCAmelCase  						=       outputs.attentions
                  self.assertEqual(len(lowercase )      ,						self.model_tester.num_hidden_layers )

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

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

                  lowerCAmelCase  						=       1
                  self.assertEqual(out_len + added_hidden_states      ,						len(lowercase ) )

                  lowerCAmelCase  						=       outputs.attentions

                  self.assertEqual(len(lowercase )      ,						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     _snake_case			(       self )		->     Optional[Any]:
            def check_hidden_states_output(lowercase      ,						lowercase      ,						lowercase ):
                  lowerCAmelCase  						=       model_class(lowercase )
                  model.to(lowercase )
                  model.eval()

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

                  lowerCAmelCase  						=       outputs.hidden_states

                  lowerCAmelCase  						=       getattr(
                      self.model_tester      ,						"""expected_num_hidden_layers"""      ,						self.model_tester.num_hidden_layers + 1 )
                  self.assertEqual(len(lowercase )      ,						lowercase )

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

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

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

                  check_hidden_states_output(lowercase      ,						lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     Union[str, Any]:
            lowerCAmelCase  						=       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_object_detection(*lowercase )





      @slow
      def     _snake_case			(       self )		->     Dict:
            for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowerCAmelCase  						=       YolosModel.from_pretrained(lowercase )
                  self.assertIsNotNone(lowercase )







def 			UpperCAmelCase__							(  ):







      '''simple docstring'''




      lowerCAmelCase  						=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
      return image






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





      @cached_property
      def     _snake_case			(       self )		->     List[str]:
            return AutoImageProcessor.from_pretrained("""hustvl/yolos-small""" ) if is_vision_available() else None





      @slow
      def     _snake_case			(       self )		->     List[str]:
            lowerCAmelCase  						=       YolosForObjectDetection.from_pretrained("""hustvl/yolos-small""" ).to(lowercase )

            lowerCAmelCase  						=       self.default_image_processor
            lowerCAmelCase  						=       prepare_img()
            lowerCAmelCase  						=       image_processor(images=lowercase      ,						return_tensors="""pt""" ).to(lowercase )

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

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

            lowerCAmelCase  						=       torch.tensor(
                [[-24.0_248, -10.3_024, -14.8_290], [-42.0_392, -16.8_200, -27.4_334], [-27.2_743, -11.8_154, -18.7_148]]      ,						device=lowercase      ,						)
            lowerCAmelCase  						=       torch.tensor(
                [[0.2_559, 0.5_455, 0.4_706], [0.2_989, 0.7_279, 0.1_875], [0.7_732, 0.4_017, 0.4_462]]      ,						device=lowercase )
            self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]      ,						lowercase      ,						atol=1e-4 ) )
            self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3]      ,						lowercase      ,						atol=1e-4 ) )

            # verify postprocessing
            lowerCAmelCase  						=       image_processor.post_process_object_detection(
                lowercase      ,						threshold=0.3      ,						target_sizes=[image.size[::-1]] )[0]
            lowerCAmelCase  						=       torch.tensor([0.9_994, 0.9_790, 0.9_964, 0.9_972, 0.9_861] ).to(lowercase )
            lowerCAmelCase  						=       [75, 75, 17, 63, 17]
            lowerCAmelCase  						=       torch.tensor([335.0_609, 79.3_848, 375.4_216, 187.2_495] ).to(lowercase )

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












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_speech_available, is_torch_available


UpperCamelCase__    			=			{
    """configuration_audio_spectrogram_transformer""": [
        """AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """ASTConfig""",
    ]
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__    			=			[
					    """AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """ASTForAudioClassification""",
					    """ASTModel""",
					    """ASTPreTrainedModel""",
					]

try:
					if not is_speech_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__    			=			["""ASTFeatureExtractor"""]

if TYPE_CHECKING:
					from .configuration_audio_spectrogram_transformer import (
					    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    ASTConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_audio_spectrogram_transformer import (
										    AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    ASTForAudioClassification,
										    ASTModel,
										    ASTPreTrainedModel,
										)

					try:
										if not is_speech_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_audio_spectrogram_transformer import ASTFeatureExtractor


else:
					import sys

					UpperCamelCase__    			=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




