





"""simple docstring"""
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  _SCREAMING_SNAKE_CASE:




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=13		,SCREAMING_SNAKE_CASE__=32		,SCREAMING_SNAKE_CASE__=2		,SCREAMING_SNAKE_CASE__=3		,SCREAMING_SNAKE_CASE__=16		,SCREAMING_SNAKE_CASE__=[32, 64, 1_28]		,SCREAMING_SNAKE_CASE__=[1, 2, 1]		,SCREAMING_SNAKE_CASE__=[2, 2, 4]		,SCREAMING_SNAKE_CASE__=2		,SCREAMING_SNAKE_CASE__=2.0		,SCREAMING_SNAKE_CASE__=True		,SCREAMING_SNAKE_CASE__=0.0		,SCREAMING_SNAKE_CASE__=0.0		,SCREAMING_SNAKE_CASE__=0.1		,SCREAMING_SNAKE_CASE__="gelu"		,SCREAMING_SNAKE_CASE__=False		,SCREAMING_SNAKE_CASE__=True		,SCREAMING_SNAKE_CASE__=0.0_2		,SCREAMING_SNAKE_CASE__=1E-5		,SCREAMING_SNAKE_CASE__=True		,SCREAMING_SNAKE_CASE__=None		,SCREAMING_SNAKE_CASE__=True		,SCREAMING_SNAKE_CASE__=10		,SCREAMING_SNAKE_CASE__=8		,SCREAMING_SNAKE_CASE__=["stage1", "stage2"]		,SCREAMING_SNAKE_CASE__=[1, 2]		,)      ->				str:





             """simple docstring"""






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




       def    _UpperCamelCase					(						self							)      ->				Any:





             """simple docstring"""






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

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

             __SCREAMING_SNAKE_CASE       :List[str]		    =  self.get_config()

             return config, pixel_values, labels




       def    _UpperCamelCase					(						self							)      ->				str:





             """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    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				Optional[int]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :int		    =  FocalNetModel(config=SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE       :str		    =  model(SCREAMING_SNAKE_CASE__							)

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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Any		    =  FocalNetBackbone(config=SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  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
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  None
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  FocalNetBackbone(config=SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE       :List[str]		    =  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    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  FocalNetForMaskedImageModeling(config=SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  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
             __SCREAMING_SNAKE_CASE       :Tuple		    =  1
             __SCREAMING_SNAKE_CASE       :Any		    =  FocalNetForMaskedImageModeling(SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()

             __SCREAMING_SNAKE_CASE       :List[str]		    =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  model(SCREAMING_SNAKE_CASE__							)
             self.parent.assertEqual(result.reconstruction.shape		,(self.batch_size, 1, self.image_size, self.image_size)							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Dict		    =  self.type_sequence_label_size
             __SCREAMING_SNAKE_CASE       :List[str]		    =  FocalNetForImageClassification(SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()
             __SCREAMING_SNAKE_CASE       :List[str]		    =  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
             __SCREAMING_SNAKE_CASE       :List[str]		    =  1
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  FocalNetForImageClassification(SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()

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




       def    _UpperCamelCase					(						self							)      ->				Optional[int]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :str		    =  self.prepare_config_and_inputs()

             __SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE       :Optional[int]		    =  config_and_inputs
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  {'''pixel_values''': pixel_values}
             return config, inputs_dict






@require_torch
class  _SCREAMING_SNAKE_CASE(       A   ,     A   ,     unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_       :				int     						=  (
           (
               FocalNetModel,
               FocalNetForImageClassification,
               FocalNetForMaskedImageModeling,
               FocalNetBackbone,
           )
           if is_torch_available()
           else ()
       )
       SCREAMING_SNAKE_CASE_       :				int     						=  (
           {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
           if is_torch_available()
           else {}
       )
       SCREAMING_SNAKE_CASE_       :				List[str]     						=  False

       SCREAMING_SNAKE_CASE_       :				Optional[int]     						=  False
       SCREAMING_SNAKE_CASE_       :				Any     						=  False
       SCREAMING_SNAKE_CASE_       :				Union[str, Any]     						=  False
       SCREAMING_SNAKE_CASE_       :				Optional[int]     						=  False




       def    _UpperCamelCase					(						self							)      ->				str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :str		    =  FocalNetModelTester(self							)
             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  ConfigTester(self		,config_class=SCREAMING_SNAKE_CASE__		,embed_dim=37		,has_text_modality=SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self							)      ->				Dict:





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





             """simple docstring"""






             return




       def    _UpperCamelCase					(						self							)      ->				Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[str]		    =  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self							)      ->				Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[Any]		    =  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self							)      ->				str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :List[str]		    =  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self							)      ->				Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :Any		    =  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    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






             pass




       @unittest.skip(reason='''FocalNet does not use feedforward chunking'''							)
       def    _UpperCamelCase					(						self							)      ->				Tuple:





             """simple docstring"""






             pass




       def    _UpperCamelCase					(						self							)      ->				Dict:





             """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[:-1]:
                   __SCREAMING_SNAKE_CASE       :Tuple		    =  model_class(SCREAMING_SNAKE_CASE__							)
                   self.assertIsInstance(model.get_input_embeddings()		,(nn.Module)							)
                   __SCREAMING_SNAKE_CASE       :Optional[int]		    =  model.get_output_embeddings()
                   self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__		,nn.Linear							)							)




       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






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

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

                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  ['''pixel_values''']
                   self.assertListEqual(arg_names[:1]		,SCREAMING_SNAKE_CASE__							)




       def    _UpperCamelCase					(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)      ->				List[str]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :str		    =  model_class(SCREAMING_SNAKE_CASE__							)
             model.to(SCREAMING_SNAKE_CASE__							)
             model.eval()

             with torch.no_grad():
                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)							)

             __SCREAMING_SNAKE_CASE       :Dict		    =  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(SCREAMING_SNAKE_CASE__							)		,SCREAMING_SNAKE_CASE__							)

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

             __SCREAMING_SNAKE_CASE       :Union[str, 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]		,)

             __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  outputs.reshaped_hidden_states
             self.assertEqual(len(SCREAMING_SNAKE_CASE__							)		,SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  reshaped_hidden_states[0].shape
             __SCREAMING_SNAKE_CASE       :List[Any]		    =  (
                 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    _UpperCamelCase					(						self							)      ->				List[str]:





             """simple docstring"""






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

             __SCREAMING_SNAKE_CASE       :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]:
                   __SCREAMING_SNAKE_CASE       :Optional[int]		    =  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"]
                   __SCREAMING_SNAKE_CASE       :str		    =  True

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




       def    _UpperCamelCase					(						self							)      ->				List[Any]:





             """simple docstring"""






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

             __SCREAMING_SNAKE_CASE       :List[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       :str		    =  (
                 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       :List[Any]		    =  image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

             for model_class in self.all_model_classes[:-1]:
                   __SCREAMING_SNAKE_CASE       :int		    =  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"]
                   __SCREAMING_SNAKE_CASE       :Tuple		    =  True
                   self.check_hidden_states_output(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,(padded_height, padded_width)							)




       @slow
       def    _UpperCamelCase					(						self							)      ->				int:





             """simple docstring"""






             for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   __SCREAMING_SNAKE_CASE       :List[str]		    =  FocalNetModel.from_pretrained(SCREAMING_SNAKE_CASE__							)
                   self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)




       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       :Union[str, Any]		    =  _config_zero_init(SCREAMING_SNAKE_CASE__							)
             for model_class in self.all_model_classes:
                   __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  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  _SCREAMING_SNAKE_CASE(       unittest.TestCase  ):




       @cached_property
       def    _UpperCamelCase					(						self							)      ->				Tuple:





             """simple docstring"""






             return AutoImageProcessor.from_pretrained('''microsoft/focalnet-tiny'''							) if is_vision_available() else None




       @slow
       def    _UpperCamelCase					(						self							)      ->				Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :int		    =  FocalNetForImageClassification.from_pretrained('''microsoft/focalnet-tiny'''							).to(SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE       :Dict		    =  self.default_image_processor

             __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
             __SCREAMING_SNAKE_CASE       :List[str]		    =  image_processor(images=SCREAMING_SNAKE_CASE__		,return_tensors='''pt'''							).to(SCREAMING_SNAKE_CASE__							)

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

             # verify the logits
             __SCREAMING_SNAKE_CASE       :Optional[int]		    =  torch.Size((1, 10_00)							)
             self.assertEqual(outputs.logits.shape		,SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE       :Any		    =  torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]							).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  _SCREAMING_SNAKE_CASE(       A   ,     unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_       :				Optional[Any]     						=  (FocalNetBackbone,) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_       :				int     						=  FocalNetConfig

       SCREAMING_SNAKE_CASE_       :				Union[str, Any]     						=  False




       def    _UpperCamelCase					(						self							)      ->				str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE       :int		    =  FocalNetModelTester(self							)






"""simple docstring"""
def 					__lowerCamelCase       (							a_					:		Union[str, Any]			,       a_					:		Optional[Any]							)      ->				Union[str, Any]:
      return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2



def 					__lowerCamelCase       (							a_					:		Optional[int]			,       a_					:		Any=0							)      ->				Optional[Any]:
      return sorted(a_			,       key=lambda a_							: x[column]							)



def 					__lowerCamelCase       (							a_					:		Optional[Any]			,       a_					:		Optional[int]			,       a_					:		str=float('''inf'''							)							)      ->				str:

      for i in range(points_counts - 1							):
            for j in range(i + 1			,       a_							):
                  __SCREAMING_SNAKE_CASE       :Dict		    =  euclidean_distance_sqr(points[i]			,       points[j]							)
                  if current_dis < min_dis:
                        __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  current_dis
      return min_dis



def 					__lowerCamelCase       (							a_					:		List[Any]			,       a_					:		Any			,       a_					:		Optional[int]=float('''inf'''							)							)      ->				Optional[Any]:

      for i in range(min(6			,       points_counts - 1							)			,       a_							):
            for j in range(max(0			,       i - 6							)			,       a_							):
                  __SCREAMING_SNAKE_CASE       :Dict		    =  euclidean_distance_sqr(points[i]			,       points[j]							)
                  if current_dis < min_dis:
                        __SCREAMING_SNAKE_CASE       :int		    =  current_dis
      return min_dis



def 					__lowerCamelCase       (							a_					:		str			,       a_					:		List[Any]			,       a_					:		int							)      ->				Optional[int]:

      # base case
      if points_counts <= 3:
            return dis_between_closest_pair(a_			,       a_							)

      # recursion
      __SCREAMING_SNAKE_CASE       :int		    =  points_counts // 2
      __SCREAMING_SNAKE_CASE       :Dict		    =  closest_pair_of_points_sqr(
          a_			,       points_sorted_on_y[:mid]			,       a_							)
      __SCREAMING_SNAKE_CASE       :Any		    =  closest_pair_of_points_sqr(
          a_			,       points_sorted_on_y[mid:]			,       points_counts - mid							)
      __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  min(a_			,       a_							)
      __SCREAMING_SNAKE_CASE       :str		    =  []
      for point in points_sorted_on_x:
            if abs(point[0] - points_sorted_on_x[mid][0]							) < closest_pair_dis:
                  cross_strip.append(a_							)

      __SCREAMING_SNAKE_CASE       :Dict		    =  dis_between_closest_in_strip(
          a_			,       len(a_							)			,       a_							)
      return min(a_			,       a_							)



def 					__lowerCamelCase       (							a_					:		int			,       a_					:		Tuple							)      ->				List[Any]:
      __SCREAMING_SNAKE_CASE       :Union[str, Any]		    =  column_based_sort(a_			,       column=0							)
      __SCREAMING_SNAKE_CASE       :int		    =  column_based_sort(a_			,       column=1							)
      return (
          closest_pair_of_points_sqr(
              a_			,       a_			,       a_							)
      ) ** 0.5


if __name__ == "__main__":
  lowerCamelCase_       =		[(2, 3), (1_2, 3_0), (4_0, 5_0), (5, 1), (1_2, 1_0), (3, 4)]
  print("Distance:", closest_pair_of_points(points, len(points)))