


'''simple docstring'''



from manim import *


class 		_snake_case       (  UpperCamelCase__						):




					def 					snake_case__    (   self):
								UpperCAmelCase__	:       str   =  Rectangle(height=0.5				,				width=0.5)
								UpperCAmelCase__	:       Optional[int]   =  Rectangle(height=0.46				,				width=0.46).set_stroke(width=0)

								UpperCAmelCase__	:       Any   =  Rectangle(height=0.25				,				width=0.25)

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

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

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

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

								UpperCAmelCase__	:       Any   =  []
								UpperCAmelCase__	:       Any   =  []

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

											UpperCAmelCase__	:       List[Any]   =  Rectangle(height=0.46				,				width=0.46).set_stroke(width=0.0).set_fill(__lowerCamelCase				,				opacity=0.8)
											cpu_target.move_to(cpu_left_col_base[i])
											model_cpu_arr.append(__lowerCamelCase)

								self.add(*__lowerCamelCase				,				*__lowerCamelCase)

								UpperCAmelCase__	:       str   =  [meta_mem.copy() for i in range(6)]
								UpperCAmelCase__	:       List[str]   =  [meta_mem.copy() for i in range(6)]
								UpperCAmelCase__	:       Tuple   =  VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,				buff=0)
								UpperCAmelCase__	:       Tuple   =  VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,				buff=0)
								UpperCAmelCase__	:       Any   =  VGroup(__lowerCamelCase				,				__lowerCamelCase).arrange(__lowerCamelCase				,				buff=0)
								UpperCAmelCase__	:       Any   =  Text("""Disk"""				,				font_size=24)
								UpperCAmelCase__	:       List[str]   =  Group(__lowerCamelCase				,				__lowerCamelCase).arrange(__lowerCamelCase				,				buff=0.5				,				aligned_edge=__lowerCamelCase)
								disk.move_to([-4, -1.25, 0])
								self.add(__lowerCamelCase				,				__lowerCamelCase)

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

								UpperCAmelCase__	:       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(__lowerCamelCase				,				__lowerCamelCase)

								UpperCAmelCase__	:       Optional[int]   =  MarkupText(
								    f'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''				,				font_size=18				,				)

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

								UpperCAmelCase__	:       str   =  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(__lowerCamelCase))

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

								self.play(Write(__lowerCamelCase))

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

								self.play(FadeOut(__lowerCamelCase))

								UpperCAmelCase__	:       Tuple   =  Arrow(start=__lowerCamelCase				,				end=__lowerCamelCase				,				color=__lowerCamelCase				,				buff=0.5)
								a.next_to(model_arr[0].get_left()				,				__lowerCamelCase				,				buff=0.2)

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

								UpperCAmelCase__	:       str   =  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(__lowerCamelCase				,				run_time=3))

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

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

								UpperCAmelCase__	:       str   =  a.copy()
								for i in range(6):
											a_c.next_to(model_arr[i].get_right() + 0.02				,				__lowerCamelCase				,				buff=0.2)

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

											UpperCAmelCase__	:       Optional[Any]   =  AnimationGroup(
											    FadeOut(__lowerCamelCase				,				run_time=0.5)				,				MoveToTarget(__lowerCamelCase				,				run_time=0.5)				,				FadeIn(__lowerCamelCase				,				run_time=0.5)				,				lag_ratio=0.2)

											self.play(__lowerCamelCase)

											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:
																	UpperCAmelCase__	:       Optional[int]   =  0.7

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

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

											UpperCAmelCase__	:       List[str]   =  a_c
											UpperCAmelCase__	:       Optional[int]   =  a_c.copy()

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

								UpperCAmelCase__	:       int   =  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(__lowerCamelCase				,				run_time=3)				,				MoveToTarget(__lowerCamelCase))

								self.wait()






import warnings

from diffusers import StableDiffusionInpaintPipeline as StableDiffusionInpaintPipeline  # noqa F401


warnings.warn(
    'The `inpainting.py` script is outdated. Please use directly `from diffusers import'
    ' StableDiffusionInpaintPipeline` instead.'
)





