'''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_small-90M''': '''https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json''',
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}






class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[str]						=			'''blenderbot-small'''
			UpperCAmelCase_     :	Any						=			['''past_key_values''']
			UpperCAmelCase_     :	Dict						=			{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}



			def __init__(  self			,       __lowerCAmelCase=50265			,       __lowerCAmelCase=512			,       __lowerCAmelCase=8			,       __lowerCAmelCase=2048			,       __lowerCAmelCase=16			,       __lowerCAmelCase=8			,       __lowerCAmelCase=2048			,       __lowerCAmelCase=16			,       __lowerCAmelCase=0.0			,       __lowerCAmelCase=0.0			,       __lowerCAmelCase=True			,       __lowerCAmelCase=True			,       __lowerCAmelCase="gelu"			,       __lowerCAmelCase=512			,       __lowerCAmelCase=0.1			,       __lowerCAmelCase=0.0			,       __lowerCAmelCase=0.0			,       __lowerCAmelCase=0.02			,       __lowerCAmelCase=1			,       __lowerCAmelCase=False			,       __lowerCAmelCase=0			,       __lowerCAmelCase=1			,       __lowerCAmelCase=2			,       __lowerCAmelCase=2			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    vocab_size
					lowerCAmelCase     =    max_position_embeddings
					lowerCAmelCase     =    d_model
					lowerCAmelCase     =    encoder_ffn_dim
					lowerCAmelCase     =    encoder_layers
					lowerCAmelCase     =    encoder_attention_heads
					lowerCAmelCase     =    decoder_ffn_dim
					lowerCAmelCase     =    decoder_layers
					lowerCAmelCase     =    decoder_attention_heads
					lowerCAmelCase     =    dropout
					lowerCAmelCase     =    attention_dropout
					lowerCAmelCase     =    activation_dropout
					lowerCAmelCase     =    activation_function
					lowerCAmelCase     =    init_std
					lowerCAmelCase     =    encoder_layerdrop
					lowerCAmelCase     =    decoder_layerdrop
					lowerCAmelCase     =    use_cache
					lowerCAmelCase     =    encoder_layers
					lowerCAmelCase     =    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			,       forced_eos_token_id=__lowerCAmelCase			,       **__lowerCAmelCase			,       )







class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			@property
			def 				a_			(  self):




					"""simple docstring"""


					if self.task in ["default", "seq2seq-lm"]:
							lowerCAmelCase     =    OrderedDict(
							    [
							        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
							        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
							    ])

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

							if self.use_past:
									self.fill_with_past_key_values_(__lowerCAmelCase			,       direction="""inputs""")
					elif self.task == "causal-lm":
							# TODO: figure this case out.
							lowerCAmelCase     =    OrderedDict(
							    [
							        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
							        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
							    ])
							if self.use_past:
									lowerCAmelCase   ,	lowerCAmelCase     =    self.num_layers
									for i in range(__lowerCAmelCase):
											lowerCAmelCase     =    {0: """batch""", 2: """past_sequence + sequence"""}
											lowerCAmelCase     =    {0: """batch""", 2: """past_sequence + sequence"""}
					else:
							lowerCAmelCase     =    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
			def 				a_			(  self):




					"""simple docstring"""


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



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase)

					# Generate decoder inputs
					lowerCAmelCase     =    seq_length if not self.use_past else 1
					lowerCAmelCase     =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase)
					lowerCAmelCase     =    {f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
					lowerCAmelCase     =    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
							lowerCAmelCase   ,	lowerCAmelCase     =    common_inputs["""input_ids"""].shape
							lowerCAmelCase     =    common_inputs["""decoder_input_ids"""].shape[1]
							lowerCAmelCase   ,	lowerCAmelCase     =    self.num_attention_heads
							lowerCAmelCase     =    (
							    batch,
							    num_encoder_attention_heads,
							    encoder_seq_length,
							    self._config.hidden_size // num_encoder_attention_heads,
							)
							lowerCAmelCase     =    decoder_seq_length + 3
							lowerCAmelCase     =    (
							    batch,
							    num_decoder_attention_heads,
							    decoder_past_length,
							    self._config.hidden_size // num_decoder_attention_heads,
							)

							lowerCAmelCase     =    torch.cat(
							    [common_inputs["""decoder_attention_mask"""], torch.ones(__lowerCAmelCase			,       __lowerCAmelCase)]			,       dim=1)

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

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



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    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
							lowerCAmelCase   ,	lowerCAmelCase     =    common_inputs["""input_ids"""].shape
							# Not using the same length for past_key_values
							lowerCAmelCase     =    seqlen + 2
							lowerCAmelCase   ,	lowerCAmelCase     =    self.num_layers
							lowerCAmelCase   ,	lowerCAmelCase     =    self.num_attention_heads
							lowerCAmelCase     =    (
							    batch,
							    num_encoder_attention_heads,
							    past_key_values_length,
							    self._config.hidden_size // num_encoder_attention_heads,
							)

							lowerCAmelCase     =    common_inputs["""attention_mask"""].dtype
							lowerCAmelCase     =    torch.cat(
							    [common_inputs["""attention_mask"""], torch.ones(__lowerCAmelCase			,       __lowerCAmelCase			,       dtype=__lowerCAmelCase)]			,       dim=1)
							lowerCAmelCase     =    [
							    (torch.zeros(__lowerCAmelCase), torch.zeros(__lowerCAmelCase)) for _ in range(__lowerCAmelCase)
							]
					return common_inputs



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    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
					lowerCAmelCase     =    tokenizer.num_special_tokens_to_add(__lowerCAmelCase)
					lowerCAmelCase     =    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
					lowerCAmelCase     =    [""" """.join([tokenizer.unk_token]) * seq_length] * batch_size
					lowerCAmelCase     =    dict(tokenizer(__lowerCAmelCase			,       return_tensors=__lowerCAmelCase))
					return common_inputs



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = -1			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       ):




					"""simple docstring"""


					if self.task in ["default", "seq2seq-lm"]:
							lowerCAmelCase     =    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":
							lowerCAmelCase     =    self._generate_dummy_inputs_for_causal_lm(
							    __lowerCAmelCase			,       batch_size=__lowerCAmelCase			,       seq_length=__lowerCAmelCase			,       is_pair=__lowerCAmelCase			,       framework=__lowerCAmelCase)
					else:
							lowerCAmelCase     =    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 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


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





