


from manim import *



class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					def   lowerCamelCase__					(self   :						Dict		)						->       List[str]:




							"""simple docstring"""


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

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

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

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

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

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

							lowercase__					      =		[]
							lowercase__					      =		[]

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

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

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

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

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

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

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

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

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

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

							lowercase__					      =		{"""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]		)		)

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

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

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

							lowercase__					      =		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()





from collections import OrderedDict
from typing import Mapping

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


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

A	:		Tuple    =       {
    'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json',
    'YituTech/conv-bert-medium-small': (
        'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json'
    ),
    'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json',
    # See all ConvBERT models at https://huggingface.co/models?filter=convbert
}



class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					A__      =			'''convbert'''

					def __init__(self   :						str				, _UpperCAmelCase   :						Union[str, Any]=3_0522				, _UpperCAmelCase   :						Dict=768				, _UpperCAmelCase   :						Optional[int]=12				, _UpperCAmelCase   :						List[str]=12				, _UpperCAmelCase   :						str=3072				, _UpperCAmelCase   :						Tuple="gelu"				, _UpperCAmelCase   :						Optional[int]=0.1				, _UpperCAmelCase   :						int=0.1				, _UpperCAmelCase   :						str=512				, _UpperCAmelCase   :						Dict=2				, _UpperCAmelCase   :						int=0.02				, _UpperCAmelCase   :						Tuple=1E-1_2				, _UpperCAmelCase   :						Dict=1				, _UpperCAmelCase   :						Optional[Any]=0				, _UpperCAmelCase   :						List[str]=2				, _UpperCAmelCase   :						str=768				, _UpperCAmelCase   :						List[Any]=2				, _UpperCAmelCase   :						Optional[Any]=9				, _UpperCAmelCase   :						List[Any]=1				, _UpperCAmelCase   :						Union[str, Any]=None				, **_UpperCAmelCase   :						List[Any]				, )						->       List[str]:




							"""simple docstring"""


							super().__init__(
							    pad_token_id=_UpperCAmelCase				, bos_token_id=_UpperCAmelCase				, eos_token_id=_UpperCAmelCase				, **_UpperCAmelCase				, )

							lowercase__					      =		vocab_size
							lowercase__					      =		hidden_size
							lowercase__					      =		num_hidden_layers
							lowercase__					      =		num_attention_heads
							lowercase__					      =		intermediate_size
							lowercase__					      =		hidden_act
							lowercase__					      =		hidden_dropout_prob
							lowercase__					      =		attention_probs_dropout_prob
							lowercase__					      =		max_position_embeddings
							lowercase__					      =		type_vocab_size
							lowercase__					      =		initializer_range
							lowercase__					      =		layer_norm_eps
							lowercase__					      =		embedding_size
							lowercase__					      =		head_ratio
							lowercase__					      =		conv_kernel_size
							lowercase__					      =		num_groups
							lowercase__					      =		classifier_dropout






class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					@property
					def   lowerCamelCase__					(self   :						Any		)						->       Mapping[str, Mapping[int, str]]:




							"""simple docstring"""


							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),
							        ("""token_type_ids""", dynamic_axis),
							    ]		)

