
"""simple docstring"""






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

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


_lowercase							 =							logging.get_logger(__name__)

_lowercase							 =							{
    '''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json''',
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}

class 				__a    (   __a					):



							'''simple docstring'''







							_lowerCamelCase				: int					      =      """blenderbot"""
							_lowerCamelCase				: Any					      =      ["""past_key_values"""]
							_lowerCamelCase				: Tuple					      =      {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}
							def __init__(    self     ,						_lowerCamelCase=8_008     ,						_lowerCamelCase=128     ,						_lowerCamelCase=2     ,						_lowerCamelCase=10_240     ,						_lowerCamelCase=32     ,						_lowerCamelCase=24     ,						_lowerCamelCase=10_240     ,						_lowerCamelCase=32     ,						_lowerCamelCase=0.0     ,						_lowerCamelCase=0.0     ,						_lowerCamelCase=True     ,						_lowerCamelCase=True     ,						_lowerCamelCase="gelu"     ,						_lowerCamelCase=2_560     ,						_lowerCamelCase=0.1     ,						_lowerCamelCase=0.0     ,						_lowerCamelCase=0.0     ,						_lowerCamelCase=0.02     ,						_lowerCamelCase=1     ,						_lowerCamelCase=False     ,						_lowerCamelCase=0     ,						_lowerCamelCase=1     ,						_lowerCamelCase=2     ,						_lowerCamelCase=3     ,						_lowerCamelCase=2     ,						**_lowerCamelCase     ,						) ->       Dict:




										'''simple docstring'''
										__lowercase						      =					vocab_size
										__lowercase						      =					max_position_embeddings
										__lowercase						      =					d_model
										__lowercase						      =					encoder_ffn_dim
										__lowercase						      =					encoder_layers
										__lowercase						      =					encoder_attention_heads
										__lowercase						      =					decoder_ffn_dim
										__lowercase						      =					decoder_layers
										__lowercase						      =					decoder_attention_heads
										__lowercase						      =					dropout
										__lowercase						      =					attention_dropout
										__lowercase						      =					activation_dropout
										__lowercase						      =					activation_function
										__lowercase						      =					init_std
										__lowercase						      =					encoder_layerdrop
										__lowercase						      =					decoder_layerdrop
										__lowercase						      =					use_cache
										__lowercase						      =					encoder_layers
										__lowercase						      =					scale_embedding  # scale factor will be sqrt(d_model) if True

										super().__init__(
										    pad_token_id=_lowerCamelCase     ,						bos_token_id=_lowerCamelCase     ,						eos_token_id=_lowerCamelCase     ,						is_encoder_decoder=_lowerCamelCase     ,						decoder_start_token_id=_lowerCamelCase     ,						encoder_no_repeat_ngram_size=_lowerCamelCase     ,						forced_eos_token_id=_lowerCamelCase     ,						**_lowerCamelCase     ,						)





