
'''simple docstring'''



import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
						from ... import PreTrainedTokenizerBase, TensorType

_lowercase          =						logging.get_logger(__name__)




class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						_lowercase						: Optional[int]										=  '''vision-encoder-decoder'''
						_lowercase						: Optional[Any]										=  True




						def __init__(   self       ,  **_lowercase ):

												"""simple docstring"""



												super().__init__(**_lowercase )
												if "encoder" not in kwargs or "decoder" not in kwargs:
																		raise ValueError(
																		    F'A configuraton of type {self.model_type} cannot be instantiated because '
																		    F'not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}' )

												_lowerCAmelCase    		=					kwargs.pop("""encoder""" )
												_lowerCAmelCase    		=					encoder_config.pop("""model_type""" )
												_lowerCAmelCase    		=					kwargs.pop("""decoder""" )
												_lowerCAmelCase    		=					decoder_config.pop("""model_type""" )

												_lowerCAmelCase    		=					AutoConfig.for_model(_lowercase       ,  **_lowercase )
												_lowerCAmelCase    		=					AutoConfig.for_model(_lowercase       ,  **_lowercase )
												_lowerCAmelCase    		=					True




						@classmethod
						def    _lowercase      (   cls       ,  _lowercase       ,  _lowercase       ,  **_lowercase ):

												"""simple docstring"""



												logger.info("""Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config""" )
												_lowerCAmelCase    		=					True
												_lowerCAmelCase    		=					True

												return cls(encoder=encoder_config.to_dict()       ,  decoder=decoder_config.to_dict()       ,  **_lowercase )




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					copy.deepcopy(self.__dict__ )
												_lowerCAmelCase    		=					self.encoder.to_dict()
												_lowerCAmelCase    		=					self.decoder.to_dict()
												_lowerCAmelCase    		=					self.__class__.model_type
												return output






class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						_lowercase						: Optional[Any]										=  version.parse('''1.11'''					)




						@property
						def    _lowercase      (   self ):

												"""simple docstring"""



												return OrderedDict(
												    [
												        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
												    ] )




						@property
						def    _lowercase      (   self ):

												"""simple docstring"""



												return 1e-4




						@property
						def    _lowercase      (   self ):

												"""simple docstring"""



												return OrderedDict({"""last_hidden_state""": {0: """batch""", 1: """encoder_sequence"""}} )






class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						@property
						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					OrderedDict()
												_lowerCAmelCase    		=					{0: """batch""", 1: """past_decoder_sequence + sequence"""}
												_lowerCAmelCase    		=					{0: """batch""", 1: """past_decoder_sequence + sequence"""}
												_lowerCAmelCase    		=					{0: """batch""", 1: """encoder_sequence"""}

												return common_inputs




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase = -1       ,  _lowercase = -1       ,  _lowercase = False       ,  _lowercase = None       ,  ):

												"""simple docstring"""



												import torch

												_lowerCAmelCase    		=					OrderedDict()

												_lowerCAmelCase    		=					super().generate_dummy_inputs(
												    _lowercase       ,  batch_size=_lowercase       ,  seq_length=_lowercase       ,  is_pair=_lowercase       ,  framework=_lowercase )

												_lowerCAmelCase		,       _lowerCAmelCase    		=					dummy_input["""input_ids"""].shape
												_lowerCAmelCase    		=					(batch, encoder_sequence, self._config.encoder_hidden_size)
												_lowerCAmelCase    		=					dummy_input.pop("""input_ids""" )
												_lowerCAmelCase    		=					dummy_input.pop("""attention_mask""" )
												_lowerCAmelCase    		=					torch.zeros(_lowercase )

												return common_inputs






class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						@property
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						def    _lowercase      (   self       ,  _lowercase ):

												"""simple docstring"""



												return VisionEncoderDecoderEncoderOnnxConfig(_lowercase )




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase       ,  _lowercase = "default" ):

												"""simple docstring"""



												_lowerCAmelCase    		=					encoder_config.hidden_size
												return VisionEncoderDecoderDecoderOnnxConfig(_lowercase       ,  _lowercase )


'''simple docstring'''



from manim import *




class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					Rectangle(height=0.5       ,  width=0.5 )
												_lowerCAmelCase    		=					Rectangle(height=0.46       ,  width=0.46 ).set_stroke(width=0 )

												_lowerCAmelCase    		=					[mem.copy() for i in range(6 )]
												_lowerCAmelCase    		=					[mem.copy() for i in range(6 )]
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					VGroup(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					Text("""CPU"""       ,  font_size=24 )
												_lowerCAmelCase    		=					Group(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0.5       ,  aligned_edge=_lowercase )
												cpu.move_to([-2.5, -0.5, 0] )
												self.add(_lowercase )

												_lowerCAmelCase    		=					[mem.copy() for i in range(1 )]
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					Text("""GPU"""       ,  font_size=24 )
												_lowerCAmelCase    		=					Group(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0.5       ,  aligned_edge=_lowercase )
												gpu.align_to(_lowercase       ,  _lowercase )
												gpu.set_x(gpu.get_x() - 1 )

												self.add(_lowercase )

												_lowerCAmelCase    		=					[mem.copy() for i in range(6 )]
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )

												_lowerCAmelCase    		=					Text("""Model"""       ,  font_size=24 )
												_lowerCAmelCase    		=					Group(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0.5       ,  aligned_edge=_lowercase )
												model.move_to([3, -1.0, 0] )

												self.play(
												    Create(_lowercase       ,  run_time=1 )       ,  Create(_lowercase       ,  run_time=1 )       ,  Create(_lowercase       ,  run_time=1 )       ,  )

												_lowerCAmelCase    		=					MarkupText(
												    F'First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.'       ,  font_size=24       ,  )

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

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

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

												step_a.move_to([2, 2, 0] )
												self.play(Write(_lowercase       ,  run_time=2.5 )       ,  Write(_lowercase )       ,  Write(_lowercase ) )

												self.add(_lowercase )

												_lowerCAmelCase    		=					[]
												_lowerCAmelCase    		=					[]
												_lowerCAmelCase    		=					[]
												for i, rect in enumerate(_lowercase ):
																		_lowerCAmelCase    		=					Rectangle(height=0.46       ,  width=0.46 ).set_stroke(width=0.0 ).set_fill(_lowercase       ,  opacity=0.7 )
																		cpu_target.move_to(_lowercase )
																		cpu_target.generate_target()
																		_lowerCAmelCase    		=					0.46 / 4
																		_lowerCAmelCase    		=					0.46 / 3

																		if i == 0:
																								cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT )       ,  buff=0.02       ,  direction=_lowercase )
																								cpu_target.target.set_x(cpu_target.target.get_x() + 0.1 )
																		elif i == 3:
																								cpu_target.target.next_to(cpu_targs[0].target       ,  direction=_lowercase       ,  buff=0.0 )
																		else:
																								cpu_target.target.next_to(cpu_targs[i - 1].target       ,  direction=_lowercase       ,  buff=0.0 )
																		cpu_targs.append(_lowercase )

																		first_animations.append(rect.animate(run_time=0.5 ).set_stroke(_lowercase ) )
																		second_animations.append(MoveToTarget(_lowercase       ,  run_time=1.5 ) )

												self.play(*_lowercase )
												self.play(*_lowercase )

												self.wait()
