




'''simple docstring'''

from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


a  :				Dict									=  logging.get_logger(__name__)

a  :				List[str]									=  {
    'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json',
    # See all Marian models at https://huggingface.co/models?filter=marian
}






class 						a				(   _lowerCamelCase     ):
				snake_case_      =		"marian"
				snake_case_      =		["past_key_values"]
				snake_case_      =		{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}


				def __init__(		self    :					List[Any]       ,				lowercase_    :					Optional[Any]=5_8101       ,				lowercase_    :					Dict=None       ,				lowercase_    :					List[str]=1024       ,				lowercase_    :					Optional[Any]=12       ,				lowercase_    :					int=4096       ,				lowercase_    :					Any=16       ,				lowercase_    :					Optional[int]=12       ,				lowercase_    :					str=4096       ,				lowercase_    :					Union[str, Any]=16       ,				lowercase_    :					Dict=0.0       ,				lowercase_    :					Union[str, Any]=0.0       ,				lowercase_    :					Optional[Any]=True       ,				lowercase_    :					Union[str, Any]=True       ,				lowercase_    :					int="gelu"       ,				lowercase_    :					Dict=1024       ,				lowercase_    :					int=0.1       ,				lowercase_    :					Tuple=0.0       ,				lowercase_    :					Tuple=0.0       ,				lowercase_    :					Tuple=0.02       ,				lowercase_    :					int=5_8100       ,				lowercase_    :					Optional[Any]=False       ,				lowercase_    :					Any=5_8100       ,				lowercase_    :					Optional[int]=0       ,				lowercase_    :					Dict=0       ,				lowercase_    :					List[str]=True       ,				**lowercase_    :					Any       ,				):
									snake_case_									=				vocab_size
									snake_case_									=				decoder_vocab_size or vocab_size
									snake_case_									=				max_position_embeddings
									snake_case_									=				d_model
									snake_case_									=				encoder_ffn_dim
									snake_case_									=				encoder_layers
									snake_case_									=				encoder_attention_heads
									snake_case_									=				decoder_ffn_dim
									snake_case_									=				decoder_layers
									snake_case_									=				decoder_attention_heads
									snake_case_									=				dropout
									snake_case_									=				attention_dropout
									snake_case_									=				activation_dropout
									snake_case_									=				activation_function
									snake_case_									=				init_std
									snake_case_									=				encoder_layerdrop
									snake_case_									=				decoder_layerdrop
									snake_case_									=				use_cache
									snake_case_									=				encoder_layers
									snake_case_									=				scale_embedding  # scale factor will be sqrt(d_model) if True
									snake_case_									=				share_encoder_decoder_embeddings
									super().__init__(
									    pad_token_id=lowercase_       ,				eos_token_id=lowercase_       ,				is_encoder_decoder=lowercase_       ,				decoder_start_token_id=lowercase_       ,				forced_eos_token_id=lowercase_       ,				**lowercase_       ,				)







