

'''simple docstring'''







from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase						    =      logging.get_logger(__name__)

__lowerCamelCase						    =      {
    '''tiiuae/falcon-40b''': '''https://huggingface.co/tiiuae/falcon-40b/resolve/main/config.json''',
    '''tiiuae/falcon-7b''': '''https://huggingface.co/tiiuae/falcon-7b/resolve/main/config.json''',
}


class    A__ ( _snake_case     ):
    lowercase		   =						"falcon"
    lowercase		   =						["past_key_values"]



    def __init__(   self						,			UpperCamelCase__=65024						,			UpperCamelCase__=4544						,			UpperCamelCase__=32						,			UpperCamelCase__=71						,			UpperCamelCase__=1e-5						,			UpperCamelCase__=0.02						,			UpperCamelCase__=True						,			UpperCamelCase__=0.0						,			UpperCamelCase__=0.0						,			UpperCamelCase__=None						,			UpperCamelCase__=False						,			UpperCamelCase__=False						,			UpperCamelCase__=True						,			UpperCamelCase__=True						,			UpperCamelCase__=False						,			UpperCamelCase__=11						,			UpperCamelCase__=11						,			**UpperCamelCase__						,			)  -> int:





           '''simple docstring'''
           A_		   = vocab_size
           # Backward compatibility with n_embed kwarg
           A_		   = kwargs.pop("""n_embed"""						,			UpperCamelCase__    )
           A_		   = hidden_size if n_embed is None else n_embed
           A_		   = num_hidden_layers
           A_		   = num_attention_heads
           A_		   = layer_norm_epsilon
           A_		   = initializer_range
           A_		   = use_cache
           A_		   = hidden_dropout
           A_		   = attention_dropout

           A_		   = bos_token_id
           A_		   = eos_token_id
           A_		   = num_attention_heads if num_kv_heads is None else num_kv_heads
           A_		   = alibi
           A_		   = new_decoder_architecture
           A_		   = multi_query  # Ignored when new_decoder_architecture is True
           A_		   = parallel_attn
           A_		   = bias

           super().__init__(bos_token_id=UpperCamelCase__						,			eos_token_id=UpperCamelCase__						,			**UpperCamelCase__    )



    @property
    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           return self.hidden_size // self.num_attention_heads







    @property
    def    snake_case_     (   self    )  -> Optional[int]:





           '''simple docstring'''
           return not self.alibi



'''simple docstring'''







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    A__ ( _snake_case     ):
    lowercase		   =						42
    lowercase		   =						42


class    A__ ( nn.Module     ):
    lowercase		   =						42
    lowercase		   =						(16, 32, 96, 256)
    lowercase		   =						jnp.floataa



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = nn.Conv(
               self.block_out_channels[0]						,			kernel_size=(3, 3)						,			padding=((1, 1), (1, 1))						,			dtype=self.dtype						,			)

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

           A_		   = 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						,			UpperCamelCase__    )  -> int:





           '''simple docstring'''
           A_		   = self.conv_in(UpperCamelCase__    )
           A_		   = nn.silu(UpperCamelCase__    )

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

           A_		   = self.conv_out(UpperCamelCase__    )

           return embedding


@flax_register_to_config
class    A__ ( nn.Module  ,  _snake_case  ,  _snake_case     ):
    lowercase		   =						32
    lowercase		   =						4
    lowercase		   =						(
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "DownBlock2D",
    )
    lowercase		   =						False
    lowercase		   =						(320, 640, 1_280, 1_280)
    lowercase		   =						2
    lowercase		   =						8
    lowercase		   =						None
    lowercase		   =						1_280
    lowercase		   =						0.0
    lowercase		   =						False
    lowercase		   =						jnp.floataa
    lowercase		   =						True
    lowercase		   =						0
    lowercase		   =						"rgb"
    lowercase		   =						(16, 32, 96, 256)



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> FrozenDict:





           '''simple docstring'''
           # init input tensors
           A_		   = (1, self.in_channels, self.sample_size, self.sample_size)
           A_		   = jnp.zeros(UpperCamelCase__						,			dtype=jnp.floataa    )
           A_		   = jnp.ones((1,)						,			dtype=jnp.intaa    )
           A_		   = jnp.zeros((1, 1, self.cross_attention_dim)						,			dtype=jnp.floataa    )
           A_		   = (1, 3, self.sample_size * 8, self.sample_size * 8)
           A_		   = jnp.zeros(UpperCamelCase__						,			dtype=jnp.floataa    )

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

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



    def    snake_case_     (   self    )  -> List[str]:





           '''simple docstring'''
           A_		   = self.block_out_channels
           A_		   = 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.
           A_		   = self.num_attention_heads or self.attention_head_dim

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

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

           A_		   = FlaxControlNetConditioningEmbedding(
               conditioning_embedding_channels=block_out_channels[0]						,			block_out_channels=self.conditioning_embedding_out_channels						,			)

           A_		   = self.only_cross_attention
           if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = (only_cross_attention,) * len(self.down_block_types    )

           if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = (num_attention_heads,) * len(self.down_block_types    )

           # down
           A_		   = []
           A_		   = []

           A_		   = block_out_channels[0]

           A_		   = nn.Conv(
               UpperCamelCase__						,			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(UpperCamelCase__    )

           for i, down_block_type in enumerate(self.down_block_types    ):
                  A_		   = output_channel
                  A_		   = block_out_channels[i]
                  A_		   = i == len(UpperCamelCase__    ) - 1

                  if down_block_type == "CrossAttnDownBlock2D":
                         A_		   = FlaxCrossAttnDownBlockaD(
                             in_channels=UpperCamelCase__						,			out_channels=UpperCamelCase__						,			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:
                         A_		   = FlaxDownBlockaD(
                             in_channels=UpperCamelCase__						,			out_channels=UpperCamelCase__						,			dropout=self.dropout						,			num_layers=self.layers_per_block						,			add_downsample=not is_final_block						,			dtype=self.dtype						,			)

                  down_blocks.append(UpperCamelCase__    )

                  for _ in range(self.layers_per_block    ):
                         A_		   = nn.Conv(
                             UpperCamelCase__						,			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(UpperCamelCase__    )

                  if not is_final_block:
                         A_		   = nn.Conv(
                             UpperCamelCase__						,			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(UpperCamelCase__    )

           A_		   = down_blocks
           A_		   = controlnet_down_blocks

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

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







    def __call__(   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__ = 1.0						,			UpperCamelCase__ = True						,			UpperCamelCase__ = False						,			)  -> Union[FlaxControlNetOutput, Tuple]:





           '''simple docstring'''
           A_		   = self.controlnet_conditioning_channel_order
           if channel_order == "bgr":
                  A_		   = jnp.flip(UpperCamelCase__						,			axis=1    )

           # 1. time
           if not isinstance(UpperCamelCase__						,			jnp.ndarray    ):
                  A_		   = jnp.array([timesteps]						,			dtype=jnp.intaa    )
           elif isinstance(UpperCamelCase__						,			jnp.ndarray    ) and len(timesteps.shape    ) == 0:
                  A_		   = timesteps.astype(dtype=jnp.floataa    )
                  A_		   = jnp.expand_dims(UpperCamelCase__						,			0    )

           A_		   = self.time_proj(UpperCamelCase__    )
           A_		   = self.time_embedding(UpperCamelCase__    )

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

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

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

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

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

           A_		   = controlnet_down_block_res_samples

           A_		   = self.controlnet_mid_block(UpperCamelCase__    )

           # 6. scaling
           A_		   = [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=UpperCamelCase__						,			mid_block_res_sample=UpperCamelCase__    )
