





'''simple docstring'''




from manim import *


class 			SCREAMING_SNAKE_CASE   (a__							):


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						:			str								=	Rectangle(height=0.5						,     width=0.5)
          __A						:			int								=	Rectangle(height=0.46						,     width=0.46).set_stroke(width=0)

          __A						:			Dict								=	Rectangle(height=0.25						,     width=0.25)

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

          __A						:			Dict								=	[mem.copy() for i in range(4)]
          __A						:			Union[str, Any]								=	VGroup(*_UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0)
          __A						:			Any								=	Text('GPU'						,     font_size=24)
          __A						:			Dict								=	Group(_UpperCAmelCase						,     _UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0.5						,     aligned_edge=_UpperCAmelCase)
          gpu.move_to([-1, -1, 0])
          self.add(_UpperCAmelCase)

          __A						:			Optional[int]								=	[mem.copy() for i in range(6)]
          __A						:			List[str]								=	VGroup(*_UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0)

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

          __A						:			List[Any]								=	[]
          __A						:			str								=	[]

          for i, rect in enumerate(_UpperCAmelCase):
               __A						:			List[Any]								=	fill.copy().set_fill(_UpperCAmelCase						,     opacity=0.8)
               target.move_to(_UpperCAmelCase)
               model_arr.append(_UpperCAmelCase)

               __A						:			Dict								=	Rectangle(height=0.46						,     width=0.46).set_stroke(width=0.0).set_fill(_UpperCAmelCase						,     opacity=0.8)
               cpu_target.move_to(cpu_left_col_base[i])
               model_cpu_arr.append(_UpperCAmelCase)

          self.add(*_UpperCAmelCase						,     *_UpperCAmelCase)

          __A						:			Optional[int]								=	[meta_mem.copy() for i in range(6)]
          __A						:			Union[str, Any]								=	[meta_mem.copy() for i in range(6)]
          __A						:			List[str]								=	VGroup(*_UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0)
          __A						:			int								=	VGroup(*_UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0)
          __A						:			Any								=	VGroup(_UpperCAmelCase						,     _UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0)
          __A						:			Optional[int]								=	Text('Disk'						,     font_size=24)
          __A						:			List[str]								=	Group(_UpperCAmelCase						,     _UpperCAmelCase).arrange(_UpperCAmelCase						,     buff=0.5						,     aligned_edge=_UpperCAmelCase)
          disk.move_to([-4, -1.25, 0])
          self.add(_UpperCAmelCase						,     _UpperCAmelCase)

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

          __A						:			str								=	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(_UpperCAmelCase						,     _UpperCAmelCase)

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

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

          __A						:			Optional[int]								=	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(_UpperCAmelCase))

          __A						:			Optional[int]								=	Square(0.3)
          input.set_fill(_UpperCAmelCase						,     opacity=1.0)
          input.set_stroke(width=0.0)
          input.next_to(model_base[0]						,     _UpperCAmelCase						,     buff=0.5)

          self.play(Write(_UpperCAmelCase))

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

          self.play(FadeOut(_UpperCAmelCase))

          __A						:			List[Any]								=	Arrow(start=_UpperCAmelCase						,     end=_UpperCAmelCase						,     color=_UpperCAmelCase						,     buff=0.5)
          a.next_to(model_arr[0].get_left()						,     _UpperCAmelCase						,     buff=0.2)

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

          __A						:			Tuple								=	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(_UpperCAmelCase						,     run_time=3))

          __A						:			Optional[int]								=	{'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

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

          __A						:			Optional[Any]								=	a.copy()
          for i in range(6):
               a_c.next_to(model_arr[i].get_right() + 0.02						,     _UpperCAmelCase						,     buff=0.2)

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

               __A						:			Dict								=	AnimationGroup(
                   FadeOut(_UpperCAmelCase						,     run_time=0.5)						,     MoveToTarget(_UpperCAmelCase						,     run_time=0.5)						,     FadeIn(_UpperCAmelCase						,     run_time=0.5)						,     lag_ratio=0.2)

               self.play(_UpperCAmelCase)

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

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

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

               __A						:			Dict								=	a_c
               __A						:			Union[str, Any]								=	a_c.copy()

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

          __A						:			List[Any]								=	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(_UpperCAmelCase						,     run_time=3)						,     MoveToTarget(_UpperCAmelCase))

          self.wait()






'''simple docstring'''




from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class 			SCREAMING_SNAKE_CASE   (a__							):
     lowerCAmelCase		      =	['''image_processor''', '''tokenizer''']
     lowerCAmelCase		      =	'''AutoImageProcessor'''
     lowerCAmelCase		      =	'''AutoTokenizer'''


     def __init__(						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          super().__init__(_UpperCAmelCase						,     _UpperCAmelCase)
          __A						:			Tuple								=	self.image_processor


     def __call__(						self						,     _UpperCAmelCase=None						,     _UpperCAmelCase=None						,     _UpperCAmelCase=None						,     **_UpperCAmelCase):

          '''simple docstring'''






          if text is None and images is None:
               raise ValueError('You have to specify either text or images. Both cannot be none.')

          if text is not None:
               __A						:			Any								=	self.tokenizer(_UpperCAmelCase						,     return_tensors=_UpperCAmelCase						,     **_UpperCAmelCase)

          if images is not None:
               __A						:			Tuple								=	self.image_processor(_UpperCAmelCase						,     return_tensors=_UpperCAmelCase						,     **_UpperCAmelCase)

          if text is not None and images is not None:
               __A						:			Optional[int]								=	image_features.pixel_values
               return encoding
          elif text is not None:
               return encoding
          else:
               return BatchEncoding(data=dict(**_UpperCAmelCase)						,     tensor_type=_UpperCAmelCase)


     def 							SCREAMING_SNAKE_CASE  (						self						,     *_UpperCAmelCase						,     **_UpperCAmelCase):

          '''simple docstring'''






          return self.tokenizer.batch_decode(*_UpperCAmelCase						,     **_UpperCAmelCase)


     def 							SCREAMING_SNAKE_CASE  (						self						,     *_UpperCAmelCase						,     **_UpperCAmelCase):

          '''simple docstring'''






          return self.tokenizer.decode(*_UpperCAmelCase						,     **_UpperCAmelCase)


     @property
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          return ["input_ids", "attention_mask", "pixel_values"]