

"""simple docstring"""






from manim import *
class        _lowercase					(     __UpperCAmelCase     ):







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      Rectangle(height=0.5 ,						width=0.5       )
      __magic_name__     =      Rectangle(height=0.4_6 ,						width=0.4_6       ).set_stroke(width=0       )

      __magic_name__     =      Rectangle(height=0.2_5 ,						width=0.2_5       )

      __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=24       )
      __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=24       )
      __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=24       )
      __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.4_6 ,						width=0.4_6       ).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=24       )
      __magic_name__     =      Group(UpperCamelCase_ ,						UpperCamelCase_       ).arrange(UpperCamelCase_ ,						buff=0.5 ,						aligned_edge=UpperCamelCase_       )
      disk.move_to([-4, -1.2_5, 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=18 ,						)

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

      self.add(UpperCamelCase_ ,						UpperCamelCase_       )

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

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

      __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.0_2       )
      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=24 ,						)
      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.0_2}

      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.0_2 ,						UpperCamelCase_ ,						buff=0.2       )

       input.generate_target()
       input.target.move_to(model_arr[i].get_right() + 0.0_2       )

       __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.0_2 ,						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.0_2 ,						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=24       )
      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_bert import BertTokenizer


__lowerCamelCase										=		logging.get_logger(__name__)

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

__lowerCamelCase										=		{
    "vocab_file": {
        "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt",
        "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt",
        "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/vocab.txt",
        "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/vocab.txt",
        "bert-base-multilingual-uncased": (
            "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt"
        ),
        "bert-base-multilingual-cased": "https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt",
        "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt",
        "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt",
        "bert-large-uncased-whole-word-masking": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt"
        ),
        "bert-large-cased-whole-word-masking": (
            "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt"
        ),
        "bert-large-uncased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"
        ),
        "bert-large-cased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"
        ),
        "bert-base-cased-finetuned-mrpc": (
            "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt"
        ),
        "bert-base-german-dbmdz-cased": "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt",
        "bert-base-german-dbmdz-uncased": (
            "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt"
        ),
        "TurkuNLP/bert-base-finnish-cased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt"
        ),
        "TurkuNLP/bert-base-finnish-uncased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt"
        ),
        "wietsedv/bert-base-dutch-cased": (
            "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json",
        "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json",
        "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json",
        "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json",
        "bert-base-multilingual-uncased": (
            "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json"
        ),
        "bert-base-multilingual-cased": (
            "https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json"
        ),
        "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json",
        "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json",
        "bert-large-uncased-whole-word-masking": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json"
        ),
        "bert-large-cased-whole-word-masking": (
            "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json"
        ),
        "bert-large-uncased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"
        ),
        "bert-large-cased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"
        ),
        "bert-base-cased-finetuned-mrpc": (
            "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json"
        ),
        "bert-base-german-dbmdz-cased": (
            "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json"
        ),
        "bert-base-german-dbmdz-uncased": (
            "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json"
        ),
        "TurkuNLP/bert-base-finnish-cased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json"
        ),
        "TurkuNLP/bert-base-finnish-uncased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json"
        ),
        "wietsedv/bert-base-dutch-cased": (
            "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json"
        ),
    },
}

__lowerCamelCase										=		{
    "bert-base-uncased": 5_12,
    "bert-large-uncased": 5_12,
    "bert-base-cased": 5_12,
    "bert-large-cased": 5_12,
    "bert-base-multilingual-uncased": 5_12,
    "bert-base-multilingual-cased": 5_12,
    "bert-base-chinese": 5_12,
    "bert-base-german-cased": 5_12,
    "bert-large-uncased-whole-word-masking": 5_12,
    "bert-large-cased-whole-word-masking": 5_12,
    "bert-large-uncased-whole-word-masking-finetuned-squad": 5_12,
    "bert-large-cased-whole-word-masking-finetuned-squad": 5_12,
    "bert-base-cased-finetuned-mrpc": 5_12,
    "bert-base-german-dbmdz-cased": 5_12,
    "bert-base-german-dbmdz-uncased": 5_12,
    "TurkuNLP/bert-base-finnish-cased-v1": 5_12,
    "TurkuNLP/bert-base-finnish-uncased-v1": 5_12,
    "wietsedv/bert-base-dutch-cased": 5_12,
}

__lowerCamelCase										=		{
    "bert-base-uncased": {"do_lower_case": True},
    "bert-large-uncased": {"do_lower_case": True},
    "bert-base-cased": {"do_lower_case": False},
    "bert-large-cased": {"do_lower_case": False},
    "bert-base-multilingual-uncased": {"do_lower_case": True},
    "bert-base-multilingual-cased": {"do_lower_case": False},
    "bert-base-chinese": {"do_lower_case": False},
    "bert-base-german-cased": {"do_lower_case": False},
    "bert-large-uncased-whole-word-masking": {"do_lower_case": True},
    "bert-large-cased-whole-word-masking": {"do_lower_case": False},
    "bert-large-uncased-whole-word-masking-finetuned-squad": {"do_lower_case": True},
    "bert-large-cased-whole-word-masking-finetuned-squad": {"do_lower_case": False},
    "bert-base-cased-finetuned-mrpc": {"do_lower_case": False},
    "bert-base-german-dbmdz-cased": {"do_lower_case": False},
    "bert-base-german-dbmdz-uncased": {"do_lower_case": True},
    "TurkuNLP/bert-base-finnish-cased-v1": {"do_lower_case": False},
    "TurkuNLP/bert-base-finnish-uncased-v1": {"do_lower_case": True},
    "wietsedv/bert-base-dutch-cased": {"do_lower_case": False},
}
class        _lowercase					(     __UpperCAmelCase     ):
     _lowerCamelCase     =       VOCAB_FILES_NAMES
     _lowerCamelCase     =       PRETRAINED_VOCAB_FILES_MAP
     _lowerCamelCase     =       PRETRAINED_INIT_CONFIGURATION
     _lowerCamelCase     =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     _lowerCamelCase     =       BertTokenizer







     def __init__(      self ,						UpperCamelCase_=None ,						UpperCamelCase_=None ,						UpperCamelCase_=True ,						UpperCamelCase_="[UNK]" ,						UpperCamelCase_="[SEP]" ,						UpperCamelCase_="[PAD]" ,						UpperCamelCase_="[CLS]" ,						UpperCamelCase_="[MASK]" ,						UpperCamelCase_=True ,						UpperCamelCase_=None ,						**UpperCamelCase_ ,						):
      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 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_=None       ):
      __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 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_ = None       ):
      __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 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_ = None       ):
      __magic_name__     =      self._tokenizer.model.save(UpperCamelCase_ ,						name=UpperCamelCase_       )
      return tuple(UpperCamelCase_       )

