



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			:       str							,   __lowerCAmelCase			:       Any							,   __lowerCAmelCase			:       Tuple=13							,   __lowerCAmelCase			:       str=32							,   __lowerCAmelCase			:       Tuple=2							,   __lowerCAmelCase			:       List[Any]=3							,   __lowerCAmelCase			:       int=16							,   __lowerCAmelCase			:       Dict=[32, 64, 128]							,   __lowerCAmelCase			:       str=[1, 2, 1]							,   __lowerCAmelCase			:       Optional[int]=[2, 2, 4]							,   __lowerCAmelCase			:       Optional[Any]=2							,   __lowerCAmelCase			:       Dict=2.0							,   __lowerCAmelCase			:       List[Any]=True							,   __lowerCAmelCase			:       str=0.0							,   __lowerCAmelCase			:       Dict=0.0							,   __lowerCAmelCase			:       Union[str, Any]=0.1							,   __lowerCAmelCase			:       Dict="gelu"							,   __lowerCAmelCase			:       List[Any]=False							,   __lowerCAmelCase			:       List[Any]=True							,   __lowerCAmelCase			:       Union[str, Any]=0.0_2							,   __lowerCAmelCase			:       Tuple=1E-5							,   __lowerCAmelCase			:       List[str]=True							,   __lowerCAmelCase			:       Optional[Any]=None							,   __lowerCAmelCase			:       List[Any]=True							,   __lowerCAmelCase			:       Dict=10							,   __lowerCAmelCase			:       List[Any]=8							,   __lowerCAmelCase			:       List[str]=["stage1", "stage2"]							,   __lowerCAmelCase			:       str=[1, 2]							,   )       ->				List[Any]:


    """simple docstring"""






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

   def 		A							(      self			:       Optional[Any]							)       ->				Optional[Any]:


    """simple docstring"""






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

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

    a						=		self.get_config()

    return config, pixel_values, labels

   def 		A							(      self			:       Any							)       ->				Tuple:


    """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 		A							(      self			:       Union[str, Any]							,   __lowerCAmelCase			:       Union[str, Any]							,   __lowerCAmelCase			:       Union[str, Any]							,   __lowerCAmelCase			:       Tuple							)       ->				Dict:


    """simple docstring"""






    a						=		FocalNetModel(config=__lowerCAmelCase							)
    model.to(__lowerCAmelCase							)
    model.eval()
    a						=		model(__lowerCAmelCase							)

    a						=		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
    a						=		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 		A							(      self			:       Optional[Any]							,   __lowerCAmelCase			:       List[Any]							,   __lowerCAmelCase			:       str							,   __lowerCAmelCase			:       int							)       ->				int:


    """simple docstring"""






    a						=		FocalNetBackbone(config=__lowerCAmelCase							)
    model.to(__lowerCAmelCase							)
    model.eval()
    a						=		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
    a						=		None
    a						=		FocalNetBackbone(config=__lowerCAmelCase							)
    model.to(__lowerCAmelCase							)
    model.eval()
    a						=		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 		A							(      self			:       Union[str, Any]							,   __lowerCAmelCase			:       int							,   __lowerCAmelCase			:       Union[str, Any]							,   __lowerCAmelCase			:       str							)       ->				Dict:


    """simple docstring"""






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

    # test greyscale images
    a						=		1
    a						=		FocalNetForMaskedImageModeling(__lowerCAmelCase							)
    model.to(__lowerCAmelCase							)
    model.eval()

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

   def 		A							(      self			:       Union[str, Any]							,   __lowerCAmelCase			:       Optional[Any]							,   __lowerCAmelCase			:       Tuple							,   __lowerCAmelCase			:       Optional[Any]							)       ->				str:


    """simple docstring"""






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

    # test greyscale images
    a						=		1
    a						=		FocalNetForImageClassification(__lowerCAmelCase							)
    model.to(__lowerCAmelCase							)
    model.eval()

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




   def 		A							(      self			:       Tuple							)       ->				int:


    """simple docstring"""






    a						=		self.prepare_config_and_inputs()

    a		,  a		,  a						=		config_and_inputs
    a						=		{"pixel_values": pixel_values}
    return config, inputs_dict



@require_torch
class 		_lowercase		(       UpperCAmelCase__,   UpperCAmelCase__,   unittest.TestCase	):
   _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 		A							(      self			:       List[str]							)       ->				str:


    """simple docstring"""






    a						=		FocalNetModelTester(self							)
    a						=		ConfigTester(self							,   config_class=__lowerCAmelCase							,   embed_dim=37							,   has_text_modality=__lowerCAmelCase							)

   def 		A							(      self			:       List[Any]							)       ->				int:


    """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 		A							(      self			:       str							)       ->				List[Any]:


    """simple docstring"""






    return

   def 		A							(      self			:       Dict							)       ->				str:


    """simple docstring"""






    a						=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__lowerCAmelCase							)

   def 		A							(      self			:       Union[str, Any]							)       ->				List[Any]:


    """simple docstring"""






    a						=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*__lowerCAmelCase							)

   def 		A							(      self			:       List[Any]							)       ->				Optional[int]:


    """simple docstring"""






    a						=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCAmelCase							)

   def 		A							(      self			:       Union[str, Any]							)       ->				Dict:


    """simple docstring"""






    a						=		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 		A							(      self			:       Tuple							)       ->				Optional[int]:


    """simple docstring"""






    pass

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


    """simple docstring"""






    pass

   def 		A							(      self			:       Optional[Any]							)       ->				Union[str, Any]:


    """simple docstring"""






    a		,  a						=		self.model_tester.prepare_config_and_inputs_for_common()

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

   def 		A							(      self			:       Optional[Any]							)       ->				List[Any]:


    """simple docstring"""






    a		,  a						=		self.model_tester.prepare_config_and_inputs_for_common()

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

     a						=		["pixel_values"]
     self.assertListEqual(arg_names[:1]							,   __lowerCAmelCase							)

   def 		A							(      self			:       List[str]							,   __lowerCAmelCase			:       Union[str, Any]							,   __lowerCAmelCase			:       Optional[int]							,   __lowerCAmelCase			:       List[str]							,   __lowerCAmelCase			:       Optional[Any]							)       ->				Dict:


    """simple docstring"""






    a						=		model_class(__lowerCAmelCase							)
    model.to(__lowerCAmelCase							)
    model.eval()

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

    a						=		outputs.hidden_states

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

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

    a						=		outputs.reshaped_hidden_states
    self.assertEqual(len(__lowerCAmelCase							)							,   __lowerCAmelCase							)

    a		,  a		,  a		,  a						=		reshaped_hidden_states[0].shape
    a						=		(
        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 		A							(      self			:       Optional[int]							)       ->				Optional[int]:


    """simple docstring"""






    a		,  a						=		self.model_tester.prepare_config_and_inputs_for_common()

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

     self.check_hidden_states_output(__lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase							)

   def 		A							(      self			:       Union[str, Any]							)       ->				List[Any]:


    """simple docstring"""






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

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

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

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

   @slow
   def 		A							(      self			:       List[str]							)       ->				str:


    """simple docstring"""






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




   def 		A							(      self			:       Tuple							)       ->				str:


    """simple docstring"""






    a		,  a						=		self.model_tester.prepare_config_and_inputs_for_common()

    a						=		_config_zero_init(__lowerCAmelCase							)
    for model_class in self.all_model_classes:
     a						=		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 		_lowercase		(       unittest.TestCase	):

   @cached_property
   def 		A							(      self			:       Tuple							)       ->				int:


    """simple docstring"""






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




   @slow
   def 		A							(      self			:       str							)       ->				Dict:


    """simple docstring"""






    a						=		FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny"							).to(__lowerCAmelCase							)
    a						=		self.default_image_processor

    a						=		Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
    a						=		image_processor(images=__lowerCAmelCase							,   return_tensors="pt"							).to(__lowerCAmelCase							)

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

    # verify the logits
    a						=		torch.Size((1, 1000)							)
    self.assertEqual(outputs.logits.shape							,   __lowerCAmelCase							)
    a						=		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 		_lowercase		(       UpperCAmelCase__,   unittest.TestCase	):
   _UpperCAmelCase     	=			(FocalNetBackbone,) if is_torch_available() else ()
   _UpperCAmelCase     	=			FocalNetConfig

   _UpperCAmelCase     	=			False

   def 		A							(      self			:       List[Any]							)       ->				Optional[Any]:


    """simple docstring"""






    a						=		FocalNetModelTester(self							)






def 	UpperCAmelCase__      (      UpperCAmelCase__ :Any					):






 '''simple docstring'''

 if not head:
  return True
 # split the list to two parts
 a		,  a						=		head.next, head
 while fast and fast.next:
  a						=		fast.next.next
  a						=		slow.next
 a						=		slow.next
 a						=		None  # Don't forget here! But forget still works!
 # reverse the second part
 a						=		None
 while second:
  a						=		second.next
  a						=		node
  a						=		second
  a						=		nxt
 # compare two parts
 # second part has the same or one less node
 while node:
  if node.val != head.val:
   return False
  a						=		node.next
  a						=		head.next
 return True


def 	UpperCAmelCase__      (      UpperCAmelCase__ :str					):






 '''simple docstring'''

 if not head or not head.next:
  return True

 # 1. Get the midpoint (slow)
 a						=		a						=		a						=		head
 while fast and fast.next:
  a		,  a						=		fast.next.next, slow.next

 # 2. Push the second half into the stack
 a						=		[slow.val]
 while slow.next:
  a						=		slow.next
  stack.append(slow.val					)

 # 3. Comparison
 while stack:
  if stack.pop() != cur.val:
   return False
  a						=		cur.next

 return True




def 	UpperCAmelCase__      (      UpperCAmelCase__ :Any					):






 '''simple docstring'''

 if not head or not head.next:
  return True
 a						=		{}
 a						=		0
 while head:
  if head.val in d:
   d[head.val].append(UpperCAmelCase__					)
  else:
   a						=		[pos]
  a						=		head.next
  pos += 1
 a						=		pos - 1
 a						=		0
 for v in d.values():
  if len(UpperCAmelCase__					) % 2 != 0:
   middle += 1
  else:
   a						=		0
   for i in range(0 ,					len(UpperCAmelCase__					)					):
    if v[i] + v[len(UpperCAmelCase__					) - 1 - step] != checksum:
     return False
    step += 1
  if middle > 1:
   return False
 return True

