

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


lowerCAmelCase__   		=      logging.get_logger(__name__)

lowerCAmelCase__   		=      {
    '''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      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




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






  def __init__( self  :	Optional[int]   ,lowercase__  :	List[str]=5_0_2_6_5   ,lowercase__  :	Optional[Any]=5_1_2   ,lowercase__  :	Optional[int]=8   ,lowercase__  :	List[Any]=2_0_4_8   ,lowercase__  :	List[str]=1_6   ,lowercase__  :	str=8   ,lowercase__  :	Any=2_0_4_8   ,lowercase__  :	Tuple=1_6   ,lowercase__  :	Tuple=0.0   ,lowercase__  :	List[str]=0.0   ,lowercase__  :	Any=True   ,lowercase__  :	str=True   ,lowercase__  :	int="gelu"   ,lowercase__  :	Tuple=5_1_2   ,lowercase__  :	List[Any]=0.1   ,lowercase__  :	Tuple=0.0   ,lowercase__  :	str=0.0   ,lowercase__  :	Any=0.0_2   ,lowercase__  :	Union[str, Any]=1   ,lowercase__  :	List[Any]=False   ,lowercase__  :	Optional[int]=0   ,lowercase__  :	Optional[int]=1   ,lowercase__  :	str=2   ,lowercase__  :	int=2   ,**lowercase__  :	List[str]   ,):
   __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=lowercase__   ,bos_token_id=lowercase__   ,eos_token_id=lowercase__   ,is_encoder_decoder=lowercase__   ,decoder_start_token_id=lowercase__   ,forced_eos_token_id=lowercase__   ,**lowercase__   ,)






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  @property
  def    SCREAMING_SNAKE_CASE ( self  :	Dict     ):
   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_(lowercase__   ,direction='''inputs'''     )
   elif self.task == "causal-lm":
    # TODO: figure this case out.
    __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(lowercase__     ):
      __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
  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]     ):
   if self.task in ["default", "seq2seq-lm"]:
    __lowercase				    =					super().outputs
   else:
    __lowercase				    =					super(lowercase__   ,self     ).outputs
    if self.use_past:
     __lowercase    ,      __lowercase				    =					self.num_layers
     for i in range(lowercase__     ):
      __lowercase				    =					{0: '''batch''', 2: '''past_sequence + sequence'''}
      __lowercase				    =					{0: '''batch''', 2: '''past_sequence + sequence'''}
   return common_outputs






  def    SCREAMING_SNAKE_CASE ( self  :	Dict   ,lowercase__  :	PreTrainedTokenizer   ,lowercase__  :	int = -1   ,lowercase__  :	int = -1   ,lowercase__  :	bool = False   ,lowercase__  :	Optional[TensorType] = None   ,):
   __lowercase				    =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
       lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )

   # Generate decoder inputs
   __lowercase				    =					seq_length if not self.use_past else 1
   __lowercase				    =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
       lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )
   __lowercase				    =					{F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
   __lowercase				    =					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
    __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 + 3
    __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(lowercase__   ,lowercase__     )]   ,dim=1     )

    __lowercase				    =					[]
    # If the number of encoder and decoder layers are present in the model configuration, both are considered
    __lowercase    ,      __lowercase				    =					self.num_layers
    __lowercase				    =					min(lowercase__   ,lowercase__     )
    __lowercase				    =					max(lowercase__   ,lowercase__     ) - min_num_layers
    __lowercase				    =					'''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.
    __lowercase				    =					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    SCREAMING_SNAKE_CASE ( self  :	Any   ,lowercase__  :	PreTrainedTokenizer   ,lowercase__  :	int = -1   ,lowercase__  :	int = -1   ,lowercase__  :	bool = False   ,lowercase__  :	Optional[TensorType] = None   ,):
   __lowercase				    =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
       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
    __lowercase    ,      __lowercase				    =					common_inputs['''input_ids'''].shape
    # Not using the same length for past_key_values
    __lowercase				    =					seqlen + 2
    __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(lowercase__   ,lowercase__   ,dtype=lowercase__     )]   ,dim=1     )
    __lowercase				    =					[
        (torch.zeros(lowercase__     ), torch.zeros(lowercase__     )) for _ in range(lowercase__     )
    ]
   return common_inputs






  def    SCREAMING_SNAKE_CASE ( 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
   __lowercase				    =					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
   __lowercase				    =					tokenizer.num_special_tokens_to_add(lowercase__     )
   __lowercase				    =					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
   __lowercase				    =					[''' '''.join([tokenizer.unk_token]     ) * seq_length] * batch_size
   __lowercase				    =					dict(tokenizer(lowercase__   ,return_tensors=lowercase__     )     )
   return common_inputs






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

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

   return common_inputs






  def    SCREAMING_SNAKE_CASE ( self  :	Tuple   ,lowercase__  :	List[Any]   ,lowercase__  :	Tuple   ,lowercase__  :	List[Any]   ,lowercase__  :	Optional[Any]     ):
   if self.task in ["default", "seq2seq-lm"]:
    __lowercase				    =					super()._flatten_past_key_values_(lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )
   else:
    __lowercase				    =					super(lowercase__   ,self     )._flatten_past_key_values_(
        lowercase__   ,lowercase__   ,lowercase__   ,lowercase__     )








'''simple docstring'''

import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding






class   UpperCAmelCase      (			UpperCamelCase__							):
 __lowercase  						=							["""image_processor""", """tokenizer"""]
 __lowercase  						=							"""CLIPImageProcessor"""
 __lowercase  						=							("""CLIPTokenizer""", """CLIPTokenizerFast""")
 def __init__(							self :List[Any]		,			lowercase_ :List[str]=None		,			lowercase_ :Any=None		,			**lowercase_ :Union[str, Any]				)->				Optional[Any]:
     A__							=     None
     if "feature_extractor" in kwargs:
         warnings.warn(
             "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
             " instead."		,			lowercase_		,			)
         A__							=     kwargs.pop("feature_extractor"				)

     A__							=     image_processor if image_processor is not None else feature_extractor
     if image_processor is None:
         raise ValueError("You need to specify an `image_processor`."				)
     if tokenizer is None:
         raise ValueError("You need to specify a `tokenizer`."				)

     super().__init__(lowercase_		,			lowercase_				)
 def __call__(							self :Optional[Any]		,			lowercase_ :Optional[int]=None		,			lowercase_ :Dict=None		,			lowercase_ :List[Any]=None		,			**lowercase_ :Optional[Any]				)->				Union[str, Any]:

     if text is None and images is None:
         raise ValueError("You have to specify either text or images. Both cannot be none."				)

     if text is not None:
         A__							=     self.tokenizer(lowercase_		,			return_tensors=lowercase_		,			**lowercase_				)

     if images is not None:
         A__							=     self.image_processor(lowercase_		,			return_tensors=lowercase_		,			**lowercase_				)

     if text is not None and images is not None:
         A__							=     image_features.pixel_values
         return encoding
     elif text is not None:
         return encoding
     else:
         return BatchEncoding(data=dict(**lowercase_				)		,			tensor_type=lowercase_				)
 def 	UpperCAmelCase_				(							self :int		,			*lowercase_ :Tuple		,			**lowercase_ :Any				)->				Dict:
     return self.tokenizer.batch_decode(*lowercase_		,			**lowercase_				)
 def 	UpperCAmelCase_				(							self :Any		,			*lowercase_ :Any		,			**lowercase_ :Any				)->				List[str]:
     return self.tokenizer.decode(*lowercase_		,			**lowercase_				)
 @property
 def 	UpperCAmelCase_				(							self :Union[str, Any]				)->				Optional[int]:
     A__							=     self.tokenizer.model_input_names
     A__							=     self.image_processor.model_input_names
     return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names				)				)
 @property
 def 	UpperCAmelCase_				(							self :List[Any]				)->				str:
     warnings.warn(
         "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."		,			lowercase_		,			)
     return self.image_processor_class



 @property
 def 	UpperCAmelCase_				(							self :List[str]				)->				List[Any]:
     warnings.warn(
         "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."		,			lowercase_		,			)
     return self.image_processor



