

'''simple docstring'''



from copy import deepcopy
from unittest.case import TestCase

import pytest

from datasets.arrow_dataset import Dataset
from datasets.features import Audio, ClassLabel, Features, Image, Sequence, Value
from datasets.info import DatasetInfo
from datasets.tasks import (
    AudioClassification,
    AutomaticSpeechRecognition,
    ImageClassification,
    LanguageModeling,
    QuestionAnsweringExtractive,
    Summarization,
    TextClassification,
    task_template_from_dict,
)
from datasets.utils.py_utils import asdict


SCREAMING_SNAKE_CASE_    =   {
    "id": "5733be284776f41900661182",
    "title": "University_of_Notre_Dame",
    "context": "Architecturally, the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend \"Venite Ad Me Omnes\". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858. At the end of the main drive (and in a direct line that connects through 3 statues and the Gold Dome), is a simple, modern stone statue of Mary.",
    "question": "To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France?",
    "answers": {"text": ["Saint Bernadette Soubirous"], "answer_start": [515]},
}

@pytest.mark.parametrize(
    'task_cls'			,      [
        AudioClassification,
        AutomaticSpeechRecognition,
        ImageClassification,
        LanguageModeling,
        QuestionAnsweringExtractive,
        Summarization,
        TextClassification,
    ]			,      )
def   lowerCamelCase__       (      a__)		->    List[Any]:



    """simple docstring"""







    _snake_case : Union[str, Any]												=		task_cls()
    _snake_case : List[str]												=		asdict(a__)
    _snake_case : Dict												=		task_template_from_dict(a__)
    assert task == reloaded