class 				__a    (   __a					):



							'''simple docstring'''







							@property
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Mapping[str, Mapping[int, str]]:




										'''simple docstring'''
										if self.task in ["default", "seq2seq-lm"]:
													__lowercase						      =					OrderedDict(
													    [
													        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
													        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
													    ]					)
													if self.use_past:
																__lowercase						      =					{0: "batch"}
																__lowercase						      =					{0: "batch", 1: "past_decoder_sequence + sequence"}
													else:
																__lowercase						      =					{0: "batch", 1: "decoder_sequence"}
																__lowercase						      =					{0: "batch", 1: "decoder_sequence"}
													if self.use_past:
																self.fill_with_past_key_values_(_lowerCamelCase     ,						direction="inputs"					)
										elif self.task == "causal-lm":
													__lowercase						      =					OrderedDict(
													    [
													        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
													        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
													    ]					)
													if self.use_past:
																__lowercase      ,				__lowercase						      =					self.num_layers
																for i in range(_lowerCamelCase					):
																			__lowercase						      =					{0: "batch", 2: "past_sequence + sequence"}
																			__lowercase						      =					{0: "batch", 2: "past_sequence + sequence"}
										else:
													__lowercase						      =					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      SCREAMING_SNAKE_CASE	(    self					) ->       Mapping[str, Mapping[int, str]]:




										'''simple docstring'''
										if self.task in ["default", "seq2seq-lm"]:
													__lowercase						      =					super().outputs
										else:
													__lowercase						      =					super(_lowerCamelCase     ,						self					).outputs
													if self.use_past:
																__lowercase      ,				__lowercase						      =					self.num_layers
																for i in range(_lowerCamelCase					):
																			__lowercase						      =					{0: "batch", 2: "past_sequence + sequence"}
																			__lowercase						      =					{0: "batch", 2: "past_sequence + sequence"}
										return common_outputs
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = False     ,						_lowerCamelCase = None     ,						) ->       Mapping[str, Any]:




										'''simple docstring'''
										__lowercase						      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    _lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					)
										# Generate decoder inputs
										__lowercase						      =					seq_length if not self.use_past else 1
										__lowercase						      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    _lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					)
										__lowercase						      =					{f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
										__lowercase						      =					dict(**_lowerCamelCase     ,						**_lowerCamelCase					)

										if self.use_past:
													if not is_torch_available():
																raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."					)
													else:
																import torch
													__lowercase      ,				__lowercase						      =					common_inputs["input_ids"].shape
													__lowercase						      =					common_inputs["decoder_input_ids"].shape[1]
													__lowercase      ,				__lowercase						      =					self.num_attention_heads
													__lowercase						      =					(
													    batch,
													    num_encoder_attention_heads,
													    encoder_seq_length,
													    self._config.hidden_size // num_encoder_attention_heads,
													)
													__lowercase						      =					decoder_seq_length
													__lowercase						      =					(
													    batch,
													    num_decoder_attention_heads,
													    decoder_past_length,
													    self._config.hidden_size // num_decoder_attention_heads,
													)
													__lowercase						      =					torch.cat(
													    [common_inputs["decoder_attention_mask"], torch.ones(_lowerCamelCase     ,						_lowerCamelCase					)]     ,						dim=1					)
													__lowercase						      =					[]
													__lowercase      ,				__lowercase						      =					self.num_layers

													for _ in range(_lowerCamelCase					):
																common_inputs["past_key_values"].append(
																    (
																        torch.zeros(_lowerCamelCase					),
																        torch.zeros(_lowerCamelCase					),
																        torch.zeros(_lowerCamelCase					),
																        torch.zeros(_lowerCamelCase					),
																    )					)
										return common_inputs
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = False     ,						_lowerCamelCase = None     ,						) ->       Mapping[str, Any]:




										'''simple docstring'''
										__lowercase						      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    _lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					)

										if self.use_past:
													if not is_torch_available():
																raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."					)
													else:
																import torch
													__lowercase      ,				__lowercase						      =					common_inputs["input_ids"].shape
													__lowercase						      =					seqlen
													__lowercase      ,				__lowercase						      =					self.num_layers
													__lowercase      ,				__lowercase						      =					self.num_attention_heads
													__lowercase						      =					(
													    batch,
													    num_encoder_attention_heads,
													    past_key_values_length,
													    self._config.hidden_size // num_encoder_attention_heads,
													)
													__lowercase						      =					common_inputs["attention_mask"].dtype
													__lowercase						      =					torch.cat(
													    [common_inputs["attention_mask"], torch.ones(_lowerCamelCase     ,						_lowerCamelCase     ,						dtype=_lowerCamelCase					)]     ,						dim=1					)
													__lowercase						      =					[
													    (torch.zeros(_lowerCamelCase					), torch.zeros(_lowerCamelCase					)) for _ in range(_lowerCamelCase					)
													]
										return common_inputs
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = False     ,						_lowerCamelCase = None     ,						) ->       Mapping[str, Any]:




										'''simple docstring'''
										# 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
										__lowercase						      =					compute_effective_axis_dimension(
										    _lowerCamelCase     ,						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
										__lowercase						      =					tokenizer.num_special_tokens_to_add(_lowerCamelCase					)
										__lowercase						      =					compute_effective_axis_dimension(
										    _lowerCamelCase     ,						fixed_dimension=OnnxConfig.default_fixed_sequence     ,						num_token_to_add=_lowerCamelCase					)

										# Generate dummy inputs according to compute batch and sequence
										__lowercase						      =					[" ".join([tokenizer.unk_token]					) * seq_length] * batch_size
										__lowercase						      =					dict(tokenizer(_lowerCamelCase     ,						return_tensors=_lowerCamelCase					)					)
										return common_inputs
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = -1     ,						_lowerCamelCase = False     ,						_lowerCamelCase = None     ,						) ->       Mapping[str, Any]:




										'''simple docstring'''
										if self.task in ["default", "seq2seq-lm"]:
													__lowercase						      =					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
													    _lowerCamelCase     ,						batch_size=_lowerCamelCase     ,						seq_length=_lowerCamelCase     ,						is_pair=_lowerCamelCase     ,						framework=_lowerCamelCase					)

										elif self.task == "causal-lm":
													__lowercase						      =					self._generate_dummy_inputs_for_causal_lm(
													    _lowerCamelCase     ,						batch_size=_lowerCamelCase     ,						seq_length=_lowerCamelCase     ,						is_pair=_lowerCamelCase     ,						framework=_lowerCamelCase					)
										else:
													__lowercase						      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
													    _lowerCamelCase     ,						batch_size=_lowerCamelCase     ,						seq_length=_lowerCamelCase     ,						is_pair=_lowerCamelCase     ,						framework=_lowerCamelCase					)

										return common_inputs
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Optional[int]:




										'''simple docstring'''
										if self.task in ["default", "seq2seq-lm"]:
													__lowercase						      =					super()._flatten_past_key_values_(_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					)
										else:
													__lowercase						      =					super(_lowerCamelCase     ,						self					)._flatten_past_key_values_(
													    _lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					)





							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Dict:




										'''simple docstring'''
										if direction not in ["inputs", "outputs"]:
													raise ValueError(f'''direction must either be "inputs" or "outputs", but {direction} was given'''					)

										__lowercase						      =					"past_key_values" if direction == "inputs" else "present"
										__lowercase      ,				__lowercase						      =					self.num_layers

										__lowercase						      =					"past_encoder_sequence"
										__lowercase						      =					"past_decoder_sequence" if direction == "inputs" else "past_decoder_sequence + sequence"

										for i in range(_lowerCamelCase					):
													__lowercase						      =					{0: "batch", 2: decoder_sequence}
													__lowercase						      =					{0: "batch", 2: decoder_sequence}
													__lowercase						      =					{0: "batch", 2: encoder_sequence}
													__lowercase						      =					{0: "batch", 2: encoder_sequence}







"""simple docstring"""






import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
					from .testing_utils import (
					    floats_tensor,
					    load_hf_numpy,
					    load_image,
					    load_numpy,
					    load_pt,
					    nightly,
					    parse_flag_from_env,
					    print_tensor_test,
					    require_torch_a,
					    require_torch_gpu,
					    skip_mps,
					    slow,
					    torch_all_close,
					    torch_device,
					)
					from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


_lowercase							 =							get_logger(__name__)



def     lowerCAmelCase__ (		__magic_name__			)	->Optional[int]:
			if version.parse(__magic_name__			) < version.parse(__magic_name__			):
						if "dev" in min_version:
									__lowercase						      =					(
									    "This example requires a source install from HuggingFace diffusers (see "
									    "`https://huggingface.co/docs/diffusers/installation#install-from-source`),"
									)
						else:
									__lowercase						      =					F'''This example requires a minimum version of {min_version},'''
						error_message += F''' but the version found is {__version__}.\n'''
						raise ImportError(__magic_name__			)





