





from manim import *



class        _lowerCAmelCase    (			UpperCAmelCase_							):


  '''simple docstring'''







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case   :				Optional[int]														=	Rectangle(height=0.5      ,				width=0.5							)
    _snake_case   :				Tuple														=	Rectangle(height=0.46      ,				width=0.46							).set_stroke(width=0							)

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

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

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

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

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

    _snake_case   :				Optional[int]														=	[]
    _snake_case   :				Optional[int]														=	[]

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

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

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

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

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

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

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

    _snake_case   :				List[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.02							)
    self.play(MoveToTarget(UpperCamelCase							)							)

    self.play(FadeOut(UpperCamelCase							)							)

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

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

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

    _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							)

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

      _snake_case   :				Optional[Any]														=	a_c
      _snake_case   :				Optional[int]														=	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							)      ,				)

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











import copy
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Optional, Union



@dataclass
class        _lowerCAmelCase    :


  '''simple docstring'''
  a_							:       Optional[Union[str, Path]]      					=None
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       Optional[Dict]      					=None
  a_							:       Optional[str]      					=None
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       bool      					=False
  a_							:       bool      					=True
  a_							:       Optional[int]      					=None
  a_							:       int      					=1
  a_							:       Optional[Union[str, bool]]      					=None
  a_							:       bool      					=False
  a_							:       Optional[Dict]      					=None
  a_							:       Optional[str]      					=None







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    return self.__class__(**{k: copy.deepcopy(UpperCamelCase							) for k, v in self.__dict__.items()}							)




