


from manim import *
class 			SCREAMING_SNAKE_CASE__  (    lowercase__      ):
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					)		->      Optional[Any]:
             a_ :		Tuple							=  Rectangle(height=0.5					,							width=0.5					)
             a_ :		Dict							=  Rectangle(height=0.46					,							width=0.46					).set_stroke(width=0					)

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

             a_ :		int							=  [mem.copy() for i in range(6					)]
             a_ :		Dict							=  [mem.copy() for i in range(6					)]
             a_ :		Tuple							=  VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		Optional[Any]							=  VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		Tuple							=  VGroup(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		Dict							=  Text('CPU'					,							font_size=2_4					)
             a_ :		int							=  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__					)

             a_ :		str							=  [mem.copy() for i in range(4					)]
             a_ :		List[str]							=  VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		str							=  Text('GPU'					,							font_size=2_4					)
             a_ :		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__					)

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

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

             a_ :		Dict							=  []
             a_ :		Tuple							=  []

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

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

             a_ :		Union[str, Any]							=  [meta_mem.copy() for i in range(6					)]
             a_ :		List[Any]							=  [meta_mem.copy() for i in range(6					)]
             a_ :		Any							=  VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		Optional[Any]							=  VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		Any							=  VGroup(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__					,							buff=0					)
             a_ :		Optional[Any]							=  Text('Disk'					,							font_size=2_4					)
             a_ :		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__					)

             a_ :		Dict							=  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=1_8					,							)

             key_text.move_to([-5, 2.4, 0]					)

             self.add(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)

             a_ :		List[str]							=  MarkupText(
                 F"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""					,							font_size=1_8					,							)

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

             a_ :		Optional[int]							=  MarkupText(
                 F"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""					,							font_size=2_4					,							)
             step_a.move_to([2, 2, 0]					)

             self.play(Write(SCREAMING_SNAKE_CASE__					)					)

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

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

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

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

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

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

                    a_ :		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:
                                  a_ :		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.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]					)					)

                    a_ :		Tuple							=  a_c
                    a_ :		List[Any]							=  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					)					,							)

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

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

             self.wait()






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_				:			Dict   =	{'configuration_vit_msn': ['VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMSNConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_				:			int   =	[
       'VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST',
       'ViTMSNModel',
       'ViTMSNForImageClassification',
       'ViTMSNPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_vit_msn import (
          VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST,
          ViTMSNForImageClassification,
          ViTMSNModel,
          ViTMSNPreTrainedModel,
      )

else:
   import sys

   UpperCAmelCase_				:			Dict   =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