'''simple docstring'''




from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
						import PIL


__lowercase        =    logging.get_logger(__name__)






class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[Any]						=			['''pixel_values''']



			def __init__(  self			,       __lowerCAmelCase = True			,       __lowerCAmelCase = None			,       __lowerCAmelCase = PILImageResampling.BICUBIC			,       __lowerCAmelCase = True			,       __lowerCAmelCase = 1 / 255			,       __lowerCAmelCase = True			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = True			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					super().__init__(**__lowerCAmelCase)
					lowerCAmelCase     =    size if size is not None else {"""height""": 384, """width""": 384}
					lowerCAmelCase     =    get_size_dict(__lowerCAmelCase			,       default_to_square=__lowerCAmelCase)

					lowerCAmelCase     =    do_resize
					lowerCAmelCase     =    size
					lowerCAmelCase     =    resample
					lowerCAmelCase     =    do_rescale
					lowerCAmelCase     =    rescale_factor
					lowerCAmelCase     =    do_normalize
					lowerCAmelCase     =    image_mean if image_mean is not None else OPENAI_CLIP_MEAN
					lowerCAmelCase     =    image_std if image_std is not None else OPENAI_CLIP_STD
					lowerCAmelCase     =    do_convert_rgb



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = PILImageResampling.BICUBIC			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    get_size_dict(__lowerCAmelCase			,       default_to_square=__lowerCAmelCase)
					if "height" not in size or "width" not in size:
							raise ValueError(f"The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}")
					lowerCAmelCase     =    (size["""height"""], size["""width"""])
					return resize(__lowerCAmelCase			,       size=__lowerCAmelCase			,       resample=__lowerCAmelCase			,       data_format=__lowerCAmelCase			,       **__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					return rescale(__lowerCAmelCase			,       scale=__lowerCAmelCase			,       data_format=__lowerCAmelCase			,       **__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					return normalize(__lowerCAmelCase			,       mean=__lowerCAmelCase			,       std=__lowerCAmelCase			,       data_format=__lowerCAmelCase			,       **__lowerCAmelCase)







			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = ChannelDimension.FIRST			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    do_resize if do_resize is not None else self.do_resize
					lowerCAmelCase     =    resample if resample is not None else self.resample
					lowerCAmelCase     =    do_rescale if do_rescale is not None else self.do_rescale
					lowerCAmelCase     =    rescale_factor if rescale_factor is not None else self.rescale_factor
					lowerCAmelCase     =    do_normalize if do_normalize is not None else self.do_normalize
					lowerCAmelCase     =    image_mean if image_mean is not None else self.image_mean
					lowerCAmelCase     =    image_std if image_std is not None else self.image_std
					lowerCAmelCase     =    do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

					lowerCAmelCase     =    size if size is not None else self.size
					lowerCAmelCase     =    get_size_dict(__lowerCAmelCase			,       default_to_square=__lowerCAmelCase)

					lowerCAmelCase     =    make_list_of_images(__lowerCAmelCase)

					if not valid_images(__lowerCAmelCase):
							raise ValueError(
							    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
							    """torch.Tensor, tf.Tensor or jax.ndarray.""")

					if do_resize and size is None or resample is None:
							raise ValueError("""Size and resample must be specified if do_resize is True.""")

					if do_rescale and rescale_factor is None:
							raise ValueError("""Rescale factor must be specified if do_rescale is True.""")

					if do_normalize and (image_mean is None or image_std is None):
							raise ValueError("""Image mean and std must be specified if do_normalize is True.""")

					# PIL RGBA images are converted to RGB
					if do_convert_rgb:
							lowerCAmelCase     =    [convert_to_rgb(__lowerCAmelCase) for image in images]

					# All transformations expect numpy arrays.
					lowerCAmelCase     =    [to_numpy_array(__lowerCAmelCase) for image in images]

					if do_resize:
							lowerCAmelCase     =    [self.resize(image=__lowerCAmelCase			,       size=__lowerCAmelCase			,       resample=__lowerCAmelCase) for image in images]

					if do_rescale:
							lowerCAmelCase     =    [self.rescale(image=__lowerCAmelCase			,       scale=__lowerCAmelCase) for image in images]

					if do_normalize:
							lowerCAmelCase     =    [self.normalize(image=__lowerCAmelCase			,       mean=__lowerCAmelCase			,       std=__lowerCAmelCase) for image in images]

					lowerCAmelCase     =    [to_channel_dimension_format(__lowerCAmelCase			,       __lowerCAmelCase) for image in images]

					lowerCAmelCase     =    BatchFeature(data={"""pixel_values""": images}			,       tensor_type=__lowerCAmelCase)

					return encoded_outputs




