






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   :
      def __init__(     self				,			a				,			a=1_3				,			a=3_2				,			a=2				,			a=3				,			a=1_6				,			a=[3_2, 6_4, 1_2_8]				,			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=1_0				,			a=8				,			a=["stage1", "stage2"]				,			a=[1, 2]				,			):
       snake_case__  :    Tuple							       =parent
       snake_case__  :    List[str]							       =batch_size
       snake_case__  :    Optional[Any]							       =image_size
       snake_case__  :    int							       =patch_size
       snake_case__  :    Tuple							       =num_channels
       snake_case__  :    str							       =embed_dim
       snake_case__  :    Optional[int]							       =hidden_sizes
       snake_case__  :    Optional[Any]							       =depths
       snake_case__  :    str							       =num_heads
       snake_case__  :    Any							       =window_size
       snake_case__  :    List[Any]							       =mlp_ratio
       snake_case__  :    Optional[int]							       =qkv_bias
       snake_case__  :    Optional[Any]							       =hidden_dropout_prob
       snake_case__  :    List[str]							       =attention_probs_dropout_prob
       snake_case__  :    int							       =drop_path_rate
       snake_case__  :    List[Any]							       =hidden_act
       snake_case__  :    Optional[Any]							       =use_absolute_embeddings
       snake_case__  :    Optional[int]							       =patch_norm
       snake_case__  :    List[str]							       =layer_norm_eps
       snake_case__  :    int							       =initializer_range
       snake_case__  :    Dict							       =is_training
       snake_case__  :    Tuple							       =scope
       snake_case__  :    Optional[Any]							       =use_labels
       snake_case__  :    int							       =type_sequence_label_size
       snake_case__  :    str							       =encoder_stride
       snake_case__  :    Dict							       =out_features
       snake_case__  :    Union[str, Any]							       =out_indices
      def 						lowercase__					(     self   ):
       snake_case__  :    int							       =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

       snake_case__  :    Optional[Any]							       =self.get_config()

       return config, pixel_values, labels
      def 						lowercase__					(     self   ):
       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 						lowercase__					(     self				,			a				,			a				,			a   ):
       snake_case__  :    List[str]							       =FocalNetModel(config=a   )
       model.to(a   )
       model.eval()
       snake_case__  :    Union[str, Any]							       =model(a   )

       snake_case__  :    Tuple							       =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
       snake_case__  :    Tuple							       =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 						lowercase__					(     self				,			a				,			a				,			a   ):
       snake_case__  :    Any							       =FocalNetBackbone(config=a   )
       model.to(a   )
       model.eval()
       snake_case__  :    List[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
       snake_case__  :    str							       =None
       snake_case__  :    List[str]							       =FocalNetBackbone(config=a   )
       model.to(a   )
       model.eval()
       snake_case__  :    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 						lowercase__					(     self				,			a				,			a				,			a   ):
       snake_case__  :    Any							       =FocalNetForMaskedImageModeling(config=a   )
       model.to(a   )
       model.eval()
       snake_case__  :    Dict							       =model(a   )
       self.parent.assertEqual(
           result.reconstruction.shape				,			(self.batch_size, self.num_channels, self.image_size, self.image_size)   )

       # test greyscale images
       snake_case__  :    int							       =1
       snake_case__  :    str							       =FocalNetForMaskedImageModeling(a   )
       model.to(a   )
       model.eval()

       snake_case__  :    str							       =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
       snake_case__  :    int							       =model(a   )
       self.parent.assertEqual(result.reconstruction.shape				,			(self.batch_size, 1, self.image_size, self.image_size)   )
      def 						lowercase__					(     self				,			a				,			a				,			a   ):
       snake_case__  :    Union[str, Any]							       =self.type_sequence_label_size
       snake_case__  :    List[Any]							       =FocalNetForImageClassification(a   )
       model.to(a   )
       model.eval()
       snake_case__  :    Optional[int]							       =model(a				,			labels=a   )
       self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.type_sequence_label_size)   )

       # test greyscale images
       snake_case__  :    Union[str, Any]							       =1
       snake_case__  :    Any							       =FocalNetForImageClassification(a   )
       model.to(a   )
       model.eval()

       snake_case__  :    Union[str, Any]							       =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
       snake_case__  :    Tuple							       =model(a   )
       self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.type_sequence_label_size)   )



      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =self.prepare_config_and_inputs()

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







