



"""simple docstring"""

import copy
import random

from transformers import CLIPTokenizer







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						def __init__(self   ,		*lowercase__   ,		**lowercase__       ):
											super().__init__(*lowercase__   ,		**lowercase__       )
											snake_case_					:		Union[str, Any] 					=					{}







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		*lowercase__   ,		**lowercase__       ):
											snake_case_					:		Optional[int] 					=					super().add_tokens(lowercase__   ,		*lowercase__   ,		**lowercase__       )
											if num_added_tokens == 0:
																raise ValueError(
																    f'The tokenizer already contains the token {placeholder_token}. Please pass a different'
																    """ `placeholder_token` that is not already in the tokenizer."""       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		*lowercase__   ,		lowercase__=1   ,		**lowercase__       ):
											snake_case_					:		Optional[int] 					=					[]
											if num_vec_per_token == 1:
																self.try_adding_tokens(lowercase__   ,		*lowercase__   ,		**lowercase__       )
																output.append(lowercase__       )
											else:
																snake_case_					:		Dict 					=					[]
																for i in range(lowercase__       ):
																					snake_case_					:		Union[str, Any] 					=					placeholder_token + f'_{i}'
																					self.try_adding_tokens(lowercase__   ,		*lowercase__   ,		**lowercase__       )
																					output.append(lowercase__       )
        # handle cases where there is a new placeholder token that contains the current placeholder token but is larger
											for token in self.token_map:
																if token in placeholder_token:
																					raise ValueError(
																					    f'The tokenizer already has placeholder token {token} that can get confused with'
																					    f' {placeholder_token}keep placeholder tokens independent'       )
											snake_case_					:		str 					=					output







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__=False   ,		lowercase__=1.0       ):
											if isinstance(lowercase__   ,		lowercase__       ):
																snake_case_					:		Dict 					=					[]
																for i in range(len(lowercase__       )       ):
																					output.append(self.replace_placeholder_tokens_in_text(text[i]   ,		vector_shuffle=lowercase__       )       )
																return output
											for placeholder_token in self.token_map:
																if placeholder_token in text:
																					snake_case_					:		str 					=					self.token_map[placeholder_token]
																					snake_case_					:		str 					=					tokens[: 1 + int(len(lowercase__       ) * prop_tokens_to_load       )]
																					if vector_shuffle:
																										snake_case_					:		Optional[Any] 					=					copy.copy(lowercase__       )
																										random.shuffle(lowercase__       )
																					snake_case_					:		Optional[int] 					=					text.replace(lowercase__   ,		""" """.join(lowercase__       )       )
											return text







						def __call__(self   ,		lowercase__   ,		*lowercase__   ,		lowercase__=False   ,		lowercase__=1.0   ,		**lowercase__       ):
											return super().__call__(
											    self.replace_placeholder_tokens_in_text(
											        lowercase__   ,		vector_shuffle=lowercase__   ,		prop_tokens_to_load=lowercase__       )   ,		*lowercase__   ,		**lowercase__   ,		)







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		*lowercase__   ,		lowercase__=False   ,		lowercase__=1.0   ,		**lowercase__       ):
											return super().encode(
											    self.replace_placeholder_tokens_in_text(
											        lowercase__   ,		vector_shuffle=lowercase__   ,		prop_tokens_to_load=lowercase__       )   ,		*lowercase__   ,		**lowercase__   ,		)









"""simple docstring"""

from manim import *







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Union[str, Any] 					=					Rectangle(height=0.5   ,		width=0.5       )
											snake_case_					:		str 					=					Rectangle(height=0.46   ,		width=0.46       ).set_stroke(width=0       )

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

											snake_case_					:		List[Any] 					=					[mem.copy() for i in range(4       )]
											snake_case_					:		Tuple 					=					VGroup(*lowercase__       ).arrange(lowercase__   ,		buff=0       )
											snake_case_					:		List[str] 					=					Text("""GPU"""   ,		font_size=24       )
											snake_case_					:		Any 					=					Group(lowercase__   ,		lowercase__       ).arrange(lowercase__   ,		buff=0.5   ,		aligned_edge=lowercase__       )
											gpu.move_to([-1, -1, 0]       )
											self.add(lowercase__       )

											snake_case_					:		Optional[Any] 					=					[mem.copy() for i in range(6       )]
											snake_case_					:		List[Any] 					=					VGroup(*lowercase__       ).arrange(lowercase__   ,		buff=0       )

											snake_case_					:		Dict 					=					Text("""Model"""   ,		font_size=24       )
											snake_case_					:		int 					=					Group(lowercase__   ,		lowercase__       ).arrange(lowercase__   ,		buff=0.5   ,		aligned_edge=lowercase__       )
											model.move_to([3, -1.0, 0]       )
											self.add(lowercase__       )

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

																snake_case_					:		List[str] 					=					Rectangle(height=0.46 / 4   ,		width=0.46 / 3       ).set_stroke(width=0.0       ).set_fill(lowercase__   ,		opacity=0.7       )

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

											snake_case_					:		List[str] 					=					[mem.copy() for i in range(6       )]
											snake_case_					:		List[str] 					=					VGroup(*lowercase__       ).arrange(lowercase__   ,		buff=0       )

											snake_case_					:		str 					=					Text("""Loaded Checkpoint"""   ,		font_size=24       )
											snake_case_					:		Any 					=					Group(lowercase__   ,		lowercase__       ).arrange(lowercase__   ,		aligned_edge=lowercase__   ,		buff=0.4       )
											checkpoint.move_to([3, 0.5, 0]       )

											snake_case_					:		Optional[Any] 					=					Square(side_length=2.2       )
											key.move_to([-5, 2, 0]       )

											snake_case_					:		Union[str, Any] 					=					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(lowercase__   ,		lowercase__       )

											snake_case_					:		List[Any] 					=					MarkupText(
											    f'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'   ,		font_size=18   ,		)

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

											snake_case_					:		List[Any] 					=					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(lowercase__       )   ,		Write(lowercase__       )       )

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

											snake_case_					:		Optional[int] 					=					[]
											snake_case_					:		List[str] 					=					[]
											for i, rect in enumerate(lowercase__       ):
																snake_case_					:		Optional[Any] 					=					fill.copy().set_fill(lowercase__   ,		opacity=0.7       )
																target.move_to(lowercase__       )
																first_animations.append(GrowFromCenter(lowercase__   ,		run_time=1       )       )

																snake_case_					:		List[Any] 					=					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(lowercase__   ,		run_time=1.5       )       )

											self.play(*lowercase__       )
											self.play(*lowercase__       )
											self.wait()




