






'''simple docstring'''







import gc
import math
import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


_A     :      Dict   					=logging.get_logger(__name__)

enable_full_determinism()

class _lowercase     (    _lowercase    ,				_lowercase    ,				unittest.TestCase		):
							a    				=	UNetaDModel
							a    				=	"""sample"""




							@property
							def 		lowerCamelCase_    (							self:    Dict					):
														lowerCamelCase__ :     int	  =	4
														lowerCamelCase__ :     str	  =	3
														lowerCamelCase__ :     Optional[int]	  =	(32, 32)

														lowerCamelCase__ :     int	  =	floats_tensor((batch_size, num_channels) + sizes					).to(UpperCamelCase__					)
														lowerCamelCase__ :     Tuple	  =	torch.tensor([10]					).to(UpperCamelCase__					)

														return {"sample": noise, "timestep": time_step}




							@property
							def 		lowerCamelCase_    (							self:    int					):
														return (3, 32, 32)




							@property
							def 		lowerCamelCase_    (							self:    Optional[Any]					):
														return (3, 32, 32)




							def 		lowerCamelCase_    (							self:    int					):
														lowerCamelCase__ :     Optional[Any]	  =	{
														    """block_out_channels""": (32, 64),
														    """down_block_types""": ("""DownBlock2D""", """AttnDownBlock2D"""),
														    """up_block_types""": ("""AttnUpBlock2D""", """UpBlock2D"""),
														    """attention_head_dim""": 3,
														    """out_channels""": 3,
														    """in_channels""": 3,
														    """layers_per_block""": 2,
														    """sample_size""": 32,
														}
														lowerCamelCase__ :     Optional[Any]	  =	self.dummy_input
														return init_dict, inputs_dict