@require_torch
class  _lowercase   (   __lowercase						,				__lowercase						,				unittest.TestCase						):
      _a							:						List[str]										=							(
          (
              FocalNetModel,
              FocalNetForImageClassification,
              FocalNetForMaskedImageModeling,
              FocalNetBackbone,
          )
          if is_torch_available()
          else ()
      )
      _a							:						Optional[Any]										=							(
          {'feature-extraction': FocalNetModel, 'image-classification': FocalNetForImageClassification}
          if is_torch_available()
          else {}
      )
      _a							:						Tuple										=							False

      _a							:						Optional[int]										=							False
      _a							:						Tuple										=							False
      _a							:						Optional[int]										=							False
      _a							:						List[str]										=							False
      def 						lowercase__					(     self   ):
       snake_case__  :    Tuple							       =FocalNetModelTester(self   )
       snake_case__  :    Any							       =ConfigTester(self				,			config_class=a				,			embed_dim=3_7				,			has_text_modality=a   )
      def 						lowercase__					(     self   ):
       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 						lowercase__					(     self   ):
       return
      def 						lowercase__					(     self   ):
       snake_case__  :    List[Any]							       =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[Any]							       =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*a   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*a   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[Any]							       =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 						lowercase__					(     self   ):
       pass
      @unittest.skip(reason="""FocalNet does not use feedforward chunking"""   )
      def 						lowercase__					(     self   ):
       pass
      def 						lowercase__					(     self   ):
       snake_case__  :    int							       =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:-1]:
        snake_case__  :    Optional[Any]							       =model_class(a   )
        self.assertIsInstance(model.get_input_embeddings()				,			(nn.Module)   )
        snake_case__  :    List[Any]							       =model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(a				,			nn.Linear   )   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Any							       =self.model_tester.prepare_config_and_inputs_for_common()

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

        snake_case__  :    Optional[int]							       =["pixel_values"]
        self.assertListEqual(arg_names[:1]				,			a   )
      def 						lowercase__					(     self				,			a				,			a				,			a				,			a   ):
       snake_case__  :    List[Any]							       =model_class(a   )
       model.to(a   )
       model.eval()

       with torch.no_grad():
        snake_case__  :    int							       =model(**self._prepare_for_class(a				,			a   )   )

       snake_case__  :    str							       =outputs.hidden_states

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

       snake_case__  :    List[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]				,			)

       snake_case__  :    Optional[Any]							       =outputs.reshaped_hidden_states
       self.assertEqual(len(a   )				,			a   )

       snake_case__  :    List[Any]							       =reshaped_hidden_states[0].shape
       snake_case__  :    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 						lowercase__					(     self   ):
       snake_case__  :    Optional[Any]							       =self.model_tester.prepare_config_and_inputs_for_common()

       snake_case__  :    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)
       )

       for model_class in self.all_model_classes[:-1]:
        snake_case__  :    str							       =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"]
        snake_case__  :    int							       =True

        self.check_hidden_states_output(a				,			a				,			a				,			a   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Tuple							       =self.model_tester.prepare_config_and_inputs_for_common()
       snake_case__  :    Any							       =3

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

       snake_case__  :    Union[str, Any]							       =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       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]:
        snake_case__  :    str							       =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"]
        snake_case__  :    Union[str, Any]							       =True
        self.check_hidden_states_output(a				,			a				,			a				,			(padded_height, padded_width)   )
      @slow
      def 						lowercase__					(     self   ):
       for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        snake_case__  :    Tuple							       =FocalNetModel.from_pretrained(a   )
        self.assertIsNotNone(a   )



      def 						lowercase__					(     self   ):
       snake_case__  :    List[str]							       =self.model_tester.prepare_config_and_inputs_for_common()

       snake_case__  :    Tuple							       =_config_zero_init(a   )
       for model_class in self.all_model_classes:
        snake_case__  :    int							       =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						):
      @cached_property
      def 						lowercase__					(     self   ):
       # TODO update organization
       return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""   ) if is_vision_available() else None



      @slow
      def 						lowercase__					(     self   ):
       snake_case__  :    str							       =FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""   ).to(a   )
       snake_case__  :    Tuple							       =self.default_image_processor

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

       # forward pass
       with torch.no_grad():
        snake_case__  :    Any							       =model(**a   )

       # verify the logits
       snake_case__  :    Any							       =torch.Size((1, 1_0_0_0)   )
       self.assertEqual(outputs.logits.shape				,			a   )
       snake_case__  :    List[Any]							       =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()				,			2_8_1   )







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

      _a							:						str										=							False
      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[Any]							       =FocalNetModelTester(self   )













def 			A__							(      _a  :					Any		,  _a  :					Optional[Any]		,  _a  :					int		,  _a  :					Any	):





 '''simple docstring'''







 if height >= 1:
  move_tower(height - 1		,  _a		,  _a		,  _a	)
  move_disk(_a		,  _a	)
  move_tower(height - 1		,  _a		,  _a		,  _a	)







def 			A__							(      _a  :					Optional[int]		,  _a  :					str	):





 '''simple docstring'''







 print("""moving disk from"""		,  _a		,  """to"""		,  _a	)







def 			A__							(      ):





 '''simple docstring'''







 snake_case__  :    Dict							       =int(input("""Height of hanoi: """	).strip()	)
 move_tower(_a		,  """A"""		,  """B"""		,  """C"""	)


if __name__ == "__main__":
       main()





