


'''simple docstring'''
from manim import *
class      lowercase			(							A__      ):

		"""simple docstring"""

		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :List[str]							      =				Rectangle(height=0.5					,     width=0.5							)
							UpperCamelCase__     :Union[str, Any]							      =				Rectangle(height=0.46					,     width=0.46							).set_stroke(width=0							)

							UpperCamelCase__     :Dict							      =				Rectangle(height=0.25					,     width=0.25							)

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

							UpperCamelCase__     :Dict							      =				[mem.copy() for i in range(4							)]
							UpperCamelCase__     :Any							      =				VGroup(*UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0							)
							UpperCamelCase__     :Dict							      =				Text('''GPU'''					,     font_size=24							)
							UpperCamelCase__     :int							      =				Group(UpperCamelCase_					,     UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0.5					,     aligned_edge=UpperCamelCase_							)
							gpu.move_to([-1, -1, 0]							)
							self.add(UpperCamelCase_							)

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

							UpperCamelCase__     :Optional[Any]							      =				Text('''Model'''					,     font_size=24							)
							UpperCamelCase__     :Tuple							      =				Group(UpperCamelCase_					,     UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0.5					,     aligned_edge=UpperCamelCase_							)
							model.move_to([3, -1.0, 0]							)
							self.add(UpperCamelCase_							)

							UpperCamelCase__     :List[Any]							      =				[]
							UpperCamelCase__     :List[Any]							      =				[]

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

												UpperCamelCase__     :Tuple							      =				Rectangle(height=0.46					,     width=0.46							).set_stroke(width=0.0							).set_fill(UpperCamelCase_					,     opacity=0.8							)
												cpu_target.move_to(cpu_left_col_base[i]							)
												model_cpu_arr.append(UpperCamelCase_							)

							self.add(*UpperCamelCase_					,     *UpperCamelCase_							)

							UpperCamelCase__     :Any							      =				[meta_mem.copy() for i in range(6							)]
							UpperCamelCase__     :Optional[Any]							      =				[meta_mem.copy() for i in range(6							)]
							UpperCamelCase__     :Dict							      =				VGroup(*UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0							)
							UpperCamelCase__     :str							      =				VGroup(*UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0							)
							UpperCamelCase__     :Dict							      =				VGroup(UpperCamelCase_					,     UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0							)
							UpperCamelCase__     :int							      =				Text('''Disk'''					,     font_size=24							)
							UpperCamelCase__     :Tuple							      =				Group(UpperCamelCase_					,     UpperCamelCase_							).arrange(UpperCamelCase_					,     buff=0.5					,     aligned_edge=UpperCamelCase_							)
							disk.move_to([-4, -1.25, 0]							)
							self.add(UpperCamelCase_					,     UpperCamelCase_							)

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

							UpperCamelCase__     :Optional[int]							      =				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_							)

							UpperCamelCase__     :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()							)
							self.add(UpperCamelCase_							)

							UpperCamelCase__     :Tuple							      =				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(UpperCamelCase_							)							)

							UpperCamelCase__     :Tuple							      =				Square(0.3							)
							input.set_fill(UpperCamelCase_					,     opacity=1.0							)
							input.set_stroke(width=0.0							)
							input.next_to(model_base[0]					,     UpperCamelCase_					,     buff=0.5							)

							self.play(Write(UpperCamelCase_							)							)

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

							self.play(FadeOut(UpperCamelCase_							)							)

							UpperCamelCase__     :Dict							      =				Arrow(start=UpperCamelCase_					,     end=UpperCamelCase_					,     color=UpperCamelCase_					,     buff=0.5							)
							a.next_to(model_arr[0].get_left()					,     UpperCamelCase_					,     buff=0.2							)

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

							UpperCamelCase__     :List[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(UpperCamelCase_					,     run_time=3							)							)

							UpperCamelCase__     :Tuple							      =				{'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.02}

							self.play(
							    Write(UpperCamelCase_							)					,     Circumscribe(model_arr[0]					,     color=UpperCamelCase_					,     **UpperCamelCase_							)					,     Circumscribe(model_cpu_arr[0]					,     color=UpperCamelCase_					,     **UpperCamelCase_							)					,     Circumscribe(gpu_rect[0]					,     color=UpperCamelCase_					,     **UpperCamelCase_							)					,     )
							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					,     UpperCamelCase_					,     buff=0.2							)

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

												UpperCamelCase__     :int							      =				AnimationGroup(
												    FadeOut(UpperCamelCase_					,     run_time=0.5							)					,     MoveToTarget(UpperCamelCase_					,     run_time=0.5							)					,     FadeIn(UpperCamelCase_					,     run_time=0.5							)					,     lag_ratio=0.2							)

												self.play(UpperCamelCase_							)

												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[Any]							      =				0.7

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

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

												UpperCamelCase__     :Optional[Any]							      =				a_c
												UpperCamelCase__     :Dict							      =				a_c.copy()

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

							UpperCamelCase__     :Tuple							      =				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(UpperCamelCase_					,     run_time=3							)					,     MoveToTarget(UpperCamelCase_							)							)

							self.wait()



'''simple docstring'''
import numpy as np


def     a   (    __a				,      __a				,      __a				,      __a				,      __a     )						->			Union[str, Any]:



					'''simple docstring'''






					UpperCamelCase__     :Tuple							      =				int(np.ceil((x_end - xa) / h     )     )
					UpperCamelCase__     :Optional[int]							      =				np.zeros((n + 1,)     )
					UpperCamelCase__     :List[str]							      =				ya
					UpperCamelCase__     :Tuple							      =				xa

					for k in range(__a     ):
										UpperCamelCase__     :Dict							      =				f(__a				,      y[k]     )
										UpperCamelCase__     :List[Any]							      =				f(x + 0.5 * h				,      y[k] + 0.5 * h * ka     )
										UpperCamelCase__     :Dict							      =				f(x + 0.5 * h				,      y[k] + 0.5 * h * ka     )
										UpperCamelCase__     :List[Any]							      =				f(x + h				,      y[k] + h * ka     )
										UpperCamelCase__     :List[str]							      =				y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
										x += h

					return y


if __name__ == "__main__":
		import doctest

		doctest.testmod()