


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_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase      =   {"""configuration_xglm""": ["""XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XGLMConfig"""]}

try:
   if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase      =   ["""XGLMTokenizer"""]

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase      =   ["""XGLMTokenizerFast"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase      =   [
       """XGLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """XGLMForCausalLM""",
       """XGLMModel""",
       """XGLMPreTrainedModel""",
   ]


try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase      =   [
       """FlaxXGLMForCausalLM""",
       """FlaxXGLMModel""",
       """FlaxXGLMPreTrainedModel""",
   ]


try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase      =   [
       """TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFXGLMForCausalLM""",
       """TFXGLMModel""",
       """TFXGLMPreTrainedModel""",
   ]


if TYPE_CHECKING:
   from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig

   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_xglm import XGLMTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_xglm_fast import XGLMTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_xglm import (
          TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFXGLMForCausalLM,
          TFXGLMModel,
          TFXGLMPreTrainedModel,
      )


else:
   import sys

   UpperCAmelCase      =   _LazyModule(__name__, globals()["""__file__"""], _import_structure)