


'''simple docstring'''
from manim import *

class     _lowerCamelCase       (     __lowerCAmelCase					):




 '''simple docstring'''


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Any	  =      Rectangle(height=0.5   ,   width=0.5    )
  __A	:		int	  =      Rectangle(height=0.4_6   ,   width=0.4_6    ).set_stroke(width=0    )

  __A	:		str	  =      Rectangle(height=0.2_5   ,   width=0.2_5    )

  __A	:		Union[str, Any]	  =      [mem.copy() for i in range(6    )]
  __A	:		Optional[int]	  =      [mem.copy() for i in range(6    )]
  __A	:		Tuple	  =      VGroup(*_UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		List[Any]	  =      VGroup(*_UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		int	  =      VGroup(_UpperCAmelCase   ,   _UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		Any	  =      Text('CPU'   ,   font_size=24    )
  __A	:		Tuple	  =      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	:		List[Any]	  =      VGroup(*_UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		Optional[Any]	  =      Text('GPU'   ,   font_size=24    )
  __A	:		List[Any]	  =      Group(_UpperCAmelCase   ,   _UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0.5   ,   aligned_edge=_UpperCAmelCase    )
  gpu.move_to([-1, -1, 0]    )
  self.add(_UpperCAmelCase    )

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

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

  __A	:		List[str]	  =      []
  __A	:		str	  =      []

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

   __A	:		List[str]	  =      Rectangle(height=0.4_6   ,   width=0.4_6    ).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	:		Any	  =      [meta_mem.copy() for i in range(6    )]
  __A	:		Union[str, Any]	  =      [meta_mem.copy() for i in range(6    )]
  __A	:		Union[str, Any]	  =      VGroup(*_UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		int	  =      VGroup(*_UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		int	  =      VGroup(_UpperCAmelCase   ,   _UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0    )
  __A	:		Optional[int]	  =      Text('Disk'   ,   font_size=24    )
  __A	:		str	  =      Group(_UpperCAmelCase   ,   _UpperCAmelCase    ).arrange(_UpperCAmelCase   ,   buff=0.5   ,   aligned_edge=_UpperCAmelCase    )
  disk.move_to([-4, -1.2_5, 0]    )
  self.add(_UpperCAmelCase   ,   _UpperCAmelCase    )

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

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

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

  __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	:		Any	  =      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.0_2    )
  self.play(MoveToTarget(_UpperCAmelCase    )    )

  self.play(FadeOut(_UpperCAmelCase    )    )

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

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

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

  __A	:		List[str]	  =      {'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.0_2}

  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	:		int	  =      a.copy()
  for i in range(6    ):
   a_c.next_to(model_arr[i].get_right() + 0.0_2   ,   _UpperCAmelCase   ,   buff=0.2    )

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

   __A	:		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	:		List[str]	  =      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.0_2   ,   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	:		List[Any]	  =      a_c
   __A	:		Optional[Any]	  =      a_c.copy()

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

  __A	:		int	  =      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"""

import math






def 		_snake_case	(   _snake_case				:   float							,    _snake_case				:   float				)       ->   float:






      '''simple docstring'''


      if (
          not isinstance(_snake_case							,    (int, float)				)
          or power_factor < -1
          or power_factor > 1
      ):
            raise ValueError('power_factor must be a valid float value between -1 and 1.'				)
      return apparent_power * power_factor






def 		_snake_case	(   _snake_case				:   float							,    _snake_case				:   float				)       ->   float:






      '''simple docstring'''


      if (
          not isinstance(_snake_case							,    (int, float)				)
          or power_factor < -1
          or power_factor > 1
      ):
            raise ValueError('power_factor must be a valid float value between -1 and 1.'				)
      return apparent_power * math.sqrt(1 - power_factor**2				)


if __name__ == "__main__":
       import doctest

       doctest.testmod()

