






'''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


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

lowercase					:							Any   =      {
    '''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 		__UpperCAmelCase   (      __a		):
							__lowercase   	= '''marian'''
							__lowercase   	= ['''past_key_values''']
							__lowercase   	= {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}


							def __init__( self					,     lowerCAmelCase_=5_81_01					,     lowerCAmelCase_=None					,     lowerCAmelCase_=10_24					,     lowerCAmelCase_=12					,     lowerCAmelCase_=40_96					,     lowerCAmelCase_=16					,     lowerCAmelCase_=12					,     lowerCAmelCase_=40_96					,     lowerCAmelCase_=16					,     lowerCAmelCase_=0.0					,     lowerCAmelCase_=0.0					,     lowerCAmelCase_=True					,     lowerCAmelCase_=True					,     lowerCAmelCase_="gelu"					,     lowerCAmelCase_=10_24					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=0.0					,     lowerCAmelCase_=0.0					,     lowerCAmelCase_=0.02					,     lowerCAmelCase_=5_81_00					,     lowerCAmelCase_=False					,     lowerCAmelCase_=5_81_00					,     lowerCAmelCase_=0					,     lowerCAmelCase_=0					,     lowerCAmelCase_=True					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								_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=snake_case__					,     eos_token_id=snake_case__					,     is_encoder_decoder=snake_case__					,     decoder_start_token_id=snake_case__					,     forced_eos_token_id=snake_case__					,     **snake_case__					,     )


class 		__UpperCAmelCase   (      __a		):


							@property
							# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								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_(snake_case__					,     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(snake_case__						):
											_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								if self.task in ["default", "seq2seq-lm"]:
									_snake_case     		=	super().outputs
								else:
									_snake_case     		=	super(snake_case__					,     self						).outputs
									if self.use_past:
										_snake_case		,				_snake_case     		=	self.num_layers
										for i in range(snake_case__						):
											_snake_case     		=	{0: 'batch', 2: 'past_sequence + sequence'}
											_snake_case     		=	{0: 'batch', 2: 'past_sequence + sequence'}
								return common_outputs


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = False					,     lowerCAmelCase_ = None					,     ):





								"""simple docstring"""






								_snake_case     		=	self._generate_dummy_inputs_for_encoder_and_decoder(
								    snake_case__					,     snake_case__					,     snake_case__					,     snake_case__					,     snake_case__						)

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

								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(snake_case__					,     snake_case__						)]					,     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(snake_case__					,     snake_case__						)
									_snake_case     		=	max(snake_case__					,     snake_case__						) - min_num_layers
									_snake_case     		=	'encoder' if num_encoder_layers > num_decoder_layers else 'decoder'

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


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = False					,     lowerCAmelCase_ = None					,     ):





								"""simple docstring"""






								_snake_case     		=	self._generate_dummy_inputs_for_encoder_and_decoder(
								    snake_case__					,     snake_case__					,     snake_case__					,     snake_case__					,     snake_case__						)

								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(snake_case__					,     snake_case__					,     dtype=snake_case__						)]					,     dim=1						)
									_snake_case     		=	[
									    (torch.zeros(snake_case__						), torch.zeros(snake_case__						)) for _ in range(snake_case__						)
									]
								return common_inputs


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = False					,     lowerCAmelCase_ = None					,     ):





								"""simple docstring"""






								_snake_case     		=	compute_effective_axis_dimension(
								    snake_case__					,     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(snake_case__						)
								_snake_case     		=	compute_effective_axis_dimension(
								    snake_case__					,     fixed_dimension=OnnxConfig.default_fixed_sequence					,     num_token_to_add=snake_case__						)

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


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = -1					,     lowerCAmelCase_ = False					,     lowerCAmelCase_ = None					,     ):





								"""simple docstring"""






								if self.task in ["default", "seq2seq-lm"]:
									_snake_case     		=	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
									    snake_case__					,     batch_size=snake_case__					,     seq_length=snake_case__					,     is_pair=snake_case__					,     framework=snake_case__						)

								else:
									_snake_case     		=	self._generate_dummy_inputs_for_causal_lm(
									    snake_case__					,     batch_size=snake_case__					,     seq_length=snake_case__					,     is_pair=snake_case__					,     framework=snake_case__						)

								return common_inputs


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								if self.task in ["default", "seq2seq-lm"]:
									_snake_case     		=	super()._flatten_past_key_values_(snake_case__					,     snake_case__					,     snake_case__					,     snake_case__						)
								else:
									_snake_case     		=	super(snake_case__					,     self						)._flatten_past_key_values_(
									    snake_case__					,     snake_case__					,     snake_case__					,     snake_case__						)




							@property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return 1E-4



'''simple docstring'''







from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
					if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.25.0")):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from ...utils.dummy_torch_and_transformers_objects import UnCLIPImageVariationPipeline, UnCLIPPipeline
else:
					from .pipeline_unclip import UnCLIPPipeline
					from .pipeline_unclip_image_variation import UnCLIPImageVariationPipeline
					from .text_proj import UnCLIPTextProjModel

