






import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase								=		logging.get_logger(__name__)






def    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    List[Any]:
							_lowercase							:   Optional[Any] 							=   SwinConfig(
							    embed_dim=192     ,     depths=(2, 2, 18, 2)     ,     num_heads=(6, 12, 24, 48)     ,     window_size=12     ,     out_features=['stage2', 'stage3', 'stage4']     ,     )

							_lowercase							:   Any 							=   DetaConfig(
							    backbone_config=SCREAMING_SNAKE_CASE     ,     num_queries=900     ,     encoder_ffn_dim=2_048     ,     decoder_ffn_dim=2_048     ,     num_feature_levels=5     ,     assign_first_stage=SCREAMING_SNAKE_CASE     ,     with_box_refine=SCREAMING_SNAKE_CASE     ,     two_stage=SCREAMING_SNAKE_CASE     ,     )

							# set labels
							_lowercase							:   int 							=   'huggingface/label-files'
							if "o365" in model_name:
														_lowercase							:   Any 							=   366
														_lowercase							:   Dict 							=   'object365-id2label.json'
							else:
														_lowercase							:   str 							=   91
														_lowercase							:   Union[str, Any] 							=   'coco-detection-id2label.json'

							_lowercase							:   Optional[int] 							=   num_labels
							_lowercase							:   Dict 							=   json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     repo_type='dataset'				)				)     ,     'r'				)				)
							_lowercase							:   List[str] 							=   {int(SCREAMING_SNAKE_CASE				): v for k, v in idalabel.items()}
							_lowercase							:   Any 							=   idalabel
							_lowercase							:   Union[str, Any] 							=   {v: k for k, v in idalabel.items()}

							return config






def    __magic_name__    (	SCREAMING_SNAKE_CASE				)     ->    Union[str, Any]:
							_lowercase							:   Union[str, Any] 							=   []

							# stem
							# fmt: off
							rename_keys.append(('backbone.0.body.patch_embed.proj.weight', 'model.backbone.model.embeddings.patch_embeddings.projection.weight')				)
							rename_keys.append(('backbone.0.body.patch_embed.proj.bias', 'model.backbone.model.embeddings.patch_embeddings.projection.bias')				)
							rename_keys.append(('backbone.0.body.patch_embed.norm.weight', 'model.backbone.model.embeddings.norm.weight')				)
							rename_keys.append(('backbone.0.body.patch_embed.norm.bias', 'model.backbone.model.embeddings.norm.bias')				)
							# stages
							for i in range(len(config.backbone_config.depths				)				):
														for j in range(config.backbone_config.depths[i]				):
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")				)

														if i < 3:
																					rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.reduction.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""")				)
																					rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.bias""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""")				)

							rename_keys.append(('backbone.0.body.norm1.weight', 'model.backbone.model.hidden_states_norms.stage2.weight')				)
							rename_keys.append(('backbone.0.body.norm1.bias', 'model.backbone.model.hidden_states_norms.stage2.bias')				)
							rename_keys.append(('backbone.0.body.norm2.weight', 'model.backbone.model.hidden_states_norms.stage3.weight')				)
							rename_keys.append(('backbone.0.body.norm2.bias', 'model.backbone.model.hidden_states_norms.stage3.bias')				)
							rename_keys.append(('backbone.0.body.norm3.weight', 'model.backbone.model.hidden_states_norms.stage4.weight')				)
							rename_keys.append(('backbone.0.body.norm3.bias', 'model.backbone.model.hidden_states_norms.stage4.bias')				)

							# transformer encoder
							for i in range(config.encoder_layers				):
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", F"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", F"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", F"""model.encoder.layers.{i}.self_attn.value_proj.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", F"""model.encoder.layers.{i}.self_attn.value_proj.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", F"""model.encoder.layers.{i}.self_attn.output_proj.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", F"""model.encoder.layers.{i}.self_attn.output_proj.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.weight""", F"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""model.encoder.layers.{i}.fc1.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""model.encoder.layers.{i}.fc1.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""model.encoder.layers.{i}.fc2.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""model.encoder.layers.{i}.fc2.bias""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""model.encoder.layers.{i}.final_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""model.encoder.layers.{i}.final_layer_norm.bias""")				)

							# transformer decoder
							for i in range(config.decoder_layers				):
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.weight""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""model.decoder.layers.{i}.self_attn.out_proj.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""model.decoder.layers.{i}.self_attn.out_proj.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.weight""", F"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.bias""", F"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""model.decoder.layers.{i}.fc1.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""model.decoder.layers.{i}.fc1.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""model.decoder.layers.{i}.fc2.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""model.decoder.layers.{i}.fc2.bias""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""model.decoder.layers.{i}.final_layer_norm.weight""")				)
														rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""model.decoder.layers.{i}.final_layer_norm.bias""")				)

							# fmt: on

							return rename_keys






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    List[str]:
							_lowercase							:   Any 							=   dct.pop(SCREAMING_SNAKE_CASE				)
							_lowercase							:   List[str] 							=   val






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    Union[str, Any]:
							_lowercase							:   Optional[Any] 							=   [int(backbone_config.embed_dim * 2**i				) for i in range(len(backbone_config.depths				)				)]
							for i in range(len(backbone_config.depths				)				):
														_lowercase							:   Union[str, Any] 							=   num_features[i]
														for j in range(backbone_config.depths[i]				):
																					# fmt: off
																					# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
																					_lowercase							:   str 							=   state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""				)
																					_lowercase							:   Optional[Any] 							=   state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"""				)
																					# next, add query, keys and values (in that order) to the state dict
																					_lowercase							:   List[str] 							=   in_proj_weight[:dim, :]
																					_lowercase							:   List[str] 							=   in_proj_bias[: dim]
																					_lowercase							:   str 							=   in_proj_weight[
																					    dim : dim * 2, :
																					]
																					_lowercase							:   Union[str, Any] 							=   in_proj_bias[
																					    dim : dim * 2
																					]
																					_lowercase							:   Dict 							=   in_proj_weight[
																					    -dim :, :
																					]
																					_lowercase							:   Union[str, Any] 							=   in_proj_bias[-dim :]
																					# fmt: on






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    Optional[Any]:
							# transformer decoder self-attention layers
							_lowercase							:   str 							=   config.d_model
							for i in range(config.decoder_layers				):
														# read in weights + bias of input projection layer of self-attention
														_lowercase							:   Dict 							=   state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""				)
														_lowercase							:   str 							=   state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""				)
														# next, add query, keys and values (in that order) to the state dict
														_lowercase							:   List[Any] 							=   in_proj_weight[:hidden_size, :]
														_lowercase							:   Optional[Any] 							=   in_proj_bias[:hidden_size]
														_lowercase							:   List[str] 							=   in_proj_weight[
														    hidden_size : hidden_size * 2, :
														]
														_lowercase							:   str 							=   in_proj_bias[hidden_size : hidden_size * 2]
														_lowercase							:   str 							=   in_proj_weight[-hidden_size:, :]
														_lowercase							:   Dict 							=   in_proj_bias[-hidden_size:]






