





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






class 					_SCREAMING_SNAKE_CASE(   A  ):




       def     _UpperCamelCase     (						self							)			->      Optional[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  Rectangle(height=0.5		,width=0.5							)
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  Rectangle(height=0.4_6		,width=0.4_6							).set_stroke(width=0							)

             __SCREAMING_SNAKE_CASE   :List[Any]						=  Rectangle(height=0.2_5		,width=0.2_5							)

             __SCREAMING_SNAKE_CASE   :int						=  [mem.copy() for i in range(6							)]
             __SCREAMING_SNAKE_CASE   :List[Any]						=  [mem.copy() for i in range(6							)]
             __SCREAMING_SNAKE_CASE   :List[str]						=  VGroup(*SCREAMING_SNAKE_CASE__							).arrange(SCREAMING_SNAKE_CASE__		,buff=0							)
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  VGroup(*SCREAMING_SNAKE_CASE__							).arrange(SCREAMING_SNAKE_CASE__		,buff=0							)
             __SCREAMING_SNAKE_CASE   :List[str]						=  VGroup(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							).arrange(SCREAMING_SNAKE_CASE__		,buff=0							)
             __SCREAMING_SNAKE_CASE   :Dict						=  Text('''CPU'''		,font_size=24							)
             __SCREAMING_SNAKE_CASE   :List[Any]						=  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__							)

             __SCREAMING_SNAKE_CASE   :Optional[int]						=  [mem.copy() for i in range(4							)]
             __SCREAMING_SNAKE_CASE   :int						=  VGroup(*SCREAMING_SNAKE_CASE__							).arrange(SCREAMING_SNAKE_CASE__		,buff=0							)
             __SCREAMING_SNAKE_CASE   :Dict						=  Text('''GPU'''		,font_size=24							)
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  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__							)

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

             __SCREAMING_SNAKE_CASE   :List[str]						=  Text('''Model'''		,font_size=24							)
             __SCREAMING_SNAKE_CASE   :str						=  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__							)

             __SCREAMING_SNAKE_CASE   :Tuple						=  []
             __SCREAMING_SNAKE_CASE   :int						=  []

             for i, rect in enumerate(SCREAMING_SNAKE_CASE__							):
                   __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  fill.copy().set_fill(SCREAMING_SNAKE_CASE__		,opacity=0.8							)
                   target.move_to(SCREAMING_SNAKE_CASE__							)
                   model_arr.append(SCREAMING_SNAKE_CASE__							)

                   __SCREAMING_SNAKE_CASE   :Any						=  Rectangle(height=0.4_6		,width=0.4_6							).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__							)

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

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

             __SCREAMING_SNAKE_CASE   :Any						=  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__							)

             __SCREAMING_SNAKE_CASE   :str						=  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__							)

             __SCREAMING_SNAKE_CASE   :Tuple						=  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__							)							)

             __SCREAMING_SNAKE_CASE   :List[str]						=  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.0_2							)
             self.play(MoveToTarget(SCREAMING_SNAKE_CASE__							)							)

             self.play(FadeOut(SCREAMING_SNAKE_CASE__							)							)

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

             __SCREAMING_SNAKE_CASE   :Optional[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(SCREAMING_SNAKE_CASE__		,run_time=3							)							)

             __SCREAMING_SNAKE_CASE   :Tuple						=  {'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.0_2}

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

             __SCREAMING_SNAKE_CASE   :List[str]						=  a.copy()
             for i in range(6							):
                   a_c.next_to(model_arr[i].get_right() + 0.0_2		,SCREAMING_SNAKE_CASE__		,buff=0.2							)

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

                   __SCREAMING_SNAKE_CASE   :Tuple						=  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:
                               __SCREAMING_SNAKE_CASE   :str						=  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.0_2		,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]							)							)

                   __SCREAMING_SNAKE_CASE   :int						=  a_c
                   __SCREAMING_SNAKE_CASE   :List[str]						=  a_c.copy()

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

             __SCREAMING_SNAKE_CASE   :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


lowerCamelCase_								=		{"configuration_dpt": ["DPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPTConfig"]}

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

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase_								=		[
      "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

  lowerCamelCase_								=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)