





'''simple docstring'''





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class       __A     (						__snake_case    ,					unittest.TestCase    ):
				__A      =				KandinskyImgaImgPipeline
				__A      =				["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""]
				__A      =				[
				    """prompt""",
				    """negative_prompt""",
				    """image_embeds""",
				    """negative_image_embeds""",
				    """image""",
				]
				__A      =				[
				    """generator""",
				    """height""",
				    """width""",
				    """strength""",
				    """guidance_scale""",
				    """negative_prompt""",
				    """num_inference_steps""",
				    """return_dict""",
				    """guidance_scale""",
				    """num_images_per_prompt""",
				    """output_type""",
				    """return_dict""",
				]
				__A      =				False


				@property
				def _snake_case       (		self							):
								return 32


				@property
				def _snake_case       (		self							):
								return 32


				@property
				def _snake_case       (		self							):
								return self.time_input_dim


				@property
				def _snake_case       (		self							):
								return self.time_input_dim * 4


				@property
				def _snake_case       (		self							):
								return 100


				@property
				def _snake_case       (		self							):
								lowerCamelCase	 =XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""							)
								return tokenizer


				@property
				def _snake_case       (		self							):
								torch.manual_seed(0							)
								lowerCamelCase	 =MCLIPConfig(
								    numDims=self.cross_attention_dim   , transformerDimensions=self.text_embedder_hidden_size   , hidden_size=self.text_embedder_hidden_size   , intermediate_size=37   , num_attention_heads=4   , num_hidden_layers=5   , vocab_size=1005   , )

								lowerCamelCase	 =MultilingualCLIP(_lowercase							)
								lowerCamelCase	 =text_encoder.eval()

								return text_encoder


				@property
				def _snake_case       (		self							):
								torch.manual_seed(0							)

								lowerCamelCase	 ={
								    """in_channels""": 4,
								    # Out channels is double in channels because predicts mean and variance
								    """out_channels""": 8,
								    """addition_embed_type""": """text_image""",
								    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
								    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
								    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
								    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
								    """layers_per_block""": 1,
								    """encoder_hid_dim""": self.text_embedder_hidden_size,
								    """encoder_hid_dim_type""": """text_image_proj""",
								    """cross_attention_dim""": self.cross_attention_dim,
								    """attention_head_dim""": 4,
								    """resnet_time_scale_shift""": """scale_shift""",
								    """class_embed_type""": None,
								}

								lowerCamelCase	 =UNetaDConditionModel(**_lowercase							)
								return model


				@property
				def _snake_case       (		self							):
								return {
								    "block_out_channels": [32, 64],
								    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
								    "in_channels": 3,
								    "latent_channels": 4,
								    "layers_per_block": 1,
								    "norm_num_groups": 8,
								    "norm_type": "spatial",
								    "num_vq_embeddings": 12,
								    "out_channels": 3,
								    "up_block_types": [
								        "AttnUpDecoderBlock2D",
								        "UpDecoderBlock2D",
								    ],
								    "vq_embed_dim": 4,
								}


				@property
				def _snake_case       (		self							):
								torch.manual_seed(0							)
								lowerCamelCase	 =VQModel(**self.dummy_movq_kwargs							)
								return model


				def _snake_case       (		self							):
								lowerCamelCase	 =self.dummy_text_encoder
								lowerCamelCase	 =self.dummy_tokenizer
								lowerCamelCase	 =self.dummy_unet
								lowerCamelCase	 =self.dummy_movq

								lowerCamelCase	 ={
								    """num_train_timesteps""": 1000,
								    """beta_schedule""": """linear""",
								    """beta_start""": 0.0_0_0_8_5,
								    """beta_end""": 0.0_1_2,
								    """clip_sample""": False,
								    """set_alpha_to_one""": False,
								    """steps_offset""": 0,
								    """prediction_type""": """epsilon""",
								    """thresholding""": False,
								}

								lowerCamelCase	 =DDIMScheduler(**_lowercase							)

								lowerCamelCase	 ={
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """movq""": movq,
								}

								return components


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_=0							):
								lowerCamelCase	 =floats_tensor((1, self.cross_attention_dim)   , rng=random.Random(_lowercase							)							).to(_lowercase							)
								lowerCamelCase	 =floats_tensor((1, self.cross_attention_dim)   , rng=random.Random(seed + 1							)							).to(_lowercase							)
								# create init_image
								lowerCamelCase	 =floats_tensor((1, 3, 64, 64)   , rng=random.Random(_lowercase							)							).to(_lowercase							)
								lowerCamelCase	 =image.cpu().permute(0   , 2   , 3   , 1							)[0]
								lowerCamelCase	 =Image.fromarray(np.uinta(_lowercase							)							).convert("""RGB"""							).resize((256, 256)							)

								if str(_lowercase							).startswith("""mps"""							):
												lowerCamelCase	 =torch.manual_seed(_lowercase							)
								else:
												lowerCamelCase	 =torch.Generator(device=_lowercase							).manual_seed(_lowercase							)
								lowerCamelCase	 ={
								    """prompt""": """horse""",
								    """image""": init_image,
								    """image_embeds""": image_embeds,
								    """negative_image_embeds""": negative_image_embeds,
								    """generator""": generator,
								    """height""": 64,
								    """width""": 64,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 7.0,
								    """strength""": 0.2,
								    """output_type""": """np""",
								}
								return inputs


				def _snake_case       (		self							):
								lowerCamelCase	 ="""cpu"""

								lowerCamelCase	 =self.get_dummy_components()

								lowerCamelCase	 =self.pipeline_class(**_lowercase							)
								lowerCamelCase	 =pipe.to(_lowercase							)

								pipe.set_progress_bar_config(disable=_lowercase							)

								lowerCamelCase	 =pipe(**self.get_dummy_inputs(_lowercase							)							)
								lowerCamelCase	 =output.images

								lowerCamelCase	 =pipe(
								    **self.get_dummy_inputs(_lowercase							)   , return_dict=_lowercase   , )[0]

								lowerCamelCase	 =image[0, -3:, -3:, -1]
								lowerCamelCase	 =image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)

								lowerCamelCase	 =np.array(
								    [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]							)
								assert (
								    np.abs(image_slice.flatten() - expected_slice							).max() < 1E-2
								), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
								assert (
								    np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 1E-2
								), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""




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


				def _snake_case       (		self							):
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()


				def _snake_case       (		self							):
								lowerCamelCase	 =load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/kandinsky/kandinsky_img2img_frog.npy"""							)

								lowerCamelCase	 =load_image(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png"""							)
								lowerCamelCase	 ="""A red cartoon frog, 4k"""

								lowerCamelCase	 =KandinskyPriorPipeline.from_pretrained(
								    """kandinsky-community/kandinsky-2-1-prior"""   , torch_dtype=torch.floataa							)
								pipe_prior.to(_lowercase							)

								lowerCamelCase	 =KandinskyImgaImgPipeline.from_pretrained(
								    """kandinsky-community/kandinsky-2-1"""   , torch_dtype=torch.floataa							)
								lowerCamelCase	 =pipeline.to(_lowercase							)

								pipeline.set_progress_bar_config(disable=_lowercase							)

								lowerCamelCase	 =torch.Generator(device="""cpu"""							).manual_seed(0							)
								lowerCamelCase	 =pipe_prior(
								    _lowercase   , generator=_lowercase   , num_inference_steps=5   , negative_prompt=""""""   , ).to_tuple()

								lowerCamelCase	 =pipeline(
								    _lowercase   , image=_lowercase   , image_embeds=_lowercase   , negative_image_embeds=_lowercase   , generator=_lowercase   , num_inference_steps=100   , height=768   , width=768   , strength=0.2   , output_type="""np"""   , )

								lowerCamelCase	 =output.images[0]

								assert image.shape == (768, 768, 3)

								assert_mean_pixel_difference(_lowercase   , _lowercase							)












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     :


				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]   , ):
								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 _snake_case       (		self							):
								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 _snake_case       (		self							):
								return FocalNetConfig(
								    image_size=self.image_size   , patch_size=self.patch_size   , num_channels=self.num_channels   , embed_dim=self.embed_dim   , hidden_sizes=self.hidden_sizes   , depths=self.depths   , num_heads=self.num_heads   , window_size=self.window_size   , mlp_ratio=self.mlp_ratio   , qkv_bias=self.qkv_bias   , hidden_dropout_prob=self.hidden_dropout_prob   , attention_probs_dropout_prob=self.attention_probs_dropout_prob   , drop_path_rate=self.drop_path_rate   , hidden_act=self.hidden_act   , use_absolute_embeddings=self.use_absolute_embeddings   , path_norm=self.patch_norm   , layer_norm_eps=self.layer_norm_eps   , initializer_range=self.initializer_range   , encoder_stride=self.encoder_stride   , out_features=self.out_features   , out_indices=self.out_indices   , )


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								lowerCamelCase	 =FocalNetModel(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase	 =model(UpperCAmelCase_							)

								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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								lowerCamelCase	 =FocalNetBackbone(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase	 =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
								lowerCamelCase	 =None
								lowerCamelCase	 =FocalNetBackbone(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase	 =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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								lowerCamelCase	 =FocalNetForMaskedImageModeling(config=UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase	 =model(UpperCAmelCase_							)
								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(UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()

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


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								lowerCamelCase	 =self.type_sequence_label_size
								lowerCamelCase	 =FocalNetForImageClassification(UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()
								lowerCamelCase	 =model(UpperCAmelCase_   , labels=UpperCAmelCase_							)
								self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.type_sequence_label_size)							)

								# test greyscale images
								lowerCamelCase	 =1
								lowerCamelCase	 =FocalNetForImageClassification(UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()

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


				def _snake_case       (		self							):
								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     (						a    ,					a    ,					unittest.TestCase    ):
				__A      =				(
				    (
				        FocalNetModel,
				        FocalNetForImageClassification,
				        FocalNetForMaskedImageModeling,
				        FocalNetBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				__A      =				(
				    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
				    if is_torch_available()
				    else {}
				)
				__A      =				False

				__A      =				False
				__A      =				False
				__A      =				False
				__A      =				False


				def _snake_case       (		self							):
								lowerCamelCase	 =FocalNetModelTester(self							)
								lowerCamelCase	 =ConfigTester(self   , config_class=UpperCAmelCase_   , embed_dim=37   , has_text_modality=UpperCAmelCase_							)


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


				def _snake_case       (		self							):
								return


				def _snake_case       (		self							):
								lowerCamelCase	 =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =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 _snake_case       (		self							):
								pass


				@unittest.skip(reason="""FocalNet does not use feedforward chunking"""							)
				def _snake_case       (		self							):
								pass


				def _snake_case       (		self							):
								lowerCamelCase ,  lowerCamelCase	 =self.model_tester.prepare_config_and_inputs_for_common()

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


				def _snake_case       (		self							):
								lowerCamelCase ,  lowerCamelCase	 =self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes[:-1]:
												lowerCamelCase	 =model_class(UpperCAmelCase_							)
												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]   , UpperCAmelCase_							)


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								lowerCamelCase	 =model_class(UpperCAmelCase_							)
								model.to(UpperCAmelCase_							)
								model.eval()

								with torch.no_grad():
												lowerCamelCase	 =model(**self._prepare_for_class(UpperCAmelCase_   , UpperCAmelCase_							)							)

								lowerCamelCase	 =outputs.hidden_states

								lowerCamelCase	 =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
								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(UpperCAmelCase_							)   , UpperCAmelCase_							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =reshaped_hidden_states[0].shape
								lowerCamelCase	 =(
								    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 _snake_case       (		self							):
								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(UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							)

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

												self.check_hidden_states_output(UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							)


				def _snake_case       (		self							):
								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(UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_   , (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(UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_   , (padded_height, padded_width)							)


				@slow
				def _snake_case       (		self							):
								for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCamelCase	 =FocalNetModel.from_pretrained(UpperCAmelCase_							)
												self.assertIsNotNone(UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase ,  lowerCamelCase	 =self.model_tester.prepare_config_and_inputs_for_common()

								lowerCamelCase	 =_config_zero_init(UpperCAmelCase_							)
								for model_class in self.all_model_classes:
												lowerCamelCase	 =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       __A     (						unittest.TestCase    ):


				@cached_property
				def _snake_case       (		self							):
								# TODO update organization
								return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""							) if is_vision_available() else None


				@slow
				def _snake_case       (		self							):
								lowerCamelCase	 =FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""							).to(UpperCAmelCase_							)
								lowerCamelCase	 =self.default_image_processor

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

								# forward pass
								with torch.no_grad():
												lowerCamelCase	 =model(**UpperCAmelCase_							)

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

				__A      =				False


				def _snake_case       (		self							):
								lowerCamelCase	 =FocalNetModelTester(self							)





