



from manim import *





class  __magic_name__   (							A__						):






		def SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					List[str]:
								'''simple docstring'''







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

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

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

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

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

								UpperCAmelCase         =     []
								UpperCAmelCase         =     []
								UpperCAmelCase         =     []

								for i, rect in enumerate(UpperCamelCase__      ):
														rect.set_stroke(UpperCamelCase__      )

														UpperCAmelCase         =     Rectangle(height=0.46 / 4				,		width=0.46 / 3      ).set_stroke(width=0.0      ).set_fill(UpperCamelCase__				,		opacity=0.7      )

														if i == 0:
																				cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT      )				,		buff=0.02				,		direction=UpperCamelCase__      )
																				cpu_target.set_x(cpu_target.get_x() + 0.1      )
														elif i == 3:
																				cpu_target.next_to(model_cpu_arr[0]				,		direction=UpperCamelCase__				,		buff=0.0      )
														else:
																				cpu_target.next_to(model_cpu_arr[i - 1]				,		direction=UpperCamelCase__				,		buff=0.0      )
														self.add(UpperCamelCase__      )
														model_cpu_arr.append(UpperCamelCase__      )

								self.add(*UpperCamelCase__				,		*UpperCamelCase__				,		*UpperCamelCase__      )

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

								UpperCAmelCase         =     Text("Loaded Checkpoint"				,		font_size=24      )
								UpperCAmelCase         =     Group(UpperCamelCase__				,		UpperCamelCase__      ).arrange(UpperCamelCase__				,		buff=0.5				,		aligned_edge=UpperCamelCase__      )
								checkpoint.move_to([3, 0.5, 0]      )

								self.add(UpperCamelCase__      )

								UpperCAmelCase         =     []
								UpperCAmelCase         =     []

								for i, rect in enumerate(UpperCamelCase__      ):
														UpperCAmelCase         =     fill.copy().set_fill(UpperCamelCase__				,		opacity=0.7      )
														target.move_to(UpperCamelCase__      )
														ckpt_arr.append(UpperCamelCase__      )

														UpperCAmelCase         =     target.copy()
														if i < 5:
																				cpu_target.move_to(cpu_left_col_base[i + 1]      )
														else:
																				cpu_target.move_to(cpu_right_col_base[i - 5]      )
														ckpt_cpu_arr.append(UpperCamelCase__      )
								self.add(*UpperCamelCase__				,		*UpperCamelCase__      )

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

								UpperCAmelCase         =     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         =     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         =     MarkupText(
								    F'Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.'				,		font_size=24				,		)
								step_a.move_to([2, 2, 0]      )

								UpperCAmelCase         =     [meta_mem.copy() for i in range(6      )]
								UpperCAmelCase         =     [meta_mem.copy() for i in range(6      )]
								UpperCAmelCase         =     VGroup(*UpperCamelCase__      ).arrange(UpperCamelCase__				,		buff=0      )
								UpperCAmelCase         =     VGroup(*UpperCamelCase__      ).arrange(UpperCamelCase__				,		buff=0      )
								UpperCAmelCase         =     VGroup(UpperCamelCase__				,		UpperCamelCase__      ).arrange(UpperCamelCase__				,		buff=0      )
								UpperCAmelCase         =     Text("Disk"				,		font_size=24      )
								UpperCAmelCase         =     Group(UpperCamelCase__				,		UpperCamelCase__      ).arrange(UpperCamelCase__				,		buff=0.5				,		aligned_edge=UpperCamelCase__      )
								disk.move_to([-4.0, -1.25, 0]      )
								self.play(Write(UpperCamelCase__				,		run_time=3      )				,		Write(UpperCamelCase__				,		run_time=1      )				,		Create(UpperCamelCase__				,		run_time=1      )      )

								UpperCAmelCase         =     []
								for i, rect in enumerate(UpperCamelCase__      ):
														UpperCAmelCase         =     rect.copy()
														target.generate_target()
														target.target.move_to(disk_left_col_base[i]      ).scale(0.5      )
														animations.append(MoveToTarget(UpperCamelCase__				,		run_time=1.5      )      )
								self.play(*UpperCamelCase__      )

								self.play(FadeOut(UpperCamelCase__      )      )

								UpperCAmelCase         =     MarkupText(F'Then, the checkpoint is removed from memory\nthrough garbage collection.'				,		font_size=24      )
								step_a.move_to([2, 2, 0]      )

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

								self.play(
								    FadeOut(UpperCamelCase__				,		UpperCamelCase__				,		*UpperCamelCase__				,		*UpperCamelCase__      )				,		)

								self.wait()








import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation





class  __magic_name__   (							unittest.TestCase						):






		def SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					str:
								'''simple docstring'''







								UpperCAmelCase         =     get_activation("swish"      )

								self.assertIsInstance(UpperCamelCase__				,		nn.SiLU      )

								self.assertEqual(act(torch.tensor(-1_00				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertNotEqual(act(torch.tensor(-1				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(0				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(20				,		dtype=torch.floataa      )      ).item()				,		20      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Tuple      )				->					List[Any]:
								'''simple docstring'''







								UpperCAmelCase         =     get_activation("silu"      )

								self.assertIsInstance(UpperCamelCase__				,		nn.SiLU      )

								self.assertEqual(act(torch.tensor(-1_00				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertNotEqual(act(torch.tensor(-1				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(0				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(20				,		dtype=torch.floataa      )      ).item()				,		20      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]      )				->					int:
								'''simple docstring'''







								UpperCAmelCase         =     get_activation("mish"      )

								self.assertIsInstance(UpperCamelCase__				,		nn.Mish      )

								self.assertEqual(act(torch.tensor(-2_00				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertNotEqual(act(torch.tensor(-1				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(0				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(20				,		dtype=torch.floataa      )      ).item()				,		20      )







		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     get_activation("gelu"      )

								self.assertIsInstance(UpperCamelCase__				,		nn.GELU      )

								self.assertEqual(act(torch.tensor(-1_00				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertNotEqual(act(torch.tensor(-1				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(0				,		dtype=torch.floataa      )      ).item()				,		0      )
								self.assertEqual(act(torch.tensor(20				,		dtype=torch.floataa      )      ).item()				,		20      )



