




from manim import *


class        UpperCAmelCase__				(							a__				):



     '''simple docstring'''
     def        lowerCAmelCase__  (				self	):
            a			   =Rectangle(height=0.5 ,    width=0.5	)
            a			   =Rectangle(height=0.46 ,    width=0.46	).set_stroke(width=0	)
            a			   =Rectangle(height=0.25 ,    width=0.25	)

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

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

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

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

            a			   =[]
            a			   =[]

            for i, rect in enumerate(__UpperCAmelCase	):
                   rect.set_stroke(__UpperCAmelCase	)

                   a			   =Rectangle(height=0.46 / 4 ,    width=0.46 / 3	).set_stroke(width=0.0	).set_fill(__UpperCAmelCase ,    opacity=0.7	)

                   if i == 0:
                          cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT	) ,    buff=0.02 ,    direction=__UpperCAmelCase	)
                          cpu_target.set_x(cpu_target.get_x() + 0.1	)
                   elif i == 3:
                          cpu_target.next_to(model_cpu_arr[0] ,    direction=__UpperCAmelCase ,    buff=0.0	)
                   else:
                          cpu_target.next_to(model_cpu_arr[i - 1] ,    direction=__UpperCAmelCase ,    buff=0.0	)
                   self.add(__UpperCAmelCase	)
                   model_cpu_arr.append(__UpperCAmelCase	)

            self.add(*__UpperCAmelCase ,    *__UpperCAmelCase	)

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

            a			   =[]

            for i in range(6	):
                   a			   =fill.copy().set_fill(__UpperCAmelCase ,    opacity=0.8	)
                   target.move_to(disk_left_col_base[i]	).scale(0.5	)
                   cpu_disk_arr.append(__UpperCAmelCase	)

            self.add(*__UpperCAmelCase	)

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

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

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

            a			   =MarkupText(F'''The offloaded weights are all sent to the CPU.''' ,    font_size=24	)
            step_a.move_to([2, 2, 0]	)

            self.play(Write(__UpperCAmelCase ,    run_time=3	)	)

            for i in range(6	):
                   a			   =cpu_disk_arr[i]
                   a			   =rect.copy().set_fill(__UpperCAmelCase ,    opacity=0.8	).scale(2.0	)
                   cpa.generate_target()
                   cpa.target.move_to(model_base[i]	)

                   if i == 0:
                          rect.set_fill(__UpperCAmelCase ,    opacity=0.8	)
                          rect.generate_target()
                          rect.target.move_to(cpu_left_col_base[0]	).scale(2.0	)

                          self.remove(
                              *__UpperCAmelCase ,    *__UpperCAmelCase ,    )

                   else:
                          rect.generate_target()
                          rect.target.move_to(cpu_left_col_base[i]	).scale(2.0	)
                   self.play(MoveToTarget(__UpperCAmelCase	) ,    MoveToTarget(__UpperCAmelCase	) ,    model_base[i].animate.set_stroke(__UpperCAmelCase	)	)
            self.play(FadeOut(__UpperCAmelCase	)	)

            a			   =MarkupText(
                F'''Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.''' ,    font_size=24 ,    )
            step_a.move_to([2, 2, 0]	)

            self.play(Write(__UpperCAmelCase ,    run_time=3	)	)

            a			   =[]
            a			   =[]
            for i in range(6	):
                   a			   =Arrow(start=__UpperCAmelCase ,    end=__UpperCAmelCase ,    color=__UpperCAmelCase ,    buff=0.5	)
                   a.next_to(model_base[i].get_left() ,    __UpperCAmelCase ,    buff=0.2	)
                   arrows.append(__UpperCAmelCase	)
                   animations.append(Write(__UpperCAmelCase	)	)
            self.play(*__UpperCAmelCase	)
            self.wait()




"""simple docstring"""






from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

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


if TYPE_CHECKING:
   from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


__snake_case												=							logging.get_logger(__name__)