class 						a				(   _lowerCamelCase     ):


				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
				def   A_ (		self    :					Union[str, Any]					):
									if self.task in ["default", "seq2seq-lm"]:
														snake_case_									=				OrderedDict(
														    [
														        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
														        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
														    ]					)

														if self.use_past:
																			snake_case_									=				{0: '''batch'''}
																			snake_case_									=				{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
														else:
																			snake_case_									=				{0: '''batch''', 1: '''decoder_sequence'''}
																			snake_case_									=				{0: '''batch''', 1: '''decoder_sequence'''}

														if self.use_past:
																			self.fill_with_past_key_values_(lowercase_       ,				direction='''inputs'''					)
									elif self.task == "causal-lm":
														# TODO: figure this case out.
														snake_case_									=				OrderedDict(
														    [
														        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
														        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
														    ]					)
														if self.use_past:
																			snake_case_			,snake_case_									=				self.num_layers
																			for i in range(lowercase_					):
																								snake_case_									=				{0: '''batch''', 2: '''past_sequence + sequence'''}
																								snake_case_									=				{0: '''batch''', 2: '''past_sequence + sequence'''}
									else:
														snake_case_									=				OrderedDict(
														    [
														        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
														        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
														        ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
														        ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
														    ]					)

									return common_inputs


				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
				def   A_ (		self    :					Dict					):
									if self.task in ["default", "seq2seq-lm"]:
														snake_case_									=				super().outputs
									else:
														snake_case_									=				super(lowercase_       ,				self					).outputs
														if self.use_past:
																			snake_case_			,snake_case_									=				self.num_layers
																			for i in range(lowercase_					):
																								snake_case_									=				{0: '''batch''', 2: '''past_sequence + sequence'''}
																								snake_case_									=				{0: '''batch''', 2: '''past_sequence + sequence'''}
									return common_outputs


				def   A_ (		self    :					Dict       ,				lowercase_    :					PreTrainedTokenizer       ,				lowercase_    :					int = -1       ,				lowercase_    :					int = -1       ,				lowercase_    :					bool = False       ,				lowercase_    :					Optional[TensorType] = None       ,				):
									snake_case_									=				self._generate_dummy_inputs_for_encoder_and_decoder(
									    lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_					)

									# Generate decoder inputs
									snake_case_									=				seq_length if not self.use_past else 1
									snake_case_									=				self._generate_dummy_inputs_for_encoder_and_decoder(
									    lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_					)
									snake_case_									=				{F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
									snake_case_									=				dict(**lowercase_       ,				**lowercase_					)

									if self.use_past:
														if not is_torch_available():
																			raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''					)
														else:
																			import torch
														snake_case_			,snake_case_									=				common_inputs['''input_ids'''].shape
														snake_case_									=				common_inputs['''decoder_input_ids'''].shape[1]
														snake_case_			,snake_case_									=				self.num_attention_heads
														snake_case_									=				(
														    batch,
														    num_encoder_attention_heads,
														    encoder_seq_length,
														    self._config.hidden_size // num_encoder_attention_heads,
														)
														snake_case_									=				decoder_seq_length + 3
														snake_case_									=				(
														    batch,
														    num_decoder_attention_heads,
														    decoder_past_length,
														    self._config.hidden_size // num_decoder_attention_heads,
														)

														snake_case_									=				torch.cat(
														    [common_inputs['''decoder_attention_mask'''], torch.ones(lowercase_       ,				lowercase_					)]       ,				dim=1					)

														snake_case_									=				[]
														# If the number of encoder and decoder layers are present in the model configuration, both are considered
														snake_case_			,snake_case_									=				self.num_layers
														snake_case_									=				min(lowercase_       ,				lowercase_					)
														snake_case_									=				max(lowercase_       ,				lowercase_					) - min_num_layers
														snake_case_									=				'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

														for _ in range(lowercase_					):
																			common_inputs["past_key_values"].append(
																			    (
																			        torch.zeros(lowercase_					),
																			        torch.zeros(lowercase_					),
																			        torch.zeros(lowercase_					),
																			        torch.zeros(lowercase_					),
																			    )					)
														# TODO: test this.
														snake_case_									=				encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
														for _ in range(lowercase_       ,				lowercase_					):
																			common_inputs["past_key_values"].append((torch.zeros(lowercase_					), torch.zeros(lowercase_					))					)
									return common_inputs


				def   A_ (		self    :					Union[str, Any]       ,				lowercase_    :					PreTrainedTokenizer       ,				lowercase_    :					int = -1       ,				lowercase_    :					int = -1       ,				lowercase_    :					bool = False       ,				lowercase_    :					Optional[TensorType] = None       ,				):
									snake_case_									=				self._generate_dummy_inputs_for_encoder_and_decoder(
									    lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_					)

									if self.use_past:
														if not is_torch_available():
																			raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''					)
														else:
																			import torch
														snake_case_			,snake_case_									=				common_inputs['''input_ids'''].shape
														# Not using the same length for past_key_values
														snake_case_									=				seqlen + 2
														snake_case_			,snake_case_									=				self.num_layers
														snake_case_			,snake_case_									=				self.num_attention_heads
														snake_case_									=				(
														    batch,
														    num_encoder_attention_heads,
														    past_key_values_length,
														    self._config.hidden_size // num_encoder_attention_heads,
														)

														snake_case_									=				common_inputs['''attention_mask'''].dtype
														snake_case_									=				torch.cat(
														    [common_inputs['''attention_mask'''], torch.ones(lowercase_       ,				lowercase_       ,				dtype=lowercase_					)]       ,				dim=1					)
														snake_case_									=				[
														    (torch.zeros(lowercase_					), torch.zeros(lowercase_					)) for _ in range(lowercase_					)
														]
									return common_inputs


				def   A_ (		self    :					List[str]       ,				lowercase_    :					PreTrainedTokenizer       ,				lowercase_    :					int = -1       ,				lowercase_    :					int = -1       ,				lowercase_    :					bool = False       ,				lowercase_    :					Optional[TensorType] = None       ,				):
									# Copied from OnnxConfig.generate_dummy_inputs
									# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
									# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
									snake_case_									=				compute_effective_axis_dimension(
									    lowercase_       ,				fixed_dimension=OnnxConfig.default_fixed_batch       ,				num_token_to_add=0					)

									# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
									snake_case_									=				tokenizer.num_special_tokens_to_add(lowercase_					)
									snake_case_									=				compute_effective_axis_dimension(
									    lowercase_       ,				fixed_dimension=OnnxConfig.default_fixed_sequence       ,				num_token_to_add=lowercase_					)

									# Generate dummy inputs according to compute batch and sequence
									snake_case_									=				[''' '''.join([tokenizer.unk_token]					) * seq_length] * batch_size
									snake_case_									=				dict(tokenizer(lowercase_       ,				return_tensors=lowercase_					)					)
									return common_inputs


				def   A_ (		self    :					Any       ,				lowercase_    :					PreTrainedTokenizer       ,				lowercase_    :					int = -1       ,				lowercase_    :					int = -1       ,				lowercase_    :					bool = False       ,				lowercase_    :					Optional[TensorType] = None       ,				):
									if self.task in ["default", "seq2seq-lm"]:
														snake_case_									=				self._generate_dummy_inputs_for_default_and_seqaseq_lm(
														    lowercase_       ,				batch_size=lowercase_       ,				seq_length=lowercase_       ,				is_pair=lowercase_       ,				framework=lowercase_					)

									else:
														snake_case_									=				self._generate_dummy_inputs_for_causal_lm(
														    lowercase_       ,				batch_size=lowercase_       ,				seq_length=lowercase_       ,				is_pair=lowercase_       ,				framework=lowercase_					)

									return common_inputs


				def   A_ (		self    :					Dict       ,				lowercase_    :					List[str]       ,				lowercase_    :					List[str]       ,				lowercase_    :					int       ,				lowercase_    :					List[str]					):
									if self.task in ["default", "seq2seq-lm"]:
														snake_case_									=				super()._flatten_past_key_values_(lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_					)
									else:
														snake_case_									=				super(lowercase_       ,				self					)._flatten_past_key_values_(
														    lowercase_       ,				lowercase_       ,				lowercase_       ,				lowercase_					)


				@property
				def   A_ (		self    :					List[str]					):
									return 1e-4







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






