



'''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 							lowercase       :


 """simple docstring"""


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







 def _snake_case (							self							)		->   Any:
        _UpperCAmelCase  :						List[str]			     = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

        _UpperCAmelCase  :						Dict			     = None
        if self.use_labels:
               _UpperCAmelCase  :						List[Any]			     = ids_tensor([self.batch_size]  ,self.type_sequence_label_size							)

        _UpperCAmelCase  :						Dict			     = self.get_config()

        return config, pixel_values, labels







 def _snake_case (							self							)		->   Tuple:
        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 _snake_case (							self  ,a_  ,a_  ,a_							)		->   str:
        _UpperCAmelCase  :						Dict			     = FocalNetModel(config=a_							)
        model.to(a_							)
        model.eval()
        _UpperCAmelCase  :						Optional[Any]			     = model(a_							)

        _UpperCAmelCase  :						Any			     = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
        _UpperCAmelCase  :						Dict			     = 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 _snake_case (							self  ,a_  ,a_  ,a_							)		->   Tuple:
        _UpperCAmelCase  :						Dict			     = FocalNetBackbone(config=a_							)
        model.to(a_							)
        model.eval()
        _UpperCAmelCase  :						Any			     = model(a_							)

        # 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
        _UpperCAmelCase  :						Optional[Any]			     = None
        _UpperCAmelCase  :						Any			     = FocalNetBackbone(config=a_							)
        model.to(a_							)
        model.eval()
        _UpperCAmelCase  :						Optional[Any]			     = model(a_							)

        # 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 _snake_case (							self  ,a_  ,a_  ,a_							)		->   int:
        _UpperCAmelCase  :						int			     = FocalNetForMaskedImageModeling(config=a_							)
        model.to(a_							)
        model.eval()
        _UpperCAmelCase  :						Tuple			     = model(a_							)
        self.parent.assertEqual(
            result.reconstruction.shape  ,(self.batch_size, self.num_channels, self.image_size, self.image_size)							)

        # test greyscale images
        _UpperCAmelCase  :						int			     = 1
        _UpperCAmelCase  :						Any			     = FocalNetForMaskedImageModeling(a_							)
        model.to(a_							)
        model.eval()

        _UpperCAmelCase  :						List[Any]			     = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
        _UpperCAmelCase  :						Tuple			     = model(a_							)
        self.parent.assertEqual(result.reconstruction.shape  ,(self.batch_size, 1, self.image_size, self.image_size)							)







 def _snake_case (							self  ,a_  ,a_  ,a_							)		->   Dict:
        _UpperCAmelCase  :						Any			     = self.type_sequence_label_size
        _UpperCAmelCase  :						int			     = FocalNetForImageClassification(a_							)
        model.to(a_							)
        model.eval()
        _UpperCAmelCase  :						Optional[Any]			     = model(a_  ,labels=a_							)
        self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.type_sequence_label_size)							)

        # test greyscale images
        _UpperCAmelCase  :						int			     = 1
        _UpperCAmelCase  :						Tuple			     = FocalNetForImageClassification(a_							)
        model.to(a_							)
        model.eval()

        _UpperCAmelCase  :						Dict			     = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
        _UpperCAmelCase  :						Union[str, Any]			     = model(a_							)
        self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.type_sequence_label_size)							)







 def _snake_case (							self							)		->   Optional[int]:
        _UpperCAmelCase  :						List[Any]			     = self.prepare_config_and_inputs()

        _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						Union[str, Any]			     = config_and_inputs
        _UpperCAmelCase  :						Dict			     = {"""pixel_values""": pixel_values}
        return config, inputs_dict







@require_torch
class 							lowercase       (  _lowerCamelCase					,					_lowerCamelCase					,					unittest.TestCase				):


 """simple docstring"""


 UpperCAmelCase							=  (
     (
         FocalNetModel,
         FocalNetForImageClassification,
         FocalNetForMaskedImageModeling,
         FocalNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 UpperCAmelCase							=  (
     {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
     if is_torch_available()
     else {}
 )
 UpperCAmelCase							=  False

 UpperCAmelCase							=  False
 UpperCAmelCase							=  False
 UpperCAmelCase							=  False
 UpperCAmelCase							=  False







 def _snake_case (							self							)		->   Optional[Any]:
        _UpperCAmelCase  :						Optional[Any]			     = FocalNetModelTester(self							)
        _UpperCAmelCase  :						Dict			     = ConfigTester(self  ,config_class=a_  ,embed_dim=37  ,has_text_modality=a_							)







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







 def _snake_case (							self							)		->   Any:
        _UpperCAmelCase  :						Optional[int]			     = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*a_							)







 def _snake_case (							self							)		->   int:
        _UpperCAmelCase  :						Tuple			     = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*a_							)







 def _snake_case (							self							)		->   str:
        _UpperCAmelCase  :						Optional[int]			     = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*a_							)







 def _snake_case (							self							)		->   Optional[int]:
        _UpperCAmelCase  :						List[str]			     = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*a_							)







 @unittest.skip(reason="""FocalNet does not use inputs_embeds"""							)
 def _snake_case (							self							)		->   List[Any]:
        pass







 @unittest.skip(reason="""FocalNet does not use feedforward chunking"""							)
 def _snake_case (							self							)		->   Optional[Any]:
        pass







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

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







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

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

               _UpperCAmelCase  :						Union[str, Any]			     = ["""pixel_values"""]
               self.assertListEqual(arg_names[:1]  ,a_							)







 def _snake_case (							self  ,a_  ,a_  ,a_  ,a_							)		->   Optional[int]:
        _UpperCAmelCase  :						Dict			     = model_class(a_							)
        model.to(a_							)
        model.eval()

        with torch.no_grad():
               _UpperCAmelCase  :						Any			     = model(**self._prepare_for_class(a_  ,a_							)							)

        _UpperCAmelCase  :						Optional[Any]			     = outputs.hidden_states

        _UpperCAmelCase  :						Tuple			     = getattr(
            self.model_tester  ,"""expected_num_hidden_layers"""  ,len(self.model_tester.depths							) + 1							)
        self.assertEqual(len(a_							)  ,a_							)

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

        _UpperCAmelCase  :						str			     = (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]  ,)

        _UpperCAmelCase  :						List[Any]			     = outputs.reshaped_hidden_states
        self.assertEqual(len(a_							)  ,a_							)

        _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						str			     = reshaped_hidden_states[0].shape
        _UpperCAmelCase  :						Union[str, Any]			     = (
            reshaped_hidden_states[0].view(a_  ,a_  ,height * width							).permute(0  ,2  ,1							)
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-2:]							)  ,[num_patches, self.model_tester.embed_dim]  ,)







 def _snake_case (							self							)		->   Optional[Any]:
        _UpperCAmelCase     ,_UpperCAmelCase  :						Any			     = self.model_tester.prepare_config_and_inputs_for_common()

        _UpperCAmelCase  :						Tuple			     = (
            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]:
               _UpperCAmelCase  :						Union[str, Any]			     = 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"]
               _UpperCAmelCase  :						Union[str, Any]			     = True

               self.check_hidden_states_output(a_  ,a_  ,a_  ,a_							)







 def _snake_case (							self							)		->   List[str]:
        _UpperCAmelCase     ,_UpperCAmelCase  :						Any			     = self.model_tester.prepare_config_and_inputs_for_common()
        _UpperCAmelCase  :						Union[str, Any]			     = 3

        _UpperCAmelCase  :						Tuple			     = (
            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)
        )
        _UpperCAmelCase  :						Optional[int]			     = (
            config.patch_size
            if isinstance(config.patch_size  ,collections.abc.Iterable							)
            else (config.patch_size, config.patch_size)
        )

        _UpperCAmelCase  :						str			     = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        _UpperCAmelCase  :						List[Any]			     = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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







 @slow
 def _snake_case (							self							)		->   Any:
        for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _UpperCAmelCase  :						Dict			     = FocalNetModel.from_pretrained(a_							)
               self.assertIsNotNone(a_							)







 def _snake_case (							self							)		->   Union[str, Any]:
        _UpperCAmelCase     ,_UpperCAmelCase  :						int			     = self.model_tester.prepare_config_and_inputs_for_common()

        _UpperCAmelCase  :						List[Any]			     = _config_zero_init(a_							)
        for model_class in self.all_model_classes:
               _UpperCAmelCase  :						List[str]			     = model_class(config=a_							)
               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 							lowercase       (  unittest.TestCase				):


 """simple docstring"""


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







 @slow
 def _snake_case (							self							)		->   Tuple:
        _UpperCAmelCase  :						List[str]			     = FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""							).to(a_							)
        _UpperCAmelCase  :						str			     = self.default_image_processor

        _UpperCAmelCase  :						Optional[int]			     = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
        _UpperCAmelCase  :						Any			     = image_processor(images=a_  ,return_tensors="""pt"""							).to(a_							)

        # forward pass
        with torch.no_grad():
               _UpperCAmelCase  :						Union[str, Any]			     = model(**a_							)

        # verify the logits
        _UpperCAmelCase  :						Dict			     = torch.Size((1, 1_000)							)
        self.assertEqual(outputs.logits.shape  ,a_							)
        _UpperCAmelCase  :						List[str]			     = torch.tensor([0.2166, -0.4368, 0.2191]							).to(a_							)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,a_  ,atol=1E-4							)							)
        self.assertTrue(outputs.logits.argmax(dim=-1							).item()  ,281							)







@require_torch
class 							lowercase       (  _lowerCamelCase					,					unittest.TestCase				):


 """simple docstring"""


 UpperCAmelCase							=  (FocalNetBackbone,) if is_torch_available() else ()
 UpperCAmelCase							=  FocalNetConfig

 UpperCAmelCase							=  False







 def _snake_case (							self							)		->   Dict:
        _UpperCAmelCase  :						List[Any]			     = FocalNetModelTester(self							)








'''simple docstring'''






# using dfs for finding eulerian path traversal




def     snake_case_					(     lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_=None		)->		List[str]:





       '''simple docstring'''


       _UpperCAmelCase  :						Any			     = (path or []) + [u]
       for v in graph[u]:
              if visited_edge[u][v] is False:
                     _UpperCAmelCase     ,_UpperCAmelCase  :						Tuple			     = True, True
                     _UpperCAmelCase  :						List[Any]			     = dfs(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_		)
       return path




def     snake_case_					(     lowerCAmelCase_       ,   lowerCAmelCase_		)->		Optional[int]:





       '''simple docstring'''


       _UpperCAmelCase  :						Optional[Any]			     = 0
       _UpperCAmelCase  :						Optional[int]			     = -1
       for i in range(lowerCAmelCase_		):
              if i not in graph.keys():
                     continue
              if len(graph[i]		) % 2 == 1:
                     odd_degree_nodes += 1
                     _UpperCAmelCase  :						Optional[int]			     = i
       if odd_degree_nodes == 0:
              return 1, odd_node
       if odd_degree_nodes == 2:
              return 2, odd_node
       return 3, odd_node




def     snake_case_					(     lowerCAmelCase_       ,   lowerCAmelCase_		)->		List[Any]:





       '''simple docstring'''


       _UpperCAmelCase  :						str			     = [[False for _ in range(max_node + 1		)] for _ in range(max_node + 1		)]
       _UpperCAmelCase     ,_UpperCAmelCase  :						int			     = check_circuit_or_path(lowerCAmelCase_       ,   lowerCAmelCase_		)
       if check == 3:
              print("""graph is not Eulerian"""		)
              print("""no path"""		)
              return
       _UpperCAmelCase  :						Dict			     = 1
       if check == 2:
              _UpperCAmelCase  :						Dict			     = odd_node
              print("""graph has a Euler path"""		)
       if check == 1:
              print("""graph has a Euler cycle"""		)
       _UpperCAmelCase  :						Dict			     = dfs(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_		)
       print(lowerCAmelCase_		)




def     snake_case_					(     )->		Union[str, Any]:





       '''simple docstring'''


       _UpperCAmelCase  :						Any			     = {1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]}
       _UpperCAmelCase  :						int			     = {1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]}
       _UpperCAmelCase  :						Tuple			     = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]}
       _UpperCAmelCase  :						List[Any]			     = {1: [2, 3], 2: [1, 3], 3: [1, 2]}
       _UpperCAmelCase  :						List[str]			     = {
           1: [],
           2: []
           # all degree is zero
       }
       _UpperCAmelCase  :						Union[str, Any]			     = 10
       check_euler(lowerCAmelCase_       ,   lowerCAmelCase_		)
       check_euler(lowerCAmelCase_       ,   lowerCAmelCase_		)
       check_euler(lowerCAmelCase_       ,   lowerCAmelCase_		)
       check_euler(lowerCAmelCase_       ,   lowerCAmelCase_		)
       check_euler(lowerCAmelCase_       ,   lowerCAmelCase_		)


if __name__ == "__main__":
   main()