def    __magic_name__    (	)     ->    Optional[int]:
							_lowercase							:   str 							=   'http://images.cocodataset.org/val2017/000000039769.jpg'
							_lowercase							:   List[Any] 							=   Image.open(requests.get(SCREAMING_SNAKE_CASE     ,     stream=SCREAMING_SNAKE_CASE				).raw				)

							return im






@torch.no_grad()
def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    Optional[Any]:
							_lowercase							:   Dict 							=   get_deta_config(SCREAMING_SNAKE_CASE				)

							# load original state dict
							if model_name == "deta-swin-large":
														_lowercase							:   int 							=   hf_hub_download(repo_id='nielsr/deta-checkpoints'     ,     filename='adet_swin_ft.pth'				)
							elif model_name == "deta-swin-large-o365":
														_lowercase							:   Dict 							=   hf_hub_download(repo_id='jozhang97/deta-swin-l-o365'     ,     filename='deta_swin_pt_o365.pth'				)
							else:
														raise ValueError(F"""Model name {model_name} not supported"""				)

							_lowercase							:   str 							=   torch.load(SCREAMING_SNAKE_CASE     ,     map_location='cpu'				)['model']

							# original state dict
							for name, param in state_dict.items():
														print(SCREAMING_SNAKE_CASE     ,     param.shape				)

							# rename keys
							_lowercase							:   Tuple 							=   create_rename_keys(SCREAMING_SNAKE_CASE				)
							for src, dest in rename_keys:
														rename_key(SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)
							read_in_swin_q_k_v(SCREAMING_SNAKE_CASE     ,     config.backbone_config				)
							read_in_decoder_q_k_v(SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)

							# fix some prefixes
							for key in state_dict.copy().keys():
														if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
																					_lowercase							:   int 							=   state_dict.pop(SCREAMING_SNAKE_CASE				)
																					_lowercase							:   List[str] 							=   val
														if "input_proj" in key:
																					_lowercase							:   Any 							=   state_dict.pop(SCREAMING_SNAKE_CASE				)
																					_lowercase							:   int 							=   val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					_lowercase							:   Union[str, Any] 							=   state_dict.pop(SCREAMING_SNAKE_CASE				)
																					_lowercase							:   Dict 							=   val

    # finally, create HuggingFace model and load state dict
							_lowercase							:   Optional[Any] 							=   DetaForObjectDetection(SCREAMING_SNAKE_CASE				)
							model.load_state_dict(SCREAMING_SNAKE_CASE				)
							model.eval()

							_lowercase							:   Tuple 							=   'cuda' if torch.cuda.is_available() else 'cpu'
							model.to(SCREAMING_SNAKE_CASE				)

							# load image processor
							_lowercase							:   Optional[int] 							=   DetaImageProcessor(format='coco_detection'				)

							# verify our conversion on image
							_lowercase							:   int 							=   prepare_img()
							_lowercase							:   Tuple 							=   processor(images=SCREAMING_SNAKE_CASE     ,     return_tensors='pt'				)
							_lowercase							:   Union[str, Any] 							=   encoding['pixel_values']
							_lowercase							:   Any 							=   model(pixel_values.to(SCREAMING_SNAKE_CASE				)				)

							# verify logits
							print('Logits:'     ,     outputs.logits[0, :3, :3]				)
							print('Boxes:'     ,     outputs.pred_boxes[0, :3, :3]				)
							if model_name == "deta-swin-large":
														_lowercase							:   Tuple 							=   torch.tensor(
														    [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]				)
														_lowercase							:   Dict 							=   torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]]				)
							elif model_name == "deta-swin-large-o365":
														_lowercase							:   Union[str, Any] 							=   torch.tensor(
														    [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]				)
														_lowercase							:   Dict 							=   torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]]				)
							assert torch.allclose(outputs.logits[0, :3, :3]     ,     expected_logits.to(SCREAMING_SNAKE_CASE				)     ,     atol=1E-4				)
							assert torch.allclose(outputs.pred_boxes[0, :3, :3]     ,     expected_boxes.to(SCREAMING_SNAKE_CASE				)     ,     atol=1E-4				)
							print('Everything ok!'				)

							if pytorch_dump_folder_path:
														# Save model and processor
														logger.info(F"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""				)
														Path(SCREAMING_SNAKE_CASE				).mkdir(exist_ok=SCREAMING_SNAKE_CASE				)
														model.save_pretrained(SCREAMING_SNAKE_CASE				)
														processor.save_pretrained(SCREAMING_SNAKE_CASE				)

							# Push to hub
							if push_to_hub:
														print('Pushing model and processor to hub...'				)
														model.push_to_hub(F"""jozhang97/{model_name}"""				)
														processor.push_to_hub(F"""jozhang97/{model_name}"""				)


if __name__ == "__main__":
							UpperCamelCase								=		argparse.ArgumentParser()

							parser.add_argument(
							    "--model_name",
							    type=str,
							    default="deta-swin-large",
							    choices=["deta-swin-large", "deta-swin-large-o365"],
							    help="Name of the model you'd like to convert.",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path",
							    default=None,
							    type=str,
							    help="Path to the folder to output PyTorch model.",
							)
							parser.add_argument(
							    "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
							)
							UpperCamelCase								=		parser.parse_args()
							convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











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,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)

