
import collections
import inspect
import unittest

from transformers import FocalNetConfig
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 (
					    FocalNetBackbone,
					    FocalNetForImageClassification,
					    FocalNetForMaskedImageModeling,
					    FocalNetModel,
					)
					from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor

class    lowerCAmelCase__     :






		def __init__(		self		:							int							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=13							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]=32							,			SCREAMING_SNAKE_CASE__		:							List[str]=2							,			SCREAMING_SNAKE_CASE__		:							int=3							,			SCREAMING_SNAKE_CASE__		:							List[str]=16							,			SCREAMING_SNAKE_CASE__		:							Dict=[32, 64, 1_28]							,			SCREAMING_SNAKE_CASE__		:							Dict=[1, 2, 1]							,			SCREAMING_SNAKE_CASE__		:							int=[2, 2, 4]							,			SCREAMING_SNAKE_CASE__		:							List[str]=2							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]=2.0							,			SCREAMING_SNAKE_CASE__		:							Tuple=True							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=0.0							,			SCREAMING_SNAKE_CASE__		:							Tuple=0.0							,			SCREAMING_SNAKE_CASE__		:							List[Any]=0.1							,			SCREAMING_SNAKE_CASE__		:							Tuple="gelu"							,			SCREAMING_SNAKE_CASE__		:							Tuple=False							,			SCREAMING_SNAKE_CASE__		:							str=True							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]=0.02							,			SCREAMING_SNAKE_CASE__		:							int=1e-5							,			SCREAMING_SNAKE_CASE__		:							Tuple=True							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=None							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]=True							,			SCREAMING_SNAKE_CASE__		:							List[str]=10							,			SCREAMING_SNAKE_CASE__		:							str=8							,			SCREAMING_SNAKE_CASE__		:							Tuple=["stage1", "stage2"]							,			SCREAMING_SNAKE_CASE__		:							str=[1, 2]							,			)     ->							Any:
						__lowerCamelCase    					=	parent
						__lowerCamelCase    					=	batch_size
						__lowerCamelCase    					=	image_size
						__lowerCamelCase    					=	patch_size
						__lowerCamelCase    					=	num_channels
						__lowerCamelCase    					=	embed_dim
						__lowerCamelCase    					=	hidden_sizes
						__lowerCamelCase    					=	depths
						__lowerCamelCase    					=	num_heads
						__lowerCamelCase    					=	window_size
						__lowerCamelCase    					=	mlp_ratio
						__lowerCamelCase    					=	qkv_bias
						__lowerCamelCase    					=	hidden_dropout_prob
						__lowerCamelCase    					=	attention_probs_dropout_prob
						__lowerCamelCase    					=	drop_path_rate
						__lowerCamelCase    					=	hidden_act
						__lowerCamelCase    					=	use_absolute_embeddings
						__lowerCamelCase    					=	patch_norm
						__lowerCamelCase    					=	layer_norm_eps
						__lowerCamelCase    					=	initializer_range
						__lowerCamelCase    					=	is_training
						__lowerCamelCase    					=	scope
						__lowerCamelCase    					=	use_labels
						__lowerCamelCase    					=	type_sequence_label_size
						__lowerCamelCase    					=	encoder_stride
						__lowerCamelCase    					=	out_features
						__lowerCamelCase    					=	out_indices






		def  __A       (		self		:							Tuple  )     ->							Any:
						__lowerCamelCase    					=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

						__lowerCamelCase    					=	self.get_config()

						return config, pixel_values, labels






		def  __A       (		self		:							Optional[int]  )     ->							List[str]:
						return FocalNetConfig(
						    image_size=self.image_size							,			patch_size=self.patch_size							,			num_channels=self.num_channels							,			embed_dim=self.embed_dim							,			hidden_sizes=self.hidden_sizes							,			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  __A       (		self		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]  )     ->							List[Any]:
						__lowerCamelCase    					=	FocalNetModel(config=SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
						__lowerCamelCase    					=	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  __A       (		self		:							Any							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							List[str]  )     ->							List[str]:
						__lowerCamelCase    					=	FocalNetBackbone(config=SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps  )							,			len(config.out_features  )  )
						self.parent.assertListEqual(list(result.feature_maps[0].shape  )							,			[self.batch_size, self.image_size, 8, 8]  )

						# verify channels
						self.parent.assertEqual(len(model.channels  )							,			len(config.out_features  )  )
						self.parent.assertListEqual(model.channels							,			config.hidden_sizes[:-1]  )

						# verify backbone works with out_features=None
						__lowerCamelCase    					=	None
						__lowerCamelCase    					=	FocalNetBackbone(config=SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps  )							,			1  )
						self.parent.assertListEqual(list(result.feature_maps[0].shape  )							,			[self.batch_size, self.image_size * 2, 4, 4]  )

						# verify channels
						self.parent.assertEqual(len(model.channels  )							,			1  )
						self.parent.assertListEqual(model.channels							,			[config.hidden_sizes[-1]]  )






		def  __A       (		self		:							Any							,			SCREAMING_SNAKE_CASE__		:							str							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							Any  )     ->							Any:
						__lowerCamelCase    					=	FocalNetForMaskedImageModeling(config=SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(
						    result.reconstruction.shape							,			(self.batch_size, self.num_channels, self.image_size, self.image_size)  )

						# test greyscale images
						__lowerCamelCase    					=	1
						__lowerCamelCase    					=	FocalNetForMaskedImageModeling(SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()

						__lowerCamelCase    					=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.reconstruction.shape							,			(self.batch_size, 1, self.image_size, self.image_size)  )






		def  __A       (		self		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							List[Any]  )     ->							str:
						__lowerCamelCase    					=	self.type_sequence_label_size
						__lowerCamelCase    					=	FocalNetForImageClassification(SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__							,			labels=SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.type_sequence_label_size)  )

						# test greyscale images
						__lowerCamelCase    					=	1
						__lowerCamelCase    					=	FocalNetForImageClassification(SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()

						__lowerCamelCase    					=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
						__lowerCamelCase    					=	model(SCREAMING_SNAKE_CASE__  )
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.type_sequence_label_size)  )







		def  __A       (		self		:							List[Any]  )     ->							Optional[Any]:
						__lowerCamelCase    					=	self.prepare_config_and_inputs()

						__lowerCamelCase					,    __lowerCamelCase					,    __lowerCamelCase    					=	config_and_inputs
						__lowerCamelCase    					=	{'''pixel_values''': pixel_values}
						return config, inputs_dict





