





'''simple docstring'''




from manim import *


class 					SCREAMING_SNAKE_CASE       (a__				):


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			Rectangle(height=0.5		,      width=0.5)
          __A		:					Tuple						=			Rectangle(height=0.46		,      width=0.46).set_stroke(width=0)

          __A		:					Dict						=			Rectangle(height=0.25		,      width=0.25)

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

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

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

          __A		:					Dict						=			Text('Model'		,      font_size=24)
          __A		:					int						=			Group(_UpperCAmelCase		,      _UpperCAmelCase).arrange(_UpperCAmelCase		,      buff=0.5		,      aligned_edge=_UpperCAmelCase)
          model.move_to([3, -1.0, 0])
          self.add(_UpperCAmelCase)

          __A		:					int						=			[]
          __A		:					Union[str, Any]						=			[]

          for i, rect in enumerate(_UpperCAmelCase):
               __A		:					List[str]						=			fill.copy().set_fill(_UpperCAmelCase		,      opacity=0.8)
               target.move_to(_UpperCAmelCase)
               model_arr.append(_UpperCAmelCase)

               __A		:					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)

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

          __A		:					List[Any]						=			Square(side_length=2.2)
          key.move_to([-5, 2, 0])

          __A		:					Dict						=			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)

          __A		:					Dict						=			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)

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

          self.play(Write(_UpperCAmelCase))

          __A		:					Dict						=			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))

          __A		:					Dict						=			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])

          __A		:					List[str]						=			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=24		,      )
          step_a.move_to([2, 2, 0])

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

          __A		:					Optional[Any]						=			{'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]))

          __A		:					List[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)

               __A		:					List[Any]						=			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:
                         __A		:					Union[str, Any]						=			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]))

               __A		:					str						=			a_c
               __A		:					Union[str, Any]						=			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)		,      )

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

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

          self.wait()






'''simple docstring'''




from __future__ import annotations






def 			_lowerCAmelCase     (    __snake_case    :					list[int]					,				__snake_case    :					list[int]					,				__snake_case    :					int     )	->	tuple[float, list[float]]:
     __A		:					int						=			list(range(len(__snake_case     )     )     )
     __A		:					Optional[Any]						=			[v / w for v, w in zip(__snake_case					,				__snake_case     )]
     index.sort(key=lambda __snake_case     : ratio[i]					,				reverse=__snake_case     )

     __A		:					float						=			0
     __A		:					list[float]						=			[0] * len(__snake_case     )
     for i in index:
          if weight[i] <= capacity:
               __A		:					Optional[int]						=			1
               max_value += value[i]
               capacity -= weight[i]
          else:
               __A		:					List[Any]						=			capacity / weight[i]
               max_value += value[i] * capacity / weight[i]
               break

     return max_value, fractions


if __name__ == "__main__":
  import doctest

  doctest.testmod()