
'''simple docstring'''
from manim import *


class      _lowerCAmelCase       (       __snake_case ):







							'''simple docstring'''

							def 			lowercase				(self    )	->  List[str]:
														_snake_case  =    Rectangle(height=0.5    ,    width=0.5    )
														_snake_case  =    Rectangle(height=0.46    ,    width=0.46    ).set_stroke(width=0    )

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

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

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

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

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

														_snake_case  =    []
														_snake_case  =    []

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

																					_snake_case  =    Rectangle(height=0.46    ,    width=0.46    ).set_stroke(width=0.0    ).set_fill(SCREAMING_SNAKE_CASE__    ,    opacity=0.8    )
																					cpu_target.move_to(cpu_left_col_base[i]    )
																					model_cpu_arr.append(SCREAMING_SNAKE_CASE__    )

														self.add(*SCREAMING_SNAKE_CASE__    ,    *SCREAMING_SNAKE_CASE__    )

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

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

														_snake_case  =    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(SCREAMING_SNAKE_CASE__    ,    SCREAMING_SNAKE_CASE__    )

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

														blue_text.next_to(SCREAMING_SNAKE_CASE__    ,    DOWN * 2.4    ,    aligned_edge=key_text.get_left()    )
														self.add(SCREAMING_SNAKE_CASE__    )

														_snake_case  =    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(SCREAMING_SNAKE_CASE__    )    )

														_snake_case  =    Square(0.3    )
														input.set_fill(SCREAMING_SNAKE_CASE__    ,    opacity=1.0    )
														input.set_stroke(width=0.0    )
														input.next_to(model_base[0]    ,    SCREAMING_SNAKE_CASE__    ,    buff=0.5    )

														self.play(Write(SCREAMING_SNAKE_CASE__    )    )

														input.generate_target()
														input.target.next_to(model_arr[0]    ,    direction=SCREAMING_SNAKE_CASE__    ,    buff=0.02    )
														self.play(MoveToTarget(SCREAMING_SNAKE_CASE__    )    )

														self.play(FadeOut(SCREAMING_SNAKE_CASE__    )    )

														_snake_case  =    Arrow(start=SCREAMING_SNAKE_CASE__    ,    end=SCREAMING_SNAKE_CASE__    ,    color=SCREAMING_SNAKE_CASE__    ,    buff=0.5    )
														a.next_to(model_arr[0].get_left()    ,    SCREAMING_SNAKE_CASE__    ,    buff=0.2    )

														model_cpu_arr[0].generate_target()
														model_cpu_arr[0].target.move_to(gpu_rect[0]    )

														_snake_case  =    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(SCREAMING_SNAKE_CASE__    ,    run_time=3    )    )

														_snake_case  =    {"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.02}

														self.play(
														    Write(SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(model_arr[0]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(model_cpu_arr[0]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(gpu_rect[0]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    )
														self.play(MoveToTarget(model_cpu_arr[0]    )    )

														_snake_case  =    a.copy()
														for i in range(6    ):
																					a_c.next_to(model_arr[i].get_right() + 0.02    ,    SCREAMING_SNAKE_CASE__    ,    buff=0.2    )

																					input.generate_target()
																					input.target.move_to(model_arr[i].get_right() + 0.02    )

																					_snake_case  =    AnimationGroup(
																					    FadeOut(SCREAMING_SNAKE_CASE__    ,    run_time=0.5    )    ,    MoveToTarget(SCREAMING_SNAKE_CASE__    ,    run_time=0.5    )    ,    FadeIn(SCREAMING_SNAKE_CASE__    ,    run_time=0.5    )    ,    lag_ratio=0.2    )

																					self.play(SCREAMING_SNAKE_CASE__    )

																					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:
																																			_snake_case  =    0.7

																												self.play(
																												    Circumscribe(model_arr[i]    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(cpu_left_col_base[i]    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(cpu_left_col_base[i + 1]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(gpu_rect[0]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(model_arr[i + 1]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    )
																												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=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(cpu_left_col_base[-1]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    Circumscribe(gpu_rect[0]    ,    color=SCREAMING_SNAKE_CASE__    ,    **SCREAMING_SNAKE_CASE__    )    ,    )

																												self.play(MoveToTarget(model_cpu_arr[i]    )    )

																					_snake_case  =    a_c
																					_snake_case  =    a_c.copy()

														input.generate_target()
														input.target.next_to(model_base[-1]    ,    RIGHT + 0.02    ,    buff=0.5    )
														self.play(
														    FadeOut(SCREAMING_SNAKE_CASE__    )    ,    FadeOut(SCREAMING_SNAKE_CASE__    ,    run_time=0.5    )    ,    )

														_snake_case  =    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(SCREAMING_SNAKE_CASE__    ,    run_time=3    )    ,    MoveToTarget(SCREAMING_SNAKE_CASE__    )    )

														self.wait()

import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format
class       _lowerCAmelCase  :

 """simple docstring"""
 SCREAMING_SNAKE_CASE_				:					Optional[Any]       						=None

 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.feature_extraction_class(**self.feat_extract_dict   )
      UpperCamelCase						    =					json.loads(feat_extract.to_json_string()   )
      for key, value in self.feat_extract_dict.items():
           self.assertEqual(obj[key]					, SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					self.feature_extraction_class(**self.feat_extract_dict   )

      with tempfile.TemporaryDirectory() as tmpdirname:
           UpperCamelCase						    =					os.path.join(SCREAMING_SNAKE_CASE__					, 'feat_extract.json'   )
           feat_extract_first.to_json_file(SCREAMING_SNAKE_CASE__   )
           UpperCamelCase						    =					self.feature_extraction_class.from_json_file(SCREAMING_SNAKE_CASE__   )

      self.assertEqual(feat_extract_second.to_dict()					, feat_extract_first.to_dict()   )

 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					self.feature_extraction_class(**self.feat_extract_dict   )

      with tempfile.TemporaryDirectory() as tmpdirname:
           UpperCamelCase						    =					feat_extract_first.save_pretrained(SCREAMING_SNAKE_CASE__   )[0]
           check_json_file_has_correct_format(SCREAMING_SNAKE_CASE__   )
           UpperCamelCase						    =					self.feature_extraction_class.from_pretrained(SCREAMING_SNAKE_CASE__   )

      self.assertEqual(feat_extract_second.to_dict()					, feat_extract_first.to_dict()   )






 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					self.feature_extraction_class()
      self.assertIsNotNone(SCREAMING_SNAKE_CASE__   )


