
"""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 __lowerCAmelCase	:





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

      '''simple docstring'''




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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

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

      __UpperCamelCase       						= self.get_config()

      return config, pixel_values, labels





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      return FocalNetConfig(
          image_size=self.image_size			,  patch_size=self.patch_size			,  num_channels=self.num_channels			,  embed_dim=self.embed_dim			,  hidden_sizes=self.hidden_sizes			,  depths=self.depths			,  num_heads=self.num_heads			,  window_size=self.window_size			,  mlp_ratio=self.mlp_ratio			,  qkv_bias=self.qkv_bias			,  hidden_dropout_prob=self.hidden_dropout_prob			,  attention_probs_dropout_prob=self.attention_probs_dropout_prob			,  drop_path_rate=self.drop_path_rate			,  hidden_act=self.hidden_act			,  use_absolute_embeddings=self.use_absolute_embeddings			,  path_norm=self.patch_norm			,  layer_norm_eps=self.layer_norm_eps			,  initializer_range=self.initializer_range			,  encoder_stride=self.encoder_stride			,  out_features=self.out_features			,  out_indices=self.out_indices			,  )





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= FocalNetModel(config=__UpperCAmelCase   )
      model.to(__UpperCAmelCase   )
      model.eval()
      __UpperCamelCase       						= model(__UpperCAmelCase   )

      __UpperCamelCase       						= ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
      __UpperCamelCase       						= 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			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= FocalNetBackbone(config=__UpperCAmelCase   )
      model.to(__UpperCAmelCase   )
      model.eval()
      __UpperCamelCase       						= model(__UpperCAmelCase   )

      # 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       						= None
      __UpperCamelCase       						= FocalNetBackbone(config=__UpperCAmelCase   )
      model.to(__UpperCAmelCase   )
      model.eval()
      __UpperCamelCase       						= model(__UpperCAmelCase   )

      # 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			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




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

      # test greyscale images
      __UpperCamelCase       						= 1
      __UpperCamelCase       						= FocalNetForMaskedImageModeling(__UpperCAmelCase   )
      model.to(__UpperCAmelCase   )
      model.eval()

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





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




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

      # test greyscale images
      __UpperCamelCase       						= 1
      __UpperCamelCase       						= FocalNetForImageClassification(__UpperCAmelCase   )
      model.to(__UpperCAmelCase   )
      model.eval()

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







     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.prepare_config_and_inputs()

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


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

     lowercase		     =		False
     lowercase		     =		False
     lowercase		     =		False
     lowercase		     =		False





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= FocalNetModelTester(self   )
      __UpperCamelCase       						= ConfigTester(self			,  config_class=__UpperCAmelCase			,  embed_dim=37			,  has_text_modality=__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      return





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase   )





     @unittest.skip(reason='FocalNet does not use inputs_embeds'   )
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      pass





     @unittest.skip(reason='FocalNet does not use feedforward chunking'   )
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      pass





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase						,			__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs_for_common()

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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase						,			__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs_for_common()

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

       __UpperCamelCase       						= ['pixel_values']
       self.assertListEqual(arg_names[:1]			,  __UpperCAmelCase   )





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= model_class(__UpperCAmelCase   )
      model.to(__UpperCAmelCase   )
      model.eval()

      with torch.no_grad():
       __UpperCamelCase       						= model(**self._prepare_for_class(__UpperCAmelCase			,  __UpperCAmelCase   )   )

      __UpperCamelCase       						= outputs.hidden_states

      __UpperCamelCase       						= getattr(
          self.model_tester			,  'expected_num_hidden_layers'			,  len(self.model_tester.depths   ) + 1   )
      self.assertEqual(len(__UpperCAmelCase   )			,  __UpperCAmelCase   )

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

      __UpperCamelCase       						= (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       						= outputs.reshaped_hidden_states
      self.assertEqual(len(__UpperCAmelCase   )			,  __UpperCAmelCase   )

      __UpperCamelCase						,			__UpperCamelCase						,			__UpperCamelCase						,			__UpperCamelCase       						= reshaped_hidden_states[0].shape
      __UpperCamelCase       						= (
          reshaped_hidden_states[0].view(__UpperCAmelCase			,  __UpperCAmelCase			,  height * width   ).permute(0			,  2			,  1   )
      )
      self.assertListEqual(
          list(reshaped_hidden_states.shape[-2:]   )			,  [num_patches, self.model_tester.embed_dim]			,  )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase						,			__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs_for_common()

      __UpperCamelCase       						= (
          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       						= True
       self.check_hidden_states_output(__UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       __UpperCamelCase       						= True

       self.check_hidden_states_output(__UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

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

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

      for model_class in self.all_model_classes[:-1]:
       __UpperCamelCase       						= True
       self.check_hidden_states_output(__UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  (padded_height, padded_width)   )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       __UpperCamelCase       						= True
       self.check_hidden_states_output(__UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  (padded_height, padded_width)   )





     @slow
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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







     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase						,			__UpperCamelCase       						= self.model_tester.prepare_config_and_inputs_for_common()

      __UpperCamelCase       						= _config_zero_init(__UpperCAmelCase   )
      for model_class in self.all_model_classes:
       __UpperCamelCase       						= model_class(config=__UpperCAmelCase   )
       for name, param in model.named_parameters():
        if "embeddings" not in name and param.requires_grad:
         self.assertIn(
             ((param.data.mean() * 1E9).round() / 1E9).item()			,  [0.0, 1.0]			,  msg=F'Parameter {name} of model {model_class} seems not properly initialized'			,  )


@require_vision
@require_torch
class __lowerCAmelCase	(   unittest.TestCase    ):





     @cached_property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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







     @slow
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'   ).to(__UpperCAmelCase   )
      __UpperCamelCase       						= self.default_image_processor

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

      # forward pass
      with torch.no_grad():
       __UpperCamelCase       						= model(**__UpperCAmelCase   )

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


@require_torch
class __lowerCAmelCase	(   __SCREAMING_SNAKE_CASE    ,						unittest.TestCase    ):
     lowercase		     =		(FocalNetBackbone,) if is_torch_available() else ()
     lowercase		     =		FocalNetConfig

     lowercase		     =		False





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= FocalNetModelTester(self   )





"""simple docstring"""

def 							A		(       snake_case   :int       ,      snake_case   :int	)   ->			int:
 return int(input_a == input_a == 0	)






def 							A		(       )   ->			None:
 print('Truth Table of NOR Gate:'	)
 print('|   Input 1   |  Input 2  | Output |'	)
 print(f'|      0      |    0      |  {nor_gate(0       ,      0	)}     |'	)
 print(f'|      0      |    1      |  {nor_gate(0       ,      1	)}     |'	)
 print(f'|      1      |    0      |  {nor_gate(1       ,      0	)}     |'	)
 print(f'|      1      |    1      |  {nor_gate(1       ,      1	)}     |'	)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()