class _lowercase     (    _lowercase    ,				_lowercase    ,				unittest.TestCase		):
							a    				=	UNetaDModel
							a    				=	"""sample"""




							@property
							def 		lowerCamelCase_    (							self:    Any					):
														lowerCamelCase__ :     Tuple	  =	4
														lowerCamelCase__ :     int	  =	4
														lowerCamelCase__ :     Tuple	  =	(32, 32)

														lowerCamelCase__ :     Optional[int]	  =	floats_tensor((batch_size, num_channels) + sizes					).to(UpperCamelCase__					)
														lowerCamelCase__ :     Optional[Any]	  =	torch.tensor([10]					).to(UpperCamelCase__					)

														return {"sample": noise, "timestep": time_step}




							@property
							def 		lowerCamelCase_    (							self:    Any					):
														return (4, 32, 32)




							@property
							def 		lowerCamelCase_    (							self:    Optional[int]					):
														return (4, 32, 32)




							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     Tuple	  =	{
														    """sample_size""": 32,
														    """in_channels""": 4,
														    """out_channels""": 4,
														    """layers_per_block""": 2,
														    """block_out_channels""": (32, 64),
														    """attention_head_dim""": 32,
														    """down_block_types""": ("""DownBlock2D""", """DownBlock2D"""),
														    """up_block_types""": ("""UpBlock2D""", """UpBlock2D"""),
														}
														lowerCamelCase__ :     Optional[Any]	  =	self.dummy_input
														return init_dict, inputs_dict




							def 		lowerCamelCase_    (							self:    Optional[Any]					):
														lowerCamelCase__ :     Optional[Any]	  =	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      ,							output_loading_info=UpperCamelCase__					)

														self.assertIsNotNone(UpperCamelCase__					)
														self.assertEqual(len(loading_info["""missing_keys"""]					)      ,							0					)

														model.to(UpperCamelCase__					)
														lowerCamelCase__ :     Dict	  =	model(**self.dummy_input					).sample

														assert image is not None, "Make sure output is not None"




							@unittest.skipIf(torch_device != """cuda"""      ,							"""This test is supposed to run on GPU"""					)
							def 		lowerCamelCase_    (							self:    List[Any]					):
														lowerCamelCase__ :     Optional[Any]	  =	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      ,							output_loading_info=UpperCamelCase__					)
														model.to(UpperCamelCase__					)
														lowerCamelCase__ :     List[Any]	  =	model(**self.dummy_input					).sample

														assert image is not None, "Make sure output is not None"




							@unittest.skipIf(torch_device != """cuda"""      ,							"""This test is supposed to run on GPU"""					)
							def 		lowerCamelCase_    (							self:    str					):
														# by defautl model loading will use accelerate as `low_cpu_mem_usage=True`
														lowerCamelCase__ :     Optional[Any]	  =	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      ,							output_loading_info=UpperCamelCase__					)
														model_accelerate.to(UpperCamelCase__					)
														model_accelerate.eval()

														lowerCamelCase__ :     str	  =	torch.randn(
														    1      ,							model_accelerate.config.in_channels      ,							model_accelerate.config.sample_size      ,							model_accelerate.config.sample_size      ,							generator=torch.manual_seed(0					)      ,							)
														lowerCamelCase__ :     List[Any]	  =	noise.to(UpperCamelCase__					)
														lowerCamelCase__ :     int	  =	torch.tensor([10] * noise.shape[0]					).to(UpperCamelCase__					)

														lowerCamelCase__ :     List[str]	  =	model_accelerate(UpperCamelCase__      ,							UpperCamelCase__					)["""sample"""]

														# two models don't need to stay in the device at the same time
														del model_accelerate
														torch.cuda.empty_cache()
														gc.collect()

														lowerCamelCase__ :     Optional[Any]	  =	UNetaDModel.from_pretrained(
														    """fusing/unet-ldm-dummy-update"""      ,							output_loading_info=UpperCamelCase__      ,							low_cpu_mem_usage=UpperCamelCase__					)
														model_normal_load.to(UpperCamelCase__					)
														model_normal_load.eval()
														lowerCamelCase__ :     str	  =	model_normal_load(UpperCamelCase__      ,							UpperCamelCase__					)["""sample"""]

														assert torch_all_close(UpperCamelCase__      ,							UpperCamelCase__      ,							rtol=1e-3					)




							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     Union[str, Any]	  =	UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""					)
														model.eval()
														model.to(UpperCamelCase__					)

														lowerCamelCase__ :     Tuple	  =	torch.randn(
														    1      ,							model.config.in_channels      ,							model.config.sample_size      ,							model.config.sample_size      ,							generator=torch.manual_seed(0					)      ,							)
														lowerCamelCase__ :     List[str]	  =	noise.to(UpperCamelCase__					)
														lowerCamelCase__ :     List[Any]	  =	torch.tensor([10] * noise.shape[0]					).to(UpperCamelCase__					)

														with torch.no_grad():
																					lowerCamelCase__ :     str	  =	model(UpperCamelCase__      ,							UpperCamelCase__					).sample

														lowerCamelCase__ :     Dict	  =	output[0, -1, -3:, -3:].flatten().cpu()
														# fmt: off
														lowerCamelCase__ :     Optional[Any]	  =	torch.tensor([-13.3_258, -20.1_100, -15.9_873, -17.6_617, -23.0_596, -17.9_419, -13.3_675, -16.1_889, -12.3_800]					)
														# fmt: on

														self.assertTrue(torch_all_close(UpperCamelCase__      ,							UpperCamelCase__      ,							rtol=1e-3					)					)



