

'''simple docstring'''






from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCAmelCase__   		=      logging.get_logger(__name__)

lowerCAmelCase__   		=      {
    '''distilbert-base-uncased''': '''https://huggingface.co/distilbert-base-uncased/resolve/main/config.json''',
    '''distilbert-base-uncased-distilled-squad''': (
        '''https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json'''
    ),
    '''distilbert-base-cased''': '''https://huggingface.co/distilbert-base-cased/resolve/main/config.json''',
    '''distilbert-base-cased-distilled-squad''': (
        '''https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json'''
    ),
    '''distilbert-base-german-cased''': '''https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json''',
    '''distilbert-base-multilingual-cased''': (
        '''https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json'''
    ),
    '''distilbert-base-uncased-finetuned-sst-2-english''': (
        '''https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json'''
    ),
}






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE       :    List[Any]							     =     'distilbert'
  SCREAMING_SNAKE_CASE       :    Any							     =     {
      'hidden_size': 'dim',
      'num_attention_heads': 'n_heads',
      'num_hidden_layers': 'n_layers',
  }






  def __init__( self  :	Union[str, Any]   ,lowercase__  :	List[Any]=3_0_5_2_2   ,lowercase__  :	Optional[int]=5_1_2   ,lowercase__  :	Optional[int]=False   ,lowercase__  :	Optional[Any]=6   ,lowercase__  :	Optional[int]=1_2   ,lowercase__  :	List[Any]=7_6_8   ,lowercase__  :	Any=4 * 7_6_8   ,lowercase__  :	Tuple=0.1   ,lowercase__  :	Tuple=0.1   ,lowercase__  :	List[str]="gelu"   ,lowercase__  :	List[Any]=0.0_2   ,lowercase__  :	Optional[int]=0.1   ,lowercase__  :	Optional[Any]=0.2   ,lowercase__  :	List[str]=0   ,**lowercase__  :	Tuple   ,):
   __lowercase				    =					vocab_size
   __lowercase				    =					max_position_embeddings
   __lowercase				    =					sinusoidal_pos_embds
   __lowercase				    =					n_layers
   __lowercase				    =					n_heads
   __lowercase				    =					dim
   __lowercase				    =					hidden_dim
   __lowercase				    =					dropout
   __lowercase				    =					attention_dropout
   __lowercase				    =					activation
   __lowercase				    =					initializer_range
   __lowercase				    =					qa_dropout
   __lowercase				    =					seq_classif_dropout
   super().__init__(**lowercase__   ,pad_token_id=lowercase__     )






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  @property
  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   if self.task == "multiple-choice":
    __lowercase				    =					{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
   else:
    __lowercase				    =					{0: '''batch''', 1: '''sequence'''}
   return OrderedDict(
       [
           ('''input_ids''', dynamic_axis),
           ('''attention_mask''', dynamic_axis),
       ]     )


'''simple docstring'''




from manim import *




class        a__ (  UpperCAmelCase__					):






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]       ):





         """simple docstring"""



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

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

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

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

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

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

         __lowerCamelCase            =    []
         __lowerCamelCase            =    []

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

             __lowerCamelCase            =    Rectangle(height=0.46    ,							width=0.46       ).set_stroke(width=0.0       ).set_fill(a    ,							opacity=0.8       )
             cpu_target.move_to(cpu_left_col_base[i]       )
             model_cpu_arr.append(a       )

         self.add(*a    ,							*a       )

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

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

         __lowerCamelCase            =    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(a    ,							a       )

         __lowerCamelCase            =    MarkupText(
             f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""    ,							font_size=18    ,							)

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

         __lowerCamelCase            =    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(a       )       )

         __lowerCamelCase            =    Square(0.3       )
         input.set_fill(a    ,							opacity=1.0       )
         input.set_stroke(width=0.0       )
         input.next_to(model_base[0]    ,							a    ,							buff=0.5       )

         self.play(Write(a       )       )

         input.generate_target()
         input.target.next_to(model_arr[0]    ,							direction=a    ,							buff=0.02       )
         self.play(MoveToTarget(a       )       )

         self.play(FadeOut(a       )       )

         __lowerCamelCase            =    Arrow(start=a    ,							end=a    ,							color=a    ,							buff=0.5       )
         a.next_to(model_arr[0].get_left()    ,							a    ,							buff=0.2       )

         model_cpu_arr[0].generate_target()
         model_cpu_arr[0].target.move_to(gpu_rect[0]       )

         __lowerCamelCase            =    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(a    ,							run_time=3       )       )

         __lowerCamelCase            =    {'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.02}

         self.play(
             Write(a       )    ,							Circumscribe(model_arr[0]    ,							color=a    ,							**a       )    ,							Circumscribe(model_cpu_arr[0]    ,							color=a    ,							**a       )    ,							Circumscribe(gpu_rect[0]    ,							color=a    ,							**a       )    ,							)
         self.play(MoveToTarget(model_cpu_arr[0]       )       )

         __lowerCamelCase            =    a.copy()
         for i in range(6       ):
             a_c.next_to(model_arr[i].get_right() + 0.02    ,							a    ,							buff=0.2       )

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

             __lowerCamelCase            =    AnimationGroup(
                 FadeOut(a    ,							run_time=0.5       )    ,							MoveToTarget(a    ,							run_time=0.5       )    ,							FadeIn(a    ,							run_time=0.5       )    ,							lag_ratio=0.2       )

             self.play(a       )

             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:
                     __lowerCamelCase            =    0.7

                 self.play(
                     Circumscribe(model_arr[i]    ,							**a       )    ,							Circumscribe(cpu_left_col_base[i]    ,							**a       )    ,							Circumscribe(cpu_left_col_base[i + 1]    ,							color=a    ,							**a       )    ,							Circumscribe(gpu_rect[0]    ,							color=a    ,							**a       )    ,							Circumscribe(model_arr[i + 1]    ,							color=a    ,							**a       )    ,							)
                 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=a    ,							**a       )    ,							Circumscribe(cpu_left_col_base[-1]    ,							color=a    ,							**a       )    ,							Circumscribe(gpu_rect[0]    ,							color=a    ,							**a       )    ,							)

                 self.play(MoveToTarget(model_cpu_arr[i]       )       )

             __lowerCamelCase            =    a_c
             __lowerCamelCase            =    a_c.copy()

         input.generate_target()
         input.target.next_to(model_base[-1]    ,							RIGHT + 0.02    ,							buff=0.5       )
         self.play(
             FadeOut(a       )    ,							FadeOut(a    ,							run_time=0.5       )    ,							)

         __lowerCamelCase            =    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(a    ,							run_time=3       )    ,							MoveToTarget(a       )       )

         self.wait()
