




from manim import *




class       a__	( UpperCamelCase__				):







     def       lowerCAmelCase_    (     self			)  ->   List[Any]:



          '''simple docstring'''



          a     =				Rectangle(height=0.5  ,		width=0.5			)
          a     =				Rectangle(height=0.4_6  ,		width=0.4_6			).set_stroke(width=0			)

          a     =				Rectangle(height=0.2_5  ,		width=0.2_5			)

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

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

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

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

          a     =				[]
          a     =				[]

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

               a     =				Rectangle(height=0.4_6  ,		width=0.4_6			).set_stroke(width=0.0			).set_fill(A  ,		opacity=0.8			)
               cpu_target.move_to(cpu_left_col_base[i]			)
               model_cpu_arr.append(A			)

          self.add(*A  ,		*A			)

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

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

          a     =				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(A  ,		A			)

          a     =				MarkupText(
              F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''  ,		font_size=18  ,		)

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

          a     =				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(A			)			)

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

          self.play(Write(A			)			)

          input.generate_target()
          input.target.next_to(model_arr[0]  ,		direction=A  ,		buff=0.0_2			)
          self.play(MoveToTarget(A			)			)

          self.play(FadeOut(A			)			)

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

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

          a     =				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(A  ,		run_time=3			)			)

          a     =				{"run_time": 1, "fade_in": True, "fade_out": True, "buff": 0.0_2}

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

          a     =				a.copy()
          for i in range(6			):
               a_c.next_to(model_arr[i].get_right() + 0.0_2  ,		A  ,		buff=0.2			)

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

               a     =				AnimationGroup(
                   FadeOut(A  ,		run_time=0.5			)  ,		MoveToTarget(A  ,		run_time=0.5			)  ,		FadeIn(A  ,		run_time=0.5			)  ,		lag_ratio=0.2			)

               self.play(A			)

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

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

                    self.play(
                        Circumscribe(model_arr[-1]  ,		color=A  ,		**A			)  ,		Circumscribe(cpu_left_col_base[-1]  ,		color=A  ,		**A			)  ,		Circumscribe(gpu_rect[0]  ,		color=A  ,		**A			)  ,		)

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

               a     =				a_c
               a     =				a_c.copy()

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

          a     =				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(A  ,		run_time=3			)  ,		MoveToTarget(A			)			)

          self.wait()







import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property




@unittest.skipUnless(os.path.exists(UpperCamelCase__				)       , """Tatoeba directory does not exist."""				)
class       a__	( unittest.TestCase				):







     @cached_property
     def       lowerCAmelCase_    (     self			)  ->   List[str]:



          '''simple docstring'''



          a     =				tempfile.mkdtemp()
          return TatoebaConverter(save_dir=A			)







     @slow
     def       lowerCAmelCase_    (     self			)  ->   int:



          '''simple docstring'''



          self.resolver.convert_models(["heb-eng"]			)







     @slow
     def       lowerCAmelCase_    (     self			)  ->   Dict:



          '''simple docstring'''



          a  ,				a     =				self.resolver.write_model_card("opus-mt-he-en"  ,		dry_run=A			)
          assert mmeta["long_pair"] == "heb-eng"

