


'''simple docstring'''





from manim import *

class        a	(UpperCamelCase_   ):




							"""simple docstring"""


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

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

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

														__snake_case	:    Dict											=     [mem.copy() for i in range(6       )]
														__snake_case	:    str											=     VGroup(*UpperCamelCase__       ).arrange(UpperCamelCase__					,			buff=0       )

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

														__snake_case	:    Optional[int]											=     []
														for i, rect in enumerate(UpperCamelCase__       ):
																					rect.set_stroke(UpperCamelCase__       )
																					# target = fill.copy().set_fill(YELLOW, opacity=0.7)
																					# target.move_to(rect)
																					# self.add(target)

																					__snake_case	:    Optional[int]											=     Rectangle(height=0.46 / 4					,			width=0.46 / 3       ).set_stroke(width=0.0       ).set_fill(UpperCamelCase__					,			opacity=0.7       )

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

														__snake_case	:    int											=     [mem.copy() for i in range(6       )]
														__snake_case	:    Optional[Any]											=     VGroup(*UpperCamelCase__       ).arrange(UpperCamelCase__					,			buff=0       )

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

														__snake_case	:    Union[str, Any]											=     Square(side_length=2.2       )
														key.move_to([-5, 2, 0]       )

														__snake_case	:    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__       )

														__snake_case	:    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()       )

														__snake_case	:    List[str]											=     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(UpperCamelCase__       )					,			Write(UpperCamelCase__       )       )

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

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

																					__snake_case	:    str											=     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(UpperCamelCase__					,			run_time=1.5       )       )

														self.play(*UpperCamelCase__       )
														self.play(*UpperCamelCase__       )
														self.wait()





import warnings

from ...utils import logging
from .image_processing_poolformer import PoolFormerImageProcessor


_snake_case  :	List[str]			      =       logging.get_logger(__name__)

class        a	(_lowerCAmelCase   ):




							"""simple docstring"""


							def __init__(							self :						int					,			*lowerCamelCase :						Any					,			**lowerCamelCase :						Union[str, Any]       )			->					None:
														warnings.warn(
														    "The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers."
														    " Please use PoolFormerImageProcessor instead."					,			lowerCamelCase					,			)
														super().__init__(*lowerCamelCase					,			**lowerCamelCase       )

