




import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


lowerCamelCase       :	int									=     False







@skip_mps
class 						A(		UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase							,   unittest.TestCase     ):



 '''simple docstring'''


 UpperCamelCase		     =		StableDiffusionAttendAndExcitePipeline
 UpperCamelCase		     =		False
 UpperCamelCase		     =		TEXT_TO_IMAGE_PARAMS
 UpperCamelCase		     =		TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}     )
 UpperCamelCase		     =		TEXT_TO_IMAGE_IMAGE_PARAMS
 UpperCamelCase		     =		TEXT_TO_IMAGE_IMAGE_PARAMS

 @classmethod
 def        a__				(       cls      :						Dict						)     ->			Optional[int]:

       """simple docstring"""






       super().setUpClass()
       torch.use_deterministic_algorithms(A_						)

 @classmethod
 def        a__				(       cls      :						Union[str, Any]						)     ->			Any:

       """simple docstring"""






       super().tearDownClass()
       torch.use_deterministic_algorithms(A_						)

 def        a__				(       self      :						int						)     ->			Dict:

       """simple docstring"""






       torch.manual_seed(0						)
       lowerCamelCase_	  =					UNetaDConditionModel(
           block_out_channels=(32, 64)		,							layers_per_block=1		,							sample_size=32		,							in_channels=4		,							out_channels=4		,							down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')		,							up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')		,							cross_attention_dim=32		,							attention_head_dim=(2, 4)		,							use_linear_projection=A_		,							)
       lowerCamelCase_	  =					DDIMScheduler(
           beta_start=0.00085		,							beta_end=0.012		,							beta_schedule='scaled_linear'		,							clip_sample=A_		,							set_alpha_to_one=A_		,							)
       torch.manual_seed(0						)
       lowerCamelCase_	  =					AutoencoderKL(
           block_out_channels=[32, 64]		,							in_channels=3		,							out_channels=3		,							down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']		,							up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']		,							latent_channels=4		,							sample_size=128		,							)
       torch.manual_seed(0						)
       lowerCamelCase_	  =					CLIPTextConfig(
           bos_token_id=0		,							eos_token_id=2		,							hidden_size=32		,							intermediate_size=37		,							layer_norm_eps=1E-05		,							num_attention_heads=4		,							num_hidden_layers=5		,							pad_token_id=1		,							vocab_size=1000		,							hidden_act='gelu'		,							projection_dim=512		,							)
       lowerCamelCase_	  =					CLIPTextModel(A_						)
       lowerCamelCase_	  =					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

       lowerCamelCase_	  =					{
           'unet': unet,
           'scheduler': scheduler,
           'vae': vae,
           'text_encoder': text_encoder,
           'tokenizer': tokenizer,
           'safety_checker': None,
           'feature_extractor': None,
       }

       return components

 def        a__				(       self      :						str		,							A_      :						Any		,							A_      :						Any=0						)     ->			Tuple:

       """simple docstring"""






       if str(A_						).startswith('mps'						):
             lowerCamelCase_	  =					torch.manual_seed(A_						)
       else:
             lowerCamelCase_	  =					torch.Generator(device=A_						).manual_seed(A_						)
       lowerCamelCase_	  =					lowerCamelCase_	  =					{
           'prompt': 'a cat and a frog',
           'token_indices': [2, 5],
           'generator': generator,
           'num_inference_steps': 1,
           'guidance_scale': 6.0,
           'output_type': 'numpy',
           'max_iter_to_alter': 2,
           'thresholds': {0: 0.7},
       }
       return inputs

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

       """simple docstring"""






       lowerCamelCase_	  =					'cpu'

       lowerCamelCase_	  =					self.get_dummy_components()
       lowerCamelCase_	  =					self.pipeline_class(**A_						)
       pipe.to(A_						)
       pipe.set_progress_bar_config(disable=A_						)

       lowerCamelCase_	  =					self.get_dummy_inputs(A_						)
       lowerCamelCase_	  =					pipe(**A_						).images
       lowerCamelCase_	  =					image[0, -3:, -3:, -1]

       self.assertEqual(image.shape		,							(1, 64, 64, 3)						)
       lowerCamelCase_	  =					np.array(
           [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]						)
       lowerCamelCase_	  =					np.abs(image_slice.flatten() - expected_slice						).max()
       self.assertLessEqual(A_		,							1E-3						)

 def        a__				(       self      :						Dict						)     ->			Tuple:

       """simple docstring"""






       super().test_cpu_offload_forward_pass(expected_max_diff=5E-4						)

 def        a__				(       self      :						int						)     ->			int:

       """simple docstring"""






       self._test_inference_batch_consistent(batch_sizes=[1, 2]						)

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

       """simple docstring"""






       self._test_inference_batch_single_identical(batch_size=2		,							expected_max_diff=7E-4						)

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

       """simple docstring"""






       super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3						)

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

       """simple docstring"""






       super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4						)

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

       """simple docstring"""






       super().test_save_load_local(expected_max_difference=5E-4						)





 def        a__				(       self      :						Tuple						)     ->			int:

       """simple docstring"""






       super().test_save_load_optional_components(expected_max_difference=4E-4						)







@require_torch_gpu
@slow
class 						A(		unittest.TestCase     ):



 '''simple docstring'''


 @classmethod
 def        a__				(       cls      :						Tuple						)     ->			Tuple:

       """simple docstring"""






       super().setUpClass()
       torch.use_deterministic_algorithms(A_						)

 @classmethod
 def        a__				(       cls      :						int						)     ->			int:

       """simple docstring"""






       super().tearDownClass()
       torch.use_deterministic_algorithms(A_						)

 def        a__				(       self      :						Dict						)     ->			Dict:

       """simple docstring"""






       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()





 def        a__				(       self      :						str						)     ->			Dict:

       """simple docstring"""






       lowerCamelCase_	  =					torch.manual_seed(51						)

       lowerCamelCase_	  =					StableDiffusionAttendAndExcitePipeline.from_pretrained(
           'CompVis/stable-diffusion-v1-4'		,							safety_checker=A_		,							torch_dtype=torch.floataa						)
       pipe.to('cuda'						)

       lowerCamelCase_	  =					'a painting of an elephant with glasses'
       lowerCamelCase_	  =					[5, 7]

       lowerCamelCase_	  =					pipe(
           prompt=A_		,							token_indices=A_		,							guidance_scale=7.5		,							generator=A_		,							num_inference_steps=5		,							max_iter_to_alter=5		,							output_type='numpy'		,							).images[0]

       lowerCamelCase_	  =					load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'						)
       assert np.abs((expected_image - image).max()						) < 5E-1









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						)



