
from manim import *




class      __A(    __lowerCamelCase			):

  """simple docstring"""







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

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

       UpperCamelCase__				=    [mem.copy() for i in range(6						)]
       UpperCamelCase__				=    [mem.copy() for i in range(6						)]
       UpperCamelCase__				=    VGroup(*SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    VGroup(*SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    VGroup(SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    Text("""CPU"""	,      font_size=24						)
       UpperCamelCase__				=    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__				=    [mem.copy() for i in range(4						)]
       UpperCamelCase__				=    VGroup(*SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    Text("""GPU"""	,      font_size=24						)
       UpperCamelCase__				=    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__				=    [mem.copy() for i in range(6						)]
       UpperCamelCase__				=    VGroup(*SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)

       UpperCamelCase__				=    Text("""Model"""	,      font_size=24						)
       UpperCamelCase__				=    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__				=    []
       UpperCamelCase__				=    []

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

            UpperCamelCase__				=    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__				=    [meta_mem.copy() for i in range(6						)]
       UpperCamelCase__				=    [meta_mem.copy() for i in range(6						)]
       UpperCamelCase__				=    VGroup(*SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    VGroup(*SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    VGroup(SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						).arrange(SCREAMING_SNAKE_CASE_	,      buff=0						)
       UpperCamelCase__				=    Text("""Disk"""	,      font_size=24						)
       UpperCamelCase__				=    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__				=    Square(side_length=2.2						)
       key.move_to([-5, 2, 0]						)

       UpperCamelCase__				=    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__				=    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__				=    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__				=    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__				=    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__				=    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__				=    {"""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__				=    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__				=    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__				=    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__				=    a_c
            UpperCamelCase__				=    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__				=    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()







from typing import TYPE_CHECKING

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


lowerCamelCase_						     =					{
    '''configuration_canine''': ['''CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CanineConfig'''],
    '''tokenization_canine''': ['''CanineTokenizer'''],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase_						     =					[
        '''CANINE_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''CanineForMultipleChoice''',
        '''CanineForQuestionAnswering''',
        '''CanineForSequenceClassification''',
        '''CanineForTokenClassification''',
        '''CanineLayer''',
        '''CanineModel''',
        '''CaninePreTrainedModel''',
        '''load_tf_weights_in_canine''',
    ]


if TYPE_CHECKING:
    from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig
    from .tokenization_canine import CanineTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_canine import (
            CANINE_PRETRAINED_MODEL_ARCHIVE_LIST,
            CanineForMultipleChoice,
            CanineForQuestionAnswering,
            CanineForSequenceClassification,
            CanineForTokenClassification,
            CanineLayer,
            CanineModel,
            CaninePreTrainedModel,
            load_tf_weights_in_canine,
        )


else:
    import sys

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