@require_torch
class    lowerCAmelCase__     (	__lowercase  ,	__lowercase  ,	unittest.TestCase			):
		a__       :						Any        =		(
		    (
		        FocalNetModel,
		        FocalNetForImageClassification,
		        FocalNetForMaskedImageModeling,
		        FocalNetBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		a__       :						Any        =		(
		    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
		    if is_torch_available()
		    else {}
		)
		a__       :						Tuple        =		False

		a__       :						Tuple        =		False
		a__       :						Dict        =		False
		a__       :						Dict        =		False
		a__       :						Dict        =		False






		def  __A       (		self		:							List[Any]  )     ->							List[Any]:
						__lowerCamelCase    					=	FocalNetModelTester(self  )
						__lowerCamelCase    					=	ConfigTester(self							,			config_class=SCREAMING_SNAKE_CASE__							,			embed_dim=37							,			has_text_modality=SCREAMING_SNAKE_CASE__  )






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






		def  __A       (		self		:							int  )     ->							Optional[Any]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							int  )     ->							List[Any]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							List[Any]  )     ->							Optional[int]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Tuple  )     ->							Optional[Any]:
						__lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__  )






		@unittest.skip(reason='''FocalNet does not use inputs_embeds'''  )
		def  __A       (		self		:							Any  )     ->							Tuple:
						pass






		@unittest.skip(reason='''FocalNet does not use feedforward chunking'''  )
		def  __A       (		self		:							str  )     ->							Any:
						pass






		def  __A       (		self		:							List[Any]  )     ->							Union[str, Any]:
						__lowerCamelCase					,    __lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes[:-1]:
										__lowerCamelCase    					=	model_class(SCREAMING_SNAKE_CASE__  )
										self.assertIsInstance(model.get_input_embeddings()							,			(nn.Module)  )
										__lowerCamelCase    					=	model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__							,			nn.Linear  )  )






		def  __A       (		self		:							List[Any]  )     ->							int:
						__lowerCamelCase					,    __lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes[:-1]:
										__lowerCamelCase    					=	model_class(SCREAMING_SNAKE_CASE__  )
										__lowerCamelCase    					=	inspect.signature(model.forward  )
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										__lowerCamelCase    					=	[*signature.parameters.keys()]

										__lowerCamelCase    					=	['''pixel_values''']
										self.assertListEqual(arg_names[:1]							,			SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							int							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							List[Any]  )     ->							Tuple:
						__lowerCamelCase    					=	model_class(SCREAMING_SNAKE_CASE__  )
						model.to(SCREAMING_SNAKE_CASE__  )
						model.eval()

						with torch.no_grad():
										__lowerCamelCase    					=	model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )  )

						__lowerCamelCase    					=	outputs.hidden_states

						__lowerCamelCase    					=	getattr(
						    self.model_tester							,			'''expected_num_hidden_layers'''							,			len(self.model_tester.depths  ) + 1  )
						self.assertEqual(len(SCREAMING_SNAKE_CASE__  )							,			SCREAMING_SNAKE_CASE__  )

						# FocalNet has a different seq_length
						__lowerCamelCase    					=	(
						    config.patch_size
						    if isinstance(config.patch_size							,			collections.abc.Iterable  )
						    else (config.patch_size, config.patch_size)
						)

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

						__lowerCamelCase    					=	outputs.reshaped_hidden_states
						self.assertEqual(len(SCREAMING_SNAKE_CASE__  )							,			SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase					,    __lowerCamelCase					,    __lowerCamelCase					,    __lowerCamelCase    					=	reshaped_hidden_states[0].shape
						__lowerCamelCase    					=	(
						    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			height * width  ).permute(0							,			2							,			1  )
						)
						self.assertListEqual(
						    list(reshaped_hidden_states.shape[-2:]  )							,			[num_patches, self.model_tester.embed_dim]							,			)






		def  __A       (		self		:							str  )     ->							Optional[int]:
						__lowerCamelCase					,    __lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs_for_common()

						__lowerCamelCase    					=	(
						    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[:-1]:
										__lowerCamelCase    					=	True
										self.check_hidden_states_output(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )

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

										self.check_hidden_states_output(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Optional[Any]  )     ->							str:
						__lowerCamelCase					,    __lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCamelCase    					=	3

						__lowerCamelCase    					=	(
						    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)
						)
						__lowerCamelCase    					=	(
						    config.patch_size
						    if isinstance(config.patch_size							,			collections.abc.Iterable  )
						    else (config.patch_size, config.patch_size)
						)

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

						for model_class in self.all_model_classes[:-1]:
										__lowerCamelCase    					=	True
										self.check_hidden_states_output(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			(padded_height, padded_width)  )

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






		@slow
		def  __A       (		self		:							int  )     ->							int:
						for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										__lowerCamelCase    					=	FocalNetModel.from_pretrained(SCREAMING_SNAKE_CASE__  )
										self.assertIsNotNone(SCREAMING_SNAKE_CASE__  )







		def  __A       (		self		:							int  )     ->							int:
						__lowerCamelCase					,    __lowerCamelCase    					=	self.model_tester.prepare_config_and_inputs_for_common()

						__lowerCamelCase    					=	_config_zero_init(SCREAMING_SNAKE_CASE__  )
						for model_class in self.all_model_classes:
										__lowerCamelCase    					=	model_class(config=SCREAMING_SNAKE_CASE__  )
										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    lowerCAmelCase__     (	unittest.TestCase			):






		@cached_property
		def  __A       (		self		:							List[Any]  )     ->							Dict:
						# TODO update organization
						return AutoImageProcessor.from_pretrained('''microsoft/focalnet-tiny'''  ) if is_vision_available() else None







		@slow
		def  __A       (		self		:							Tuple  )     ->							Tuple:
						__lowerCamelCase    					=	FocalNetForImageClassification.from_pretrained('''microsoft/focalnet-tiny'''  ).to(SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	self.default_image_processor

						__lowerCamelCase    					=	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
						__lowerCamelCase    					=	image_processor(images=SCREAMING_SNAKE_CASE__							,			return_tensors='''pt'''  ).to(SCREAMING_SNAKE_CASE__  )

						# forward pass
						with torch.no_grad():
										__lowerCamelCase    					=	model(**SCREAMING_SNAKE_CASE__  )

						# verify the logits
						__lowerCamelCase    					=	torch.Size((1, 10_00)  )
						self.assertEqual(outputs.logits.shape							,			SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	torch.tensor([0.2166, -0.4368, 0.2191]  ).to(SCREAMING_SNAKE_CASE__  )
						self.assertTrue(torch.allclose(outputs.logits[0, :3]							,			SCREAMING_SNAKE_CASE__							,			atol=1e-4  )  )
						self.assertTrue(outputs.logits.argmax(dim=-1  ).item()							,			2_81  )





@require_torch
class    lowerCAmelCase__     (	__lowercase  ,	unittest.TestCase			):
		a__       :						List[Any]        =		(FocalNetBackbone,) if is_torch_available() else ()
		a__       :						List[str]        =		FocalNetConfig

		a__       :						Optional[Any]        =		False






		def  __A       (		self		:							Union[str, Any]  )     ->							Tuple:
						__lowerCamelCase    					=	FocalNetModelTester(self  )





from abc import ABC, abstractmethod
from argparse import ArgumentParser

class    lowerCAmelCase__     (	__lowercase			):






		@staticmethod
		@abstractmethod
		def  __A       (		SCREAMING_SNAKE_CASE__		:							ArgumentParser  )     ->							str:
						raise NotImplementedError()







		@abstractmethod
		def  __A       (		self		:							Optional[int]  )     ->							Union[str, Any]:
						raise NotImplementedError()



