




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

      def __init__( self :     List[Any]				,							lowerCamelCase__ :     Any				,							lowerCamelCase__ :     Optional[int]=13				,							lowerCamelCase__ :     List[str]=32				,							lowerCamelCase__ :     int=2				,							lowerCamelCase__ :     Optional[Any]=3				,							lowerCamelCase__ :     List[str]=16				,							lowerCamelCase__ :     Union[str, Any]=[32, 64, 128]				,							lowerCamelCase__ :     Tuple=[1, 2, 1]				,							lowerCamelCase__ :     Optional[int]=[2, 2, 4]				,							lowerCamelCase__ :     Optional[Any]=2				,							lowerCamelCase__ :     str=2.0				,							lowerCamelCase__ :     Any=True				,							lowerCamelCase__ :     List[Any]=0.0				,							lowerCamelCase__ :     Tuple=0.0				,							lowerCamelCase__ :     str=0.1				,							lowerCamelCase__ :     Dict="gelu"				,							lowerCamelCase__ :     Tuple=False				,							lowerCamelCase__ :     Optional[int]=True				,							lowerCamelCase__ :     str=0.0_2				,							lowerCamelCase__ :     int=1e-5				,							lowerCamelCase__ :     int=True				,							lowerCamelCase__ :     Union[str, Any]=None				,							lowerCamelCase__ :     List[Any]=True				,							lowerCamelCase__ :     Union[str, Any]=10				,							lowerCamelCase__ :     Any=8				,							lowerCamelCase__ :     str=["stage1", "stage2"]				,							lowerCamelCase__ :     Dict=[1, 2]				,							)    ->						str:
             """simple docstring"""


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






      def     UpperCAmelCase_      ( self :     Optional[int]				)    ->						List[str]:
             """simple docstring"""


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

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

             __lowercase      =    self.get_config()

             return config, pixel_values, labels






      def     UpperCAmelCase_      ( self :     Union[str, Any]				)    ->						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 :     Any				,							lowerCamelCase__ :     Optional[int]				,							lowerCamelCase__ :     int				,							lowerCamelCase__ :     int				)    ->						Optional[int]:
             """simple docstring"""


             __lowercase      =    FocalNetModel(config=lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()
             __lowercase      =    model(lowerCamelCase__				)

             __lowercase      =    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
             __lowercase      =    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 :     Optional[Any]				,							lowerCamelCase__ :     int				,							lowerCamelCase__ :     List[Any]				,							lowerCamelCase__ :     Dict				)    ->						Tuple:
             """simple docstring"""


             __lowercase      =    FocalNetBackbone(config=lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()
             __lowercase      =    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
             __lowercase      =    None
             __lowercase      =    FocalNetBackbone(config=lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()
             __lowercase      =    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     UpperCAmelCase_      ( self :     List[str]				,							lowerCamelCase__ :     List[Any]				,							lowerCamelCase__ :     Optional[Any]				,							lowerCamelCase__ :     int				)    ->						Optional[Any]:
             """simple docstring"""


             __lowercase      =    FocalNetForMaskedImageModeling(config=lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()
             __lowercase      =    model(lowerCamelCase__				)
             self.parent.assertEqual(
                 result.reconstruction.shape				,							(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

             # test greyscale images
             __lowercase      =    1
             __lowercase      =    FocalNetForMaskedImageModeling(lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()

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






      def     UpperCAmelCase_      ( self :     str				,							lowerCamelCase__ :     Union[str, Any]				,							lowerCamelCase__ :     Union[str, Any]				,							lowerCamelCase__ :     Dict				)    ->						Union[str, Any]:
             """simple docstring"""


             __lowercase      =    self.type_sequence_label_size
             __lowercase      =    FocalNetForImageClassification(lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()
             __lowercase      =    model(lowerCamelCase__				,							labels=lowerCamelCase__				)
             self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.type_sequence_label_size)				)

             # test greyscale images
             __lowercase      =    1
             __lowercase      =    FocalNetForImageClassification(lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()

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






      def     UpperCAmelCase_      ( self :     List[str]				)    ->						List[str]:
             """simple docstring"""


             __lowercase      =    self.prepare_config_and_inputs()

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







@require_torch
class a (     __SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						unittest.TestCase  ):
      """simple docstring"""

      UpperCamelCase_	:       Tuple       	=		(
          (
              FocalNetModel,
              FocalNetForImageClassification,
              FocalNetForMaskedImageModeling,
              FocalNetBackbone,
          )
          if is_torch_available()
          else ()
      )
      UpperCamelCase_	:       List[str]       	=		(
          {'feature-extraction': FocalNetModel, 'image-classification': FocalNetForImageClassification}
          if is_torch_available()
          else {}
      )
      UpperCamelCase_	:       Union[str, Any]       	=		False

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






      def     UpperCAmelCase_      ( self :     List[Any]				)    ->						List[Any]:
             """simple docstring"""


             __lowercase      =    FocalNetModelTester(self				)
             __lowercase      =    ConfigTester(self				,							config_class=lowerCamelCase__				,							embed_dim=37				,							has_text_modality=lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     Tuple				)    ->						Tuple:
             """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 :     Dict				)    ->						Tuple:
             """simple docstring"""


             return






      def     UpperCAmelCase_      ( self :     Any				)    ->						List[str]:
             """simple docstring"""


             __lowercase      =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     Tuple				)    ->						Optional[Any]:
             """simple docstring"""


             __lowercase      =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_backbone(*lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     Optional[int]				)    ->						Optional[Any]:
             """simple docstring"""


             __lowercase      =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     Union[str, Any]				)    ->						Tuple:
             """simple docstring"""


             __lowercase      =    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     UpperCAmelCase_      ( self :     Union[str, Any]				)    ->						Any:
             """simple docstring"""


             pass






      @unittest.skip(reason='''FocalNet does not use feedforward chunking'''				)
      def     UpperCAmelCase_      ( self :     Any				)    ->						Tuple:
             """simple docstring"""


             pass






      def     UpperCAmelCase_      ( self :     Tuple				)    ->						Any:
             """simple docstring"""


             __lowercase     ,     __lowercase      =    self.model_tester.prepare_config_and_inputs_for_common()

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






      def     UpperCAmelCase_      ( self :     List[str]				)    ->						Tuple:
             """simple docstring"""


             __lowercase     ,     __lowercase      =    self.model_tester.prepare_config_and_inputs_for_common()

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

                    __lowercase      =    ['''pixel_values''']
                    self.assertListEqual(arg_names[:1]				,							lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     Union[str, Any]				,							lowerCamelCase__ :     Optional[Any]				,							lowerCamelCase__ :     Any				,							lowerCamelCase__ :     int				,							lowerCamelCase__ :     List[str]				)    ->						Union[str, Any]:
             """simple docstring"""


             __lowercase      =    model_class(lowerCamelCase__				)
             model.to(lowerCamelCase__				)
             model.eval()

             with torch.no_grad():
                    __lowercase      =    model(**self._prepare_for_class(lowerCamelCase__				,							lowerCamelCase__				)				)

             __lowercase      =    outputs.hidden_states

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

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

             __lowercase      =    outputs.reshaped_hidden_states
             self.assertEqual(len(lowerCamelCase__				)				,							lowerCamelCase__				)

             __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase      =    reshaped_hidden_states[0].shape
             __lowercase      =    (
                 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     UpperCAmelCase_      ( self :     Dict				)    ->						List[Any]:
             """simple docstring"""


             __lowercase     ,     __lowercase      =    self.model_tester.prepare_config_and_inputs_for_common()

             __lowercase      =    (
                 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]:
                    __lowercase      =    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"]
                    __lowercase      =    True

                    self.check_hidden_states_output(lowerCamelCase__				,							lowerCamelCase__				,							lowerCamelCase__				,							lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     Optional[Any]				)    ->						str:
             """simple docstring"""


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

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

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

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






      @slow
      def     UpperCAmelCase_      ( self :     List[Any]				)    ->						List[str]:
             """simple docstring"""


             for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    __lowercase      =    FocalNetModel.from_pretrained(lowerCamelCase__				)
                    self.assertIsNotNone(lowerCamelCase__				)






      def     UpperCAmelCase_      ( self :     List[Any]				)    ->						str:
             """simple docstring"""


             __lowercase     ,     __lowercase      =    self.model_tester.prepare_config_and_inputs_for_common()

             __lowercase      =    _config_zero_init(lowerCamelCase__				)
             for model_class in self.all_model_classes:
                    __lowercase      =    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 a (     unittest.TestCase  ):
      """simple docstring"""

      @cached_property
      def     UpperCAmelCase_      ( self :     Optional[Any]				)    ->						str:
             """simple docstring"""


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






      @slow
      def     UpperCAmelCase_      ( self :     Tuple				)    ->						Any:
             """simple docstring"""


             __lowercase      =    FocalNetForImageClassification.from_pretrained('''microsoft/focalnet-tiny'''				).to(lowerCamelCase__				)
             __lowercase      =    self.default_image_processor

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

             # forward pass
             with torch.no_grad():
                    __lowercase      =    model(**lowerCamelCase__				)

             # verify the logits
             __lowercase      =    torch.Size((1, 1_000)				)
             self.assertEqual(outputs.logits.shape				,							lowerCamelCase__				)
             __lowercase      =    torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]				).to(lowerCamelCase__				)
             self.assertTrue(torch.allclose(outputs.logits[0, :3]				,							lowerCamelCase__				,							atol=1e-4				)				)
             self.assertTrue(outputs.logits.argmax(dim=-1				).item()				,							281				)







@require_torch
class a (     __SCREAMING_SNAKE_CASE       ,						unittest.TestCase  ):
      """simple docstring"""

      UpperCamelCase_	:       Any       	=		(FocalNetBackbone,) if is_torch_available() else ()
      UpperCamelCase_	:       Union[str, Any]       	=		FocalNetConfig

      UpperCamelCase_	:       Union[str, Any]       	=		False






      def     UpperCAmelCase_      ( self :     Optional[Any]				)    ->						int:
             """simple docstring"""


             __lowercase      =    FocalNetModelTester(self				)












import os







def 		_A(       UpperCamelCase__							:			str = "matrix.txt"				)    -> int:
							'''simple docstring'''


							with open(os.path.join(os.path.dirname(UpperCamelCase__				)				,       UpperCamelCase__				)				) as in_file:
														__lowercase      =    in_file.read()

							__lowercase      =    [[int(UpperCamelCase__				) for cell in row.split(''','''				)] for row in data.strip().splitlines()]
							__lowercase      =    [[0 for cell in row] for row in grid]
							__lowercase      =    len(grid[0]				)

							__lowercase      =    [[0 for i in range(UpperCamelCase__				)] for j in range(UpperCamelCase__				)]
							__lowercase      =    grid[0][0]
							for i in range(1				,       UpperCamelCase__				):
														__lowercase      =    grid[0][i] + dp[0][i - 1]
							for i in range(1				,       UpperCamelCase__				):
														__lowercase      =    grid[i][0] + dp[i - 1][0]

							for i in range(1				,       UpperCamelCase__				):
														for j in range(1				,       UpperCamelCase__				):
																					__lowercase      =    grid[i][j] + min(dp[i - 1][j]				,       dp[i][j - 1]				)

							return dp[-1][-1]


if __name__ == "__main__":
			print(F"""{solution() = }""")






