






'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase    :      Optional[Any]  			=		{
    'configuration_electra': ['ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ElectraConfig', 'ElectraOnnxConfig'],
    'tokenization_electra': ['ElectraTokenizer'],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase    :      Optional[Any]  			=		['ElectraTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase    :      str  			=		[
							    'ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'ElectraForCausalLM',
							    'ElectraForMaskedLM',
							    'ElectraForMultipleChoice',
							    'ElectraForPreTraining',
							    'ElectraForQuestionAnswering',
							    'ElectraForSequenceClassification',
							    'ElectraForTokenClassification',
							    'ElectraModel',
							    'ElectraPreTrainedModel',
							    'load_tf_weights_in_electra',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase    :      Optional[Any]  			=		[
							    'TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFElectraForMaskedLM',
							    'TFElectraForMultipleChoice',
							    'TFElectraForPreTraining',
							    'TFElectraForQuestionAnswering',
							    'TFElectraForSequenceClassification',
							    'TFElectraForTokenClassification',
							    'TFElectraModel',
							    'TFElectraPreTrainedModel',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase    :      Dict  			=		[
							    'FlaxElectraForCausalLM',
							    'FlaxElectraForMaskedLM',
							    'FlaxElectraForMultipleChoice',
							    'FlaxElectraForPreTraining',
							    'FlaxElectraForQuestionAnswering',
							    'FlaxElectraForSequenceClassification',
							    'FlaxElectraForTokenClassification',
							    'FlaxElectraModel',
							    'FlaxElectraPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
							from .tokenization_electra import ElectraTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_electra_fast import ElectraTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_electra import (
														    ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ElectraForCausalLM,
														    ElectraForMaskedLM,
														    ElectraForMultipleChoice,
														    ElectraForPreTraining,
														    ElectraForQuestionAnswering,
														    ElectraForSequenceClassification,
														    ElectraForTokenClassification,
														    ElectraModel,
														    ElectraPreTrainedModel,
														    load_tf_weights_in_electra,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_electra import (
														    TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFElectraForMaskedLM,
														    TFElectraForMultipleChoice,
														    TFElectraForPreTraining,
														    TFElectraForQuestionAnswering,
														    TFElectraForSequenceClassification,
														    TFElectraForTokenClassification,
														    TFElectraModel,
														    TFElectraPreTrainedModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_electra import (
														    FlaxElectraForCausalLM,
														    FlaxElectraForMaskedLM,
														    FlaxElectraForMultipleChoice,
														    FlaxElectraForPreTraining,
														    FlaxElectraForQuestionAnswering,
														    FlaxElectraForSequenceClassification,
														    FlaxElectraForTokenClassification,
														    FlaxElectraModel,
														    FlaxElectraPreTrainedModel,
														)

else:
							import sys

							UpperCamelCase    :      Optional[int]  			=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)









'''simple docstring'''







from manim import *




class 		UpperCamelCase__    (a			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  Rectangle(height=0.5   ,width=0.5       )
								lowerCamelCase__         =  Rectangle(height=0.46   ,width=0.46       ).set_stroke(width=0       )

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

								lowerCamelCase__         =  [mem.copy() for i in range(1       )]
								lowerCamelCase__         =  VGroup(*_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0       )
								lowerCamelCase__         =  Text("""GPU"""   ,font_size=24       )
								lowerCamelCase__         =  Group(_lowerCAmelCase   ,_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0.5   ,aligned_edge=_lowerCAmelCase       )
								gpu.align_to(_lowerCAmelCase   ,_lowerCAmelCase       )
								gpu.set_x(gpu.get_x() - 1       )

								self.add(_lowerCAmelCase       )

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

								lowerCamelCase__         =  Text("""Model"""   ,font_size=24       )
								lowerCamelCase__         =  Group(_lowerCAmelCase   ,_lowerCAmelCase       ).arrange(_lowerCAmelCase   ,buff=0.5   ,aligned_edge=_lowerCAmelCase       )
								model.move_to([3, -1.0, 0]       )

								self.play(
								    Create(_lowerCAmelCase   ,run_time=1       )   ,Create(_lowerCAmelCase   ,run_time=1       )   ,Create(_lowerCAmelCase   ,run_time=1       )   ,)

								lowerCamelCase__         =  MarkupText(
								    F'''First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.'''   ,font_size=24   ,)

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

								step_a.move_to([2, 2, 0]       )
								self.play(Write(_lowerCAmelCase   ,run_time=2.5       )   ,Write(_lowerCAmelCase       )   ,Write(_lowerCAmelCase       )       )

								self.add(_lowerCAmelCase       )

								lowerCamelCase__         =  []
								lowerCamelCase__         =  []
								lowerCamelCase__         =  []
								for i, rect in enumerate(_lowerCAmelCase       ):
														lowerCamelCase__         =  Rectangle(height=0.46   ,width=0.46       ).set_stroke(width=0.0       ).set_fill(_lowerCAmelCase   ,opacity=0.7       )
														cpu_target.move_to(_lowerCAmelCase       )
														cpu_target.generate_target()
														lowerCamelCase__         =  0.46 / 4
														lowerCamelCase__         =  0.46 / 3

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

														first_animations.append(rect.animate(run_time=0.5       ).set_stroke(_lowerCAmelCase       )       )
														second_animations.append(MoveToTarget(_lowerCAmelCase   ,run_time=1.5       )       )

								self.play(*_lowerCAmelCase       )
								self.play(*_lowerCAmelCase       )

								self.wait()

