






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							,       __lowerCAmelCase							,       __lowerCAmelCase=1_3							,       __lowerCAmelCase=3_2							,       __lowerCAmelCase=2							,       __lowerCAmelCase=3							,       __lowerCAmelCase=1_6							,       __lowerCAmelCase=[3_2, 6_4, 1_2_8]							,       __lowerCAmelCase=[1, 2, 1]							,       __lowerCAmelCase=[2, 2, 4]							,       __lowerCAmelCase=2							,       __lowerCAmelCase=2.0							,       __lowerCAmelCase=True							,       __lowerCAmelCase=0.0							,       __lowerCAmelCase=0.0							,       __lowerCAmelCase=0.1							,       __lowerCAmelCase="gelu"							,       __lowerCAmelCase=False							,       __lowerCAmelCase=True							,       __lowerCAmelCase=0.02							,       __lowerCAmelCase=1E-5							,       __lowerCAmelCase=True							,       __lowerCAmelCase=None							,       __lowerCAmelCase=True							,       __lowerCAmelCase=1_0							,       __lowerCAmelCase=8							,       __lowerCAmelCase=["stage1", "stage2"]							,       __lowerCAmelCase=[1, 2]							,       ):
								"""simple docstring"""
								__magic_name__		:List[Any]   =   parent
								__magic_name__		:Optional[int]   =   batch_size
								__magic_name__		:str   =   image_size
								__magic_name__		:List[Any]   =   patch_size
								__magic_name__		:Optional[int]   =   num_channels
								__magic_name__		:int   =   embed_dim
								__magic_name__		:Union[str, Any]   =   hidden_sizes
								__magic_name__		:Dict   =   depths
								__magic_name__		:Optional[Any]   =   num_heads
								__magic_name__		:Any   =   window_size
								__magic_name__		:Union[str, Any]   =   mlp_ratio
								__magic_name__		:Any   =   qkv_bias
								__magic_name__		:Dict   =   hidden_dropout_prob
								__magic_name__		:List[Any]   =   attention_probs_dropout_prob
								__magic_name__		:int   =   drop_path_rate
								__magic_name__		:Union[str, Any]   =   hidden_act
								__magic_name__		:Optional[Any]   =   use_absolute_embeddings
								__magic_name__		:str   =   patch_norm
								__magic_name__		:Tuple   =   layer_norm_eps
								__magic_name__		:Tuple   =   initializer_range
								__magic_name__		:List[Any]   =   is_training
								__magic_name__		:Union[str, Any]   =   scope
								__magic_name__		:Dict   =   use_labels
								__magic_name__		:Dict   =   type_sequence_label_size
								__magic_name__		:List[Any]   =   encoder_stride
								__magic_name__		:int   =   out_features
								__magic_name__		:Any   =   out_indices







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								__magic_name__		:Optional[Any]   =   None
								if self.use_labels:
												__magic_name__		:List[str]   =   ids_tensor([self.batch_size]							,       self.type_sequence_label_size  )

								__magic_name__		:Union[str, Any]   =   self.get_config()

								return config, pixel_values, labels







				def       A						(    self  ):
								"""simple docstring"""
								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							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]   =   FocalNetModel(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:Optional[Any]   =   model(__lowerCAmelCase  )

								__magic_name__		:Optional[int]   =   ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
								__magic_name__		:str   =   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							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:str   =   FocalNetBackbone(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:Union[str, Any]   =   model(__lowerCAmelCase  )

								# 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
								__magic_name__		:str   =   None
								__magic_name__		:Optional[int]   =   FocalNetBackbone(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:str   =   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, 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							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   FocalNetForMaskedImageModeling(config=__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:List[str]   =   model(__lowerCAmelCase  )
								self.parent.assertEqual(
								    result.reconstruction.shape							,       (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

								# test greyscale images
								__magic_name__		:Optional[int]   =   1
								__magic_name__		:Any   =   FocalNetForMaskedImageModeling(__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()

								__magic_name__		:Dict   =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
								__magic_name__		:Any   =   model(__lowerCAmelCase  )
								self.parent.assertEqual(result.reconstruction.shape							,       (self.batch_size, 1, self.image_size, self.image_size)  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   self.type_sequence_label_size
								__magic_name__		:Optional[int]   =   FocalNetForImageClassification(__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()
								__magic_name__		:List[str]   =   model(__lowerCAmelCase							,       labels=__lowerCAmelCase  )
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.type_sequence_label_size)  )

								# test greyscale images
								__magic_name__		:List[Any]   =   1
								__magic_name__		:Tuple   =   FocalNetForImageClassification(__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()

								__magic_name__		:Tuple   =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
								__magic_name__		:int   =   model(__lowerCAmelCase  )
								self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.type_sequence_label_size)  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Dict   =   self.prepare_config_and_inputs()

								__magic_name__  ,					__magic_name__  ,					__magic_name__		:Dict   =   config_and_inputs
								__magic_name__		:List[str]   =   {'''pixel_values''': pixel_values}
								return config, inputs_dict







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

				a__       							=	False
				a__       							=	False
				a__       							=	False
				a__       							=	False







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:str   =   FocalNetModelTester(self  )
								__magic_name__		:Optional[int]   =   ConfigTester(self							,       config_class=__lowerCAmelCase							,       embed_dim=3_7							,       has_text_modality=__lowerCAmelCase  )







				def       A						(    self  ):
								"""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       A						(    self  ):
								"""simple docstring"""
								return







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:List[str]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Optional[int]   =   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase  )







				@unittest.skip(reason='''FocalNet does not use inputs_embeds'''  )
				def       A						(    self  ):
								"""simple docstring"""
								pass







				@unittest.skip(reason='''FocalNet does not use feedforward chunking'''  )
				def       A						(    self  ):
								"""simple docstring"""
								pass







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:str   =   self.model_tester.prepare_config_and_inputs_for_common()

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







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:int   =   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes[:-1]:
												__magic_name__		:Union[str, Any]   =   model_class(__lowerCAmelCase  )
												__magic_name__		:Dict   =   inspect.signature(model.forward  )
												# signature.parameters is an OrderedDict => so arg_names order is deterministic
												__magic_name__		:Tuple   =   [*signature.parameters.keys()]

												__magic_name__		:Tuple   =   ['''pixel_values''']
												self.assertListEqual(arg_names[:1]							,       __lowerCAmelCase  )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								__magic_name__		:Dict   =   model_class(__lowerCAmelCase  )
								model.to(__lowerCAmelCase  )
								model.eval()

								with torch.no_grad():
												__magic_name__		:List[Any]   =   model(**self._prepare_for_class(__lowerCAmelCase							,       __lowerCAmelCase  )  )

								__magic_name__		:Dict   =   outputs.hidden_states

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

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

								__magic_name__		:Dict   =   (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]							,       )

								__magic_name__		:Optional[int]   =   outputs.reshaped_hidden_states
								self.assertEqual(len(__lowerCAmelCase  )							,       __lowerCAmelCase  )

								__magic_name__  ,					__magic_name__  ,					__magic_name__  ,					__magic_name__		:List[str]   =   reshaped_hidden_states[0].shape
								__magic_name__		: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       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:List[str]   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:Optional[int]   =   (
								    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]:
												__magic_name__		: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"]
												__magic_name__		:Union[str, Any]   =   True

												self.check_hidden_states_output(__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:Any   =   self.model_tester.prepare_config_and_inputs_for_common()
								__magic_name__		:Optional[int]   =   3

								__magic_name__		: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)
								)
								__magic_name__		:List[Any]   =   (
								    config.patch_size
								    if isinstance(config.patch_size							,       collections.abc.Iterable  )
								    else (config.patch_size, config.patch_size)
								)

								__magic_name__		:Any   =   image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								__magic_name__		:int   =   image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes[:-1]:
												__magic_name__		:Any   =   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"]
												__magic_name__		:List[Any]   =   True
												self.check_hidden_states_output(__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       (padded_height, padded_width)  )







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												__magic_name__		:Dict   =   FocalNetModel.from_pretrained(__lowerCAmelCase  )
												self.assertIsNotNone(__lowerCAmelCase  )







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__  ,					__magic_name__		:Any   =   self.model_tester.prepare_config_and_inputs_for_common()

								__magic_name__		:Tuple   =   _config_zero_init(__lowerCAmelCase  )
								for model_class in self.all_model_classes:
												__magic_name__		:Optional[int]   =   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     lowerCamelCase_					(   unittest.TestCase			):







				@cached_property
				def       A						(    self  ):
								"""simple docstring"""
								# TODO update organization
								return AutoImageProcessor.from_pretrained('''microsoft/focalnet-tiny'''  ) if is_vision_available() else None







				@slow
				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Any   =   FocalNetForImageClassification.from_pretrained('''microsoft/focalnet-tiny'''  ).to(__lowerCAmelCase  )
								__magic_name__		:List[str]   =   self.default_image_processor

								__magic_name__		:Tuple   =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
								__magic_name__		:str   =   image_processor(images=__lowerCAmelCase							,       return_tensors='''pt'''  ).to(__lowerCAmelCase  )

								# forward pass
								with torch.no_grad():
												__magic_name__		:Dict   =   model(**__lowerCAmelCase  )

								# verify the logits
								__magic_name__		:Tuple   =   torch.Size((1, 1_0_0_0)  )
								self.assertEqual(outputs.logits.shape							,       __lowerCAmelCase  )
								__magic_name__		:str   =   torch.tensor([0.2166, -0.4368, 0.2191]  ).to(__lowerCAmelCase  )
								self.assertTrue(torch.allclose(outputs.logits[0, :3]							,       __lowerCAmelCase							,       atol=1E-4  )  )
								self.assertTrue(outputs.logits.argmax(dim=-1  ).item()							,       2_8_1  )







@require_torch
class     lowerCamelCase_					(   _a      ,					unittest.TestCase			):
				a__       							=	(FocalNetBackbone,) if is_torch_available() else ()
				a__       							=	FocalNetConfig

				a__       							=	False







				def       A						(    self  ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]   =   FocalNetModelTester(self  )













from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase__           =			logging.get_logger(__name__)

UpperCamelCase__           =			{
    "tanreinama/GPTSAN-2.8B-spout_is_uniform": (
        "https://huggingface.co/tanreinama/GPTSAN-2.8B-spout_is_uniform/resolve/main/config.json"
    ),
}

class 							__SCREAMING_SNAKE_CASE       (  _a							):
							snake_case  :   Optional[Any]      =							"""gptsan-japanese"""
							snake_case  :   Any      =							[
							    """past_key_values""",
							]
							snake_case  :   str      =							{
							    """hidden_size""": """d_model""",
							    """num_attention_heads""": """num_heads""",
							    """num_hidden_layers""": """num_layers""",
							}






							def __init__(    self	,			__lowerCAmelCase=36000	,			__lowerCAmelCase=1280	,			__lowerCAmelCase=1024	,			__lowerCAmelCase=8192	,			__lowerCAmelCase=4096	,			__lowerCAmelCase=128	,			__lowerCAmelCase=10	,			__lowerCAmelCase=0	,			__lowerCAmelCase=16	,			__lowerCAmelCase=16	,			__lowerCAmelCase=128	,			__lowerCAmelCase=0.0	,			__lowerCAmelCase=1E-5	,			__lowerCAmelCase=False	,			__lowerCAmelCase=0.0	,			__lowerCAmelCase="float32"	,			__lowerCAmelCase=False	,			__lowerCAmelCase=False	,			__lowerCAmelCase=False	,			__lowerCAmelCase=0.002	,			__lowerCAmelCase=False	,			__lowerCAmelCase=True	,			__lowerCAmelCase=35998	,			__lowerCAmelCase=35995	,			__lowerCAmelCase=35999	,			**__lowerCAmelCase	,			):
														UpperCamelCase__					  =      vocab_size
														UpperCamelCase__					  =      max_position_embeddings
														UpperCamelCase__					  =      d_model
														UpperCamelCase__					  =      d_ff
														UpperCamelCase__					  =      d_ext
														UpperCamelCase__					  =      d_spout
														UpperCamelCase__					  =      num_switch_layers
														UpperCamelCase__					  =      num_ext_layers
														UpperCamelCase__					  =      num_switch_layers + num_ext_layers
														UpperCamelCase__					  =      num_heads
														UpperCamelCase__					  =      num_experts
														UpperCamelCase__					  =      expert_capacity
														UpperCamelCase__					  =      dropout_rate
														UpperCamelCase__					  =      layer_norm_epsilon
														UpperCamelCase__					  =      router_bias
														UpperCamelCase__					  =      router_jitter_noise
														UpperCamelCase__					  =      router_dtype
														UpperCamelCase__					  =      router_ignore_padding_tokens
														UpperCamelCase__					  =      output_hidden_states
														UpperCamelCase__					  =      output_attentions
														UpperCamelCase__					  =      initializer_factor
														UpperCamelCase__					  =      output_router_logits
														UpperCamelCase__					  =      use_cache

														super().__init__(
														    separator_token_id=__lowerCAmelCase	,			pad_token_id=__lowerCAmelCase	,			eos_token_id=__lowerCAmelCase	,			**__lowerCAmelCase	,			)