@flax.struct.dataclass
class     snake_case_		(   a							):






 '''simple docstring'''





 __UpperCamelCase       =      42
 __UpperCamelCase       =      42

class     snake_case_		(   nn.Module							):






 '''simple docstring'''





 __UpperCamelCase       =      42
 __UpperCamelCase       =      (1_6, 3_2, 9_6, 2_5_6)
 __UpperCamelCase       =      jnp.floataa

 def  __UpperCAmelCase						(  self		)	->       Any:
    UpperCAmelCase__						=nn.Conv(
        self.block_out_channels[0],		kernel_size=(3, 3),		padding=((1, 1), (1, 1)),		dtype=self.dtype,		)

    UpperCAmelCase__						=[]
    for i in range(len(self.block_out_channels		) - 1		):
       UpperCAmelCase__						=self.block_out_channels[i]
       UpperCAmelCase__						=self.block_out_channels[i + 1]
       UpperCAmelCase__						=nn.Conv(
           A_,		kernel_size=(3, 3),		padding=((1, 1), (1, 1)),		dtype=self.dtype,		)
       blocks.append(A_		)
       UpperCAmelCase__						=nn.Conv(
           A_,		kernel_size=(3, 3),		strides=(2, 2),		padding=((1, 1), (1, 1)),		dtype=self.dtype,		)
       blocks.append(A_		)
    UpperCAmelCase__						=blocks

    UpperCAmelCase__						=nn.Conv(
        self.conditioning_embedding_channels,		kernel_size=(3, 3),		padding=((1, 1), (1, 1)),		kernel_init=nn.initializers.zeros_init(),		bias_init=nn.initializers.zeros_init(),		dtype=self.dtype,		)






 def __call__(  self,		A_		)	->       Any:
    UpperCAmelCase__						=self.conv_in(A_		)
    UpperCAmelCase__						=nn.silu(A_		)

    for block in self.blocks:
       UpperCAmelCase__						=block(A_		)
       UpperCAmelCase__						=nn.silu(A_		)

    UpperCAmelCase__						=self.conv_out(A_		)

    return embedding

