




'''simple docstring'''


import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_snake_case   :   Dict     							=	logging.get_logger(__name__)

_snake_case   :   int     							=	{
    'microsoft/git-base': 'https://huggingface.co/microsoft/git-base/resolve/main/config.json',
}

class     A					(	_a					):
							lowercase_           =       'git_vision_model'







							def __init__(						self :						Union[str, Any]							,    lowerCAmelCase_ :						Dict=7_68							,    lowerCAmelCase_ :						Tuple=30_72							,    lowerCAmelCase_ :						List[Any]=12							,    lowerCAmelCase_ :						Any=12							,    lowerCAmelCase_ :						Optional[int]=3							,    lowerCAmelCase_ :						Any=2_24							,    lowerCAmelCase_ :						Optional[Any]=16							,    lowerCAmelCase_ :						str="quick_gelu"							,    lowerCAmelCase_ :						Union[str, Any]=1e-5							,    lowerCAmelCase_ :						str=0.0							,    lowerCAmelCase_ :						Union[str, Any]=0.0_2							,    **lowerCAmelCase_ :						Dict							,    )    ->							List[str]:


														"""simple docstring"""


														super().__init__(**lowerCAmelCase_      )

														_a			  =       hidden_size
														_a			  =       intermediate_size
														_a			  =       num_hidden_layers
														_a			  =       num_attention_heads
														_a			  =       num_channels
														_a			  =       patch_size
														_a			  =       image_size
														_a			  =       initializer_range
														_a			  =       attention_dropout
														_a			  =       layer_norm_eps
														_a			  =       hidden_act







							@classmethod
							def      __lowerCAmelCase    (						cls :						Union[str, Any]							,    lowerCAmelCase_ :						Union[str, os.PathLike]							,    **lowerCAmelCase_ :						Any      )    ->							"PretrainedConfig":


														"""simple docstring"""


														cls._set_token_in_kwargs(lowerCAmelCase_      )

														_a  ,							_a			  =       cls.get_config_dict(lowerCAmelCase_							,    **lowerCAmelCase_      )

														# get the vision config dict if we are loading from GITConfig
														if config_dict.get('''model_type'''      ) == "git":
																					_a			  =       config_dict['''vision_config''']

														if "model_type" in config_dict and hasattr(cls							,    '''model_type'''      ) and config_dict["model_type"] != cls.model_type:
																					logger.warning(
																					    F'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
																					    F'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'      )

														return cls.from_dict(lowerCAmelCase_							,    **lowerCAmelCase_      )



class     A					(	_a					):
							lowercase_           =       'git'







							def __init__(						self :						List[str]							,    lowerCAmelCase_ :						Tuple=None							,    lowerCAmelCase_ :						Tuple=3_05_22							,    lowerCAmelCase_ :						Optional[Any]=7_68							,    lowerCAmelCase_ :						List[Any]=6							,    lowerCAmelCase_ :						Optional[Any]=12							,    lowerCAmelCase_ :						Any=30_72							,    lowerCAmelCase_ :						Optional[int]="gelu"							,    lowerCAmelCase_ :						str=0.1							,    lowerCAmelCase_ :						List[str]=0.1							,    lowerCAmelCase_ :						Any=10_24							,    lowerCAmelCase_ :						int=0.0_2							,    lowerCAmelCase_ :						Any=1e-12							,    lowerCAmelCase_ :						int=0							,    lowerCAmelCase_ :						Union[str, Any]="absolute"							,    lowerCAmelCase_ :						str=True							,    lowerCAmelCase_ :						str=False							,    lowerCAmelCase_ :						List[str]=1_01							,    lowerCAmelCase_ :						Optional[int]=1_02							,    lowerCAmelCase_ :						List[Any]=None							,    **lowerCAmelCase_ :						Dict							,    )    ->							List[str]:


														"""simple docstring"""


														super().__init__(bos_token_id=lowerCAmelCase_							,    eos_token_id=lowerCAmelCase_							,    pad_token_id=lowerCAmelCase_							,    **lowerCAmelCase_      )

														if vision_config is None:
																					_a			  =       {}
																					logger.info('''vision_config is None. initializing the GitVisionConfig with default values.'''      )

														_a			  =       GitVisionConfig(**lowerCAmelCase_      )
														_a			  =       vocab_size
														_a			  =       hidden_size
														_a			  =       num_hidden_layers
														_a			  =       num_attention_heads
														_a			  =       hidden_act
														_a			  =       intermediate_size
														_a			  =       hidden_dropout_prob
														_a			  =       attention_probs_dropout_prob
														_a			  =       max_position_embeddings
														_a			  =       initializer_range
														_a			  =       layer_norm_eps
														_a			  =       position_embedding_type
														_a			  =       use_cache
														_a			  =       tie_word_embeddings
														_a			  =       num_image_with_embedding

														_a			  =       bos_token_id
														_a			  =       eos_token_id







							def      __lowerCAmelCase    (						self :						int      )    ->							Union[str, Any]:


														"""simple docstring"""


														_a			  =       copy.deepcopy(self.__dict__      )
														_a			  =       self.vision_config.to_dict()
														_a			  =       self.__class__.model_type
														return output







