


from manim import *







class lowerCAmelCase_						(			lowerCamelCase__	):

 '''simple docstring'''

 def 						UpperCamelCase__					(     self ):
       snake_case_	=				Rectangle(height=0.5		,				width=0.5 )
       snake_case_	=				Rectangle(height=0.46		,				width=0.46 ).set_stroke(width=0 )

       snake_case_	=				Rectangle(height=0.25		,				width=0.25 )

       snake_case_	=				[mem.copy() for i in range(6 )]
       snake_case_	=				[mem.copy() for i in range(6 )]
       snake_case_	=				VGroup(*_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				VGroup(*_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				VGroup(_UpperCAmelCase		,				_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				Text('''CPU'''		,				font_size=24 )
       snake_case_	=				Group(_UpperCAmelCase		,				_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0.5		,				aligned_edge=_UpperCAmelCase )
       cpu.move_to([-2.5, -0.5, 0] )
       self.add(_UpperCAmelCase )

       snake_case_	=				[mem.copy() for i in range(4 )]
       snake_case_	=				VGroup(*_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				Text('''GPU'''		,				font_size=24 )
       snake_case_	=				Group(_UpperCAmelCase		,				_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0.5		,				aligned_edge=_UpperCAmelCase )
       gpu.move_to([-1, -1, 0] )
       self.add(_UpperCAmelCase )

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

       snake_case_	=				Text('''Model'''		,				font_size=24 )
       snake_case_	=				Group(_UpperCAmelCase		,				_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0.5		,				aligned_edge=_UpperCAmelCase )
       model.move_to([3, -1.0, 0] )
       self.add(_UpperCAmelCase )

       snake_case_	=				[]
       snake_case_	=				[]

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

             snake_case_	=				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_	=				[meta_mem.copy() for i in range(6 )]
       snake_case_	=				[meta_mem.copy() for i in range(6 )]
       snake_case_	=				VGroup(*_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				VGroup(*_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				VGroup(_UpperCAmelCase		,				_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0 )
       snake_case_	=				Text('''Disk'''		,				font_size=24 )
       snake_case_	=				Group(_UpperCAmelCase		,				_UpperCAmelCase ).arrange(_UpperCAmelCase		,				buff=0.5		,				aligned_edge=_UpperCAmelCase )
       disk.move_to([-4, -1.25, 0] )
       self.add(_UpperCAmelCase		,				_UpperCAmelCase )

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

       snake_case_	=				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_	=				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_	=				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_	=				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_	=				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_	=				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_	=				{'''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_	=				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_	=				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_	=				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_	=				a_c
             snake_case_	=				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_	=				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()



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase      =   {"""configuration_vit_msn""": ["""VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViTMSNConfig"""]}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase      =   [
       """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      =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)