@flax.struct.dataclass
class 						a				(   _lowerCamelCase     ):
				snake_case_      =		42







@flax_register_to_config
class 						a				(   nn.Module   ,     _lowerCamelCase   ,     _lowerCamelCase     ):
				snake_case_      =		32
				snake_case_      =		4
				snake_case_      =		4
				snake_case_      =		(
				    "CrossAttnDownBlock2D",
				    "CrossAttnDownBlock2D",
				    "CrossAttnDownBlock2D",
				    "DownBlock2D",
				)
				snake_case_      =		("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
				snake_case_      =		False
				snake_case_      =		(320, 640, 1_280, 1_280)
				snake_case_      =		2
				snake_case_      =		8
				snake_case_      =		None
				snake_case_      =		1_280
				snake_case_      =		0.0
				snake_case_      =		False
				snake_case_      =		jnp.floataa
				snake_case_      =		True
				snake_case_      =		0
				snake_case_      =		False


				def   A_ (		self    :					Optional[int]       ,				lowercase_    :					jax.random.KeyArray					):
									# init input tensors
									snake_case_									=				(1, self.in_channels, self.sample_size, self.sample_size)
									snake_case_									=				jnp.zeros(lowercase_       ,				dtype=jnp.floataa					)
									snake_case_									=				jnp.ones((1,)       ,				dtype=jnp.intaa					)
									snake_case_									=				jnp.zeros((1, 1, self.cross_attention_dim)       ,				dtype=jnp.floataa					)

									snake_case_			,snake_case_									=				jax.random.split(lowercase_					)
									snake_case_									=				{'''params''': params_rng, '''dropout''': dropout_rng}

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


				def   A_ (		self    :					List[str]					):
									snake_case_									=				self.block_out_channels
									snake_case_									=				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.
									snake_case_									=				self.num_attention_heads or self.attention_head_dim

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

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

									snake_case_									=				self.only_cross_attention
									if isinstance(lowercase_       ,				lowercase_					):
														snake_case_									=				(only_cross_attention,) * len(self.down_block_types					)

									if isinstance(lowercase_       ,				lowercase_					):
														snake_case_									=				(num_attention_heads,) * len(self.down_block_types					)

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

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

														down_blocks.append(lowercase_					)
									snake_case_									=				down_blocks

									# mid
									snake_case_									=				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
									snake_case_									=				[]
									snake_case_									=				list(reversed(lowercase_					)					)
									snake_case_									=				list(reversed(lowercase_					)					)
									snake_case_									=				list(reversed(lowercase_					)					)
									snake_case_									=				reversed_block_out_channels[0]
									for i, up_block_type in enumerate(self.up_block_types					):
														snake_case_									=				output_channel
														snake_case_									=				reversed_block_out_channels[i]
														snake_case_									=				reversed_block_out_channels[min(i + 1       ,				len(lowercase_					) - 1					)]

														snake_case_									=				i == len(lowercase_					) - 1

														if up_block_type == "CrossAttnUpBlock2D":
																			snake_case_									=				FlaxCrossAttnUpBlockaD(
																			    in_channels=lowercase_       ,				out_channels=lowercase_       ,				prev_output_channel=lowercase_       ,				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:
																			snake_case_									=				FlaxUpBlockaD(
																			    in_channels=lowercase_       ,				out_channels=lowercase_       ,				prev_output_channel=lowercase_       ,				num_layers=self.layers_per_block + 1       ,				add_upsample=not is_final_block       ,				dropout=self.dropout       ,				dtype=self.dtype       ,				)

														up_blocks.append(lowercase_					)
														snake_case_									=				output_channel
									snake_case_									=				up_blocks

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


				def __call__(		self    :					Union[str, Any]       ,				lowercase_    :					Union[str, Any]       ,				lowercase_    :					int       ,				lowercase_    :					Any       ,				lowercase_    :					int=None       ,				lowercase_    :					Any=None       ,				lowercase_    :					bool = True       ,				lowercase_    :					bool = False       ,				):
									# 1. time
									if not isinstance(lowercase_       ,				jnp.ndarray					):
														snake_case_									=				jnp.array([timesteps]       ,				dtype=jnp.intaa					)
									elif isinstance(lowercase_       ,				jnp.ndarray					) and len(timesteps.shape					) == 0:
														snake_case_									=				timesteps.astype(dtype=jnp.floataa					)
														snake_case_									=				jnp.expand_dims(lowercase_       ,				0					)

									snake_case_									=				self.time_proj(lowercase_					)
									snake_case_									=				self.time_embedding(lowercase_					)

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

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

									if down_block_additional_residuals is not None:
														snake_case_									=				()

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

														snake_case_									=				new_down_block_res_samples

									# 4. mid
									snake_case_									=				self.mid_block(lowercase_       ,				lowercase_       ,				lowercase_       ,				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:
														snake_case_									=				down_block_res_samples[-(self.layers_per_block + 1) :]
														snake_case_									=				down_block_res_samples[: -(self.layers_per_block + 1)]
														if isinstance(lowercase_       ,				lowercase_					):
																			snake_case_									=				up_block(
																			    lowercase_       ,				temb=lowercase_       ,				encoder_hidden_states=lowercase_       ,				res_hidden_states_tuple=lowercase_       ,				deterministic=not train       ,				)
														else:
																			snake_case_									=				up_block(lowercase_       ,				temb=lowercase_       ,				res_hidden_states_tuple=lowercase_       ,				deterministic=not train					)

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

									if not return_dict:
														return (sample,)

									return FlaxUNetaDConditionOutput(sample=lowercase_					)

