




from manim import *



class    lowercase_		(__A ):



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							Rectangle(height=0.5					,							width=0.5  )
								SCREAMING_SNAKE_CASE_					      =							Rectangle(height=0.46					,							width=0.46  ).set_stroke(width=0  )

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

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

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

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

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

								SCREAMING_SNAKE_CASE_					      =							[]
								SCREAMING_SNAKE_CASE_					      =							[]

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

										SCREAMING_SNAKE_CASE_					      =							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__  )

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

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

								SCREAMING_SNAKE_CASE_					      =							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__  )

								SCREAMING_SNAKE_CASE_					      =							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__  )

								SCREAMING_SNAKE_CASE_					      =							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__  )  )

								SCREAMING_SNAKE_CASE_					      =							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__  )  )

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

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

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

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

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

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

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

								SCREAMING_SNAKE_CASE_					      =							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'''







def       __UpperCamelCase					(      lowercase_       :  list[int]   ,       lowercase_       :  list[int]   ,       lowercase_       :  int   ):
       """simple docstring"""




       return not any(
           neighbour == 1 and colored_vertices[i] == color
           for i, neighbour in enumerate(lowercase_   )   )


def       __UpperCamelCase					(      lowercase_       :  list[list[int]]   ,       lowercase_       :  int   ,       lowercase_       :  list[int]   ,       lowercase_       :  int   ):
       """simple docstring"""




       if index == len(lowercase_   ):
              return True

       # Recursive Step
       for i in range(lowercase_   ):
              if valid_coloring(graph[index]   ,       lowercase_   ,       lowercase_   ):
                     # Color current vertex
                     a_						     =			i
                     # Validate coloring
                     if util_color(lowercase_   ,       lowercase_   ,       lowercase_   ,       index + 1   ):
                            return True
                     # Backtrack
                     a_						     =			-1
       return False


def       __UpperCamelCase					(      lowercase_       :  list[list[int]]   ,       lowercase_       :  int   ):
       """simple docstring"""




       a_						     =			[-1] * len(lowercase_   )

       if util_color(lowercase_   ,       lowercase_   ,       lowercase_   ,       0   ):
              return colored_vertices

       return []




