




"""simple docstring"""







from manim import *






class 					SCREAMING_SNAKE_CASE__    (    snake_case_    ):


						def      __lowercase       (							self :	Any    ):
										lowerCAmelCase              = Rectangle(height=0.5  ,  width=0.5    )
										lowerCAmelCase              = Rectangle(height=0.46  ,  width=0.46    ).set_stroke(width=0    )

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

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

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

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

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

										lowerCAmelCase              = []
										lowerCAmelCase              = []

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

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

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

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

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

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

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

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

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

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

										lowerCAmelCase              = {"""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]    )    )

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

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

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

										lowerCAmelCase              = 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 numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor





def 						__UpperCAmelCase			(     a_):
							return (data["data"], data["target"])





def 						__UpperCAmelCase			(     a_							,     a_							,     a_):
							snake_case_				=							XGBRegressor(verbosity=0							,     random_state=42)
							xgb.fit(a_							,     a_)
							# Predict target for test data
							snake_case_				=							xgb.predict(a_)
							snake_case_				=							predictions.reshape(len(a_)							,     1)
							return predictions





def 						__UpperCAmelCase			(     ):
							snake_case_				=							fetch_california_housing()
							snake_case_			,		snake_case_				=							data_handling(a_)
							snake_case_			,		snake_case_			,		snake_case_			,		snake_case_				=							train_test_split(
							    a_							,     a_							,     test_size=0.25							,     random_state=1)
							snake_case_				=							xgboost(a_							,     a_							,     a_)
							# Error printing
							print(f'''Mean Absolute Error : {mean_absolute_error(a_							,     a_)}''')
							print(f'''Mean Square Error  : {mean_squared_error(a_							,     a_)}''')


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)
	main()





