





from manim import *


class 						lowerCamelCase       (__lowerCamelCase      ):







       """simple docstring"""




       def  A_     ( self     :					str						)				->			int:





              """simple docstring"""
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Rectangle(height=0.5,			width=0.5						)
              SCREAMING_SNAKE_CASE__       :      List[str]     =						Rectangle(height=0.46,			width=0.46						).set_stroke(width=0						)

              SCREAMING_SNAKE_CASE__       :      Tuple     =						Rectangle(height=0.25,			width=0.25						)

              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						[mem.copy() for i in range(6						)]
              SCREAMING_SNAKE_CASE__       :      Any     =						[mem.copy() for i in range(6						)]
              SCREAMING_SNAKE_CASE__       :      Any     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      List[str]     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						VGroup(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      int     =						Text("CPU",			font_size=2_4						)
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
              cpu.move_to([-2.5, -0.5, 0]						)
              self.add(_UpperCAmelCase						)

              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						[mem.copy() for i in range(4						)]
              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						Text("GPU",			font_size=2_4						)
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
              gpu.move_to([-1, -1, 0]						)
              self.add(_UpperCAmelCase						)

              SCREAMING_SNAKE_CASE__       :      List[Any]     =						[mem.copy() for i in range(6						)]
              SCREAMING_SNAKE_CASE__       :      Tuple     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)

              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Text("Model",			font_size=2_4						)
              SCREAMING_SNAKE_CASE__       :      Tuple     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
              model.move_to([3, -1.0, 0]						)
              self.add(_UpperCAmelCase						)

              SCREAMING_SNAKE_CASE__       :      List[str]     =						[]
              SCREAMING_SNAKE_CASE__       :      Any     =						[]

              for i, rect in enumerate(_UpperCAmelCase						):
                     SCREAMING_SNAKE_CASE__       :      Optional[int]     =						fill.copy().set_fill(_UpperCAmelCase,			opacity=0.8						)
                     target.move_to(_UpperCAmelCase						)
                     model_arr.append(_UpperCAmelCase						)

                     SCREAMING_SNAKE_CASE__       :      Dict     =						Rectangle(height=0.46,			width=0.46						).set_stroke(width=0.0						).set_fill(_UpperCAmelCase,			opacity=0.8						)
                     cpu_target.move_to(cpu_left_col_base[i]						)
                     model_cpu_arr.append(_UpperCAmelCase						)

              self.add(*_UpperCAmelCase,			*_UpperCAmelCase						)

              SCREAMING_SNAKE_CASE__       :      int     =						[meta_mem.copy() for i in range(6						)]
              SCREAMING_SNAKE_CASE__       :      Any     =						[meta_mem.copy() for i in range(6						)]
              SCREAMING_SNAKE_CASE__       :      Any     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      Tuple     =						VGroup(*_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      str     =						VGroup(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0						)
              SCREAMING_SNAKE_CASE__       :      int     =						Text("Disk",			font_size=2_4						)
              SCREAMING_SNAKE_CASE__       :      List[Any]     =						Group(_UpperCAmelCase,			_UpperCAmelCase						).arrange(_UpperCAmelCase,			buff=0.5,			aligned_edge=_UpperCAmelCase						)
              disk.move_to([-4, -1.25, 0]						)
              self.add(_UpperCAmelCase,			_UpperCAmelCase						)

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

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

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

              self.add(_UpperCAmelCase,			_UpperCAmelCase						)

              SCREAMING_SNAKE_CASE__       :      str     =						MarkupText(
                  F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint''',			font_size=1_8,			)

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

              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						MarkupText(
                  F'''Now watch as an input is passed through the model\nand how the memory is utilized and handled.''',			font_size=2_4,			)
              step_a.move_to([2, 2, 0]						)

              self.play(Write(_UpperCAmelCase						)						)

              SCREAMING_SNAKE_CASE__       :      str     =						Square(0.3						)
              input.set_fill(_UpperCAmelCase,			opacity=1.0						)
              input.set_stroke(width=0.0						)
              input.next_to(model_base[0],			_UpperCAmelCase,			buff=0.5						)

              self.play(Write(_UpperCAmelCase						)						)

              input.generate_target()
              input.target.next_to(model_arr[0],			direction=_UpperCAmelCase,			buff=0.02						)
              self.play(MoveToTarget(_UpperCAmelCase						)						)

              self.play(FadeOut(_UpperCAmelCase						)						)

              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						Arrow(start=_UpperCAmelCase,			end=_UpperCAmelCase,			color=_UpperCAmelCase,			buff=0.5						)
              a.next_to(model_arr[0].get_left(),			_UpperCAmelCase,			buff=0.2						)

              model_cpu_arr[0].generate_target()
              model_cpu_arr[0].target.move_to(gpu_rect[0]						)

              SCREAMING_SNAKE_CASE__       :      int     =						MarkupText(
                  F'''As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.''',			font_size=2_4,			)
              step_a.move_to([2, 2, 0]						)

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

              SCREAMING_SNAKE_CASE__       :      List[str]     =						{"run_time": 1, "fade_in": True, "fade_out": True, "buff": 0.02}

              self.play(
                  Write(_UpperCAmelCase						),			Circumscribe(model_arr[0],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			Circumscribe(model_cpu_arr[0],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			Circumscribe(gpu_rect[0],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			)
              self.play(MoveToTarget(model_cpu_arr[0]						)						)

              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						a.copy()
              for i in range(6						):
                     a_c.next_to(model_arr[i].get_right() + 0.02,			_UpperCAmelCase,			buff=0.2						)

                     input.generate_target()
                     input.target.move_to(model_arr[i].get_right() + 0.02						)

                     SCREAMING_SNAKE_CASE__       :      int     =						AnimationGroup(
                         FadeOut(_UpperCAmelCase,			run_time=0.5						),			MoveToTarget(_UpperCAmelCase,			run_time=0.5						),			FadeIn(_UpperCAmelCase,			run_time=0.5						),			lag_ratio=0.2						)

                     self.play(_UpperCAmelCase						)

                     model_cpu_arr[i].generate_target()
                     model_cpu_arr[i].target.move_to(cpu_left_col_base[i]						)

                     if i < 5:
                            model_cpu_arr[i + 1].generate_target()
                            model_cpu_arr[i + 1].target.move_to(gpu_rect[0]						)
                            if i >= 1:
                                   SCREAMING_SNAKE_CASE__       :      Tuple     =						0.7

                            self.play(
                                Circumscribe(model_arr[i],			**_UpperCAmelCase						),			Circumscribe(cpu_left_col_base[i],			**_UpperCAmelCase						),			Circumscribe(cpu_left_col_base[i + 1],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			Circumscribe(gpu_rect[0],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			Circumscribe(model_arr[i + 1],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			)
                            if i < 1:
                                   self.play(
                                       MoveToTarget(model_cpu_arr[i]						),			MoveToTarget(model_cpu_arr[i + 1]						),			)
                            else:
                                   self.play(
                                       MoveToTarget(model_cpu_arr[i],			run_time=0.7						),			MoveToTarget(model_cpu_arr[i + 1],			run_time=0.7						),			)
                     else:
                            model_cpu_arr[i].generate_target()
                            model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]						)
                            input.generate_target()
                            input.target.next_to(model_arr[-1].get_right(),			RIGHT + 0.02,			buff=0.2						)

                            self.play(
                                Circumscribe(model_arr[-1],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			Circumscribe(cpu_left_col_base[-1],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			Circumscribe(gpu_rect[0],			color=_UpperCAmelCase,			**_UpperCAmelCase						),			)

                            self.play(MoveToTarget(model_cpu_arr[i]						)						)

                     SCREAMING_SNAKE_CASE__       :      Tuple     =						a_c
                     SCREAMING_SNAKE_CASE__       :      Dict     =						a_c.copy()

              input.generate_target()
              input.target.next_to(model_base[-1],			RIGHT + 0.02,			buff=0.5						)
              self.play(
                  FadeOut(_UpperCAmelCase						),			FadeOut(_UpperCAmelCase,			run_time=0.5						),			)

              SCREAMING_SNAKE_CASE__       :      Dict     =						MarkupText(F'''Inference on a model too large for GPU memory\nis successfully completed.''',			font_size=2_4						)
              step_a.move_to([2, 2, 0]						)

              self.play(Write(_UpperCAmelCase,			run_time=3						),			MoveToTarget(_UpperCAmelCase						)						)

              self.wait()













def _a (  SCREAMING_SNAKE_CASE__      :  str       )	->    str:

							'''simple docstring'''






							if not all(char in "01" for char in bin_string       ):
														raise ValueError("Non-binary value was passed to the function"       )
							if not bin_string:
														raise ValueError("Empty string was passed to the function"       )
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						""
							while len(SCREAMING_SNAKE_CASE__       ) % 3 != 0:
														SCREAMING_SNAKE_CASE__       :      str     =						"0" + bin_string
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						[
							    bin_string[index : index + 3]
							    for index in range(len(SCREAMING_SNAKE_CASE__       )       )
							    if index % 3 == 0
							]
							for bin_group in bin_string_in_3_list:
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						0
														for index, val in enumerate(SCREAMING_SNAKE_CASE__       ):
																					oct_val += int(2 ** (2 - index) * int(SCREAMING_SNAKE_CASE__       )       )
														oct_string += str(SCREAMING_SNAKE_CASE__       )
							return oct_string


if __name__ == "__main__":
		from doctest import testmod

		testmod()






