

'''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-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json",
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}







class lowerCamelCase   (    __lowerCAmelCase				):
				snake_case_							     = '''blenderbot'''
				snake_case_							     = ['''past_key_values''']
				snake_case_							     = {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}

				def __init__(       self,						lowercase_=8008,						lowercase_=128,						lowercase_=2,						lowercase_=10240,						lowercase_=32,						lowercase_=24,						lowercase_=10240,						lowercase_=32,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=True,						lowercase_=True,						lowercase_="gelu",						lowercase_=2560,						lowercase_=0.1,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=0.02,						lowercase_=1,						lowercase_=False,						lowercase_=0,						lowercase_=1,						lowercase_=2,						lowercase_=3,						lowercase_=2,						**lowercase_,						)    ->							Any:
					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=lowercase_,						bos_token_id=lowercase_,						eos_token_id=lowercase_,						is_encoder_decoder=lowercase_,						decoder_start_token_id=lowercase_,						encoder_no_repeat_ngram_size=lowercase_,						forced_eos_token_id=lowercase_,						**lowercase_,						)







class lowerCamelCase   (    __lowerCAmelCase				):

				@property
				def 					_lowerCamelCase    (       self )    ->							Mapping[str, Mapping[int, str]]:
					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_(lowercase_,						direction='inputs' )
					elif self.task == "causal-lm":
						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(lowercase_ ):
								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 )    ->							Mapping[str, Mapping[int, str]]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					super().outputs
					else:
						snake_case							=					super(lowercase_,						self ).outputs
						if self.use_past:
							snake_case			,			snake_case							=					self.num_layers
							for i in range(lowercase_ ):
								snake_case							=					{0: 'batch', 2: 'past_sequence + sequence'}
								snake_case							=					{0: 'batch', 2: 'past_sequence + sequence'}
					return common_outputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = None,						)    ->							Mapping[str, Any]:
					snake_case							=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )
					# 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(
					    lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )
					snake_case							=					{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
					snake_case							=					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
						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
						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(lowercase_,						lowercase_ )],						dim=1 )
						snake_case							=					[]
						snake_case			,			snake_case							=					self.num_layers

						for _ in range(lowercase_ ):
							common_inputs["past_key_values"].append(
							    (
							        torch.zeros(lowercase_ ),
							        torch.zeros(lowercase_ ),
							        torch.zeros(lowercase_ ),
							        torch.zeros(lowercase_ ),
							    ) )
					return common_inputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = None,						)    ->							Mapping[str, Any]:
					snake_case							=					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
						snake_case			,			snake_case							=					common_inputs['input_ids'].shape
						snake_case							=					seqlen
						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(lowercase_,						lowercase_,						dtype=lowercase_ )],						dim=1 )
						snake_case							=					[
						    (torch.zeros(lowercase_ ), torch.zeros(lowercase_ )) for _ in range(lowercase_ )
						]
					return common_inputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = 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(
					    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
					snake_case							=					tokenizer.num_special_tokens_to_add(lowercase_ )
					snake_case							=					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
					snake_case							=					[' '.join([tokenizer.unk_token] ) * seq_length] * batch_size
					snake_case							=					dict(tokenizer(lowercase_,						return_tensors=lowercase_ ) )
					return common_inputs

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ = -1,						lowercase_ = -1,						lowercase_ = False,						lowercase_ = None,						)    ->							Mapping[str, Any]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					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":
						snake_case							=					self._generate_dummy_inputs_for_causal_lm(
						    lowercase_,						batch_size=lowercase_,						seq_length=lowercase_,						is_pair=lowercase_,						framework=lowercase_ )
					else:
						snake_case							=					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 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )    ->							List[str]:
					if self.task in ["default", "seq2seq-lm"]:
						snake_case							=					super()._flatten_past_key_values_(lowercase_,						lowercase_,						lowercase_,						lowercase_ )
					else:
						snake_case							=					super(lowercase_,						self )._flatten_past_key_values_(
						    lowercase_,						lowercase_,						lowercase_,						lowercase_ )






				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_ )    ->							List[str]:
					if direction not in ["inputs", "outputs"]:
						raise ValueError(F'''direction must either be "inputs" or "outputs", but {direction} was given''' )

					snake_case							=					'past_key_values' if direction == 'inputs' else 'present'
					snake_case			,			snake_case							=					self.num_layers

					snake_case							=					'past_encoder_sequence'
					snake_case							=					'past_decoder_sequence' if direction == 'inputs' else 'past_decoder_sequence + sequence'

					for i in range(lowercase_ ):
						snake_case							=					{0: 'batch', 2: decoder_sequence}
						snake_case							=					{0: 'batch', 2: decoder_sequence}
						snake_case							=					{0: 'batch', 2: encoder_sequence}
						snake_case							=					{0: 'batch', 2: encoder_sequence}












# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from pathlib import Path

from .config_args import default_config_file, load_config_from_file
from .config_utils import SubcommandHelpFormatter


__lowercase				    =      """Update an existing config file with the latest defaults while maintaining the old configuration."""


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Optional[Any]):



  '''simple docstring'''






  __lowerCAmelCase								=					args.config_file
  if config_file is None and Path(__lowercase).exists():
    __lowerCAmelCase								=					default_config_file
  elif not Path(__lowercase).exists():
    raise ValueError(F'''The passed config file located at {config_file} doesn\'t exist.''')
  __lowerCAmelCase								=					load_config_from_file(__lowercase)

  if config_file.endswith('''.json'''):
    config.to_json_file(__lowercase)
  else:
    config.to_yaml_file(__lowercase)
  return config_file


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Tuple  ,				__lowercase:		int):



  '''simple docstring'''






  __lowerCAmelCase								=					parser.add_parser('''update'''  ,				parents=__lowercase  ,				help=__lowercase  ,				formatter_class=__lowercase)
  parser.add_argument(
      '''--config_file'''  ,				default=__lowercase  ,				help=(
          '''The path to the config file to update. Will default to a file named default_config.yaml in the cache '''
          '''location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '''
          '''such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '''
          '''with \'huggingface\'.'''
      )  ,				)

  parser.set_defaults(func=__lowercase)
  return parser




def        __SCREAMING_SNAKE_CASE	(				__lowercase:		Any):



  '''simple docstring'''






  __lowerCAmelCase								=					update_config(__lowercase)
  print(F'''Sucessfully updated the configuration file at {config_file}.''')
