




from copy import deepcopy
from typing import Optional, Union

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_tf_available, is_torch_available


if is_torch_available():
 import torch

if is_tf_available():
 import tensorflow as tf







class 						A(		__lowercase     ):



 '''simple docstring'''


 UpperCamelCase		     =		['''image_processor''']
 UpperCamelCase		     =		'''SamImageProcessor'''

 def __init__(       self      :						List[str]		,							A_      :						int						)     ->			Any:

       """simple docstring"""






       super().__init__(_A						)
       lowerCamelCase_	  =					self.image_processor
       lowerCamelCase_	  =					-10
       lowerCamelCase_	  =					self.image_processor.size['longest_edge']

 def __call__(       self      :						Optional[Any]		,							A_      :						Tuple=None		,							A_      :						List[Any]=None		,							A_      :						Dict=None		,							A_      :						Any=None		,							A_      :						Optional[Union[str, TensorType]] = None		,							**A_      :						List[str]		,							)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					self.image_processor(
           _A		,							return_tensors=_A		,							**_A		,							)

       # pop arguments that are not used in the foward but used nevertheless
       lowerCamelCase_	  =					encoding_image_processor['original_sizes']

       if hasattr(_A		,							'numpy'						):  # Checks if Torch or TF tensor
             lowerCamelCase_	  =					original_sizes.numpy()

       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					self._check_and_preprocess_points(
           input_points=_A		,							input_labels=_A		,							input_boxes=_A		,							)

       lowerCamelCase_	  =					self._normalize_and_convert(
           _A		,							_A		,							input_points=_A		,							input_labels=_A		,							input_boxes=_A		,							return_tensors=_A		,							)

       return encoding_image_processor

 def        a__				(       self      :						str		,							A_      :						List[Any]		,							A_      :						Optional[int]		,							A_      :						Union[str, Any]=None		,							A_      :						Optional[int]=None		,							A_      :						Optional[Any]=None		,							A_      :						Dict="pt"		,							)     ->			Optional[Any]:

       """simple docstring"""






       if input_points is not None:
             if len(_A						) != len(_A						):
                   lowerCamelCase_	  =					[
                       self._normalize_coordinates(self.target_size		,							_A		,							original_sizes[0]						) for point in input_points
                   ]
             else:
                   lowerCamelCase_	  =					[
                       self._normalize_coordinates(self.target_size		,							_A		,							_A						)
                       for point, original_size in zip(_A		,							_A						)
                   ]
             # check that all arrays have the same shape
             if not all(point.shape == input_points[0].shape for point in input_points						):
                   if input_labels is not None:
                         lowerCamelCase_  ,       lowerCamelCase_	  =					self._pad_points_and_labels(_A		,							_A						)

             lowerCamelCase_	  =					np.array(_A						)

       if input_labels is not None:
             lowerCamelCase_	  =					np.array(_A						)

       if input_boxes is not None:
             if len(_A						) != len(_A						):
                   lowerCamelCase_	  =					[
                       self._normalize_coordinates(self.target_size		,							_A		,							original_sizes[0]		,							is_bounding_box=_A						)
                       for box in input_boxes
                   ]
             else:
                   lowerCamelCase_	  =					[
                       self._normalize_coordinates(self.target_size		,							_A		,							_A		,							is_bounding_box=_A						)
                       for box, original_size in zip(_A		,							_A						)
                   ]
             lowerCamelCase_	  =					np.array(_A						)

       if input_boxes is not None:
             if return_tensors == "pt":
                   lowerCamelCase_	  =					torch.from_numpy(_A						)
                   # boxes batch size of 1 by default
                   lowerCamelCase_	  =					input_boxes.unsqueeze(1						) if len(input_boxes.shape						) != 3 else input_boxes
             elif return_tensors == "tf":
                   lowerCamelCase_	  =					tf.convert_to_tensor(_A						)
                   # boxes batch size of 1 by default
                   lowerCamelCase_	  =					tf.expand_dims(_A		,							1						) if len(input_boxes.shape						) != 3 else input_boxes
             encoding_image_processor.update({'input_boxes': input_boxes}						)
       if input_points is not None:
             if return_tensors == "pt":
                   lowerCamelCase_	  =					torch.from_numpy(_A						)
                   # point batch size of 1 by default
                   lowerCamelCase_	  =					input_points.unsqueeze(1						) if len(input_points.shape						) != 4 else input_points
             elif return_tensors == "tf":
                   lowerCamelCase_	  =					tf.convert_to_tensor(_A						)
                   # point batch size of 1 by default
                   lowerCamelCase_	  =					tf.expand_dims(_A		,							1						) if len(input_points.shape						) != 4 else input_points
             encoding_image_processor.update({'input_points': input_points}						)
       if input_labels is not None:
             if return_tensors == "pt":
                   lowerCamelCase_	  =					torch.from_numpy(_A						)
                   # point batch size of 1 by default
                   lowerCamelCase_	  =					input_labels.unsqueeze(1						) if len(input_labels.shape						) != 3 else input_labels
             elif return_tensors == "tf":
                   lowerCamelCase_	  =					tf.convert_to_tensor(_A						)
                   # point batch size of 1 by default
                   lowerCamelCase_	  =					tf.expand_dims(_A		,							1						) if len(input_labels.shape						) != 3 else input_labels
             encoding_image_processor.update({'input_labels': input_labels}						)

       return encoding_image_processor

 def        a__				(       self      :						Any		,							A_      :						str		,							A_      :						Dict						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					max([point.shape[0] for point in input_points]						)
       lowerCamelCase_	  =					[]
       for i, point in enumerate(_A						):
             if point.shape[0] != expected_nb_points:
                   lowerCamelCase_	  =					np.concatenate(
                       [point, np.zeros((expected_nb_points - point.shape[0], 2)						) + self.point_pad_value]		,							axis=0						)
                   lowerCamelCase_	  =					np.append(input_labels[i]		,							[self.point_pad_value]						)
             processed_input_points.append(_A						)
       lowerCamelCase_	  =					processed_input_points
       return input_points, input_labels

 def        a__				(       self      :						List[Any]		,							A_      :						int		,							A_      :						np.ndarray		,							A_      :						Any		,							A_      :						Dict=False						)     ->			Optional[int]:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					original_size
       lowerCamelCase_  ,       lowerCamelCase_	  =					self.image_processor._get_preprocess_shape(_A		,							longest_edge=_A						)
       lowerCamelCase_	  =					deepcopy(_A						).astype(_A						)

       if is_bounding_box:
             lowerCamelCase_	  =					coords.reshape(-1		,							2		,							2						)

       lowerCamelCase_	  =					coords[..., 0] * (new_w / old_w)
       lowerCamelCase_	  =					coords[..., 1] * (new_h / old_h)

       if is_bounding_box:
             lowerCamelCase_	  =					coords.reshape(-1		,							4						)

       return coords

 def        a__				(       self      :						Any		,							A_      :						Optional[int]=None		,							A_      :						List[str]=None		,							A_      :						Optional[int]=None		,							)     ->			Union[str, Any]:

       """simple docstring"""






       if input_points is not None:
             if hasattr(_A		,							'numpy'						):  # Checks for TF or Torch tensor
                   lowerCamelCase_	  =					input_points.numpy().tolist()

             if not isinstance(_A		,							_A						) or not isinstance(input_points[0]		,							_A						):
                   raise ValueError('Input points must be a list of list of floating points.'						)
             lowerCamelCase_	  =					[np.array(_A						) for input_point in input_points]
       else:
             lowerCamelCase_	  =					None

       if input_labels is not None:
             if hasattr(_A		,							'numpy'						):
                   lowerCamelCase_	  =					input_labels.numpy().tolist()

             if not isinstance(_A		,							_A						) or not isinstance(input_labels[0]		,							_A						):
                   raise ValueError('Input labels must be a list of list integers.'						)
             lowerCamelCase_	  =					[np.array(_A						) for label in input_labels]
       else:
             lowerCamelCase_	  =					None

       if input_boxes is not None:
             if hasattr(_A		,							'numpy'						):
                   lowerCamelCase_	  =					input_boxes.numpy().tolist()

             if (
                 not isinstance(_A		,							_A						)
                 or not isinstance(input_boxes[0]		,							_A						)
                 or not isinstance(input_boxes[0][0]		,							_A						)
             ):
                   raise ValueError('Input boxes must be a list of list of list of floating points.'						)
             lowerCamelCase_	  =					[np.array(_A						).astype(np.floataa						) for box in input_boxes]
       else:
             lowerCamelCase_	  =					None

       return input_points, input_labels, input_boxes

 @property
 def        a__				(       self      :						List[str]						)     ->			str:

       """simple docstring"""






       lowerCamelCase_	  =					self.image_processor.model_input_names
       return list(dict.fromkeys(_A						)						)





 def        a__				(       self      :						List[Any]		,							*A_      :						Union[str, Any]		,							**A_      :						Optional[Any]						)     ->			int:

       """simple docstring"""






       return self.image_processor.post_process_masks(*_A		,							**_A						)









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

       """simple docstring"""






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

 def        a__				(       self      :						List[str]						)     ->			List[Any]:

       """simple docstring"""






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

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

       lowerCamelCase_	  =					self.get_config()

       return config, pixel_values, labels

 def        a__				(       self      :						List[Any]						)     ->			Any:

       """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]		,							A_      :						Dict		,							A_      :						int		,							A_      :						Optional[int]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetModel(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					model(A_						)

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

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetBackbone(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					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
       lowerCamelCase_	  =					None
       lowerCamelCase_	  =					FocalNetBackbone(config=A_						)
       model.to(A_						)
       model.eval()
       lowerCamelCase_	  =					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        a__				(       self      :						int		,							A_      :						Optional[Any]		,							A_      :						Optional[int]		,							A_      :						Any						)     ->			Any:

       """simple docstring"""






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

       # test greyscale images
       lowerCamelCase_	  =					1
       lowerCamelCase_	  =					FocalNetForMaskedImageModeling(A_						)
       model.to(A_						)
       model.eval()

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

 def        a__				(       self      :						Tuple		,							A_      :						List[Any]		,							A_      :						int		,							A_      :						Dict						)     ->			Union[str, Any]:

       """simple docstring"""






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

       # test greyscale images
       lowerCamelCase_	  =					1
       lowerCamelCase_	  =					FocalNetForImageClassification(A_						)
       model.to(A_						)
       model.eval()

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





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

       """simple docstring"""






       lowerCamelCase_	  =					self.prepare_config_and_inputs()

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







@require_torch
class 						A(		UpperCamelCase							,   UpperCamelCase							,   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        a__				(       self      :						List[Any]						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetModelTester(self						)
       lowerCamelCase_	  =					ConfigTester(self		,							config_class=A_		,							embed_dim=37		,							has_text_modality=A_						)

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

       """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      :						Any						)     ->			Optional[int]:

       """simple docstring"""






       return

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

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_						)

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

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*A_						)

 def        a__				(       self      :						Dict						)     ->			int:

       """simple docstring"""






       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*A_						)

 def        a__				(       self      :						List[str]						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					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        a__				(       self      :						int						)     ->			int:

       """simple docstring"""






       pass

 @unittest.skip(reason='FocalNet does not use feedforward chunking'						)
 def        a__				(       self      :						Tuple						)     ->			List[str]:

       """simple docstring"""






       pass

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

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

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

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

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

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

             lowerCamelCase_	  =					['pixel_values']
             self.assertListEqual(arg_names[:1]		,							A_						)

 def        a__				(       self      :						int		,							A_      :						List[Any]		,							A_      :						int		,							A_      :						Dict		,							A_      :						Dict						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_	  =					model_class(A_						)
       model.to(A_						)
       model.eval()

       with torch.no_grad():
             lowerCamelCase_	  =					model(**self._prepare_for_class(A_		,							A_						)						)

       lowerCamelCase_	  =					outputs.hidden_states

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

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

       lowerCamelCase_	  =					outputs.reshaped_hidden_states
       self.assertEqual(len(A_						)		,							A_						)

       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_  ,       lowerCamelCase_	  =					reshaped_hidden_states[0].shape
       lowerCamelCase_	  =					(
           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        a__				(       self      :						Optional[int]						)     ->			List[Any]:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

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

             self.check_hidden_states_output(A_		,							A_		,							A_		,							A_						)

 def        a__				(       self      :						List[str]						)     ->			Dict:

       """simple docstring"""






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

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

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

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

 @slow
 def        a__				(       self      :						str						)     ->			Optional[Any]:

       """simple docstring"""






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





 def        a__				(       self      :						List[Any]						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_  ,       lowerCamelCase_	  =					self.model_tester.prepare_config_and_inputs_for_common()

       lowerCamelCase_	  =					_config_zero_init(A_						)
       for model_class in self.all_model_classes:
             lowerCamelCase_	  =					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 						A(		unittest.TestCase     ):



 '''simple docstring'''


 @cached_property
 def        a__				(       self      :						List[str]						)     ->			Optional[int]:

       """simple docstring"""






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





 @slow
 def        a__				(       self      :						Tuple						)     ->			Any:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'						).to(A_						)
       lowerCamelCase_	  =					self.default_image_processor

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

       # forward pass
       with torch.no_grad():
             lowerCamelCase_	  =					model(**A_						)

       # verify the logits
       lowerCamelCase_	  =					torch.Size((1, 1000)						)
       self.assertEqual(outputs.logits.shape		,							A_						)
       lowerCamelCase_	  =					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 						A(		UpperCamelCase							,   unittest.TestCase     ):



 '''simple docstring'''


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

 UpperCamelCase		     =		False

 def        a__				(       self      :						List[str]						)     ->			Tuple:

       """simple docstring"""






       lowerCamelCase_	  =					FocalNetModelTester(self						)