'''simple docstring'''


from manim import *

class     A					(	_a					):







							def      __lowerCAmelCase    (						self :						Tuple      )    ->							Dict:


														"""simple docstring"""


														_a			  =       Rectangle(height=0.5							,    width=0.5      )
														_a			  =       Rectangle(height=0.4_6							,    width=0.4_6      ).set_stroke(width=0      )

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

														_a			  =       [mem.copy() for i in range(4      )]
														_a			  =       VGroup(*lowerCAmelCase_      ).arrange(lowerCAmelCase_							,    buff=0      )
														_a			  =       Text('''GPU'''							,    font_size=24      )
														_a			  =       Group(lowerCAmelCase_							,    lowerCAmelCase_      ).arrange(lowerCAmelCase_							,    buff=0.5							,    aligned_edge=lowerCAmelCase_      )
														gpu.move_to([-1, -1, 0]      )
														self.add(lowerCAmelCase_      )

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

														_a			  =       Text('''Model'''							,    font_size=24      )
														_a			  =       Group(lowerCAmelCase_							,    lowerCAmelCase_      ).arrange(lowerCAmelCase_							,    buff=0.5							,    aligned_edge=lowerCAmelCase_      )
														model.move_to([3, -1.0, 0]      )
														self.add(lowerCAmelCase_      )

														_a			  =       []
														for i, rect in enumerate(lowerCAmelCase_      ):
																					rect.set_stroke(lowerCAmelCase_      )
																					# target = fill.copy().set_fill(YELLOW, opacity=0.7)
																					# target.move_to(rect)
																					# self.add(target)

																					_a			  =       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(cpu_targs[0]							,    direction=lowerCAmelCase_							,    buff=0.0      )
																					else:
																												cpu_target.next_to(cpu_targs[i - 1]							,    direction=lowerCAmelCase_							,    buff=0.0      )
																					self.add(lowerCAmelCase_      )
																					cpu_targs.append(lowerCAmelCase_      )

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

														_a			  =       Text('''Loaded Checkpoint'''							,    font_size=24      )
														_a			  =       Group(lowerCAmelCase_							,    lowerCAmelCase_      ).arrange(lowerCAmelCase_							,    aligned_edge=lowerCAmelCase_							,    buff=0.4      )
														checkpoint.move_to([3, 0.5, 0]      )

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

														_a			  =       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_      )

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

														blue_text.next_to(lowerCAmelCase_							,    DOWN * 2.4							,    aligned_edge=key_text.get_left()      )

														_a			  =       MarkupText(
														    F'Next, a <i><span fgcolor="{BLUE}">second</span></i> model is loaded into memory,\nwith the weights of a <span fgcolor="{BLUE}">single shard</span>.'							,    font_size=24							,    )
														step_a.move_to([2, 2, 0]      )
														self.play(Write(lowerCAmelCase_      )							,    Write(lowerCAmelCase_      )      )

														self.play(Write(lowerCAmelCase_							,    run_time=1      )							,    Create(lowerCAmelCase_							,    run_time=1      )      )

														_a			  =       []
														_a			  =       []
														for i, rect in enumerate(lowerCAmelCase_      ):
																					_a			  =       fill.copy().set_fill(lowerCAmelCase_							,    opacity=0.7      )
																					target.move_to(lowerCAmelCase_      )
																					first_animations.append(GrowFromCenter(lowerCAmelCase_							,    run_time=1      )      )

																					_a			  =       target.copy()
																					cpu_target.generate_target()
																					if i < 5:
																												cpu_target.target.move_to(cpu_left_col_base[i + 1]      )
																					else:
																												cpu_target.target.move_to(cpu_right_col_base[i - 5]      )
																					second_animations.append(MoveToTarget(lowerCAmelCase_							,    run_time=1.5      )      )

														self.play(*lowerCAmelCase_      )
														self.play(*lowerCAmelCase_      )
														self.wait()

