



"""simple docstring"""
from manim import *



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	Rectangle(height=0.5      ,     width=0.5						)
    UpperCAmelCase	:					Optional[Any]	=	Rectangle(height=0.46      ,     width=0.46						).set_stroke(width=0						)

    UpperCAmelCase	:					List[str]	=	Rectangle(height=0.25      ,     width=0.25						)

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

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

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

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

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

    for i, rect in enumerate(_SCREAMING_SNAKE_CASE						):
     UpperCAmelCase	:					Optional[Any]	=	fill.copy().set_fill(_SCREAMING_SNAKE_CASE      ,     opacity=0.8						)
     target.move_to(_SCREAMING_SNAKE_CASE						)
     model_arr.append(_SCREAMING_SNAKE_CASE						)

     UpperCAmelCase	:					str	=	Rectangle(height=0.46      ,     width=0.46						).set_stroke(width=0.0						).set_fill(_SCREAMING_SNAKE_CASE      ,     opacity=0.8						)
     cpu_target.move_to(cpu_left_col_base[i]						)
     model_cpu_arr.append(_SCREAMING_SNAKE_CASE						)

    self.add(*_SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)

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

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

    UpperCAmelCase	:					Tuple	=	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(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					Tuple	=	MarkupText(
        F"<span fgcolor='{BLUE}'>●</span> Checkpoint"      ,     font_size=18      ,     )

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

    UpperCAmelCase	:					Dict	=	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(_SCREAMING_SNAKE_CASE						)						)

    UpperCAmelCase	:					Tuple	=	Square(0.3						)
    input.set_fill(_SCREAMING_SNAKE_CASE      ,     opacity=1.0						)
    input.set_stroke(width=0.0						)
    input.next_to(model_base[0]      ,     _SCREAMING_SNAKE_CASE      ,     buff=0.5						)

    self.play(Write(_SCREAMING_SNAKE_CASE						)						)

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

    self.play(FadeOut(_SCREAMING_SNAKE_CASE						)						)

    UpperCAmelCase	:					List[Any]	=	Arrow(start=_SCREAMING_SNAKE_CASE      ,     end=_SCREAMING_SNAKE_CASE      ,     color=_SCREAMING_SNAKE_CASE      ,     buff=0.5						)
    a.next_to(model_arr[0].get_left()      ,     _SCREAMING_SNAKE_CASE      ,     buff=0.2						)

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

    UpperCAmelCase	:					Any	=	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(_SCREAMING_SNAKE_CASE      ,     run_time=3						)						)

    UpperCAmelCase	:					Tuple	=	{"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.02}

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

    UpperCAmelCase	:					Optional[int]	=	a.copy()
    for i in range(6						):
     a_c.next_to(model_arr[i].get_right() + 0.02      ,     _SCREAMING_SNAKE_CASE      ,     buff=0.2						)

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

     UpperCAmelCase	:					Any	=	AnimationGroup(
         FadeOut(_SCREAMING_SNAKE_CASE      ,     run_time=0.5						)      ,     MoveToTarget(_SCREAMING_SNAKE_CASE      ,     run_time=0.5						)      ,     FadeIn(_SCREAMING_SNAKE_CASE      ,     run_time=0.5						)      ,     lag_ratio=0.2						)

     self.play(_SCREAMING_SNAKE_CASE						)

     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:
       UpperCAmelCase	:					Tuple	=	0.7

      self.play(
          Circumscribe(model_arr[i]      ,     **_SCREAMING_SNAKE_CASE						)      ,     Circumscribe(cpu_left_col_base[i]      ,     **_SCREAMING_SNAKE_CASE						)      ,     Circumscribe(cpu_left_col_base[i + 1]      ,     color=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)      ,     Circumscribe(gpu_rect[0]      ,     color=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)      ,     Circumscribe(model_arr[i + 1]      ,     color=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)      ,     )
      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=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)      ,     Circumscribe(cpu_left_col_base[-1]      ,     color=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)      ,     Circumscribe(gpu_rect[0]      ,     color=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)      ,     )

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

     UpperCAmelCase	:					Optional[Any]	=	a_c
     UpperCAmelCase	:					str	=	a_c.copy()

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

    UpperCAmelCase	:					Optional[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(_SCREAMING_SNAKE_CASE      ,     run_time=3						)      ,     MoveToTarget(_SCREAMING_SNAKE_CASE						)						)

    self.wait()





"""simple docstring"""
from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available
from ...utils import OptionalDependencyNotAvailable


A:   List[str]								=		{"configuration_dpt": ["DPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPTConfig"]}

try:
      if not is_vision_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A:   Tuple								=		["DPTFeatureExtractor"]
      A:   int								=		["DPTImageProcessor"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A:   Optional[Any]								=		[
          "DPT_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPTForDepthEstimation",
          "DPTForSemanticSegmentation",
          "DPTModel",
          "DPTPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_dpt import DPTFeatureExtractor
            from .image_processing_dpt import DPTImageProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_dpt import (
                DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPTForDepthEstimation,
                DPTForSemanticSegmentation,
                DPTModel,
                DPTPreTrainedModel,
            )


else:
      import sys

      A:   str								=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