@flax_register_to_config
class     snake_case_		(   nn.Module,		a,		a							):






 '''simple docstring'''





 __UpperCamelCase       =      3_2
 __UpperCamelCase       =      4
 __UpperCamelCase       =      (
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "CrossAttnDownBlock2D",
     "DownBlock2D",
 )
 __UpperCamelCase       =      False
 __UpperCamelCase       =      (3_2_0, 6_4_0, 1_2_8_0, 1_2_8_0)
 __UpperCamelCase       =      2
 __UpperCamelCase       =      8
 __UpperCamelCase       =      None
 __UpperCamelCase       =      1_2_8_0
 __UpperCamelCase       =      0.0
 __UpperCamelCase       =      False
 __UpperCamelCase       =      jnp.floataa
 __UpperCamelCase       =      True
 __UpperCamelCase       =      0
 __UpperCamelCase       =      "rgb"
 __UpperCamelCase       =      (1_6, 3_2, 9_6, 2_5_6)

 def  __UpperCAmelCase						(  self,		A_		)	->       FrozenDict:
    # init input tensors
    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__						=(1, 3, self.sample_size * 8, self.sample_size * 8)
    UpperCAmelCase__						=jnp.zeros(A_,		dtype=jnp.floataa		)

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

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

 def  __UpperCAmelCase						(  self		)	->       int:
    UpperCAmelCase__						=self.block_out_channels
    UpperCAmelCase__						=block_out_channels[0] * 4

    # 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__						=FlaxControlNetConditioningEmbedding(
        conditioning_embedding_channels=block_out_channels[0],		block_out_channels=self.conditioning_embedding_out_channels,		)

    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__						=[]

    UpperCAmelCase__						=block_out_channels[0]

    UpperCAmelCase__						=nn.Conv(
        A_,		kernel_size=(1, 1),		padding="VALID",		kernel_init=nn.initializers.zeros_init(),		bias_init=nn.initializers.zeros_init(),		dtype=self.dtype,		)
    controlnet_down_blocks.append(A_		)

    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],		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_		)

       for _ in range(self.layers_per_block		):
          UpperCAmelCase__						=nn.Conv(
              A_,		kernel_size=(1, 1),		padding="VALID",		kernel_init=nn.initializers.zeros_init(),		bias_init=nn.initializers.zeros_init(),		dtype=self.dtype,		)
          controlnet_down_blocks.append(A_		)

       if not is_final_block:
          UpperCAmelCase__						=nn.Conv(
              A_,		kernel_size=(1, 1),		padding="VALID",		kernel_init=nn.initializers.zeros_init(),		bias_init=nn.initializers.zeros_init(),		dtype=self.dtype,		)
          controlnet_down_blocks.append(A_		)

    UpperCAmelCase__						=down_blocks
    UpperCAmelCase__						=controlnet_down_blocks

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

    UpperCAmelCase__						=nn.Conv(
        A_,		kernel_size=(1, 1),		padding="VALID",		kernel_init=nn.initializers.zeros_init(),		bias_init=nn.initializers.zeros_init(),		dtype=self.dtype,		)






 def __call__(  self,		A_,		A_,		A_,		A_,		A_ = 1.0,		A_ = True,		A_ = False,		)	->       Union[FlaxControlNetOutput, Tuple]:
    UpperCAmelCase__						=self.controlnet_conditioning_channel_order
    if channel_order == "bgr":
       UpperCAmelCase__						=jnp.flip(A_,		axis=1		)

    # 1. time
    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_		)

    UpperCAmelCase__						=jnp.transpose(A_,		(0, 2, 3, 1)		)
    UpperCAmelCase__						=self.controlnet_cond_embedding(A_		)
    sample += controlnet_cond

    # 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

    # 4. mid
    UpperCAmelCase__						=self.mid_block(A_,		A_,		A_,		deterministic=not train		)

    # 5. contronet blocks
    UpperCAmelCase__						=()
    for down_block_res_sample, controlnet_block in zip(A_,		self.controlnet_down_blocks		):
       UpperCAmelCase__						=controlnet_block(A_		)
       controlnet_down_block_res_samples += (down_block_res_sample,)

    UpperCAmelCase__						=controlnet_down_block_res_samples

    UpperCAmelCase__						=self.controlnet_mid_block(A_		)

    # 6. scaling
    UpperCAmelCase__						=[sample * conditioning_scale for sample in down_block_res_samples]
    mid_block_res_sample *= conditioning_scale

    if not return_dict:
       return (down_block_res_samples, mid_block_res_sample)

    return FlaxControlNetOutput(
        down_block_res_samples=A_,		mid_block_res_sample=A_		)



