






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


__magic_name__:					Union[str, Any]							=     logging.get_logger(__name__)

__magic_name__:					Union[str, Any]							=     {
    "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 	snake_case__ (							_lowerCAmelCase				):
	lowercase__						:					Optional[int]											=   '''blenderbot-small'''
	lowercase__						:					Dict											=   ['''past_key_values''']
	lowercase__						:					Union[str, Any]											=   {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
	def __init__(    self      ,       lowerCAmelCase__=5_02_65      ,       lowerCAmelCase__=5_12      ,       lowerCAmelCase__=8      ,       lowerCAmelCase__=20_48      ,       lowerCAmelCase__=16      ,       lowerCAmelCase__=8      ,       lowerCAmelCase__=20_48      ,       lowerCAmelCase__=16      ,       lowerCAmelCase__=0.0      ,       lowerCAmelCase__=0.0      ,       lowerCAmelCase__=True      ,       lowerCAmelCase__=True      ,       lowerCAmelCase__="gelu"      ,       lowerCAmelCase__=5_12      ,       lowerCAmelCase__=0.1      ,       lowerCAmelCase__=0.0      ,       lowerCAmelCase__=0.0      ,       lowerCAmelCase__=0.0_2      ,       lowerCAmelCase__=1      ,       lowerCAmelCase__=False      ,       lowerCAmelCase__=0      ,       lowerCAmelCase__=1      ,       lowerCAmelCase__=2      ,       lowerCAmelCase__=2      ,       **lowerCAmelCase__      ,       )							->				Dict:
							__magic_name__      :       List[Any]       						= vocab_size
							__magic_name__      :       str       						= max_position_embeddings
							__magic_name__      :       Dict       						= d_model
							__magic_name__      :       int       						= encoder_ffn_dim
							__magic_name__      :       Union[str, Any]       						= encoder_layers
							__magic_name__      :       str       						= encoder_attention_heads
							__magic_name__      :       Dict       						= decoder_ffn_dim
							__magic_name__      :       int       						= decoder_layers
							__magic_name__      :       Union[str, Any]       						= decoder_attention_heads
							__magic_name__      :       List[Any]       						= dropout
							__magic_name__      :       Union[str, Any]       						= attention_dropout
							__magic_name__      :       Optional[Any]       						= activation_dropout
							__magic_name__      :       Optional[Any]       						= activation_function
							__magic_name__      :       List[Any]       						= init_std
							__magic_name__      :       int       						= encoder_layerdrop
							__magic_name__      :       Union[str, Any]       						= decoder_layerdrop
							__magic_name__      :       Optional[int]       						= use_cache
							__magic_name__      :       Tuple       						= encoder_layers
							__magic_name__      :       List[Any]       						= 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 	snake_case__ (							_lowerCAmelCase				):
	@property
	def       __magic_name__    (    self			)							->				Optional[int]:
							if self.task in ["default", "seq2seq-lm"]:
													__magic_name__      :       str       						= OrderedDict(
													    [
													        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
													        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
													    ]			)

													if self.use_past:
																			__magic_name__      :       str       						= {0: 'batch'}
																			__magic_name__      :       Optional[Any]       						= {0: 'batch', 1: 'past_decoder_sequence + sequence'}
													else:
																			__magic_name__      :       int       						= {0: 'batch', 1: 'decoder_sequence'}
																			__magic_name__      :       Any       						= {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.
													__magic_name__      :       Union[str, Any]       						= OrderedDict(
													    [
													        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
													        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
													    ]			)
													if self.use_past:
																			__magic_name__      :       Tuple       						= self.num_layers
																			for i in range(lowerCAmelCase__			):
																									__magic_name__      :       List[str]       						= {0: 'batch', 2: 'past_sequence + sequence'}
																									__magic_name__      :       Optional[int]       						= {0: 'batch', 2: 'past_sequence + sequence'}
							else:
													__magic_name__      :       Any       						= 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       __magic_name__    (    self			)							->				Dict:
							if self.task in ["default", "seq2seq-lm"]:
													__magic_name__      :       List[str]       						= super().outputs
							else:
													__magic_name__      :       str       						= super(lowerCAmelCase__      ,       self			).outputs
													if self.use_past:
																			__magic_name__      :       List[Any]       						= self.num_layers
																			for i in range(lowerCAmelCase__			):
																									__magic_name__      :       List[str]       						= {0: 'batch', 2: 'past_sequence + sequence'}
																									__magic_name__      :       List[Any]       						= {0: 'batch', 2: 'past_sequence + sequence'}
							return common_outputs
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = False      ,       lowerCAmelCase__ = None      ,       )							->				Any:
							__magic_name__      :       str       						= self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)

							# Generate decoder inputs
							__magic_name__      :       int       						= seq_length if not self.use_past else 1
							__magic_name__      :       int       						= self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)
							__magic_name__      :       List[Any]       						= {F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
							__magic_name__      :       Union[str, Any]       						= 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
													__magic_name__      :       Optional[Any]       						= common_inputs['input_ids'].shape
													__magic_name__      :       str       						= common_inputs['decoder_input_ids'].shape[1]
													__magic_name__      :       Optional[int]       						= self.num_attention_heads
													__magic_name__      :       Optional[Any]       						= (
													    batch,
													    num_encoder_attention_heads,
													    encoder_seq_length,
													    self._config.hidden_size // num_encoder_attention_heads,
													)
													__magic_name__      :       Optional[int]       						= decoder_seq_length + 3
													__magic_name__      :       List[str]       						= (
													    batch,
													    num_decoder_attention_heads,
													    decoder_past_length,
													    self._config.hidden_size // num_decoder_attention_heads,
													)

													__magic_name__      :       str       						= torch.cat(
													    [common_inputs["""decoder_attention_mask"""], torch.ones(lowerCAmelCase__      ,       lowerCAmelCase__			)]      ,       dim=1			)

													__magic_name__      :       Optional[Any]       						= []
													# If the number of encoder and decoder layers are present in the model configuration, both are considered
													__magic_name__      :       int       						= self.num_layers
													__magic_name__      :       Any       						= min(lowerCAmelCase__      ,       lowerCAmelCase__			)
													__magic_name__      :       str       						= max(lowerCAmelCase__      ,       lowerCAmelCase__			) - min_num_layers
													__magic_name__      :       List[str]       						= '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.
													__magic_name__      :       Tuple       						= 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       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = False      ,       lowerCAmelCase__ = None      ,       )							->				Tuple:
							__magic_name__      :       Optional[int]       						= 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
													__magic_name__      :       str       						= common_inputs['input_ids'].shape
													# Not using the same length for past_key_values
													__magic_name__      :       int       						= seqlen + 2
													__magic_name__      :       Union[str, Any]       						= self.num_layers
													__magic_name__      :       List[Any]       						= self.num_attention_heads
													__magic_name__      :       List[str]       						= (
													    batch,
													    num_encoder_attention_heads,
													    past_key_values_length,
													    self._config.hidden_size // num_encoder_attention_heads,
													)

													__magic_name__      :       Tuple       						= common_inputs['attention_mask'].dtype
													__magic_name__      :       int       						= torch.cat(
													    [common_inputs["""attention_mask"""], torch.ones(lowerCAmelCase__      ,       lowerCAmelCase__      ,       dtype=lowerCAmelCase__			)]      ,       dim=1			)
													__magic_name__      :       List[str]       						= [
													    (torch.zeros(lowerCAmelCase__			), torch.zeros(lowerCAmelCase__			)) for _ in range(lowerCAmelCase__			)
													]
							return common_inputs
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = False      ,       lowerCAmelCase__ = None      ,       )							->				str:
							# 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
							__magic_name__      :       Union[str, Any]       						= 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
							__magic_name__      :       Tuple       						= tokenizer.num_special_tokens_to_add(lowerCAmelCase__			)
							__magic_name__      :       Any       						= 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
							__magic_name__      :       int       						= [' '.join([tokenizer.unk_token]			) * seq_length] * batch_size
							__magic_name__      :       Union[str, Any]       						= dict(tokenizer(lowerCAmelCase__      ,       return_tensors=lowerCAmelCase__			)			)
							return common_inputs
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = -1      ,       lowerCAmelCase__ = False      ,       lowerCAmelCase__ = None      ,       )							->				Any:
							if self.task in ["default", "seq2seq-lm"]:
													__magic_name__      :       Union[str, Any]       						= 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":
													__magic_name__      :       List[str]       						= self._generate_dummy_inputs_for_causal_lm(
													    lowerCAmelCase__      ,       batch_size=lowerCAmelCase__      ,       seq_length=lowerCAmelCase__      ,       is_pair=lowerCAmelCase__      ,       framework=lowerCAmelCase__			)
							else:
													__magic_name__      :       Any       						= 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       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)							->				List[Any]:
							if self.task in ["default", "seq2seq-lm"]:
													__magic_name__      :       Optional[int]       						= super()._flatten_past_key_values_(lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)
							else:
													__magic_name__      :       Dict       						= super(lowerCAmelCase__      ,       self			)._flatten_past_key_values_(
													    lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)








