






"""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:  str					,		__A:  str					,		__A:  Optional[Any]=13					,		__A:  Tuple=32					,		__A:  Optional[int]=2					,		__A:  Tuple=3					,		__A:  int=16					,		__A:  str=[1, 2, 1]					,		__A:  int=[2, 2, 4]					,		__A:  Dict=2					,		__A:  int=2.0					,		__A:  Dict=True					,		__A:  int=0.0					,		__A:  str=0.0					,		__A:  str=0.1					,		__A:  List[Any]="gelu"					,		__A:  List[Any]=False					,		__A:  Optional[Any]=True					,		__A:  str=0.0_2					,		__A:  List[str]=1e-5					,		__A:  Union[str, Any]=True					,		__A:  Union[str, Any]=None					,		__A:  List[Any]=True					,		__A:  List[Any]=10					,		__A:  Tuple=8					,		):

												'''simple docstring'''

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




							def 			lowercase		( self:  List[Any]     ):

												'''simple docstring'''

												a__ 							=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

												a__ 							=	self.get_config()

												return config, pixel_values, labels




							def 			lowercase		( self:  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 			lowercase		( self:  Optional[int]					,		__A:  Any					,		__A:  int					,		__A:  List[str]     ):

												'''simple docstring'''

												a__ 							=	TFSwinModel(config=__A     )
												a__ 							=	model(__A     )

												a__ 							=	((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
												a__ 							=	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 			lowercase		( self:  int					,		__A:  int					,		__A:  Tuple					,		__A:  str     ):

												'''simple docstring'''

												a__ 							=	TFSwinForMaskedImageModeling(config=__A     )
												a__ 							=	model(__A     )
												self.parent.assertEqual(
												    result.logits.shape					,		(self.batch_size, self.num_channels, self.image_size, self.image_size)     )

												# test greyscale images
												a__ 							=	1
												a__ 							=	TFSwinForMaskedImageModeling(__A     )

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




							def 			lowercase		( self:  Tuple					,		__A:  Tuple					,		__A:  Any					,		__A:  Union[str, Any]     ):

												'''simple docstring'''

												a__ 							=	self.type_sequence_label_size
												a__ 							=	TFSwinForImageClassification(__A     )
												a__ 							=	model(__A					,		labels=__A     )
												self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.type_sequence_label_size)     )

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





							def 			lowercase		( self:  str     ):

												'''simple docstring'''

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







@require_tf
class 							_SCREAMING_SNAKE_CASE    (	__snake_case							,			__snake_case							,			unittest.TestCase				):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE     =(
							    (
							        TFSwinModel,
							        TFSwinForImageClassification,
							        TFSwinForMaskedImageModeling,
							    )
							    if is_tf_available()
							    else ()
							)
							_SCREAMING_SNAKE_CASE     =(
							    {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
							    if is_tf_available()
							    else {}
							)

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




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

												'''simple docstring'''

												a__ 							=	TFSwinModelTester(self     )
												a__ 							=	ConfigTester(self					,		config_class=__A					,		embed_dim=37     )




							def 			lowercase		( self:  List[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 			lowercase		( self:  List[Any]     ):

												'''simple docstring'''

												return




							def 			lowercase		( self:  List[str]     ):

												'''simple docstring'''

												a__ 							=	self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__A     )




							def 			lowercase		( self:  Optional[int]     ):

												'''simple docstring'''

												a__ 							=	self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_image_modeling(*__A     )




							def 			lowercase		( self:  Tuple     ):

												'''simple docstring'''

												a__ 							=	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 			lowercase		( self:  int     ):

												'''simple docstring'''

												pass




							def 			lowercase		( self:  Optional[int]     ):

												'''simple docstring'''

												a__							,a__ 							=	self.model_tester.prepare_config_and_inputs_for_common()

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




							def 			lowercase		( self:  Any     ):

												'''simple docstring'''

												a__							,a__ 							=	self.model_tester.prepare_config_and_inputs_for_common()

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

																	a__ 							=	['''pixel_values''']
																	self.assertListEqual(arg_names[:1]					,		__A     )




							def 			lowercase		( self:  Any     ):

												'''simple docstring'''

												a__							,a__ 							=	self.model_tester.prepare_config_and_inputs_for_common()
												a__ 							=	True

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

																	# check that output_attentions also work using config
																	del inputs_dict["output_attentions"]
																	a__ 							=	True
																	a__ 							=	config.window_size**2
																	a__ 							=	model_class(__A     )
																	a__ 							=	model(**self._prepare_for_class(__A					,		__A     )     )
																	a__ 							=	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]					,		)
																	a__ 							=	len(__A     )

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

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

																	a__ 							=	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 			lowercase		( self:  str					,		__A:  Dict					,		__A:  Union[str, Any]					,		__A:  int					,		__A:  Optional[int]     ):

												'''simple docstring'''

												a__ 							=	model_class(__A     )
												a__ 							=	model(**self._prepare_for_class(__A					,		__A     )     )
												a__ 							=	outputs.hidden_states

												a__ 							=	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
												a__ 							=	to_atuple(config.patch_size     )

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

												a__ 							=	outputs.reshaped_hidden_states
												self.assertEqual(len(__A     )					,		__A     )

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

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

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




							def 			lowercase		( self:  Optional[int]     ):

												'''simple docstring'''

												a__							,a__ 							=	self.model_tester.prepare_config_and_inputs_for_common()

												a__ 							=	to_atuple(self.model_tester.image_size     )

												for model_class in self.all_model_classes:
																	a__ 							=	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"]
																	a__ 							=	True

																	self.check_hidden_states_output(__A					,		__A					,		__A					,		__A     )




							def 			lowercase		( self:  Tuple     ):

												'''simple docstring'''

												a__							,a__ 							=	self.model_tester.prepare_config_and_inputs_for_common()
												a__ 							=	3

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

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

												for model_class in self.all_model_classes:
																	a__ 							=	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"]
																	a__ 							=	True
																	self.check_hidden_states_output(__A					,		__A					,		__A					,		(padded_height, padded_width)     )





							@slow
							def 			lowercase		( self:  str     ):

												'''simple docstring'''

												for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	a__ 							=	TFSwinModel.from_pretrained(__A     )
																	self.assertIsNotNone(__A     )







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





							"""simple docstring"""





							@cached_property
							def 			lowercase		( self:  Dict     ):

												'''simple docstring'''

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





							@slow
							def 			lowercase		( self:  List[Any]     ):

												'''simple docstring'''

												a__ 							=	TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''     )
												a__ 							=	self.default_image_processor

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

												# forward pass
												a__ 							=	model(__A     )

												# verify the logits
												a__ 							=	tf.TensorShape((1, 1000)     )
												self.assertEqual(outputs.logits.shape					,		__A     )
												a__ 							=	tf.constant([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]     )
												self.assertTrue(np.allclose(outputs.logits[0, :3]					,		__A					,		atol=1e-4     )     )










"""simple docstring"""







from __future__ import annotations

from collections.abc import Iterator
from typing import Any







class 							_SCREAMING_SNAKE_CASE    :





							"""simple docstring"""





							def __init__( self:  Optional[int]					,		__A:  Any     ):

												'''simple docstring'''

												a__ 							=	data
												a__ 							=	None





							def __str__( self:  str     ):

												'''simple docstring'''

												return F'{self.data}'







class 							_SCREAMING_SNAKE_CASE    :





							"""simple docstring"""





							def __init__( self:  int     ):

												'''simple docstring'''

												a__ 							=	None
												a__ 							=	None




							def __iter__( self:  Tuple     ):

												'''simple docstring'''

												a__ 							=	self.front
												while node:
																	yield node.data
																	a__ 							=	node.next




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

												'''simple docstring'''

												return len(tuple(iter(self     )     )     )




							def __str__( self:  Any     ):

												'''simple docstring'''

												return " <- ".join(str(__A     ) for item in self     )




							def 			lowercase		( self:  Any     ):

												'''simple docstring'''

												return len(self     ) == 0




							def 			lowercase		( self:  Tuple					,		__A:  Any     ):

												'''simple docstring'''

												a__ 							=	Node(__A     )
												if self.is_empty():
																	a__ 							=	a__ 							=	node
												else:
																	assert isinstance(self.rear					,		__A     )
																	a__ 							=	node
																	a__ 							=	node




							def 			lowercase		( self:  List[Any]     ):

												'''simple docstring'''

												if self.is_empty():
																	raise IndexError('''dequeue from empty queue'''     )
												assert isinstance(self.front					,		__A     )
												a__ 							=	self.front
												a__ 							=	self.front.next
												if self.front is None:
																	a__ 							=	None
												return node.data





							def 			lowercase		( self:  Dict     ):

												'''simple docstring'''

												a__ 							=	a__ 							=	None


if __name__ == "__main__":
	from doctest import testmod

	testmod()