class _lowercase     (    _lowercase    ,				_lowercase    ,				unittest.TestCase		):
							a    				=	UNetaDModel
							a    				=	"""sample"""




							@property
							def 		lowerCamelCase_    (							self:    List[str]      ,							UpperCamelCase__:    List[Any]=(32, 32)					):
														lowerCamelCase__ :     Any	  =	4
														lowerCamelCase__ :     List[str]	  =	3

														lowerCamelCase__ :     List[str]	  =	floats_tensor((batch_size, num_channels) + sizes					).to(UpperCamelCase__					)
														lowerCamelCase__ :     str	  =	torch.tensor(batch_size * [10]					).to(dtype=torch.intaa      ,							device=UpperCamelCase__					)

														return {"sample": noise, "timestep": time_step}




							@property
							def 		lowerCamelCase_    (							self:    int					):
														return (3, 32, 32)




							@property
							def 		lowerCamelCase_    (							self:    Optional[int]					):
														return (3, 32, 32)




							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     Optional[int]	  =	{
														    """block_out_channels""": [32, 64, 64, 64],
														    """in_channels""": 3,
														    """layers_per_block""": 1,
														    """out_channels""": 3,
														    """time_embedding_type""": """fourier""",
														    """norm_eps""": 1e-6,
														    """mid_block_scale_factor""": math.sqrt(2.0					),
														    """norm_num_groups""": None,
														    """down_block_types""": [
														        """SkipDownBlock2D""",
														        """AttnSkipDownBlock2D""",
														        """SkipDownBlock2D""",
														        """SkipDownBlock2D""",
														    ],
														    """up_block_types""": [
														        """SkipUpBlock2D""",
														        """SkipUpBlock2D""",
														        """AttnSkipUpBlock2D""",
														        """SkipUpBlock2D""",
														    ],
														}
														lowerCamelCase__ :     Union[str, Any]	  =	self.dummy_input
														return init_dict, inputs_dict




							@slow
							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     List[Any]	  =	UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""      ,							output_loading_info=UpperCamelCase__					)
														self.assertIsNotNone(UpperCamelCase__					)
														self.assertEqual(len(loading_info["""missing_keys"""]					)      ,							0					)

														model.to(UpperCamelCase__					)
														lowerCamelCase__ :     List[Any]	  =	self.dummy_input
														lowerCamelCase__ :     Union[str, Any]	  =	floats_tensor((4, 3) + (256, 256)					).to(UpperCamelCase__					)
														lowerCamelCase__ :     Union[str, Any]	  =	noise
														lowerCamelCase__ :     List[Any]	  =	model(**UpperCamelCase__					)

														assert image is not None, "Make sure output is not None"




							@slow
							def 		lowerCamelCase_    (							self:    Optional[Any]					):
														lowerCamelCase__ :     int	  =	UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""					)
														model.to(UpperCamelCase__					)

														lowerCamelCase__ :     Union[str, Any]	  =	4
														lowerCamelCase__ :     Any	  =	3
														lowerCamelCase__ :     Dict	  =	(256, 256)

														lowerCamelCase__ :     Optional[int]	  =	torch.ones((batch_size, num_channels) + sizes					).to(UpperCamelCase__					)
														lowerCamelCase__ :     Dict	  =	torch.tensor(batch_size * [1e-4]					).to(UpperCamelCase__					)

														with torch.no_grad():
																					lowerCamelCase__ :     Optional[int]	  =	model(UpperCamelCase__      ,							UpperCamelCase__					).sample

														lowerCamelCase__ :     Any	  =	output[0, -3:, -3:, -1].flatten().cpu()
														# fmt: off
														lowerCamelCase__ :     List[Any]	  =	torch.tensor([-4_842.8_691, -6_499.6_631, -3_800.1_953, -7_978.2_686, -10_980.7_129, -20_028.8_535, 8_148.2_822, 2_342.2_905, 567.7_608]					)
														# fmt: on

														self.assertTrue(torch_all_close(UpperCamelCase__      ,							UpperCamelCase__      ,							rtol=1e-2					)					)




							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     Dict	  =	UNetaDModel.from_pretrained("""fusing/ncsnpp-ffhq-ve-dummy-update"""					)
														model.to(UpperCamelCase__					)

														lowerCamelCase__ :     List[Any]	  =	4
														lowerCamelCase__ :     Optional[int]	  =	3
														lowerCamelCase__ :     List[str]	  =	(32, 32)

														lowerCamelCase__ :     int	  =	torch.ones((batch_size, num_channels) + sizes					).to(UpperCamelCase__					)
														lowerCamelCase__ :     Any	  =	torch.tensor(batch_size * [1e-4]					).to(UpperCamelCase__					)

														with torch.no_grad():
																					lowerCamelCase__ :     List[Any]	  =	model(UpperCamelCase__      ,							UpperCamelCase__					).sample

														lowerCamelCase__ :     Optional[int]	  =	output[0, -3:, -3:, -1].flatten().cpu()
														# fmt: off
														lowerCamelCase__ :     str	  =	torch.tensor([-0.0_325, -0.0_900, -0.0_869, -0.0_332, -0.0_725, -0.0_270, -0.0_101, 0.0_227, 0.0_256]					)
														# fmt: on

														self.assertTrue(torch_all_close(UpperCamelCase__      ,							UpperCamelCase__      ,							rtol=1e-2					)					)




							def 		lowerCamelCase_    (							self:    Any					):
														# not required for this model
														pass











