




'''simple docstring'''


from manim import *
class 						a_				(			UpperCAmelCase__						):




	def   lowercase__   (       self     :  str      ):
							__snake_case						 =   Rectangle(height=0.5       ,		width=0.5      )
							__snake_case						 =   Rectangle(height=0.46       ,		width=0.46      ).set_stroke(width=0      )

							__snake_case						 =   Rectangle(height=0.25       ,		width=0.25      )

							__snake_case						 =   [mem.copy() for i in range(6      )]
							__snake_case						 =   [mem.copy() for i in range(6      )]
							__snake_case						 =   VGroup(*__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   VGroup(*__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   VGroup(__lowerCAmelCase       ,		__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   Text('CPU'       ,		font_size=2_4      )
							__snake_case						 =   Group(__lowerCAmelCase       ,		__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0.5       ,		aligned_edge=__lowerCAmelCase      )
							cpu.move_to([-2.5, -0.5, 0]      )
							self.add(__lowerCAmelCase      )

							__snake_case						 =   [mem.copy() for i in range(4      )]
							__snake_case						 =   VGroup(*__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   Text('GPU'       ,		font_size=2_4      )
							__snake_case						 =   Group(__lowerCAmelCase       ,		__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0.5       ,		aligned_edge=__lowerCAmelCase      )
							gpu.move_to([-1, -1, 0]      )
							self.add(__lowerCAmelCase      )

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

							__snake_case						 =   Text('Model'       ,		font_size=2_4      )
							__snake_case						 =   Group(__lowerCAmelCase       ,		__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0.5       ,		aligned_edge=__lowerCAmelCase      )
							model.move_to([3, -1.0, 0]      )
							self.add(__lowerCAmelCase      )

							__snake_case						 =   []
							__snake_case						 =   []

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

													__snake_case						 =   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      )

							__snake_case						 =   [meta_mem.copy() for i in range(6      )]
							__snake_case						 =   [meta_mem.copy() for i in range(6      )]
							__snake_case						 =   VGroup(*__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   VGroup(*__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   VGroup(__lowerCAmelCase       ,		__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0      )
							__snake_case						 =   Text('Disk'       ,		font_size=2_4      )
							__snake_case						 =   Group(__lowerCAmelCase       ,		__lowerCAmelCase      ).arrange(__lowerCAmelCase       ,		buff=0.5       ,		aligned_edge=__lowerCAmelCase      )
							disk.move_to([-4, -1.25, 0]      )
							self.add(__lowerCAmelCase       ,		__lowerCAmelCase      )

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

							__snake_case						 =   MarkupText(
							    F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'       ,		font_size=1_8       ,		)

							key_text.move_to([-5, 2.4, 0]      )

							self.add(__lowerCAmelCase       ,		__lowerCAmelCase      )

							__snake_case						 =   MarkupText(
							    F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'       ,		font_size=1_8       ,		)

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

							__snake_case						 =   MarkupText(
							    F'Now watch as an input is passed through the model\nand how the memory is utilized and handled.'       ,		font_size=2_4       ,		)
							step_a.move_to([2, 2, 0]      )

							self.play(Write(__lowerCAmelCase      )      )

							__snake_case						 =   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      )      )

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

							__snake_case						 =   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=2_4       ,		)
							step_a.move_to([2, 2, 0]      )

							self.play(Write(__lowerCAmelCase       ,		run_time=3      )      )

							__snake_case						 =   {'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]      )      )

							__snake_case						 =   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      )

													__snake_case						 =   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:
																									__snake_case						 =   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]      )      )

													__snake_case						 =   a_c
													__snake_case						 =   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      )       ,		)

							__snake_case						 =   MarkupText(F'Inference on a model too large for GPU memory\nis successfully completed.'       ,		font_size=2_4      )
							step_a.move_to([2, 2, 0]      )

							self.play(Write(__lowerCAmelCase       ,		run_time=3      )       ,		MoveToTarget(__lowerCAmelCase      )      )

							self.wait()







'''simple docstring'''


def 						lowerCamelCase__   (				a							):
						if number < 0:
												raise ValueError('number must not be negative'							)
						return number & (number - 1) == 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()

