





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      ):
				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 _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      ):
				UpperCAmelCase_								=			(FocalNetBackbone,) if is_torch_available() else ()
				UpperCAmelCase_								=			FocalNetConfig

				UpperCAmelCase_								=			False


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












import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin

@skip_mps
class  __A       (  a      ,   a      ,   unittest.TestCase      ):
				__A								=			IFInpaintingSuperResolutionPipeline
				__A								=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""}
				__A								=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""}      )
				__A								=			PipelineTesterMixin.required_optional_params - {"""latents"""}


				def _snake_case    (						self							):
								return self._get_superresolution_dummy_components()


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_=0							):
								if str(UpperCAmelCase_							).startswith("""mps"""							):
												lowerCamelCase			=torch.manual_seed(UpperCAmelCase_							)
								else:
												lowerCamelCase			=torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)

								lowerCamelCase			=floats_tensor((1, 3, 16, 16)				,	rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)
								lowerCamelCase			=floats_tensor((1, 3, 32, 32)				,	rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)
								lowerCamelCase			=floats_tensor((1, 3, 32, 32)				,	rng=random.Random(UpperCAmelCase_							)							).to(UpperCAmelCase_							)

								lowerCamelCase			={
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """image""": image,
								    """original_image""": original_image,
								    """mask_image""": mask_image,
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}

								return inputs


				@unittest.skipIf(
				    torch_device != """cuda""" or not is_xformers_available()				,	reason="""XFormers attention is only available with CUDA and `xformers` installed"""				,	)
				def _snake_case    (						self							):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3							)


				def _snake_case    (						self							):
								self._test_save_load_optional_components()


				@unittest.skipIf(torch_device != """cuda"""				,	reason="""float16 requires CUDA"""							)
				def _snake_case    (						self							):
								# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
								super().test_save_load_floataa(expected_max_diff=1E-1							)


				def _snake_case    (						self							):
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2							)


				def _snake_case    (						self							):
								self._test_save_load_local()


				def _snake_case    (						self							):
								self._test_inference_batch_single_identical(
								    expected_max_diff=1E-2				,	)





