






'''simple docstring'''







from manim import *

class _lowercase	(				_lowercase		):




							def 		lowerCamelCase_				(							self:				List[Any]     ):
														lowerCamelCase__					:	List[Any]         =       Rectangle(height=0.5			,							width=0.5     )
														lowerCamelCase__					:	int         =       Rectangle(height=0.25			,							width=0.25     )
														lowerCamelCase__					:	Optional[int]         =       Rectangle(height=0.46			,							width=0.46     ).set_stroke(width=0     )

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

														lowerCamelCase__					:	str         =       [mem.copy() for i in range(4     )]
														lowerCamelCase__					:	Dict         =       VGroup(*UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0     )
														lowerCamelCase__					:	Dict         =       Text("""GPU"""			,							font_size=24     )
														lowerCamelCase__					:	Union[str, Any]         =       Group(UpperCamelCase__			,							UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0.5			,							aligned_edge=UpperCamelCase__     )
														gpu.move_to([-1, -1, 0]     )
														self.add(UpperCamelCase__     )

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

														lowerCamelCase__					:	List[Any]         =       Text("""Model"""			,							font_size=24     )
														lowerCamelCase__					:	Any         =       Group(UpperCamelCase__			,							UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0.5			,							aligned_edge=UpperCamelCase__     )
														model.move_to([3, -1.0, 0]     )
														self.add(UpperCamelCase__     )

														lowerCamelCase__					:	Optional[int]         =       []
														lowerCamelCase__					:	Tuple         =       []
														lowerCamelCase__					:	Union[str, Any]         =       []

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

																					lowerCamelCase__					:	Dict         =       Rectangle(height=0.46 / 4			,							width=0.46 / 3     ).set_stroke(width=0.0     ).set_fill(UpperCamelCase__			,							opacity=0.7     )

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

														self.add(*UpperCamelCase__			,							*UpperCamelCase__			,							*UpperCamelCase__     )

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

														lowerCamelCase__					:	Dict         =       Text("""Loaded Checkpoint"""			,							font_size=24     )
														lowerCamelCase__					:	Tuple         =       Group(UpperCamelCase__			,							UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0.5			,							aligned_edge=UpperCamelCase__     )
														checkpoint.move_to([3, 0.5, 0]     )

														self.add(UpperCamelCase__     )

														lowerCamelCase__					:	Dict         =       []
														lowerCamelCase__					:	Dict         =       []

														for i, rect in enumerate(UpperCamelCase__     ):
																					lowerCamelCase__					:	Tuple         =       fill.copy().set_fill(UpperCamelCase__			,							opacity=0.7     )
																					target.move_to(UpperCamelCase__     )
																					ckpt_arr.append(UpperCamelCase__     )

																					lowerCamelCase__					:	List[Any]         =       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(UpperCamelCase__     )
														self.add(*UpperCamelCase__			,							*UpperCamelCase__     )

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

														lowerCamelCase__					:	int         =       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(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Optional[int]         =       MarkupText(
														    F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''			,							font_size=18			,							)

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

														lowerCamelCase__					:	Tuple         =       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]     )

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

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

														self.play(FadeOut(UpperCamelCase__     )     )

														lowerCamelCase__					:	Any         =       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(UpperCamelCase__			,							run_time=3     )     )

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

														self.wait()






'''simple docstring'''




# Copyright 2021 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.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


UpperCamelCase__       :	List[Any]    = [
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]


def 				lowerCAmelCase_   (	_lowerCamelCase:   str       ,      _lowerCamelCase:   Union[str, Any]=None       ,      _lowerCamelCase:   Optional[int]=None       ,      _lowerCamelCase:   str=None					):
		__SCREAMING_SNAKE_CASE       :		Optional[int]           =		True
		while ask_again:
				__SCREAMING_SNAKE_CASE       :		Tuple           =		input(_lowerCamelCase					)
				try:
						if default is not None and len(_lowerCamelCase					) == 0:
								return default
						return convert_value(_lowerCamelCase					) if convert_value is not None else result
				except Exception:
						if error_message is not None:
								print(_lowerCamelCase					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple       ,      _lowerCamelCase:   Union[str, Any]=[]       ,      _lowerCamelCase:   List[Any]=None       ,      _lowerCamelCase:   Optional[Any]=0					):
		__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		BulletMenu(_lowerCamelCase       ,      _lowerCamelCase					)
		__SCREAMING_SNAKE_CASE       :		Dict           =		menu.run(default_choice=_lowerCamelCase					)
		return convert_value(_lowerCamelCase					) if convert_value is not None else result


def 				lowerCAmelCase_   (	_lowerCamelCase:   Optional[Any]					):
		__SCREAMING_SNAKE_CASE       :		List[str]           =		int(_lowerCamelCase					)
		return ComputeEnvironment(["""LOCAL_MACHINE""", """AMAZON_SAGEMAKER"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Any					):
		__SCREAMING_SNAKE_CASE       :		str           =		int(_lowerCamelCase					)
		return DistributedType(["""NO""", """MULTI_CPU""", """MULTI_XPU""", """MULTI_GPU""", """MULTI_NPU""", """TPU"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple					):
		__SCREAMING_SNAKE_CASE       :		Tuple           =		int(_lowerCamelCase					)
		return DynamoBackend(DYNAMO_BACKENDS[value]					).value


def 				lowerCAmelCase_   (	_lowerCamelCase:   Union[str, Any]					):
		__SCREAMING_SNAKE_CASE       :		List[str]           =		int(_lowerCamelCase					)
		return PrecisionType(["""no""", """fp16""", """bf16""", """fp8"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple					):
		__SCREAMING_SNAKE_CASE       :		int           =		int(_lowerCamelCase					)
		return SageMakerDistributedType(["""NO""", """DATA_PARALLEL""", """MODEL_PARALLEL"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   List[Any]					):
		return {"yes": True, "no": False}[value.lower()]






class 						_UpperCamelCase  (							argparse.RawDescriptionHelpFormatter    ):


			'''simple docstring'''

			def UpperCamelCase__					(							self     : Tuple							,     lowerCAmelCase__     : Optional[Any]							,     lowerCAmelCase__     : Dict							,     lowerCAmelCase__     : List[Any]							,     lowerCAmelCase__     : List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		super()._format_usage(lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE       :		Any           =		usage.replace("""<command> [<args>] """							,     """"""						)
					return usage