



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


UpperCamelCase__	:     List[str]    =			{
    '''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''': [5_15]},
}


@pytest.mark.parametrize(
    """task_cls"""	,				[
        AudioClassification,
        AutomaticSpeechRecognition,
        ImageClassification,
        LanguageModeling,
        QuestionAnsweringExtractive,
        Summarization,
        TextClassification,
    ]	,				)
def     lowerCAmelCase_       (     _lowerCamelCase:       Optional[int] ):
		__SCREAMING_SNAKE_CASE	:		int   	=		task_cls()
		__SCREAMING_SNAKE_CASE	:		Tuple   	=		asdict(_lowerCamelCase )
		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		task_template_from_dict(_lowerCamelCase )
		assert task == reloaded






class 						_UpperCamelCase  :


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		LanguageModeling(text_column="""input_text"""						)
					assert {"input_text": "text"} == task.column_mapping



			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		Features({"""text""": Value("""string"""						)}						)
					__SCREAMING_SNAKE_CASE	:		Tuple   	=		{"""text_column""": """input_text"""}
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		LanguageModeling.from_dict(lowerCAmelCase__						)
					assert "language-modeling" == task.task
					assert input_schema == task.input_schema






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		sorted(["""pos""", """neg"""]						)

			def UpperCamelCase__ (							self					:			Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		int   	=		TextClassification(text_column="""input_text"""							,					label_column="""input_label"""						)
					self.assertDictEqual({"""input_text""": """text""", """input_label""": """labels"""}							,					task.column_mapping						)

			def UpperCamelCase__ (							self					:			Any						):





					"""simple docstring"""






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



			def UpperCamelCase__ (							self					:			List[str]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		TextClassification(text_column="""input_text"""							,					label_column="""input_label"""						)
					self.assertEqual(task.label_schema["""labels"""]							,					lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		task.align_with_features(Features({"""input_label""": ClassLabel(names=self.labels						)}						)						)
					self.assertEqual(task.label_schema["""labels"""]							,					ClassLabel(names=self.labels						)						)






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			List[str]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Optional[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					:			int						):





					"""simple docstring"""






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






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			Any						):





					"""simple docstring"""






					__SCREAMING_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"""






					__SCREAMING_SNAKE_CASE	:		Dict   	=		Features({"""text""": Value("""string"""						)}						)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		Features({"""summary""": Value("""string"""						)}						)
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		{"""text_column""": """input_text""", """summary_column""": """input_summary"""}
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		Summarization.from_dict(lowerCAmelCase__						)
					self.assertEqual("""summarization"""							,					task.task						)
					self.assertEqual(lowerCAmelCase__							,					task.input_schema						)
					self.assertEqual(lowerCAmelCase__							,					task.label_schema						)






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		str   	=		AutomaticSpeechRecognition(audio_column="""input_audio"""							,					transcription_column="""input_transcription"""						)
					self.assertDictEqual({"""input_audio""": """audio""", """input_transcription""": """transcription"""}							,					task.column_mapping						)



			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		Features({"""audio""": Audio()}						)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		Features({"""transcription""": Value("""string"""						)}						)
					__SCREAMING_SNAKE_CASE	:		Any   	=		{
					    """audio_column""": """input_audio""",
					    """transcription_column""": """input_transcription""",
					}
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		AutomaticSpeechRecognition.from_dict(lowerCAmelCase__						)
					self.assertEqual("""automatic-speech-recognition"""							,					task.task						)
					self.assertEqual(lowerCAmelCase__							,					task.input_schema						)
					self.assertEqual(lowerCAmelCase__							,					task.label_schema						)






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

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





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		int   	=		sorted(["""pos""", """neg"""]						)

			def UpperCamelCase__ (							self					:			str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		AudioClassification(audio_column="""input_audio"""							,					label_column="""input_label"""						)
					self.assertDictEqual({"""input_audio""": """audio""", """input_label""": """labels"""}							,					task.column_mapping						)

			def UpperCamelCase__ (							self					:			Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Any   	=		Features({"""audio""": Audio()}						)
					__SCREAMING_SNAKE_CASE	:		Dict   	=		Features({"""labels""": ClassLabel}						)
					__SCREAMING_SNAKE_CASE	:		str   	=		{
					    """audio_column""": """input_image""",
					    """label_column""": """input_label""",
					}
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		AudioClassification.from_dict(lowerCAmelCase__						)
					self.assertEqual("""audio-classification"""							,					task.task						)
					self.assertEqual(lowerCAmelCase__							,					task.input_schema						)
					self.assertEqual(lowerCAmelCase__							,					task.label_schema						)



			def UpperCamelCase__ (							self					:			Optional[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Dict   	=		AudioClassification(audio_column="""input_audio"""							,					label_column="""input_label"""						)
					self.assertEqual(task.label_schema["""labels"""]							,					lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE	:		int   	=		task.align_with_features(Features({"""input_label""": ClassLabel(names=self.labels						)}						)						)
					self.assertEqual(task.label_schema["""labels"""]							,					ClassLabel(names=self.labels						)						)






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		sorted(["""pos""", """neg"""]						)

			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Dict   	=		ImageClassification(image_column="""input_image"""							,					label_column="""input_label"""						)
					self.assertDictEqual({"""input_image""": """image""", """input_label""": """labels"""}							,					task.column_mapping						)

			def UpperCamelCase__ (							self					:			List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		Features({"""image""": Image()}						)
					__SCREAMING_SNAKE_CASE	:		Any   	=		Features({"""labels""": ClassLabel}						)
					__SCREAMING_SNAKE_CASE	:		str   	=		{
					    """image_column""": """input_image""",
					    """label_column""": """input_label""",
					}
					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		ImageClassification.from_dict(lowerCAmelCase__						)
					self.assertEqual("""image-classification"""							,					task.task						)
					self.assertEqual(lowerCAmelCase__							,					task.input_schema						)
					self.assertEqual(lowerCAmelCase__							,					task.label_schema						)



			def UpperCamelCase__ (							self					:			Optional[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		ImageClassification(image_column="""input_image"""							,					label_column="""input_label"""						)
					self.assertEqual(task.label_schema["""labels"""]							,					lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		task.align_with_features(Features({"""input_label""": ClassLabel(names=self.labels						)}						)						)
					self.assertEqual(task.label_schema["""labels"""]							,					ClassLabel(names=self.labels						)						)






class 						_UpperCamelCase  (							lowerCamelCase__   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






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

					def keep_task(lowerCAmelCase__					:			Any						):
							return x

					def dont_keep_task(lowerCAmelCase__					:			Union[str, Any]						):
							__SCREAMING_SNAKE_CASE	:		Tuple   	=		deepcopy(lowerCAmelCase__						)
							__SCREAMING_SNAKE_CASE	:		Tuple   	=		0
							return out

					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		dataset.map(lowerCAmelCase__						)
					assert mapped_dataset.info.task_templates == dataset.info.task_templates
					# reload from cache
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		dataset.map(lowerCAmelCase__						)
					assert mapped_dataset.info.task_templates == dataset.info.task_templates

					__SCREAMING_SNAKE_CASE	:		Any   	=		dataset.map(lowerCAmelCase__						)
					assert mapped_dataset.info.task_templates == []
					# reload from cache
					__SCREAMING_SNAKE_CASE	:		int   	=		dataset.map(lowerCAmelCase__						)
					assert mapped_dataset.info.task_templates == []



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





					"""simple docstring"""






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

					def process(lowerCAmelCase__					:			List[str]						):
							return example

					__SCREAMING_SNAKE_CASE	:		List[str]   	=		dataset.remove_columns("""label"""						)
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		modified_dataset.map(lowerCAmelCase__						)
					assert mapped_dataset.info.task_templates == []




'''simple docstring'''




import collections
import inspect
import unittest

from transformers import SwinConfig
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_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
						from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor






class 						_UpperCamelCase  :


			'''simple docstring'''

			def __init__(							self					:			Dict							,					lowerCAmelCase__					:			List[str]							,					lowerCAmelCase__					:			Tuple=1_3							,					lowerCAmelCase__					:			Tuple=3_2							,					lowerCAmelCase__					:			Optional[int]=2							,					lowerCAmelCase__					:			str=3							,					lowerCAmelCase__					:			Optional[int]=1_6							,					lowerCAmelCase__					:			List[str]=[1, 2, 1]							,					lowerCAmelCase__					:			Dict=[2, 2, 4]							,					lowerCAmelCase__					:			Any=2							,					lowerCAmelCase__					:			str=2.0							,					lowerCAmelCase__					:			List[Any]=True							,					lowerCAmelCase__					:			Any=0.0							,					lowerCAmelCase__					:			List[Any]=0.0							,					lowerCAmelCase__					:			Optional[Any]=0.1							,					lowerCAmelCase__					:			Optional[int]="gelu"							,					lowerCAmelCase__					:			Dict=False							,					lowerCAmelCase__					:			Union[str, Any]=True							,					lowerCAmelCase__					:			Any=0.02							,					lowerCAmelCase__					:			List[str]=1E-5							,					lowerCAmelCase__					:			Union[str, Any]=True							,					lowerCAmelCase__					:			int=None							,					lowerCAmelCase__					:			Optional[Any]=True							,					lowerCAmelCase__					:			int=1_0							,					lowerCAmelCase__					:			List[Any]=8							,					lowerCAmelCase__					:			Union[str, Any]=["stage1", "stage2"]							,					lowerCAmelCase__					:			Any=[1, 2]							,					):





					"""simple docstring"""






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

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





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[str]   	=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

					__SCREAMING_SNAKE_CASE	:		Tuple   	=		self.get_config()

					return config, pixel_values, labels

			def UpperCamelCase__ (							self					:			Optional[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							,					out_features=self.out_features							,					out_indices=self.out_indices							,					)

			def UpperCamelCase__ (							self					:			Optional[int]							,					lowerCAmelCase__					:			Tuple							,					lowerCAmelCase__					:			Tuple							,					lowerCAmelCase__					:			int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		SwinModel(config=lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		model(lowerCAmelCase__						)

					__SCREAMING_SNAKE_CASE	:		List[str]   	=		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
					__SCREAMING_SNAKE_CASE	:		Dict   	=		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					:			List[Any]							,					lowerCAmelCase__					:			Dict							,					lowerCAmelCase__					:			int							,					lowerCAmelCase__					:			Tuple						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		SwinBackbone(config=lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()
					__SCREAMING_SNAKE_CASE	:		Any   	=		model(lowerCAmelCase__						)

					# verify hidden states
					self.parent.assertEqual(len(result.feature_maps						)							,					len(config.out_features						)						)
					self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,					[self.batch_size, model.channels[0], 1_6, 1_6]						)

					# verify channels
					self.parent.assertEqual(len(model.channels						)							,					len(config.out_features						)						)

					# verify backbone works with out_features=None
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		None
					__SCREAMING_SNAKE_CASE	:		str   	=		SwinBackbone(config=lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()
					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		model(lowerCAmelCase__						)

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps						)							,					1						)
					self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,					[self.batch_size, model.channels[-1], 4, 4]						)

					# verify channels
					self.parent.assertEqual(len(model.channels						)							,					1						)

			def UpperCamelCase__ (							self					:			Tuple							,					lowerCAmelCase__					:			Dict							,					lowerCAmelCase__					:			Optional[Any]							,					lowerCAmelCase__					:			List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Any   	=		SwinForMaskedImageModeling(config=lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		model(lowerCAmelCase__						)
					self.parent.assertEqual(
					    result.logits.shape							,					(self.batch_size, self.num_channels, self.image_size, self.image_size)						)

					# test greyscale images
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		1
					__SCREAMING_SNAKE_CASE	:		Dict   	=		SwinForMaskedImageModeling(lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()

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

			def UpperCamelCase__ (							self					:			Dict							,					lowerCAmelCase__					:			Any							,					lowerCAmelCase__					:			Any							,					lowerCAmelCase__					:			Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		self.type_sequence_label_size
					__SCREAMING_SNAKE_CASE	:		Dict   	=		SwinForImageClassification(lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		model(lowerCAmelCase__							,					labels=lowerCAmelCase__						)
					self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.type_sequence_label_size)						)

					# test greyscale images
					__SCREAMING_SNAKE_CASE	:		Dict   	=		1
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		SwinForImageClassification(lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()

					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
					__SCREAMING_SNAKE_CASE	:		Dict   	=		model(lowerCAmelCase__						)
					self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.type_sequence_label_size)						)



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





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		str   	=		self.prepare_config_and_inputs()
					(
					    (
					    __SCREAMING_SNAKE_CASE
					)	,						(
					    __SCREAMING_SNAKE_CASE
					)	,						(
					    __SCREAMING_SNAKE_CASE
					)	,						
					)	:		Union[str, Any]   	=		config_and_inputs
					__SCREAMING_SNAKE_CASE	:		Any   	=		{"""pixel_values""": pixel_values}
					return config, inputs_dict






@require_torch
class 						_UpperCamelCase  (							lowerCamelCase__   , lowerCamelCase__   , unittest.TestCase   ):


			'''simple docstring'''

			_A				:		Dict         =		(
			    (
			        SwinModel,
			        SwinBackbone,
			        SwinForImageClassification,
			        SwinForMaskedImageModeling,
			    )
			    if is_torch_available()
			    else ()
			)
			_A				:		List[str]         =		(
			    {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
			    if is_torch_available()
			    else {}
			)
			_A				:		int         =		True

			_A				:		str         =		False
			_A				:		str         =		False
			_A				:		Optional[int]         =		False

			def UpperCamelCase__ (							self					:			str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[str]   	=		SwinModelTester(self						)
					__SCREAMING_SNAKE_CASE	:		Dict   	=		ConfigTester(self							,					config_class=lowerCAmelCase__							,					embed_dim=3_7						)

			def UpperCamelCase__ (							self					:			Any						):





					"""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					:			Dict						):





					"""simple docstring"""






					return

			def UpperCamelCase__ (							self					:			Optional[Any]						):





					"""simple docstring"""






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

			@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""						)
			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					pass

			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






					super().test_training_gradient_checkpointing()

			def UpperCamelCase__ (							self					:			Tuple						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		int   	=		self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*lowerCAmelCase__						)

			def UpperCamelCase__ (							self					:			Dict						):





					"""simple docstring"""






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

			def UpperCamelCase__ (							self					:			List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		str   	=		self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__						)

			@unittest.skip(reason="""Swin does not use inputs_embeds"""						)
			def UpperCamelCase__ (							self					:			List[Any]						):





					"""simple docstring"""






					pass

			@unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""						)
			def UpperCamelCase__ (							self					:			str						):





					"""simple docstring"""






					pass

			def UpperCamelCase__ (							self					:			int						):





					"""simple docstring"""






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

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

			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	:		int   	=		self.model_tester.prepare_config_and_inputs_for_common()

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

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

			def UpperCamelCase__ (							self					:			List[Any]						):





					"""simple docstring"""






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

					for model_class in self.all_model_classes:
							__SCREAMING_SNAKE_CASE	:		List[Any]   	=		True
							__SCREAMING_SNAKE_CASE	:		int   	=		False
							__SCREAMING_SNAKE_CASE	:		str   	=		True
							__SCREAMING_SNAKE_CASE	:		List[str]   	=		model_class(lowerCAmelCase__						)
							model.to(lowerCAmelCase__						)
							model.eval()
							with torch.no_grad():
									__SCREAMING_SNAKE_CASE	:		List[Any]   	=		model(**self._prepare_for_class(lowerCAmelCase__							,					lowerCAmelCase__						)						)
							__SCREAMING_SNAKE_CASE	:		Any   	=		outputs.attentions
							__SCREAMING_SNAKE_CASE	:		Tuple   	=		len(self.model_tester.depths						)
							self.assertEqual(len(lowerCAmelCase__						)							,					lowerCAmelCase__						)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							__SCREAMING_SNAKE_CASE	:		str   	=		True
							__SCREAMING_SNAKE_CASE	:		Dict   	=		config.window_size**2
							__SCREAMING_SNAKE_CASE	:		Tuple   	=		model_class(lowerCAmelCase__						)
							model.to(lowerCAmelCase__						)
							model.eval()
							with torch.no_grad():
									__SCREAMING_SNAKE_CASE	:		Dict   	=		model(**self._prepare_for_class(lowerCAmelCase__							,					lowerCAmelCase__						)						)
							__SCREAMING_SNAKE_CASE	:		str   	=		outputs.attentions
							self.assertEqual(len(lowerCAmelCase__						)							,					lowerCAmelCase__						)

							self.assertListEqual(
							    list(attentions[0].shape[-3:]						)							,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]							,					)
							__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		len(lowerCAmelCase__						)

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

							# also another +1 for reshaped_hidden_states
							__SCREAMING_SNAKE_CASE	:		List[str]   	=		1 if model_class.__name__ == """SwinBackbone""" else 2
							self.assertEqual(out_len + added_hidden_states							,					len(lowerCAmelCase__						)						)

							__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		outputs.attentions

							self.assertEqual(len(lowerCAmelCase__						)							,					lowerCAmelCase__						)

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

			def UpperCamelCase__ (							self					:			Optional[int]							,					lowerCAmelCase__					:			int							,					lowerCAmelCase__					:			Tuple							,					lowerCAmelCase__					:			str							,					lowerCAmelCase__					:			Optional[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		model_class(lowerCAmelCase__						)
					model.to(lowerCAmelCase__						)
					model.eval()

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

					__SCREAMING_SNAKE_CASE	:		List[str]   	=		outputs.hidden_states

					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		getattr(
					    self.model_tester							,					"""expected_num_hidden_layers"""							,					len(self.model_tester.depths						) + 1						)
					self.assertEqual(len(lowerCAmelCase__						)							,					lowerCAmelCase__						)

					# Swin has a different seq_length
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		(
					    config.patch_size
					    if isinstance(config.patch_size							,					collections.abc.Iterable						)
					    else (config.patch_size, config.patch_size)
					)

					__SCREAMING_SNAKE_CASE	:		Any   	=		(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]							,					)

					if not model_class.__name__ == "SwinBackbone":
							__SCREAMING_SNAKE_CASE	:		int   	=		outputs.reshaped_hidden_states
							self.assertEqual(len(lowerCAmelCase__						)							,					lowerCAmelCase__						)

							__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	:		int   	=		reshaped_hidden_states[0].shape
							__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(
							    reshaped_hidden_states[0].view(lowerCAmelCase__							,					lowerCAmelCase__							,					height * width						).permute(0							,					2							,					1						)
							)
							self.assertListEqual(
							    list(reshaped_hidden_states.shape[-2:]						)							,					[num_patches, self.model_tester.embed_dim]							,					)

			def UpperCamelCase__ (							self					:			Optional[Any]						):





					"""simple docstring"""






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

					__SCREAMING_SNAKE_CASE	:		List[str]   	=		(
					    self.model_tester.image_size
					    if isinstance(self.model_tester.image_size							,					collections.abc.Iterable						)
					    else (self.model_tester.image_size, self.model_tester.image_size)
					)

					for model_class in self.all_model_classes:
							__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		True
							self.check_hidden_states_output(lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__						)

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

							self.check_hidden_states_output(lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__						)

			def UpperCamelCase__ (							self					:			Tuple						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	:		List[str]   	=		self.model_tester.prepare_config_and_inputs_for_common()
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		3

					__SCREAMING_SNAKE_CASE	:		Any   	=		(
					    self.model_tester.image_size
					    if isinstance(self.model_tester.image_size							,					collections.abc.Iterable						)
					    else (self.model_tester.image_size, self.model_tester.image_size)
					)
					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(
					    config.patch_size
					    if isinstance(config.patch_size							,					collections.abc.Iterable						)
					    else (config.patch_size, config.patch_size)
					)

					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							__SCREAMING_SNAKE_CASE	:		List[str]   	=		True
							self.check_hidden_states_output(lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					(padded_height, padded_width)						)

			@slow
			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		SwinModel.from_pretrained(lowerCAmelCase__						)
							self.assertIsNotNone(lowerCAmelCase__						)



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





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		self.model_tester.prepare_config_and_inputs_for_common()

					__SCREAMING_SNAKE_CASE	:		Any   	=		_config_zero_init(lowerCAmelCase__						)
					for model_class in self.all_model_classes:
							__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		model_class(config=lowerCAmelCase__						)
							for name, param in model.named_parameters():
									if "embeddings" not in name and param.requires_grad:
											self.assertIn(
											    ((param.data.mean() * 1E9).round() / 1E9).item()							,					[0.0, 1.0]							,					msg=F"Parameter {name} of model {model_class} seems not properly initialized"							,					)






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


			'''simple docstring'''

			@cached_property
			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






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



			@slow
			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""						).to(lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		self.default_image_processor

					__SCREAMING_SNAKE_CASE	:		Dict   	=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		image_processor(images=lowerCAmelCase__							,					return_tensors="""pt"""						).to(lowerCAmelCase__						)

					# forward pass
					with torch.no_grad():
							__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		model(**lowerCAmelCase__						)

					# verify the logits
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		torch.Size((1, 1_0_0_0)						)
					self.assertEqual(outputs.logits.shape							,					lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		torch.tensor([-0.09_48, -0.64_54, -0.09_21]						).to(lowerCAmelCase__						)
					self.assertTrue(torch.allclose(outputs.logits[0, :3]							,					lowerCAmelCase__							,					atol=1E-4						)						)






@require_torch
class 						_UpperCamelCase  (							unittest.TestCase   , lowerCamelCase__   ):


			'''simple docstring'''

			_A				:		Tuple         =		(SwinBackbone,) if is_torch_available() else ()
			_A				:		Optional[int]         =		SwinConfig

			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		SwinModelTester(self						)