'''simple docstring'''




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       ,    __lowerCAmelCase       ,    __lowerCAmelCase=13       ,    __lowerCAmelCase=32       ,    __lowerCAmelCase=2       ,    __lowerCAmelCase=3       ,    __lowerCAmelCase=16       ,    __lowerCAmelCase=[32, 64, 128]       ,    __lowerCAmelCase=[1, 2, 1]       ,    __lowerCAmelCase=[2, 2, 4]       ,    __lowerCAmelCase=2       ,    __lowerCAmelCase=2.0       ,    __lowerCAmelCase=True       ,    __lowerCAmelCase=0.0       ,    __lowerCAmelCase=0.0       ,    __lowerCAmelCase=0.1       ,    __lowerCAmelCase="gelu"       ,    __lowerCAmelCase=False       ,    __lowerCAmelCase=True       ,    __lowerCAmelCase=0.02       ,    __lowerCAmelCase=1E-5       ,    __lowerCAmelCase=True       ,    __lowerCAmelCase=None       ,    __lowerCAmelCase=True       ,    __lowerCAmelCase=10       ,    __lowerCAmelCase=8       ,    __lowerCAmelCase=["stage1", "stage2"]       ,    __lowerCAmelCase=[1, 2]       ,    ):




					"""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):




					"""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):




					"""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       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


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

					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       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  FocalNetBackbone(config=__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase   					=  model(__lowerCAmelCase)

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps)       ,    len(config.out_features))
					self.parent.assertListEqual(list(result.feature_maps[0].shape)       ,    [self.batch_size, self.image_size, 8, 8])

					# verify channels
					self.parent.assertEqual(len(model.channels)       ,    len(config.out_features))
					self.parent.assertListEqual(model.channels       ,    config.hidden_sizes[:-1])

					# verify backbone works with out_features=None
					lowerCAmelCase   					=  None
					lowerCAmelCase   					=  FocalNetBackbone(config=__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase   					=  model(__lowerCAmelCase)

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps)       ,    1)
					self.parent.assertListEqual(list(result.feature_maps[0].shape)       ,    [self.batch_size, self.image_size * 2, 4, 4])

					# verify channels
					self.parent.assertEqual(len(model.channels)       ,    1)
					self.parent.assertListEqual(model.channels       ,    [config.hidden_sizes[-1]])



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  FocalNetForMaskedImageModeling(config=__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase   					=  model(__lowerCAmelCase)
					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(__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()

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



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


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

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

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







			def 							a_       (   self):




					"""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__(					lowerCAmelCase__ ,						lowerCAmelCase__ ,						unittest.TestCase	):


			'''simple docstring'''






			UpperCAmelCase_			:     int      =       (
			    (
			        FocalNetModel,
			        FocalNetForImageClassification,
			        FocalNetForMaskedImageModeling,
			        FocalNetBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			UpperCAmelCase_			:     str      =       (
			    {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
			    if is_torch_available()
			    else {}
			)
			UpperCAmelCase_			:     str      =       False

			UpperCAmelCase_			:     List[str]      =       False
			UpperCAmelCase_			:     int      =       False
			UpperCAmelCase_			:     Dict      =       False
			UpperCAmelCase_			:     List[str]      =       False



			def 							a_       (   self):




					"""simple docstring"""


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



			def 							a_       (   self):




					"""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):




					"""simple docstring"""


					return



			def 							a_       (   self):




					"""simple docstring"""


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



			def 							a_       (   self):




					"""simple docstring"""


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



			def 							a_       (   self):




					"""simple docstring"""


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



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase)



			@unittest.skip(reason="""FocalNet does not use inputs_embeds""")
			def 							a_       (   self):




					"""simple docstring"""


					pass



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




					"""simple docstring"""


					pass



			def 							a_       (   self):




					"""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(__lowerCAmelCase)
							self.assertIsInstance(model.get_input_embeddings()       ,    (nn.Module))
							lowerCAmelCase   					=  model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(__lowerCAmelCase       ,    nn.Linear))



			def 							a_       (   self):




					"""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(__lowerCAmelCase)
							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]       ,    __lowerCAmelCase)



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase):




					"""simple docstring"""


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

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

					lowerCAmelCase   					=  outputs.hidden_states

					lowerCAmelCase   					=  getattr(
					    self.model_tester       ,    """expected_num_hidden_layers"""       ,    len(self.model_tester.depths) + 1)
					self.assertEqual(len(__lowerCAmelCase)       ,    __lowerCAmelCase)

					# FocalNet has a different seq_length
					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(__lowerCAmelCase)       ,    __lowerCAmelCase)

					lowerCAmelCase					,     lowerCAmelCase					,     lowerCAmelCase					,     lowerCAmelCase   					=  reshaped_hidden_states[0].shape
					lowerCAmelCase   					=  (
					    reshaped_hidden_states[0].view(__lowerCAmelCase       ,    __lowerCAmelCase       ,    height * width).permute(0       ,    2       ,    1)
					)
					self.assertListEqual(
					    list(reshaped_hidden_states.shape[-2:])       ,    [num_patches, self.model_tester.embed_dim]       ,    )



			def 							a_       (   self):




					"""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(__lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase)

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

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



			def 							a_       (   self):




					"""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(__lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    (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(__lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    (padded_height, padded_width))



			@slow
			def 							a_       (   self):




					"""simple docstring"""


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







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase					,     lowerCAmelCase   					=  self.model_tester.prepare_config_and_inputs_for_common()

					lowerCAmelCase   					=  _config_zero_init(__lowerCAmelCase)
					for model_class in self.all_model_classes:
							lowerCAmelCase   					=  model_class(config=__lowerCAmelCase)
							for name, param in model.named_parameters():
									if "embeddings" not in name and param.requires_grad:
											self.assertIn(
											    ((param.data.mean() * 1E9).round() / 1E9).item()       ,    [0.0, 1.0]       ,    msg=f"Parameter {name} of model {model_class} seems not properly initialized"       ,    )







@require_vision
@require_torch
class 				a__(					unittest.TestCase	):


			'''simple docstring'''






			@cached_property
			def 							a_       (   self):




					"""simple docstring"""


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







			@slow
			def 							a_       (   self):




					"""simple docstring"""


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

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

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

					# verify the logits
					lowerCAmelCase   					=  torch.Size((1, 1000))
					self.assertEqual(outputs.logits.shape       ,    __lowerCAmelCase)
					lowerCAmelCase   					=  torch.tensor([0.2166, -0.4368, 0.2191]).to(__lowerCAmelCase)
					self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,    __lowerCAmelCase       ,    atol=1E-4))
					self.assertTrue(outputs.logits.argmax(dim=-1).item()       ,    281)







@require_torch
class 				a__(					lowerCAmelCase__ ,						unittest.TestCase	):


			'''simple docstring'''






			UpperCAmelCase_			:     str      =       (FocalNetBackbone,) if is_torch_available() else ()
			UpperCAmelCase_			:     Union[str, Any]      =       FocalNetConfig

			UpperCAmelCase_			:     List[Any]      =       False



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  FocalNetModelTester(self)





'''simple docstring'''




import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class 				a__(					unittest.TestCase	):


			'''simple docstring'''






			@property
			def 							a_       (   self):




					"""simple docstring"""


					torch.manual_seed(0)
					lowerCAmelCase   					=  UNetaDModel(
					    block_out_channels=(32, 64)       ,    layers_per_block=2       ,    sample_size=32       ,    in_channels=3       ,    out_channels=3       ,    down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")       ,    up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")       ,    )
					return model







			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  self.dummy_uncond_unet
					lowerCAmelCase   					=  PNDMScheduler()

					lowerCAmelCase   					=  PNDMPipeline(unet=__lowerCAmelCase       ,    scheduler=__lowerCAmelCase)
					pndm.to(__lowerCAmelCase)
					pndm.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase   					=  torch.manual_seed(0)
					lowerCAmelCase   					=  pndm(generator=__lowerCAmelCase       ,    num_inference_steps=20       ,    output_type="""numpy""").images

					lowerCAmelCase   					=  torch.manual_seed(0)
					lowerCAmelCase   					=  pndm(generator=__lowerCAmelCase       ,    num_inference_steps=20       ,    output_type="""numpy"""       ,    return_dict=__lowerCAmelCase)[0]

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

					assert image.shape == (1, 32, 32, 3)
					lowerCAmelCase   					=  np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0])

					assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
					assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2







@slow
@require_torch
class 				a__(					unittest.TestCase	):


			'''simple docstring'''






			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  """google/ddpm-cifar10-32"""

					lowerCAmelCase   					=  UNetaDModel.from_pretrained(__lowerCAmelCase)
					lowerCAmelCase   					=  PNDMScheduler()

					lowerCAmelCase   					=  PNDMPipeline(unet=__lowerCAmelCase       ,    scheduler=__lowerCAmelCase)
					pndm.to(__lowerCAmelCase)
					pndm.set_progress_bar_config(disable=__lowerCAmelCase)
					lowerCAmelCase   					=  torch.manual_seed(0)
					lowerCAmelCase   					=  pndm(generator=__lowerCAmelCase       ,    output_type="""numpy""").images

					lowerCAmelCase   					=  image[0, -3:, -3:, -1]

					assert image.shape == (1, 32, 32, 3)
					lowerCAmelCase   					=  np.array([0.1564, 0.14645, 0.1406, 0.14715, 0.12425, 0.14045, 0.13115, 0.12175, 0.125])

					assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2




