
from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)







@flax.struct.dataclass
class        lowerCAmelCase__      (   __lowercase	):
						UpperCamelCase_							: jnp.ndarray







@flax_register_to_config
class        lowerCAmelCase__      (   nn.Module		,	__lowercase		,	__lowercase	):
						UpperCamelCase_							: int	=		32
						UpperCamelCase_							: int	=		4
						UpperCamelCase_							: int	=		4
						UpperCamelCase_							: Tuple[str]	=		(
						    "CrossAttnDownBlock2D",
						    "CrossAttnDownBlock2D",
						    "CrossAttnDownBlock2D",
						    "DownBlock2D",
						)
						UpperCamelCase_							: Tuple[str]	=		("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
						UpperCamelCase_							: Union[bool, Tuple[bool]]	=		False
						UpperCamelCase_							: Tuple[int]	=		(320, 640, 1280, 1280)
						UpperCamelCase_							: int	=		2
						UpperCamelCase_							: Union[int, Tuple[int]]	=		8
						UpperCamelCase_							: Optional[Union[int, Tuple[int]]]	=		None
						UpperCamelCase_							: int	=		1280
						UpperCamelCase_							: float	=		0.0
						UpperCamelCase_							: bool	=		False
						UpperCamelCase_							: jnp.dtype	=		jnp.floataa
						UpperCamelCase_							: bool	=		True
						UpperCamelCase_							: int	=		0
						UpperCamelCase_							: bool	=		False

						def  A_				(			self       ,							a				)					->      FrozenDict:


								'''simple docstring'''

								_UpperCamelCase						    =	(1, self.in_channels, self.sample_size, self.sample_size)
								_UpperCamelCase						    =	jnp.zeros(a       ,							dtype=jnp.floataa				)
								_UpperCamelCase						    =	jnp.ones((1,)       ,							dtype=jnp.intaa				)
								_UpperCamelCase						    =	jnp.zeros((1, 1, self.cross_attention_dim)       ,							dtype=jnp.floataa				)

								_UpperCamelCase    ,	_UpperCamelCase						    =	jax.random.split(a				)
								_UpperCamelCase						    =	{"""params""": params_rng, """dropout""": dropout_rng}

								return self.init(a       ,							a       ,							a       ,							a				)["params"]

						def  A_				(			self				)					->      Dict:


								'''simple docstring'''

								_UpperCamelCase						    =	self.block_out_channels
								_UpperCamelCase						    =	block_out_channels[0] * 4

								if self.num_attention_heads is not None:
										raise ValueError(
										    """At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19."""				)

								# If `num_attention_heads` is not defined (which is the case for most models)
								# it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
								# The reason for this behavior is to correct for incorrectly named variables that were introduced
								# when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
								# Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
								# which is why we correct for the naming here.
								_UpperCamelCase						    =	self.num_attention_heads or self.attention_head_dim

								# input
								_UpperCamelCase						    =	nn.Conv(
								    block_out_channels[0]       ,							kernel_size=(3, 3)       ,							strides=(1, 1)       ,							padding=((1, 1), (1, 1))       ,							dtype=self.dtype       ,							)

								# time
								_UpperCamelCase						    =	FlaxTimesteps(
								    block_out_channels[0]       ,							flip_sin_to_cos=self.flip_sin_to_cos       ,							freq_shift=self.config.freq_shift				)
								_UpperCamelCase						    =	FlaxTimestepEmbedding(a       ,							dtype=self.dtype				)

								_UpperCamelCase						    =	self.only_cross_attention
								if isinstance(a       ,							a				):
										_UpperCamelCase						    =	(only_cross_attention,) * len(self.down_block_types				)

								if isinstance(a       ,							a				):
										_UpperCamelCase						    =	(num_attention_heads,) * len(self.down_block_types				)

								# down
								_UpperCamelCase						    =	[]
								_UpperCamelCase						    =	block_out_channels[0]
								for i, down_block_type in enumerate(self.down_block_types				):
										_UpperCamelCase						    =	output_channel
										_UpperCamelCase						    =	block_out_channels[i]
										_UpperCamelCase						    =	i == len(a				) - 1

										if down_block_type == "CrossAttnDownBlock2D":
												_UpperCamelCase						    =	FlaxCrossAttnDownBlockaD(
												    in_channels=a       ,							out_channels=a       ,							dropout=self.dropout       ,							num_layers=self.layers_per_block       ,							num_attention_heads=num_attention_heads[i]       ,							add_downsample=not is_final_block       ,							use_linear_projection=self.use_linear_projection       ,							only_cross_attention=only_cross_attention[i]       ,							use_memory_efficient_attention=self.use_memory_efficient_attention       ,							dtype=self.dtype       ,							)
										else:
												_UpperCamelCase						    =	FlaxDownBlockaD(
												    in_channels=a       ,							out_channels=a       ,							dropout=self.dropout       ,							num_layers=self.layers_per_block       ,							add_downsample=not is_final_block       ,							dtype=self.dtype       ,							)

										down_blocks.append(a				)
								_UpperCamelCase						    =	down_blocks

								# mid
								_UpperCamelCase						    =	FlaxUNetMidBlockaDCrossAttn(
								    in_channels=block_out_channels[-1]       ,							dropout=self.dropout       ,							num_attention_heads=num_attention_heads[-1]       ,							use_linear_projection=self.use_linear_projection       ,							use_memory_efficient_attention=self.use_memory_efficient_attention       ,							dtype=self.dtype       ,							)

								# up
								_UpperCamelCase						    =	[]
								_UpperCamelCase						    =	list(reversed(a				)				)
								_UpperCamelCase						    =	list(reversed(a				)				)
								_UpperCamelCase						    =	list(reversed(a				)				)
								_UpperCamelCase						    =	reversed_block_out_channels[0]
								for i, up_block_type in enumerate(self.up_block_types				):
										_UpperCamelCase						    =	output_channel
										_UpperCamelCase						    =	reversed_block_out_channels[i]
										_UpperCamelCase						    =	reversed_block_out_channels[min(i + 1       ,							len(a				) - 1				)]

										_UpperCamelCase						    =	i == len(a				) - 1

										if up_block_type == "CrossAttnUpBlock2D":
												_UpperCamelCase						    =	FlaxCrossAttnUpBlockaD(
												    in_channels=a       ,							out_channels=a       ,							prev_output_channel=a       ,							num_layers=self.layers_per_block + 1       ,							num_attention_heads=reversed_num_attention_heads[i]       ,							add_upsample=not is_final_block       ,							dropout=self.dropout       ,							use_linear_projection=self.use_linear_projection       ,							only_cross_attention=only_cross_attention[i]       ,							use_memory_efficient_attention=self.use_memory_efficient_attention       ,							dtype=self.dtype       ,							)
										else:
												_UpperCamelCase						    =	FlaxUpBlockaD(
												    in_channels=a       ,							out_channels=a       ,							prev_output_channel=a       ,							num_layers=self.layers_per_block + 1       ,							add_upsample=not is_final_block       ,							dropout=self.dropout       ,							dtype=self.dtype       ,							)

										up_blocks.append(a				)
										_UpperCamelCase						    =	output_channel
								_UpperCamelCase						    =	up_blocks

								# out
								_UpperCamelCase						    =	nn.GroupNorm(num_groups=32       ,							epsilon=1e-5				)
								_UpperCamelCase						    =	nn.Conv(
								    self.out_channels       ,							kernel_size=(3, 3)       ,							strides=(1, 1)       ,							padding=((1, 1), (1, 1))       ,							dtype=self.dtype       ,							)







						def __call__(			self       ,							a       ,							a       ,							a       ,							a=None       ,							a=None       ,							a = True       ,							a = False       ,							)					->      Union[FlaxUNetaDConditionOutput, Tuple]:


								'''simple docstring'''

								if not isinstance(a       ,							jnp.ndarray				):
										_UpperCamelCase						    =	jnp.array([timesteps]       ,							dtype=jnp.intaa				)
								elif isinstance(a       ,							jnp.ndarray				) and len(timesteps.shape				) == 0:
										_UpperCamelCase						    =	timesteps.astype(dtype=jnp.floataa				)
										_UpperCamelCase						    =	jnp.expand_dims(a       ,							0				)

								_UpperCamelCase						    =	self.time_proj(a				)
								_UpperCamelCase						    =	self.time_embedding(a				)

								# 2. pre-process
								_UpperCamelCase						    =	jnp.transpose(a       ,							(0, 2, 3, 1)				)
								_UpperCamelCase						    =	self.conv_in(a				)

								# 3. down
								_UpperCamelCase						    =	(sample,)
								for down_block in self.down_blocks:
										if isinstance(a       ,							a				):
												_UpperCamelCase    ,	_UpperCamelCase						    =	down_block(a       ,							a       ,							a       ,							deterministic=not train				)
										else:
												_UpperCamelCase    ,	_UpperCamelCase						    =	down_block(a       ,							a       ,							deterministic=not train				)
										down_block_res_samples += res_samples

								if down_block_additional_residuals is not None:
										_UpperCamelCase						    =	()

										for down_block_res_sample, down_block_additional_residual in zip(
										    a       ,							a				):
												down_block_res_sample += down_block_additional_residual
												new_down_block_res_samples += (down_block_res_sample,)

										_UpperCamelCase						    =	new_down_block_res_samples

								# 4. mid
								_UpperCamelCase						    =	self.mid_block(a       ,							a       ,							a       ,							deterministic=not train				)

								if mid_block_additional_residual is not None:
										sample += mid_block_additional_residual

								# 5. up
								for up_block in self.up_blocks:
										_UpperCamelCase						    =	down_block_res_samples[-(self.layers_per_block + 1) :]
										_UpperCamelCase						    =	down_block_res_samples[: -(self.layers_per_block + 1)]
										if isinstance(a       ,							a				):
												_UpperCamelCase						    =	up_block(
												    a       ,							temb=a       ,							encoder_hidden_states=a       ,							res_hidden_states_tuple=a       ,							deterministic=not train       ,							)
										else:
												_UpperCamelCase						    =	up_block(a       ,							temb=a       ,							res_hidden_states_tuple=a       ,							deterministic=not train				)

        # 6. post-process
								_UpperCamelCase						    =	self.conv_norm_out(a				)
								_UpperCamelCase						    =	nn.silu(a				)
								_UpperCamelCase						    =	self.conv_out(a				)
								_UpperCamelCase						    =	jnp.transpose(a       ,							(0, 3, 1, 2)				)

								if not return_dict:
										return (sample,)

								return FlaxUNetaDConditionOutput(sample=a				)





import copy

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


lowerCamelCase__	=							logging.get_logger(__name__)

lowerCamelCase__	=							{
    "ut/deta": "https://huggingface.co/ut/deta/resolve/main/config.json",
}







class        lowerCAmelCase__      (   __lowercase	):
						UpperCamelCase_							: int	=		"deta"
						UpperCamelCase_							: Union[str, Any]	=		{
						    "hidden_size": "d_model",
						    "num_attention_heads": "encoder_attention_heads",
						}

						def __init__(			self       ,							a=None       ,							a=9_00       ,							a=20_48       ,							a=6       ,							a=20_48       ,							a=8       ,							a=6       ,							a=10_24       ,							a=8       ,							a=0.0       ,							a=True       ,							a="relu"       ,							a=2_56       ,							a=0.1       ,							a=0.0       ,							a=0.0       ,							a=0.02       ,							a=1.0       ,							a=True       ,							a=False       ,							a="sine"       ,							a=5       ,							a=4       ,							a=4       ,							a=True       ,							a=3_00       ,							a=True       ,							a=True       ,							a=1       ,							a=5       ,							a=2       ,							a=1       ,							a=1       ,							a=5       ,							a=2       ,							a=0.1       ,							a=0.25       ,							**a       ,							)					->      Dict:


								'''simple docstring'''

								if backbone_config is None:
										logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""				)
										_UpperCamelCase						    =	CONFIG_MAPPING["""resnet"""](out_features=["""stage2""", """stage3""", """stage4"""]				)
								else:
										if isinstance(a       ,							a				):
												_UpperCamelCase						    =	backbone_config.pop("""model_type"""				)
												_UpperCamelCase						    =	CONFIG_MAPPING[backbone_model_type]
												_UpperCamelCase						    =	config_class.from_dict(a				)

								_UpperCamelCase						    =	backbone_config
								_UpperCamelCase						    =	num_queries
								_UpperCamelCase						    =	max_position_embeddings
								_UpperCamelCase						    =	d_model
								_UpperCamelCase						    =	encoder_ffn_dim
								_UpperCamelCase						    =	encoder_layers
								_UpperCamelCase						    =	encoder_attention_heads
								_UpperCamelCase						    =	decoder_ffn_dim
								_UpperCamelCase						    =	decoder_layers
								_UpperCamelCase						    =	decoder_attention_heads
								_UpperCamelCase						    =	dropout
								_UpperCamelCase						    =	attention_dropout
								_UpperCamelCase						    =	activation_dropout
								_UpperCamelCase						    =	activation_function
								_UpperCamelCase						    =	init_std
								_UpperCamelCase						    =	init_xavier_std
								_UpperCamelCase						    =	encoder_layerdrop
								_UpperCamelCase						    =	auxiliary_loss
								_UpperCamelCase						    =	position_embedding_type
								# deformable attributes
								_UpperCamelCase						    =	num_feature_levels
								_UpperCamelCase						    =	encoder_n_points
								_UpperCamelCase						    =	decoder_n_points
								_UpperCamelCase						    =	two_stage
								_UpperCamelCase						    =	two_stage_num_proposals
								_UpperCamelCase						    =	with_box_refine
								_UpperCamelCase						    =	assign_first_stage
								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
								_UpperCamelCase						    =	class_cost
								_UpperCamelCase						    =	bbox_cost
								_UpperCamelCase						    =	giou_cost
								# Loss coefficients
								_UpperCamelCase						    =	mask_loss_coefficient
								_UpperCamelCase						    =	dice_loss_coefficient
								_UpperCamelCase						    =	bbox_loss_coefficient
								_UpperCamelCase						    =	giou_loss_coefficient
								_UpperCamelCase						    =	eos_coefficient
								_UpperCamelCase						    =	focal_alpha
								super().__init__(is_encoder_decoder=a       ,							**a				)

						@property
						def  A_				(			self				)					->      int:


								'''simple docstring'''

								return self.encoder_attention_heads

						@property
						def  A_				(			self				)					->      int:


								'''simple docstring'''

								return self.d_model







						def  A_				(			self				)					->      Tuple:


								'''simple docstring'''

								_UpperCamelCase						    =	copy.deepcopy(self.__dict__				)
								_UpperCamelCase						    =	self.backbone_config.to_dict()
								_UpperCamelCase						    =	self.__class__.model_type
								return output



