




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase								=	{'configuration_deit': ['DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DeiTConfig', 'DeiTOnnxConfig']}

try:
     if not is_vision_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase								=	['DeiTFeatureExtractor']
     UpperCamelCase								=	['DeiTImageProcessor']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase								=	[
         'DEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
         'DeiTForImageClassification',
         'DeiTForImageClassificationWithTeacher',
         'DeiTForMaskedImageModeling',
         'DeiTModel',
         'DeiTPreTrainedModel',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase								=	[
         'TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TFDeiTForImageClassification',
         'TFDeiTForImageClassificationWithTeacher',
         'TFDeiTForMaskedImageModeling',
         'TFDeiTModel',
         'TFDeiTPreTrainedModel',
     ]


if TYPE_CHECKING:
     from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

     try:
          if not is_vision_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .feature_extraction_deit import DeiTFeatureExtractor
          from .image_processing_deit import DeiTImageProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_deit import (
              DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
              DeiTForImageClassification,
              DeiTForImageClassificationWithTeacher,
              DeiTForMaskedImageModeling,
              DeiTModel,
              DeiTPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_deit import (
              TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFDeiTForImageClassification,
              TFDeiTForImageClassificationWithTeacher,
              TFDeiTForMaskedImageModeling,
              TFDeiTModel,
              TFDeiTPreTrainedModel,
          )


else:
     import sys

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


"""simple docstring"""






from manim import *





class 				a__					(						A__       ):



     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Tuple   	=Rectangle(height=0.5      ,  width=0.5   )
      UpperCamelCase_     :					Any   	=Rectangle(height=0.46      ,  width=0.46   ).set_stroke(width=0   )

      UpperCamelCase_     :					Any   	=[mem.copy() for i in range(6   )]
      UpperCamelCase_     :					Optional[int]   	=[mem.copy() for i in range(6   )]
      UpperCamelCase_     :					List[str]   	=VGroup(*_lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0   )
      UpperCamelCase_     :					Optional[int]   	=VGroup(*_lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0   )
      UpperCamelCase_     :					Union[str, Any]   	=VGroup(_lowerCamelCase      ,  _lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0   )
      UpperCamelCase_     :					str   	=Text('CPU'      ,  font_size=24   )
      UpperCamelCase_     :					str   	=Group(_lowerCamelCase      ,  _lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0.5      ,  aligned_edge=_lowerCamelCase   )
      cpu.move_to([-2.5, -0.5, 0]   )
      self.add(_lowerCamelCase   )

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

      UpperCamelCase_     :					List[str]   	=[mem.copy() for i in range(6   )]
      UpperCamelCase_     :					str   	=VGroup(*_lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0   )

      UpperCamelCase_     :					Optional[int]   	=Text('Model'      ,  font_size=24   )
      UpperCamelCase_     :					List[Any]   	=Group(_lowerCamelCase      ,  _lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0.5      ,  aligned_edge=_lowerCamelCase   )
      model.move_to([3, -1.0, 0]   )
      self.add(_lowerCamelCase   )

      UpperCamelCase_     :					int   	=[]
      for i, rect in enumerate(_lowerCamelCase   ):
       rect.set_stroke(_lowerCamelCase   )
       # target = fill.copy().set_fill(YELLOW, opacity=0.7)
       # target.move_to(rect)
       # self.add(target)

       UpperCamelCase_     :					str   	=Rectangle(height=0.46 / 4      ,  width=0.46 / 3   ).set_stroke(width=0.0   ).set_fill(_lowerCamelCase      ,  opacity=0.7   )

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

      UpperCamelCase_     :					List[str]   	=[mem.copy() for i in range(6   )]
      UpperCamelCase_     :					Any   	=VGroup(*_lowerCamelCase   ).arrange(_lowerCamelCase      ,  buff=0   )

      UpperCamelCase_     :					Optional[int]   	=Text('Loaded Checkpoint'      ,  font_size=24   )
      UpperCamelCase_     :					List[Any]   	=Group(_lowerCamelCase      ,  _lowerCamelCase   ).arrange(_lowerCamelCase      ,  aligned_edge=_lowerCamelCase      ,  buff=0.4   )
      checkpoint.move_to([3, 0.5, 0]   )

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

      UpperCamelCase_     :					Optional[Any]   	=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(_lowerCamelCase      ,  _lowerCamelCase   )

      UpperCamelCase_     :					Any   	=MarkupText(
          f'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''      ,  font_size=18      ,  )

      blue_text.next_to(_lowerCamelCase      ,  DOWN * 2.4      ,  aligned_edge=key_text.get_left()   )

      UpperCamelCase_     :					Dict   	=MarkupText(
          f'''Next, a <i><span fgcolor="{BLUE}">second</span></i> model is loaded into memory,\nwith the weights of a <span fgcolor="{BLUE}">single shard</span>.'''      ,  font_size=24      ,  )
      step_a.move_to([2, 2, 0]   )
      self.play(Write(_lowerCamelCase   )      ,  Write(_lowerCamelCase   )   )

      self.play(Write(_lowerCamelCase      ,  run_time=1   )      ,  Create(_lowerCamelCase      ,  run_time=1   )   )

      UpperCamelCase_     :					Union[str, Any]   	=[]
      UpperCamelCase_     :					List[Any]   	=[]
      for i, rect in enumerate(_lowerCamelCase   ):
       UpperCamelCase_     :					str   	=fill.copy().set_fill(_lowerCamelCase      ,  opacity=0.7   )
       target.move_to(_lowerCamelCase   )
       first_animations.append(GrowFromCenter(_lowerCamelCase      ,  run_time=1   )   )

       UpperCamelCase_     :					Any   	=target.copy()
       cpu_target.generate_target()
       if i < 5:
        cpu_target.target.move_to(cpu_left_col_base[i + 1]   )
       else:
        cpu_target.target.move_to(cpu_right_col_base[i - 5]   )
       second_animations.append(MoveToTarget(_lowerCamelCase      ,  run_time=1.5   )   )

      self.play(*_lowerCamelCase   )
      self.play(*_lowerCamelCase   )
      self.wait()