'''simple docstring'''







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


_A     :      Union[str, Any]   					=logging.get_logger(__name__)

_A     :      List[Any]   					={
    '''SenseTime/deformable-detr''': '''https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json''',
    # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr
}

class _lowercase     (    _lowercase		):
							a    				=	"""deformable_detr"""
							a    				=	{
							    """hidden_size""": """d_model""",
							    """num_attention_heads""": """encoder_attention_heads""",
							}




							def __init__(							self:    Optional[int]      ,							UpperCamelCase__:    Tuple=True      ,							UpperCamelCase__:    Tuple=None      ,							UpperCamelCase__:    List[str]=3      ,							UpperCamelCase__:    Any=300      ,							UpperCamelCase__:    Optional[int]=1_024      ,							UpperCamelCase__:    int=6      ,							UpperCamelCase__:    str=1_024      ,							UpperCamelCase__:    Optional[Any]=8      ,							UpperCamelCase__:    Optional[Any]=6      ,							UpperCamelCase__:    Union[str, Any]=1_024      ,							UpperCamelCase__:    Tuple=8      ,							UpperCamelCase__:    str=0.0      ,							UpperCamelCase__:    Tuple=True      ,							UpperCamelCase__:    Any="relu"      ,							UpperCamelCase__:    Any=256      ,							UpperCamelCase__:    List[Any]=0.1      ,							UpperCamelCase__:    Optional[int]=0.0      ,							UpperCamelCase__:    Any=0.0      ,							UpperCamelCase__:    List[str]=0.02      ,							UpperCamelCase__:    str=1.0      ,							UpperCamelCase__:    Any=True      ,							UpperCamelCase__:    List[Any]=False      ,							UpperCamelCase__:    str="sine"      ,							UpperCamelCase__:    Optional[Any]="resnet50"      ,							UpperCamelCase__:    Optional[int]=True      ,							UpperCamelCase__:    Optional[int]=False      ,							UpperCamelCase__:    List[Any]=4      ,							UpperCamelCase__:    Any=4      ,							UpperCamelCase__:    int=4      ,							UpperCamelCase__:    int=False      ,							UpperCamelCase__:    Optional[Any]=300      ,							UpperCamelCase__:    str=False      ,							UpperCamelCase__:    int=1      ,							UpperCamelCase__:    Tuple=5      ,							UpperCamelCase__:    List[Any]=2      ,							UpperCamelCase__:    Optional[int]=1      ,							UpperCamelCase__:    int=1      ,							UpperCamelCase__:    Tuple=5      ,							UpperCamelCase__:    str=2      ,							UpperCamelCase__:    str=0.1      ,							UpperCamelCase__:    List[str]=0.25      ,							UpperCamelCase__:    Any=False      ,							**UpperCamelCase__:    Optional[Any]      ,							):
														if backbone_config is not None and use_timm_backbone:
																					raise ValueError("""You can't specify both `backbone_config` and `use_timm_backbone`."""					)

														if not use_timm_backbone:
																					if backbone_config is None:
																												logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""					)
																												lowerCamelCase__ :     Union[str, Any]	  =	CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""]					)
																					elif isinstance(UpperCamelCase__      ,							UpperCamelCase__					):
																												lowerCamelCase__ :     Tuple	  =	backbone_config.get("""model_type"""					)
																												lowerCamelCase__ :     Dict	  =	CONFIG_MAPPING[backbone_model_type]
																												lowerCamelCase__ :     Optional[Any]	  =	config_class.from_dict(UpperCamelCase__					)
														lowerCamelCase__ :     Tuple	  =	use_timm_backbone
														lowerCamelCase__ :     Tuple	  =	backbone_config
														lowerCamelCase__ :     Union[str, Any]	  =	num_channels
														lowerCamelCase__ :     str	  =	num_queries
														lowerCamelCase__ :     int	  =	max_position_embeddings
														lowerCamelCase__ :     str	  =	d_model
														lowerCamelCase__ :     Dict	  =	encoder_ffn_dim
														lowerCamelCase__ :     Union[str, Any]	  =	encoder_layers
														lowerCamelCase__ :     int	  =	encoder_attention_heads
														lowerCamelCase__ :     str	  =	decoder_ffn_dim
														lowerCamelCase__ :     Optional[Any]	  =	decoder_layers
														lowerCamelCase__ :     Optional[int]	  =	decoder_attention_heads
														lowerCamelCase__ :     int	  =	dropout
														lowerCamelCase__ :     Optional[Any]	  =	attention_dropout
														lowerCamelCase__ :     List[Any]	  =	activation_dropout
														lowerCamelCase__ :     List[Any]	  =	activation_function
														lowerCamelCase__ :     int	  =	init_std
														lowerCamelCase__ :     Dict	  =	init_xavier_std
														lowerCamelCase__ :     Tuple	  =	encoder_layerdrop
														lowerCamelCase__ :     str	  =	auxiliary_loss
														lowerCamelCase__ :     int	  =	position_embedding_type
														lowerCamelCase__ :     Tuple	  =	backbone
														lowerCamelCase__ :     Tuple	  =	use_pretrained_backbone
														lowerCamelCase__ :     Optional[int]	  =	dilation
														# deformable attributes
														lowerCamelCase__ :     Optional[int]	  =	num_feature_levels
														lowerCamelCase__ :     Tuple	  =	encoder_n_points
														lowerCamelCase__ :     Tuple	  =	decoder_n_points
														lowerCamelCase__ :     Dict	  =	two_stage
														lowerCamelCase__ :     int	  =	two_stage_num_proposals
														lowerCamelCase__ :     Any	  =	with_box_refine
														if two_stage is True and with_box_refine is False:
																					raise ValueError("""If two_stage is True, with_box_refine must be True."""					)
														# Hungarian matcher
														lowerCamelCase__ :     Optional[int]	  =	class_cost
														lowerCamelCase__ :     List[str]	  =	bbox_cost
														lowerCamelCase__ :     Any	  =	giou_cost
														# Loss coefficients
														lowerCamelCase__ :     Union[str, Any]	  =	mask_loss_coefficient
														lowerCamelCase__ :     Tuple	  =	dice_loss_coefficient
														lowerCamelCase__ :     int	  =	bbox_loss_coefficient
														lowerCamelCase__ :     Optional[Any]	  =	giou_loss_coefficient
														lowerCamelCase__ :     Dict	  =	eos_coefficient
														lowerCamelCase__ :     Any	  =	focal_alpha
														lowerCamelCase__ :     Optional[Any]	  =	disable_custom_kernels
														super().__init__(is_encoder_decoder=UpperCamelCase__      ,							**UpperCamelCase__					)




							@property
							def 		lowerCamelCase_    (							self:    Dict					):
														return self.encoder_attention_heads




							@property
							def 		lowerCamelCase_    (							self:    Any					):
														return self.d_model




							def 		lowerCamelCase_    (							self:    List[str]					):
														lowerCamelCase__ :     Optional[int]	  =	copy.deepcopy(self.__dict__					)
														if self.backbone_config is not None:
																					lowerCamelCase__ :     int	  =	self.backbone_config.to_dict()
														lowerCamelCase__ :     int	  =	self.__class__.model_type
														return output

