



from manim import *


class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






					def     _a							(     self					:       List[Any]					):






								"""simple docstring"""


								A__       =    Rectangle(height=0.5				,					width=0.5					)
								A__       =    Rectangle(height=0.46				,					width=0.46					).set_stroke(width=0					)

								A__       =    [mem.copy() for i in range(6					)]
								A__       =    [mem.copy() for i in range(6					)]
								A__       =    VGroup(*_snake_case					).arrange(_snake_case				,					buff=0					)
								A__       =    VGroup(*_snake_case					).arrange(_snake_case				,					buff=0					)
								A__       =    VGroup(_snake_case				,					_snake_case					).arrange(_snake_case				,					buff=0					)
								A__       =    Text('CPU'				,					font_size=24					)
								A__       =    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					)

								A__       =    [mem.copy() for i in range(1					)]
								A__       =    VGroup(*_snake_case					).arrange(_snake_case				,					buff=0					)
								A__       =    Text('GPU'				,					font_size=24					)
								A__       =    Group(_snake_case				,					_snake_case					).arrange(_snake_case				,					buff=0.5				,					aligned_edge=_snake_case					)
								gpu.align_to(_snake_case				,					_snake_case					)
								gpu.set_x(gpu.get_x() - 1					)

								self.add(_snake_case					)

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

								A__       =    Text('Model'				,					font_size=24					)
								A__       =    Group(_snake_case				,					_snake_case					).arrange(_snake_case				,					buff=0.5				,					aligned_edge=_snake_case					)
								model.move_to([3, -1.0, 0]					)

								self.play(
								    Create(_snake_case				,					run_time=1					)				,					Create(_snake_case				,					run_time=1					)				,					Create(_snake_case				,					run_time=1					)				,					)

								A__       =    MarkupText(
								    F'''First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.'''				,					font_size=24				,					)

								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]					)

								step_a.move_to([2, 2, 0]					)
								self.play(Write(_snake_case				,					run_time=2.5					)				,					Write(_snake_case					)				,					Write(_snake_case					)					)

								self.add(_snake_case					)

								A__       =    []
								A__       =    []
								A__       =    []
								for i, rect in enumerate(_snake_case					):
											A__       =    Rectangle(height=0.46				,					width=0.46					).set_stroke(width=0.0					).set_fill(_snake_case				,					opacity=0.7					)
											cpu_target.move_to(_snake_case					)
											cpu_target.generate_target()
											A__       =    0.46 / 4
											A__       =    0.46 / 3

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

											first_animations.append(rect.animate(run_time=0.5					).set_stroke(_snake_case					)					)
											second_animations.append(MoveToTarget(_snake_case				,					run_time=1.5					)					)

								self.play(*_snake_case					)
								self.play(*_snake_case					)

								self.wait()









from typing import Dict

from .base import GenericTensor, Pipeline


class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






					def     _a							(     self					:       Any				,					_snake_case					:       str=None				,					_snake_case					:       Dict=None				,					_snake_case					:       Any=None				,					**_snake_case					:       str					):






								"""simple docstring"""


								if tokenize_kwargs is None:
											A__       =    {}

								if truncation is not None:
											if "truncation" in tokenize_kwargs:
														raise ValueError(
														    'truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)'					)
											A__       =    truncation

								A__       =    tokenize_kwargs

								A__       =    {}
								if return_tensors is not None:
											A__       =    return_tensors

								return preprocess_params, {}, postprocess_params



					def     _a							(     self					:       Any				,					_snake_case					:       Dict				,					**_snake_case					:       Optional[Any]					):






								"""simple docstring"""


								A__       =    self.framework
								A__       =    self.tokenizer(_snake_case				,					return_tensors=_snake_case				,					**_snake_case					)
								return model_inputs



					def     _a							(     self					:       List[Any]				,					_snake_case					:       Dict					):






								"""simple docstring"""


								A__       =    self.model(**_snake_case					)
								return model_outputs



					def     _a							(     self					:       Optional[Any]				,					_snake_case					:       List[Any]				,					_snake_case					:       str=False					):






								"""simple docstring"""


								if return_tensors:
											return model_outputs[0]
								if self.framework == "pt":
											return model_outputs[0].tolist()
								elif self.framework == "tf":
											return model_outputs[0].numpy().tolist()



					def __call__(     self					:       Dict				,					*_snake_case					:       int				,					**_snake_case					:       List[str]					):






								"""simple docstring"""


								return super().__call__(*_snake_case				,					**_snake_case					)