from manim import *





class 	snake_case__ (							_lowerCAmelCase				):
	def       __magic_name__    (    self			)							->				Dict:
							__magic_name__      :       int       						= Rectangle(height=0.5      ,       width=0.5			)
							__magic_name__      :       Optional[int]       						= Rectangle(height=0.2_5      ,       width=0.2_5			)
							__magic_name__      :       str       						= Rectangle(height=0.4_6      ,       width=0.4_6			).set_stroke(width=0			)

							__magic_name__      :       List[Any]       						= [mem.copy() for i in range(6			)]
							__magic_name__      :       int       						= [mem.copy() for i in range(6			)]
							__magic_name__      :       Tuple       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       List[str]       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       str       						= VGroup(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       Union[str, Any]       						= Text("""CPU"""      ,       font_size=24			)
							__magic_name__      :       Tuple       						= Group(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0.5      ,       aligned_edge=lowerCAmelCase__			)
							cpu.move_to([-2.5, -0.5, 0]			)
							self.add(lowerCAmelCase__			)

							__magic_name__      :       Any       						= [mem.copy() for i in range(4			)]
							__magic_name__      :       List[Any]       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       Tuple       						= Text("""GPU"""      ,       font_size=24			)
							__magic_name__      :       Tuple       						= Group(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0.5      ,       aligned_edge=lowerCAmelCase__			)
							gpu.move_to([-1, -1, 0]			)
							self.add(lowerCAmelCase__			)

							__magic_name__      :       Union[str, Any]       						= [mem.copy() for i in range(6			)]
							__magic_name__      :       Union[str, Any]       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)

							__magic_name__      :       str       						= Text("""Model"""      ,       font_size=24			)
							__magic_name__      :       Optional[int]       						= Group(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0.5      ,       aligned_edge=lowerCAmelCase__			)
							model.move_to([3, -1.0, 0]			)
							self.add(lowerCAmelCase__			)

							__magic_name__      :       str       						= []
							__magic_name__      :       Tuple       						= []
							__magic_name__      :       Union[str, Any]       						= []

							for i, rect in enumerate(lowerCAmelCase__			):
													rect.set_stroke(lowerCAmelCase__			)

													__magic_name__      :       Optional[Any]       						= Rectangle(height=0.4_6 / 4      ,       width=0.4_6 / 3			).set_stroke(width=0.0			).set_fill(lowerCAmelCase__      ,       opacity=0.7			)

													if i == 0:
																			cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT			)      ,       buff=0.0_2      ,       direction=lowerCAmelCase__			)
																			cpu_target.set_x(cpu_target.get_x() + 0.1			)
													elif i == 3:
																			cpu_target.next_to(model_cpu_arr[0]      ,       direction=lowerCAmelCase__      ,       buff=0.0			)
													else:
																			cpu_target.next_to(model_cpu_arr[i - 1]      ,       direction=lowerCAmelCase__      ,       buff=0.0			)
													self.add(lowerCAmelCase__			)
													model_cpu_arr.append(lowerCAmelCase__			)

							self.add(*lowerCAmelCase__      ,       *lowerCAmelCase__      ,       *lowerCAmelCase__			)

							__magic_name__      :       Optional[Any]       						= [mem.copy() for i in range(6			)]
							__magic_name__      :       Optional[Any]       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)

							__magic_name__      :       Any       						= Text("""Loaded Checkpoint"""      ,       font_size=24			)
							__magic_name__      :       Optional[int]       						= Group(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0.5      ,       aligned_edge=lowerCAmelCase__			)
							checkpoint.move_to([3, 0.5, 0]			)

							self.add(lowerCAmelCase__			)

							__magic_name__      :       Optional[int]       						= []
							__magic_name__      :       Tuple       						= []

							for i, rect in enumerate(lowerCAmelCase__			):
													__magic_name__      :       Dict       						= fill.copy().set_fill(lowerCAmelCase__      ,       opacity=0.7			)
													target.move_to(lowerCAmelCase__			)
													ckpt_arr.append(lowerCAmelCase__			)

													__magic_name__      :       int       						= target.copy()
													if i < 5:
																			cpu_target.move_to(cpu_left_col_base[i + 1]			)
													else:
																			cpu_target.move_to(cpu_right_col_base[i - 5]			)
													ckpt_cpu_arr.append(lowerCAmelCase__			)
							self.add(*lowerCAmelCase__      ,       *lowerCAmelCase__			)

							__magic_name__      :       Tuple       						= Square(side_length=2.2			)
							key.move_to([-5, 2, 0]			)

							__magic_name__      :       str       						= MarkupText(
							    F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'      ,       font_size=18      ,       )

							key_text.move_to([-5, 2.4, 0]			)

							self.add(lowerCAmelCase__      ,       lowerCAmelCase__			)

							__magic_name__      :       Any       						= MarkupText(
							    F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'      ,       font_size=18      ,       )

							blue_text.next_to(lowerCAmelCase__      ,       DOWN * 2.4      ,       aligned_edge=key_text.get_left()			)
							self.add(lowerCAmelCase__			)

							__magic_name__      :       Optional[Any]       						= MarkupText(
							    F'Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.'      ,       font_size=24      ,       )
							step_a.move_to([2, 2, 0]			)

							__magic_name__      :       int       						= [meta_mem.copy() for i in range(6			)]
							__magic_name__      :       Union[str, Any]       						= [meta_mem.copy() for i in range(6			)]
							__magic_name__      :       Any       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       str       						= VGroup(*lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       Tuple       						= VGroup(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0			)
							__magic_name__      :       int       						= Text("""Disk"""      ,       font_size=24			)
							__magic_name__      :       Union[str, Any]       						= Group(lowerCAmelCase__      ,       lowerCAmelCase__			).arrange(lowerCAmelCase__      ,       buff=0.5      ,       aligned_edge=lowerCAmelCase__			)
							disk.move_to([-4.0, -1.2_5, 0]			)
							self.play(Write(lowerCAmelCase__      ,       run_time=3			)      ,       Write(lowerCAmelCase__      ,       run_time=1			)      ,       Create(lowerCAmelCase__      ,       run_time=1			)			)

							__magic_name__      :       List[Any]       						= []
							for i, rect in enumerate(lowerCAmelCase__			):
													__magic_name__      :       Dict       						= rect.copy()
													target.generate_target()
													target.target.move_to(disk_left_col_base[i]			).scale(0.5			)
													animations.append(MoveToTarget(lowerCAmelCase__      ,       run_time=1.5			)			)
							self.play(*lowerCAmelCase__			)

							self.play(FadeOut(lowerCAmelCase__			)			)

							__magic_name__      :       str       						= MarkupText(F'Then, the checkpoint is removed from memory\nthrough garbage collection.'      ,       font_size=24			)
							step_a.move_to([2, 2, 0]			)

							self.play(Write(lowerCAmelCase__      ,       run_time=3			)			)

							self.play(
							    FadeOut(lowerCAmelCase__      ,       lowerCAmelCase__      ,       *lowerCAmelCase__      ,       *lowerCAmelCase__			)      ,       )

							self.wait()
