



'''simple docstring'''






from manim import *

class     SCREAMING_SNAKE_CASE(							lowerCAmelCase_      ):







 """simple docstring"""






 def 					A     (						self      :					List[Any]		)      ->		Dict:
        UpperCAmelCase			:	str										=		Rectangle(height=0.5		,      width=0.5		)
        UpperCAmelCase			:	str										=		Rectangle(height=0.46		,      width=0.46		).set_stroke(width=0		)
        UpperCAmelCase			:	List[Any]										=		Rectangle(height=0.25		,      width=0.25		)

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

        UpperCAmelCase			:	Optional[int]										=		[mem.copy() for i in range(4		)]
        UpperCAmelCase			:	int										=		VGroup(*_snake_case		).arrange(_snake_case		,      buff=0		)
        UpperCAmelCase			:	str										=		Text('''GPU'''		,      font_size=24		)
        UpperCAmelCase			:	List[Any]										=		Group(_snake_case		,      _snake_case		).arrange(_snake_case		,      buff=0.5		,      aligned_edge=_snake_case		)
        gpu.move_to([-1, -1, 0]		)
        self.add(_snake_case		)

        UpperCAmelCase			:	Optional[int]										=		[mem.copy() for i in range(6		)]
        UpperCAmelCase			:	Union[str, Any]										=		VGroup(*_snake_case		).arrange(_snake_case		,      buff=0		)

        UpperCAmelCase			:	int										=		Text('''Model'''		,      font_size=24		)
        UpperCAmelCase			:	List[Any]										=		Group(_snake_case		,      _snake_case		).arrange(_snake_case		,      buff=0.5		,      aligned_edge=_snake_case		)
        model.move_to([3, -1.0, 0]		)
        self.add(_snake_case		)

        UpperCAmelCase			:	Any										=		[]
        UpperCAmelCase			:	Optional[int]										=		[]

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

               UpperCAmelCase			:	Union[str, Any]										=		Rectangle(height=0.46 / 4		,      width=0.46 / 3		).set_stroke(width=0.0		).set_fill(_snake_case		,      opacity=0.7		)

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

        self.add(*_snake_case		,      *_snake_case		)

        UpperCAmelCase			:	Optional[Any]										=		[meta_mem.copy() for i in range(6		)]
        UpperCAmelCase			:	List[Any]										=		[meta_mem.copy() for i in range(6		)]
        UpperCAmelCase			:	Dict										=		VGroup(*_snake_case		).arrange(_snake_case		,      buff=0		)
        UpperCAmelCase			:	Tuple										=		VGroup(*_snake_case		).arrange(_snake_case		,      buff=0		)
        UpperCAmelCase			:	int										=		VGroup(_snake_case		,      _snake_case		).arrange(_snake_case		,      buff=0		)
        UpperCAmelCase			:	Union[str, Any]										=		Text('''Disk'''		,      font_size=24		)
        UpperCAmelCase			:	int										=		Group(_snake_case		,      _snake_case		).arrange(_snake_case		,      buff=0.5		,      aligned_edge=_snake_case		)
        disk.move_to([-4.0, -1.25, 0]		)
        self.add(_snake_case		,      _snake_case		)

        UpperCAmelCase			:	str										=		[]

        for i in range(6		):
               UpperCAmelCase			:	str										=		fill.copy().set_fill(_snake_case		,      opacity=0.8		)
               target.move_to(disk_left_col_base[i]		).scale(0.5		)
               cpu_disk_arr.append(_snake_case		)

        self.add(*_snake_case		)

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

        UpperCAmelCase			:	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(_snake_case		,      _snake_case		)

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

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

        UpperCAmelCase			:	Optional[int]										=		MarkupText(F"""The offloaded weights are all sent to the CPU."""		,      font_size=24		)
        step_a.move_to([2, 2, 0]		)

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

        for i in range(6		):
               UpperCAmelCase			:	int										=		cpu_disk_arr[i]
               UpperCAmelCase			:	Optional[Any]										=		rect.copy().set_fill(_snake_case		,      opacity=0.8		).scale(2.0		)
               cpa.generate_target()
               cpa.target.move_to(model_base[i]		)

               if i == 0:
                      rect.set_fill(_snake_case		,      opacity=0.8		)
                      rect.generate_target()
                      rect.target.move_to(cpu_left_col_base[0]		).scale(2.0		)

                      self.remove(
                          *_snake_case		,      *_snake_case		,      )

               else:
                      rect.generate_target()
                      rect.target.move_to(cpu_left_col_base[i]		).scale(2.0		)
               self.play(MoveToTarget(_snake_case		)		,      MoveToTarget(_snake_case		)		,      model_base[i].animate.set_stroke(_snake_case		)		)
        self.play(FadeOut(_snake_case		)		)

        UpperCAmelCase			:	Optional[Any]										=		MarkupText(
            F"""Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed."""		,      font_size=24		,      )
        step_a.move_to([2, 2, 0]		)

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

        UpperCAmelCase			:	str										=		[]
        UpperCAmelCase			:	Optional[Any]										=		[]
        for i in range(6		):
               UpperCAmelCase			:	List[Any]										=		Arrow(start=_snake_case		,      end=_snake_case		,      color=_snake_case		,      buff=0.5		)
               a.next_to(model_base[i].get_left()		,      _snake_case		,      buff=0.2		)
               arrows.append(_snake_case		)
               animations.append(Write(_snake_case		)		)
        self.play(*_snake_case		)
        self.wait()










'''simple docstring'''






import importlib.metadata
import subprocess
import sys


def 			snake_case_					( _lowerCAmelCase  :						bool = False  )				->       str:
							UpperCAmelCase			:	List[str]										=		False
							if "IPython" in sys.modules:
														UpperCAmelCase			:	Optional[Any]										=		'''google.colab''' in str(sys.modules['''IPython'''].get_ipython()  )

							if in_colab:
														if upgrade:
																					UpperCAmelCase			:	List[Any]										=		['''pip''', '''install''', '''-U''', '''torch''']
																					subprocess.run(_lowerCAmelCase       ,				check=_lowerCAmelCase  )
														# get the current version of torch
														UpperCAmelCase			:	Dict										=		importlib.metadata.version('''torch'''  )
														UpperCAmelCase			:	int										=		torch_version[: torch_version.rindex('''.'''  )]
														UpperCAmelCase			:	Any										=		f"""https://storage.googleapis.com/tpu-pytorch/wheels/colab/torch_xla-{torch_version_trunc}-cp37-cp37m-linux_x86_64.whl"""
														UpperCAmelCase			:	List[str]										=		['''pip''', '''install''', xla_wheel]
														subprocess.run(_lowerCAmelCase       ,				check=_lowerCAmelCase  )
							else:
														raise RuntimeError('''`install_xla` utility works only on google colab.'''  )





