




'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


_snake_case   :   Union[str, Any]     							=	{
    'configuration_gpt_bigcode': ['GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTBigCodeConfig'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case   :   Dict     							=	[
				    'GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'GPTBigCodeForSequenceClassification',
				    'GPTBigCodeForTokenClassification',
				    'GPTBigCodeForCausalLM',
				    'GPTBigCodeModel',
				    'GPTBigCodePreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_gpt_bigcode import (
								    GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
								    GPTBigCodeForCausalLM,
								    GPTBigCodeForSequenceClassification,
								    GPTBigCodeForTokenClassification,
								    GPTBigCodeModel,
								    GPTBigCodePreTrainedModel,
								)


else:
				import sys

				_snake_case   :   Optional[int]     							=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)







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

