






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



class        UpperCamelCase__ (				a_):







    """simple docstring"""







    def 				a__			(		self :	List[Any] ):





           '''simple docstring'''

           __magic_name__      				=    Rectangle(height=0.5				,    width=0.5 )
           __magic_name__      				=    Rectangle(height=0.46				,    width=0.46 ).set_stroke(width=0 )

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

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

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

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

           __magic_name__      				=    Text('Model'				,    font_size=2_4 )
           __magic_name__      				=    Group(UpperCamelCase_				,    UpperCamelCase_ ).arrange(UpperCamelCase_				,    buff=0.5				,    aligned_edge=UpperCamelCase_ )
           model.move_to([3, -1.0, 0] )
           self.add(UpperCamelCase_ )

           __magic_name__      				=    []
           __magic_name__      				=    []

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

                  __magic_name__      				=    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_ )

           __magic_name__      				=    [meta_mem.copy() for i in range(6 )]
           __magic_name__      				=    [meta_mem.copy() for i in range(6 )]
           __magic_name__      				=    VGroup(*UpperCamelCase_ ).arrange(UpperCamelCase_				,    buff=0 )
           __magic_name__      				=    VGroup(*UpperCamelCase_ ).arrange(UpperCamelCase_				,    buff=0 )
           __magic_name__      				=    VGroup(UpperCamelCase_				,    UpperCamelCase_ ).arrange(UpperCamelCase_				,    buff=0 )
           __magic_name__      				=    Text('Disk'				,    font_size=2_4 )
           __magic_name__      				=    Group(UpperCamelCase_				,    UpperCamelCase_ ).arrange(UpperCamelCase_				,    buff=0.5				,    aligned_edge=UpperCamelCase_ )
           disk.move_to([-4, -1.25, 0] )
           self.add(UpperCamelCase_				,    UpperCamelCase_ )

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

           __magic_name__      				=    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(UpperCamelCase_				,    UpperCamelCase_ )

           __magic_name__      				=    MarkupText(
               f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""				,    font_size=1_8				,    )

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

           __magic_name__      				=    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(UpperCamelCase_ ) )

           __magic_name__      				=    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_ ) )

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

           __magic_name__      				=    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(UpperCamelCase_				,    run_time=3 ) )

           __magic_name__      				=    {'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] ) )

           __magic_name__      				=    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 )

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

                  __magic_name__      				=    a_c
                  __magic_name__      				=    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 )				,    )

           __magic_name__      				=    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(UpperCamelCase_				,    run_time=3 )				,    MoveToTarget(UpperCamelCase_ ) )

           self.wait()







"""simple docstring"""
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_mobilebert import MobileBertTokenizer


snake_case : Optional[Any]     		=		logging.get_logger(__name__)

snake_case : str     		=		{"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

snake_case : List[Any]     		=		{
    """vocab_file""": {"""mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/vocab.txt"""},
    """tokenizer_file""": {
        """mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/tokenizer.json"""
    },
}

snake_case : Tuple     		=		{"""mobilebert-uncased""": 5_1_2}


snake_case : List[str]     		=		{}



class        UpperCamelCase__ (				a_):







    """simple docstring"""
    __UpperCAmelCase           = VOCAB_FILES_NAMES
    __UpperCAmelCase           = PRETRAINED_VOCAB_FILES_MAP
    __UpperCAmelCase           = PRETRAINED_INIT_CONFIGURATION
    __UpperCAmelCase           = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    __UpperCAmelCase           = MobileBertTokenizer







    def __init__(		self :	Optional[int]				,    UpperCamelCase_ :	Optional[int]=None				,    UpperCamelCase_ :	str=None				,    UpperCamelCase_ :	Tuple=True				,    UpperCamelCase_ :	Any="[UNK]"				,    UpperCamelCase_ :	str="[SEP]"				,    UpperCamelCase_ :	Any="[PAD]"				,    UpperCamelCase_ :	Dict="[CLS]"				,    UpperCamelCase_ :	str="[MASK]"				,    UpperCamelCase_ :	Union[str, Any]=True				,    UpperCamelCase_ :	Dict=None				,    **UpperCamelCase_ :	Dict				,    ):





           '''simple docstring'''

           super().__init__(
               UpperCamelCase_				,    tokenizer_file=UpperCamelCase_				,    do_lower_case=UpperCamelCase_				,    unk_token=UpperCamelCase_				,    sep_token=UpperCamelCase_				,    pad_token=UpperCamelCase_				,    cls_token=UpperCamelCase_				,    mask_token=UpperCamelCase_				,    tokenize_chinese_chars=UpperCamelCase_				,    strip_accents=UpperCamelCase_				,    **UpperCamelCase_				,    )

           __magic_name__      				=    json.loads(self.backend_tokenizer.normalizer.__getstate__() )
           if (
               normalizer_state.get('lowercase'				,    UpperCamelCase_ ) != do_lower_case
               or normalizer_state.get('strip_accents'				,    UpperCamelCase_ ) != strip_accents
               or normalizer_state.get('handle_chinese_chars'				,    UpperCamelCase_ ) != tokenize_chinese_chars
           ):
                  __magic_name__      				=    getattr(UpperCamelCase_				,    normalizer_state.pop('type' ) )
                  __magic_name__      				=    do_lower_case
                  __magic_name__      				=    strip_accents
                  __magic_name__      				=    tokenize_chinese_chars
                  __magic_name__      				=    normalizer_class(**UpperCamelCase_ )

           __magic_name__      				=    do_lower_case







    def 				a__			(		self :	Dict				,    UpperCamelCase_ :	List[str]				,    UpperCamelCase_ :	List[Any]=None ):





           '''simple docstring'''

           __magic_name__      				=    [self.cls_token_id] + token_ids_a + [self.sep_token_id]

           if token_ids_a:
                  output += token_ids_a + [self.sep_token_id]

           return output







    def 				a__			(		self :	List[Any]				,    UpperCamelCase_ :	List[int]				,    UpperCamelCase_ :	Optional[List[int]] = None ):





           '''simple docstring'''

           __magic_name__      				=    [self.sep_token_id]
           __magic_name__      				=    [self.cls_token_id]
           if token_ids_a is None:
                  return len(cls + token_ids_a + sep ) * [0]
           return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]







    def 				a__			(		self :	List[str]				,    UpperCamelCase_ :	str				,    UpperCamelCase_ :	Optional[str] = None ):





           '''simple docstring'''

           __magic_name__      				=    self._tokenizer.model.save(UpperCamelCase_				,    name=UpperCamelCase_ )
           return tuple(UpperCamelCase_ )