class 			SCREAMING_SNAKE_CASE					:






      '''simple docstring'''






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



          """simple docstring"""





          _snake_case : Any												=		LanguageModeling(text_column='input_text'   )
          assert {"input_text": "text"} == task.column_mapping




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : List[Any]												=		Features({'text': Value('string'   )}   )
          _snake_case : Dict												=		{'text_column': 'input_text'}
          _snake_case : List[Any]												=		LanguageModeling.from_dict(snake_case   )
          assert "language-modeling" == task.task
          assert input_schema == task.input_schema



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          _snake_case : str												=		sorted(['pos', 'neg']   )




      def 	__UpperCAmelCase			(					self :		Optional[Any]   ):



          """simple docstring"""





          _snake_case : Optional[int]												=		TextClassification(text_column='input_text'     ,					label_column='input_label'   )
          self.assertDictEqual({'input_text': 'text', 'input_label': 'labels'}     ,					task.column_mapping   )




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



          """simple docstring"""





          _snake_case : Union[str, Any]												=		Features({'text': Value('string'   )}   )
          # Labels are cast to tuple during `TextClassification.__post_init__`, so we do the same here
          _snake_case : Optional[int]												=		Features({'labels': ClassLabel}   )
          _snake_case : Optional[Any]												=		{'text_column': 'input_text', 'label_column': 'input_labels'}
          _snake_case : int												=		TextClassification.from_dict(snake_case   )
          self.assertEqual('text-classification'     ,					task.task   )
          self.assertEqual(snake_case     ,					task.input_schema   )
          self.assertEqual(snake_case     ,					task.label_schema   )




      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          _snake_case : List[Any]												=		TextClassification(text_column='input_text'     ,					label_column='input_label'   )
          self.assertEqual(task.label_schema['labels']     ,					snake_case   )
          _snake_case : str												=		task.align_with_features(Features({'input_label': ClassLabel(names=self.labels   )}   )   )
          self.assertEqual(task.label_schema['labels']     ,					ClassLabel(names=self.labels   )   )



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		List[Any]   ):



          """simple docstring"""





          _snake_case : Union[str, Any]												=		QuestionAnsweringExtractive(
              context_column='input_context'     ,					question_column='input_question'     ,					answers_column='input_answers'   )
          self.assertDictEqual(
              {'input_context': 'context', 'input_question': 'question', 'input_answers': 'answers'}     ,					task.column_mapping   )




      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          _snake_case : str												=		Features({'question': Value('string'   ), 'context': Value('string'   )}   )
          _snake_case : Dict												=		Features(
              {
                  'answers': Sequence(
                      {
                          'text': Value('string'   ),
                          'answer_start': Value('int32'   ),
                      }   )
              }   )
          _snake_case : Optional[int]												=		{
              'context_column': 'input_input_context',
              'question_column': 'input_question',
              'answers_column': 'input_answers',
          }
          _snake_case : Union[str, Any]												=		QuestionAnsweringExtractive.from_dict(snake_case   )
          self.assertEqual('question-answering-extractive'     ,					task.task   )
          self.assertEqual(snake_case     ,					task.input_schema   )
          self.assertEqual(snake_case     ,					task.label_schema   )



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		List[Any]   ):



          """simple docstring"""





          _snake_case : List[Any]												=		Summarization(text_column='input_text'     ,					summary_column='input_summary'   )
          self.assertDictEqual({'input_text': 'text', 'input_summary': 'summary'}     ,					task.column_mapping   )




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          _snake_case : int												=		Features({'text': Value('string'   )}   )
          _snake_case : str												=		Features({'summary': Value('string'   )}   )
          _snake_case : int												=		{'text_column': 'input_text', 'summary_column': 'input_summary'}
          _snake_case : Dict												=		Summarization.from_dict(snake_case   )
          self.assertEqual('summarization'     ,					task.task   )
          self.assertEqual(snake_case     ,					task.input_schema   )
          self.assertEqual(snake_case     ,					task.label_schema   )



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		List[str]   ):



          """simple docstring"""





          _snake_case : Optional[Any]												=		AutomaticSpeechRecognition(audio_column='input_audio'     ,					transcription_column='input_transcription'   )
          self.assertDictEqual({'input_audio': 'audio', 'input_transcription': 'transcription'}     ,					task.column_mapping   )




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : Any												=		Features({'audio': Audio()}   )
          _snake_case : int												=		Features({'transcription': Value('string'   )}   )
          _snake_case : Dict												=		{
              'audio_column': 'input_audio',
              'transcription_column': 'input_transcription',
          }
          _snake_case : str												=		AutomaticSpeechRecognition.from_dict(snake_case   )
          self.assertEqual('automatic-speech-recognition'     ,					task.task   )
          self.assertEqual(snake_case     ,					task.input_schema   )
          self.assertEqual(snake_case     ,					task.label_schema   )



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		Tuple   ):



          """simple docstring"""





          _snake_case : Union[str, Any]												=		sorted(['pos', 'neg']   )




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          _snake_case : Optional[Any]												=		AudioClassification(audio_column='input_audio'     ,					label_column='input_label'   )
          self.assertDictEqual({'input_audio': 'audio', 'input_label': 'labels'}     ,					task.column_mapping   )




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          _snake_case : Optional[int]												=		Features({'audio': Audio()}   )
          _snake_case : str												=		Features({'labels': ClassLabel}   )
          _snake_case : List[Any]												=		{
              'audio_column': 'input_image',
              'label_column': 'input_label',
          }
          _snake_case : int												=		AudioClassification.from_dict(snake_case   )
          self.assertEqual('audio-classification'     ,					task.task   )
          self.assertEqual(snake_case     ,					task.input_schema   )
          self.assertEqual(snake_case     ,					task.label_schema   )




      def 	__UpperCAmelCase			(					self :		int   ):



          """simple docstring"""





          _snake_case : Tuple												=		AudioClassification(audio_column='input_audio'     ,					label_column='input_label'   )
          self.assertEqual(task.label_schema['labels']     ,					snake_case   )
          _snake_case : List[Any]												=		task.align_with_features(Features({'input_label': ClassLabel(names=self.labels   )}   )   )
          self.assertEqual(task.label_schema['labels']     ,					ClassLabel(names=self.labels   )   )



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		List[str]   ):



          """simple docstring"""





          _snake_case : List[str]												=		sorted(['pos', 'neg']   )




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          _snake_case : List[str]												=		ImageClassification(image_column='input_image'     ,					label_column='input_label'   )
          self.assertDictEqual({'input_image': 'image', 'input_label': 'labels'}     ,					task.column_mapping   )




      def 	__UpperCAmelCase			(					self :		List[str]   ):



          """simple docstring"""





          _snake_case : str												=		Features({'image': Image()}   )
          _snake_case : List[Any]												=		Features({'labels': ClassLabel}   )
          _snake_case : Optional[Any]												=		{
              'image_column': 'input_image',
              'label_column': 'input_label',
          }
          _snake_case : int												=		ImageClassification.from_dict(snake_case   )
          self.assertEqual('image-classification'     ,					task.task   )
          self.assertEqual(snake_case     ,					task.input_schema   )
          self.assertEqual(snake_case     ,					task.label_schema   )




      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          _snake_case : List[Any]												=		ImageClassification(image_column='input_image'     ,					label_column='input_label'   )
          self.assertEqual(task.label_schema['labels']     ,					snake_case   )
          _snake_case : List[str]												=		task.align_with_features(Features({'input_label': ClassLabel(names=self.labels   )}   )   )
          self.assertEqual(task.label_schema['labels']     ,					ClassLabel(names=self.labels   )   )