__snake_case												=							{
    '''microsoft/deberta-base''': '''https://huggingface.co/microsoft/deberta-base/resolve/main/config.json''',
    '''microsoft/deberta-large''': '''https://huggingface.co/microsoft/deberta-large/resolve/main/config.json''',
    '''microsoft/deberta-xlarge''': '''https://huggingface.co/microsoft/deberta-xlarge/resolve/main/config.json''',
    '''microsoft/deberta-base-mnli''': '''https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/config.json''',
    '''microsoft/deberta-large-mnli''': '''https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/config.json''',
    '''microsoft/deberta-xlarge-mnli''': '''https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/config.json''',
}


class      __lowerCamelCase	(       a__					):

     '''simple docstring'''
     A_							:						List[Any]     =		'deberta'


     def __init__(   self     ,					__UpperCAmelCase=50265     ,					__UpperCAmelCase=768     ,					__UpperCAmelCase=12     ,					__UpperCAmelCase=12     ,					__UpperCAmelCase=3072     ,					__UpperCAmelCase="gelu"     ,					__UpperCAmelCase=0.1     ,					__UpperCAmelCase=0.1     ,					__UpperCAmelCase=512     ,					__UpperCAmelCase=0     ,					__UpperCAmelCase=0.02     ,					__UpperCAmelCase=1e-7     ,					__UpperCAmelCase=False     ,					__UpperCAmelCase=-1     ,					__UpperCAmelCase=0     ,					__UpperCAmelCase=True     ,					__UpperCAmelCase=None     ,					__UpperCAmelCase=0     ,					__UpperCAmelCase="gelu"     ,					**__UpperCAmelCase     ,					)							->				Any:
          super().__init__(**__UpperCAmelCase				)

          _a     						=					hidden_size
          _a     						=					num_hidden_layers
          _a     						=					num_attention_heads
          _a     						=					intermediate_size
          _a     						=					hidden_act
          _a     						=					hidden_dropout_prob
          _a     						=					attention_probs_dropout_prob
          _a     						=					max_position_embeddings
          _a     						=					type_vocab_size
          _a     						=					initializer_range
          _a     						=					relative_attention
          _a     						=					max_relative_positions
          _a     						=					pad_token_id
          _a     						=					position_biased_input

          # Backwards compatibility
          if type(__UpperCAmelCase				) == str:
               _a     						=					[x.strip() for x in pos_att_type.lower().split('''|'''				)]

          _a     						=					pos_att_type
          _a     						=					vocab_size
          _a     						=					layer_norm_eps

          _a     						=					kwargs.get('''pooler_hidden_size'''     ,					__UpperCAmelCase				)
          _a     						=					pooler_dropout
          _a     						=					pooler_hidden_act







class      __lowerCamelCase	(       a__					):

     '''simple docstring'''


     @property
     def 				_UpperCAmelCase   (   self				)							->				Mapping[str, Mapping[int, str]]:
          if self.task == "multiple-choice":
               _a     						=					{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
          else:
               _a     						=					{0: '''batch''', 1: '''sequence'''}
          if self._config.type_vocab_size > 0:
               return OrderedDict(
                   [('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ('''token_type_ids''', dynamic_axis)]				)
          else:
               return OrderedDict([('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis)]				)


     @property
     def 				_UpperCAmelCase   (   self				)							->				int:
          return 12





     def 				_UpperCAmelCase   (   self     ,					__UpperCAmelCase     ,					__UpperCAmelCase = -1     ,					__UpperCAmelCase = -1     ,					__UpperCAmelCase = -1     ,					__UpperCAmelCase = False     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = 3     ,					__UpperCAmelCase = 40     ,					__UpperCAmelCase = 40     ,					__UpperCAmelCase = None     ,					)							->				Mapping[str, Any]:
          _a     						=					super().generate_dummy_inputs(preprocessor=__UpperCAmelCase     ,					framework=__UpperCAmelCase				)
          if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
               del dummy_inputs["token_type_ids"]
          return dummy_inputs