

"""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 	_lowerCAmelCase    :

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

									"""simple docstring"""
									lowercase										=							parent
									lowercase										=							batch_size
									lowercase										=							image_size
									lowercase										=							patch_size
									lowercase										=							num_channels
									lowercase										=							embed_dim
									lowercase										=							depths
									lowercase										=							num_heads
									lowercase										=							window_size
									lowercase										=							mlp_ratio
									lowercase										=							qkv_bias
									lowercase										=							hidden_dropout_prob
									lowercase										=							attention_probs_dropout_prob
									lowercase										=							drop_path_rate
									lowercase										=							hidden_act
									lowercase										=							use_absolute_embeddings
									lowercase										=							patch_norm
									lowercase										=							layer_norm_eps
									lowercase										=							initializer_range
									lowercase										=							is_training
									lowercase										=							scope
									lowercase										=							use_labels
									lowercase										=							type_sequence_label_size
									lowercase										=							encoder_stride

							def 					_lowerCAmelCase  ( self       :    Dict    )   ->    Any:

									"""simple docstring"""
									lowercase										=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

									lowercase										=							None
									if self.use_labels:
											lowercase										=							ids_tensor([self.batch_size] ,		self.type_sequence_label_size    )

									lowercase										=							self.get_config()

									return config, pixel_values, labels

							def 					_lowerCAmelCase  ( self       :    Dict    )   ->    List[str]:

									"""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 					_lowerCAmelCase  ( self       :    List[str] ,		a       :    str ,		a       :    List[str] ,		a       :    Dict    )   ->    List[str]:

									"""simple docstring"""
									lowercase										=							TFSwinModel(config=a    )
									lowercase										=							model(a    )

									lowercase										=							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
									lowercase										=							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 					_lowerCAmelCase  ( self       :    Tuple ,		a       :    List[Any] ,		a       :    Tuple ,		a       :    List[Any]    )   ->    str:

									"""simple docstring"""
									lowercase										=							TFSwinForMaskedImageModeling(config=a    )
									lowercase										=							model(a    )
									self.parent.assertEqual(
									    result.logits.shape ,		(self.batch_size, self.num_channels, self.image_size, self.image_size)    )

									# test greyscale images
									lowercase										=							1
									lowercase										=							TFSwinForMaskedImageModeling(a    )

									lowercase										=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
									lowercase										=							model(a    )
									self.parent.assertEqual(result.logits.shape ,		(self.batch_size, 1, self.image_size, self.image_size)    )

							def 					_lowerCAmelCase  ( self       :    List[Any] ,		a       :    Dict ,		a       :    Tuple ,		a       :    List[Any]    )   ->    Union[str, Any]:

									"""simple docstring"""
									lowercase										=							self.type_sequence_label_size
									lowercase										=							TFSwinForImageClassification(a    )
									lowercase										=							model(a ,		labels=a    )
									self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.type_sequence_label_size)    )

									# test greyscale images
									lowercase										=							1
									lowercase										=							TFSwinForImageClassification(a    )
									lowercase										=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
									lowercase										=							model(a    )
									self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.type_sequence_label_size)    )

							def 					_lowerCAmelCase  ( self       :    Any    )   ->    Any:

									"""simple docstring"""
									lowercase										=							self.prepare_config_and_inputs()
									lowercase					,  lowercase					,  lowercase										=							config_and_inputs
									lowercase										=							{'''pixel_values''': pixel_values}
									return config, inputs_dict