class 			SCREAMING_SNAKE_CASE					(							lowercase_					):






      '''simple docstring'''






      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          _snake_case : str												=		DatasetInfo(task_templates=QuestionAnsweringExtractive()   )
          _snake_case : int												=		Dataset.from_dict({k: [v] for k, v in SAMPLE_QUESTION_ANSWERING_EXTRACTIVE.items()}     ,					info=snake_case   )
          assert isinstance(dataset.info.task_templates     ,					snake_case   )
          assert len(dataset.info.task_templates   ) == 1

          def keep_task(snake_case :		int   ):
              return x

          def dont_keep_task(snake_case :		Optional[int]   ):
              _snake_case : Tuple												=		deepcopy(snake_case   )
              _snake_case : str												=		0
              return out

          _snake_case : str												=		dataset.map(snake_case   )
          assert mapped_dataset.info.task_templates == dataset.info.task_templates
          # reload from cache
          _snake_case : Dict												=		dataset.map(snake_case   )
          assert mapped_dataset.info.task_templates == dataset.info.task_templates

          _snake_case : List[Any]												=		dataset.map(snake_case   )
          assert mapped_dataset.info.task_templates == []
          # reload from cache
          _snake_case : int												=		dataset.map(snake_case   )
          assert mapped_dataset.info.task_templates == []




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : List[str]												=		Features({'text': Value('string'   ), 'label': ClassLabel(names=('pos', 'neg')   )}   )
          _snake_case : str												=		TextClassification(text_column='text'     ,					label_column='label'   )
          _snake_case : Optional[Any]												=		DatasetInfo(features=snake_case     ,					task_templates=snake_case   )
          _snake_case : Optional[Any]												=		Dataset.from_dict({'text': ['A sentence.'], 'label': ['pos']}     ,					info=snake_case   )

          def process(snake_case :		Union[str, Any]   ):
              return example

          _snake_case : Tuple												=		dataset.remove_columns('label'   )
          _snake_case : Union[str, Any]												=		modified_dataset.map(snake_case   )
          assert mapped_dataset.info.task_templates == []






'''simple docstring'''



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers.models.swin.modeling_tf_swin import (
       TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFSwinForImageClassification,
       TFSwinForMaskedImageModeling,
       TFSwinModel,
   )


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor

