





'''simple docstring'''






import os
import sys

A__    :       Tuple              =os.path.join(os.path.dirname(__file__), '''src''')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


A__    :       int              =[
    '''torch''',
    '''numpy''',
    '''tokenizers''',
    '''filelock''',
    '''requests''',
    '''tqdm''',
    '''regex''',
    '''sentencepiece''',
    '''sacremoses''',
    '''importlib_metadata''',
    '''huggingface_hub''',
]
@add_start_docstrings(AutoConfig.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoConfig.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )
@add_start_docstrings(AutoTokenizer.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoTokenizer.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )
@add_start_docstrings(AutoModel.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoModel.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )
@add_start_docstrings(AutoModelForCausalLM.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoModelForCausalLM.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )
@add_start_docstrings(AutoModelForMaskedLM.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoModelForMaskedLM.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )
@add_start_docstrings(AutoModelForSequenceClassification.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoModelForSequenceClassification.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__  )
def        UpperCamelCase__				(		*lowerCAmelCase							,     **lowerCAmelCase  ):





      """simple docstring"""


      return AutoModelForQuestionAnswering.from_pretrained(*lowerCAmelCase							,     **lowerCAmelCase  )













'''simple docstring'''






from manim import *




class 			UpperCAmelCase					(      snake_case_       ):




      def     lowercase__   (      self      :			Union[str, Any]  )    ->				str:
            _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(*__snake_case  ).arrange(__snake_case      ,      buff=0  )
            _lowerCAmelCase												=							VGroup(*__snake_case  ).arrange(__snake_case      ,      buff=0  )
            _lowerCAmelCase												=							VGroup(__snake_case      ,      __snake_case  ).arrange(__snake_case      ,      buff=0  )
            _lowerCAmelCase												=							Text("""CPU"""      ,      font_size=24  )
            _lowerCAmelCase												=							Group(__snake_case      ,      __snake_case  ).arrange(__snake_case      ,      buff=0.5      ,      aligned_edge=__snake_case  )
            cpu.move_to([-2.5, -0.5, 0]  )
            self.add(__snake_case  )

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

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

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

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

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

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

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

            _lowerCAmelCase												=							Text("""Loaded Checkpoint"""      ,      font_size=24  )
            _lowerCAmelCase												=							Group(__snake_case      ,      __snake_case  ).arrange(__snake_case      ,      aligned_edge=__snake_case      ,      buff=0.4  )
            checkpoint.move_to([3, 0.5, 0]  )

            _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(__snake_case      ,      __snake_case  )

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

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

            _lowerCAmelCase												=							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(__snake_case  )      ,      Write(__snake_case  )  )

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

            _lowerCAmelCase												=							[]
            _lowerCAmelCase												=							[]
            for i, rect in enumerate(__snake_case  ):
                  _lowerCAmelCase												=							fill.copy().set_fill(__snake_case      ,      opacity=0.7  )
                  target.move_to(__snake_case  )
                  first_animations.append(GrowFromCenter(__snake_case      ,      run_time=1  )  )

                  _lowerCAmelCase												=							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(__snake_case      ,      run_time=1.5  )  )

            self.play(*__snake_case  )
            self.play(*__snake_case  )
            self.wait()