@require_tf
class 	_lowerCAmelCase    (      __snake_case       ,       __snake_case       ,       unittest.TestCase       ):
							__lowerCAmelCase					:    Union[str, Any]     =  (
							    (
							        TFSwinModel,
							        TFSwinForImageClassification,
							        TFSwinForMaskedImageModeling,
							    )
							    if is_tf_available()
							    else ()
							)
							__lowerCAmelCase					:    Union[str, Any]     =  (
							    {'''feature-extraction''': TFSwinModel, '''image-classification''': TFSwinForImageClassification}
							    if is_tf_available()
							    else {}
							)

							__lowerCAmelCase					:    Tuple     =  False
							__lowerCAmelCase					:    List[str]     =  False
							__lowerCAmelCase					:    List[Any]     =  False
							__lowerCAmelCase					:    Any     =  False

							def 					_lowerCAmelCase  ( self       :    List[str]    )   ->    List[Any]:

									"""simple docstring"""
									lowercase										=							TFSwinModelTester(self    )
									lowercase										=							ConfigTester(self ,		config_class=a ,		embed_dim=37    )

							def 					_lowerCAmelCase  ( self       :    Optional[int]    )   ->    str:

									"""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 					_lowerCAmelCase  ( self       :    List[Any]    )   ->    Union[str, Any]:

									"""simple docstring"""
									return

							def 					_lowerCAmelCase  ( self       :    List[str]    )   ->    int:

									"""simple docstring"""
									lowercase										=							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*a    )

							def 					_lowerCAmelCase  ( self       :    str    )   ->    Optional[int]:

									"""simple docstring"""
									lowercase										=							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*a    )

							def 					_lowerCAmelCase  ( self       :    Any    )   ->    Any:

									"""simple docstring"""
									lowercase										=							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*a    )

							@unittest.skip(reason='''Swin does not use inputs_embeds'''    )
							def 					_lowerCAmelCase  ( self       :    Tuple    )   ->    List[Any]:

									"""simple docstring"""
									pass

							def 					_lowerCAmelCase  ( self       :    Optional[Any]    )   ->    Tuple:

									"""simple docstring"""
									lowercase					,  lowercase										=							self.model_tester.prepare_config_and_inputs_for_common()

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

							def 					_lowerCAmelCase  ( self       :    List[str]    )   ->    List[Any]:

									"""simple docstring"""
									lowercase					,  lowercase										=							self.model_tester.prepare_config_and_inputs_for_common()

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

											lowercase										=							['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,		a    )

							def 					_lowerCAmelCase  ( self       :    str    )   ->    Any:

									"""simple docstring"""
									lowercase					,  lowercase										=							self.model_tester.prepare_config_and_inputs_for_common()
									lowercase										=							True

									for model_class in self.all_model_classes:
											lowercase										=							True
											lowercase										=							False
											lowercase										=							True
											lowercase										=							model_class(a    )
											lowercase										=							model(**self._prepare_for_class(a ,		a    )    )
											lowercase										=							outputs.attentions
											lowercase										=							len(self.model_tester.depths    )
											self.assertEqual(len(a    ) ,		a    )

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											lowercase										=							True
											lowercase										=							config.window_size**2
											lowercase										=							model_class(a    )
											lowercase										=							model(**self._prepare_for_class(a ,		a    )    )
											lowercase										=							outputs.attentions
											self.assertEqual(len(a    ) ,		a    )

											self.assertListEqual(
											    list(attentions[0].shape[-3:]    ) ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,		)
											lowercase										=							len(a    )

											# Check attention is always last and order is fine
											lowercase										=							True
											lowercase										=							True
											lowercase										=							model_class(a    )
											lowercase										=							model(**self._prepare_for_class(a ,		a    )    )

											if hasattr(self.model_tester ,		'''num_hidden_states_types'''    ):
													lowercase										=							self.model_tester.num_hidden_states_types
											else:
													# also another +1 for reshaped_hidden_states
													lowercase										=							2
											self.assertEqual(out_len + added_hidden_states ,		len(a    )    )

											lowercase										=							outputs.attentions

											self.assertEqual(len(a    ) ,		a    )

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

							def 					_lowerCAmelCase  ( self       :    Optional[int] ,		a       :    Optional[int] ,		a       :    Dict ,		a       :    Dict ,		a       :    List[Any]    )   ->    Optional[int]:

									"""simple docstring"""
									lowercase										=							model_class(a    )
									lowercase										=							model(**self._prepare_for_class(a ,		a    )    )
									lowercase										=							outputs.hidden_states

									lowercase										=							getattr(
									    self.model_tester ,		'''expected_num_hidden_layers''' ,		len(self.model_tester.depths    ) + 1    )
									self.assertEqual(len(a    ) ,		a    )

									# Swin has a different seq_length
									lowercase										=							to_atuple(config.patch_size    )

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

									lowercase										=							outputs.reshaped_hidden_states
									self.assertEqual(len(a    ) ,		a    )

									lowercase					,  lowercase					,  lowercase					,  lowercase										=							reshaped_hidden_states[0].shape

									lowercase										=							tf.reshape(reshaped_hidden_states[0] ,		(batch_size, num_channels, height * width)    )
									lowercase										=							tf.transpose(a ,		(0, 2, 1)    )

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

							def 					_lowerCAmelCase  ( self       :    str    )   ->    List[str]:

									"""simple docstring"""
									lowercase					,  lowercase										=							self.model_tester.prepare_config_and_inputs_for_common()

									lowercase										=							to_atuple(self.model_tester.image_size    )

									for model_class in self.all_model_classes:
											lowercase										=							True
											self.check_hidden_states_output(a ,		a ,		a ,		a    )

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

											self.check_hidden_states_output(a ,		a ,		a ,		a    )

							def 					_lowerCAmelCase  ( self       :    Union[str, Any]    )   ->    int:

									"""simple docstring"""
									lowercase					,  lowercase										=							self.model_tester.prepare_config_and_inputs_for_common()
									lowercase										=							3

									lowercase										=							to_atuple(self.model_tester.image_size    )
									lowercase										=							to_atuple(config.patch_size    )

									lowercase										=							image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
									lowercase										=							image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

									for model_class in self.all_model_classes:
											lowercase										=							True
											self.check_hidden_states_output(a ,		a ,		a ,		(padded_height, padded_width)    )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowercase										=							True
											self.check_hidden_states_output(a ,		a ,		a ,		(padded_height, padded_width)    )

							@slow
							def 					_lowerCAmelCase  ( self       :    List[Any]    )   ->    Dict:

									"""simple docstring"""
									for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											lowercase										=							TFSwinModel.from_pretrained(a    )
											self.assertIsNotNone(a    )




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

							@cached_property
							def 					_lowerCAmelCase  ( self       :    int    )   ->    str:

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

							@slow
							def 					_lowerCAmelCase  ( self       :    Dict    )   ->    Dict:

									"""simple docstring"""
									lowercase										=							TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''    )
									lowercase										=							self.default_image_processor

									lowercase										=							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
									lowercase										=							image_processor(images=a ,		return_tensors='''tf'''    )

									# forward pass
									lowercase										=							model(a    )

									# verify the logits
									lowercase										=							tf.TensorShape((1, 1000)    )
									self.assertEqual(outputs.logits.shape ,		a    )
									lowercase										=							tf.constant([-0.0_948, -0.6_454, -0.0_921]    )
									self.assertTrue(np.allclose(outputs.logits[0, :3] ,		a ,		atol=1E-4    )    )


"""simple docstring"""






import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


__lowerCAmelCase				      =   logging.get_logger(__name__)
class 	_lowerCAmelCase    (      __snake_case       ):

							def __init__( self       :    Dict ,		*a       :    Any ,		**a       :    List[str]    )   ->    None:

									"""simple docstring"""
									warnings.warn(
									    '''The class ConvNextFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
									    ''' Please use ConvNextImageProcessor instead.''' ,		a ,		)
									super().__init__(*a ,		**a    )