class 			SCREAMING_SNAKE_CASE					:






      '''simple docstring'''






      def __init__(					self :		List[str]     ,					snake_case :		Any     ,					snake_case :		List[Any]=13     ,					snake_case :		Dict=32     ,					snake_case :		Any=2     ,					snake_case :		List[Any]=3     ,					snake_case :		Tuple=16     ,					snake_case :		Union[str, Any]=[1, 2, 1]     ,					snake_case :		int=[2, 2, 4]     ,					snake_case :		Any=2     ,					snake_case :		Any=2.0     ,					snake_case :		List[str]=True     ,					snake_case :		Tuple=0.0     ,					snake_case :		Any=0.0     ,					snake_case :		Dict=0.1     ,					snake_case :		Union[str, Any]="gelu"     ,					snake_case :		Optional[Any]=False     ,					snake_case :		List[Any]=True     ,					snake_case :		str=0.02     ,					snake_case :		int=1e-5     ,					snake_case :		Optional[Any]=True     ,					snake_case :		Tuple=None     ,					snake_case :		List[str]=True     ,					snake_case :		int=10     ,					snake_case :		Optional[int]=8     ,					):



          """simple docstring"""





          _snake_case : List[str]												=		parent
          _snake_case : Tuple												=		batch_size
          _snake_case : str												=		image_size
          _snake_case : List[str]												=		patch_size
          _snake_case : Optional[int]												=		num_channels
          _snake_case : List[str]												=		embed_dim
          _snake_case : Union[str, Any]												=		depths
          _snake_case : Optional[int]												=		num_heads
          _snake_case : str												=		window_size
          _snake_case : Union[str, Any]												=		mlp_ratio
          _snake_case : str												=		qkv_bias
          _snake_case : Any												=		hidden_dropout_prob
          _snake_case : List[str]												=		attention_probs_dropout_prob
          _snake_case : Dict												=		drop_path_rate
          _snake_case : Dict												=		hidden_act
          _snake_case : Tuple												=		use_absolute_embeddings
          _snake_case : List[str]												=		patch_norm
          _snake_case : str												=		layer_norm_eps
          _snake_case : List[str]												=		initializer_range
          _snake_case : Optional[Any]												=		is_training
          _snake_case : Tuple												=		scope
          _snake_case : List[str]												=		use_labels
          _snake_case : List[str]												=		type_sequence_label_size
          _snake_case : int												=		encoder_stride




      def 	__UpperCAmelCase			(					self :		int   ):



          """simple docstring"""





          _snake_case : Optional[int]												=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

          _snake_case : str												=		None
          if self.use_labels:
              _snake_case : Optional[int]												=		ids_tensor([self.batch_size]     ,					self.type_sequence_label_size   )

          _snake_case : Optional[int]												=		self.get_config()

          return config, pixel_values, labels




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          return SwinConfig(
              image_size=self.image_size     ,					patch_size=self.patch_size     ,					num_channels=self.num_channels     ,					embed_dim=self.embed_dim     ,					depths=self.depths     ,					num_heads=self.num_heads     ,					window_size=self.window_size     ,					mlp_ratio=self.mlp_ratio     ,					qkv_bias=self.qkv_bias     ,					hidden_dropout_prob=self.hidden_dropout_prob     ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,					drop_path_rate=self.drop_path_rate     ,					hidden_act=self.hidden_act     ,					use_absolute_embeddings=self.use_absolute_embeddings     ,					path_norm=self.patch_norm     ,					layer_norm_eps=self.layer_norm_eps     ,					initializer_range=self.initializer_range     ,					encoder_stride=self.encoder_stride     ,					)




      def 	__UpperCAmelCase			(					self :		Tuple     ,					snake_case :		Any     ,					snake_case :		str     ,					snake_case :		List[str]   ):



          """simple docstring"""





          _snake_case : Any												=		TFSwinModel(config=snake_case   )
          _snake_case : List[str]												=		model(snake_case   )

          _snake_case : Tuple												=		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
          _snake_case : Any												=		int(config.embed_dim * 2 ** (len(config.depths   ) - 1)   )

          self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, expected_seq_len, expected_dim)   )




      def 	__UpperCAmelCase			(					self :		Optional[Any]     ,					snake_case :		Union[str, Any]     ,					snake_case :		List[str]     ,					snake_case :		List[str]   ):



          """simple docstring"""





          _snake_case : Any												=		TFSwinForMaskedImageModeling(config=snake_case   )
          _snake_case : Tuple												=		model(snake_case   )
          self.parent.assertEqual(
              result.logits.shape     ,					(self.batch_size, self.num_channels, self.image_size, self.image_size)   )

          # test greyscale images
          _snake_case : Any												=		1
          _snake_case : Any												=		TFSwinForMaskedImageModeling(snake_case   )

          _snake_case : int												=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
          _snake_case : List[Any]												=		model(snake_case   )
          self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, 1, self.image_size, self.image_size)   )




      def 	__UpperCAmelCase			(					self :		Any     ,					snake_case :		str     ,					snake_case :		int     ,					snake_case :		Union[str, Any]   ):



          """simple docstring"""





          _snake_case : List[str]												=		self.type_sequence_label_size
          _snake_case : int												=		TFSwinForImageClassification(snake_case   )
          _snake_case : int												=		model(snake_case     ,					labels=snake_case   )
          self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.type_sequence_label_size)   )

          # test greyscale images
          _snake_case : Union[str, Any]												=		1
          _snake_case : Tuple												=		TFSwinForImageClassification(snake_case   )
          _snake_case : Any												=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
          _snake_case : Union[str, Any]												=		model(snake_case   )
          self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.type_sequence_label_size)   )




      def 	__UpperCAmelCase			(					self :		Dict   ):



          """simple docstring"""





          _snake_case : str												=		self.prepare_config_and_inputs()
          _snake_case					,							_snake_case					,							_snake_case : Any												=		config_and_inputs
          _snake_case : Tuple												=		{'pixel_values': pixel_values}
          return config, inputs_dict



