
'''simple docstring'''
from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available


@dataclass
# Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
class     _lowerCAmelCase					(					__snake_case   ):







							'''simple docstring'''

							lowerCAmelCase_      		=		42
							lowerCAmelCase_      		=		42


if is_transformers_available() and is_torch_available():
					from .modeling_roberta_series import RobertaSeriesModelWithTransformation
					from .pipeline_alt_diffusion import AltDiffusionPipeline
					from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline

'''simple docstring'''
from collections import OrderedDict
from typing import Any, Mapping, Optional

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


__lowerCAmelCase  							= logging.get_logger(__name__)

__lowerCAmelCase  							= {
    'facebook/m2m100_418M': 'https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json',
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}


class     _lowerCAmelCase					(					__snake_case   ):







							'''simple docstring'''

							lowerCAmelCase_      		=		"m2m_100"
							lowerCAmelCase_      		=		["past_key_values"]
							lowerCAmelCase_      		=		{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}

							def __init__(self						,						UpperCAmelCase=128112						,						UpperCAmelCase=1024						,						UpperCAmelCase=12						,						UpperCAmelCase=4096						,						UpperCAmelCase=16						,						UpperCAmelCase=12						,						UpperCAmelCase=4096						,						UpperCAmelCase=16						,						UpperCAmelCase=0.05						,						UpperCAmelCase=0.05						,						UpperCAmelCase=True						,						UpperCAmelCase=True						,						UpperCAmelCase="relu"						,						UpperCAmelCase=1024						,						UpperCAmelCase=0.1						,						UpperCAmelCase=0.1						,						UpperCAmelCase=0.0						,						UpperCAmelCase=0.02						,						UpperCAmelCase=2						,						UpperCAmelCase=True						,						UpperCAmelCase=1						,						UpperCAmelCase=0						,						UpperCAmelCase=2						,						**UpperCAmelCase						,						)  ->     int:
														_snake_case     =						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

														super().__init__(
														    pad_token_id=UpperCAmelCase						,						bos_token_id=UpperCAmelCase						,						eos_token_id=UpperCAmelCase						,						is_encoder_decoder=UpperCAmelCase						,						decoder_start_token_id=UpperCAmelCase						,						**UpperCAmelCase						,						)


class     _lowerCAmelCase					(					__snake_case   ):







							'''simple docstring'''

							@property
							def  lowercase							(self						)  ->     Mapping[str, Mapping[int, str]]:
														_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_(UpperCAmelCase						,						direction="""inputs"""						)
														return common_inputs

							def  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase = -1						,						UpperCAmelCase = -1						,						UpperCAmelCase = False						,						UpperCAmelCase = None						,						)  ->     Mapping[str, Any]:
														# 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(
														    UpperCAmelCase						,						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(UpperCAmelCase						)
														_snake_case     =						compute_effective_axis_dimension(
														    UpperCAmelCase						,						fixed_dimension=OnnxConfig.default_fixed_sequence						,						num_token_to_add=UpperCAmelCase						)

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

							def  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase = -1						,						UpperCAmelCase = -1						,						UpperCAmelCase = False						,						UpperCAmelCase = None						,						)  ->     Mapping[str, Any]:
														_snake_case     =						self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
														    UpperCAmelCase						,						UpperCAmelCase						,						UpperCAmelCase						,						UpperCAmelCase						,						UpperCAmelCase						)

														# Generate decoder inputs
														_snake_case     =						seq_length if not self.use_past else 1
														_snake_case     =						self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
														    UpperCAmelCase						,						UpperCAmelCase						,						UpperCAmelCase						,						UpperCAmelCase						,						UpperCAmelCase						)
														_snake_case     =						{f"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
														_snake_case     =						dict(**UpperCAmelCase						,						**UpperCAmelCase						)

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

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





							lowerCAmelCase_      		=		_generate_dummy_inputs_for_default_and_seqaseq_lm