@require_tf
class 			SCREAMING_SNAKE_CASE					(							lowercase_      ,lowercase_      ,unittest.TestCase					):






      '''simple docstring'''






      SCREAMING_SNAKE_CASE__ :				List[Any]    =				(
          (
              TFSwinModel,
              TFSwinForImageClassification,
              TFSwinForMaskedImageModeling,
          )
          if is_tf_available()
          else ()
      )
      SCREAMING_SNAKE_CASE__ :				List[Any]    =				(
          {'''feature-extraction''': TFSwinModel, '''image-classification''': TFSwinForImageClassification}
          if is_tf_available()
          else {}
      )

      SCREAMING_SNAKE_CASE__ :				Optional[Any]    =				False
      SCREAMING_SNAKE_CASE__ :				List[Any]    =				False
      SCREAMING_SNAKE_CASE__ :				str    =				False
      SCREAMING_SNAKE_CASE__ :				Optional[Any]    =				False




      def 	__UpperCAmelCase			(					self :		Dict   ):



          """simple docstring"""





          _snake_case : List[str]												=		TFSwinModelTester(self   )
          _snake_case : Tuple												=		ConfigTester(self     ,					config_class=snake_case     ,					embed_dim=37   )




      def 	__UpperCAmelCase			(					self :		Optional[int]   ):



          """simple docstring"""





          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          return




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



          """simple docstring"""





          _snake_case : Tuple												=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case   )




      def 	__UpperCAmelCase			(					self :		Dict   ):



          """simple docstring"""





          _snake_case : Union[str, Any]												=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*snake_case   )




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : List[Any]												=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*snake_case   )




      @unittest.skip(reason='Swin does not use inputs_embeds'   )
      def 	__UpperCAmelCase			(					self :		Optional[Any]   ):



          """simple docstring"""





          pass




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



          """simple docstring"""





          _snake_case					,							_snake_case : Tuple												=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              _snake_case : Any												=		model_class(snake_case   )
              self.assertIsInstance(model.get_input_embeddings()     ,					tf.keras.layers.Layer   )
              _snake_case : str												=		model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(snake_case     ,					tf.keras.layers.Dense   )   )




      def 	__UpperCAmelCase			(					self :		Optional[Any]   ):



          """simple docstring"""





          _snake_case					,							_snake_case : Optional[int]												=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              _snake_case : Optional[int]												=		model_class(snake_case   )
              _snake_case : Any												=		inspect.signature(model.call   )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              _snake_case : List[Any]												=		[*signature.parameters.keys()]

              _snake_case : List[Any]												=		['pixel_values']
              self.assertListEqual(arg_names[:1]     ,					snake_case   )




      def 	__UpperCAmelCase			(					self :		str   ):



          """simple docstring"""





          _snake_case					,							_snake_case : Dict												=		self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case : Any												=		True

          for model_class in self.all_model_classes:
              _snake_case : Optional[int]												=		True
              _snake_case : int												=		False
              _snake_case : Tuple												=		True
              _snake_case : Dict												=		model_class(snake_case   )
              _snake_case : int												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )
              _snake_case : Any												=		outputs.attentions
              _snake_case : Optional[int]												=		len(self.model_tester.depths   )
              self.assertEqual(len(snake_case   )     ,					snake_case   )

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              _snake_case : Any												=		True
              _snake_case : str												=		config.window_size**2
              _snake_case : Optional[int]												=		model_class(snake_case   )
              _snake_case : Optional[int]												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )
              _snake_case : List[Any]												=		outputs.attentions
              self.assertEqual(len(snake_case   )     ,					snake_case   )

              self.assertListEqual(
                  list(attentions[0].shape[-3:]   )     ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,					)
              _snake_case : Optional[int]												=		len(snake_case   )

              # Check attention is always last and order is fine
              _snake_case : Any												=		True
              _snake_case : Tuple												=		True
              _snake_case : int												=		model_class(snake_case   )
              _snake_case : Dict												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )

              if hasattr(self.model_tester     ,					'num_hidden_states_types'   ):
                  _snake_case : Any												=		self.model_tester.num_hidden_states_types
              else:
                  # also another +1 for reshaped_hidden_states
                  _snake_case : Union[str, Any]												=		2
              self.assertEqual(out_len + added_hidden_states     ,					len(snake_case   )   )

              _snake_case : Tuple												=		outputs.attentions

              self.assertEqual(len(snake_case   )     ,					snake_case   )

              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]   )     ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,					)




      def 	__UpperCAmelCase			(					self :		int     ,					snake_case :		List[str]     ,					snake_case :		Union[str, Any]     ,					snake_case :		Dict     ,					snake_case :		Tuple   ):



          """simple docstring"""





          _snake_case : int												=		model_class(snake_case   )
          _snake_case : Any												=		model(**self._prepare_for_class(snake_case     ,					snake_case   )   )
          _snake_case : Optional[int]												=		outputs.hidden_states

          _snake_case : List[str]												=		getattr(
              self.model_tester     ,					'expected_num_hidden_layers'     ,					len(self.model_tester.depths   ) + 1   )
          self.assertEqual(len(snake_case   )     ,					snake_case   )

          # Swin has a different seq_length
          _snake_case : Optional[int]												=		to_atuple(config.patch_size   )

          _snake_case : Optional[int]												=		(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

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

          _snake_case : Optional[int]												=		outputs.reshaped_hidden_states
          self.assertEqual(len(snake_case   )     ,					snake_case   )

          _snake_case					,							_snake_case					,							_snake_case					,							_snake_case : List[str]												=		reshaped_hidden_states[0].shape

          _snake_case : Any												=		tf.reshape(reshaped_hidden_states[0]     ,					(batch_size, num_channels, height * width)   )
          _snake_case : List[Any]												=		tf.transpose(snake_case     ,					(0, 2, 1)   )

          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:]   )     ,					[num_patches, self.model_tester.embed_dim]     ,					)




      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case					,							_snake_case : List[Any]												=		self.model_tester.prepare_config_and_inputs_for_common()

          _snake_case : Optional[int]												=		to_atuple(self.model_tester.image_size   )

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

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              _snake_case : Dict												=		True

              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					snake_case   )




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



          """simple docstring"""





          _snake_case					,							_snake_case : Tuple												=		self.model_tester.prepare_config_and_inputs_for_common()
          _snake_case : Tuple												=		3

          _snake_case : Any												=		to_atuple(self.model_tester.image_size   )
          _snake_case : str												=		to_atuple(config.patch_size   )

          _snake_case : List[str]												=		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          _snake_case : Tuple												=		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
              _snake_case : Union[str, Any]												=		True
              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					(padded_height, padded_width)   )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              _snake_case : int												=		True
              self.check_hidden_states_output(snake_case     ,					snake_case     ,					snake_case     ,					(padded_height, padded_width)   )




      @slow
      def 	__UpperCAmelCase			(					self :		int   ):



          """simple docstring"""





          for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case : Optional[int]												=		TFSwinModel.from_pretrained(snake_case   )
              self.assertIsNotNone(snake_case   )



@require_vision
@require_tf
class 			SCREAMING_SNAKE_CASE					(							unittest.TestCase					):






      '''simple docstring'''






      @cached_property
      def 	__UpperCAmelCase			(					self :		List[str]   ):



          """simple docstring"""





          return (
              AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'   )
              if is_vision_available()
              else None
          )




      @slow
      def 	__UpperCAmelCase			(					self :		Any   ):



          """simple docstring"""





          _snake_case : Dict												=		TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'   )
          _snake_case : str												=		self.default_image_processor

          _snake_case : List[str]												=		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
          _snake_case : int												=		image_processor(images=snake_case     ,					return_tensors='tf'   )

          # forward pass
          _snake_case : Union[str, Any]												=		model(snake_case   )

          # verify the logits
          _snake_case : List[Any]												=		tf.TensorShape((1, 1000)   )
          self.assertEqual(outputs.logits.shape     ,					snake_case   )
          _snake_case : List[Any]												=		tf.constant([-0.0948, -0.6454, -0.0921]   )
          self.assertTrue(np.allclose(outputs.logits[0, :3]     ,					snake_case     ,					atol=1e-4   )   )



