




from manim import *






class 					__lowerCAmelCase				( UpperCAmelCase__				):







			def UpperCamelCase    ( self					:    Any   ):




									"""simple docstring"""


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

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

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

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

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

									_UpperCAmelCase									=  []
									_UpperCAmelCase									=  []

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

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

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

									self.add(*snake_case__					,					*snake_case__   )

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

									_UpperCAmelCase									=  []

									for i in range(6   ):
															_UpperCAmelCase									=  fill.copy().set_fill(snake_case__					,					opacity=0.8   )
															target.move_to(disk_left_col_base[i]   ).scale(0.5   )
															cpu_disk_arr.append(snake_case__   )

									self.add(*snake_case__   )

									_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(snake_case__					,					snake_case__   )

									_UpperCAmelCase									=  MarkupText(
									    F"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""					,					font_size=18					,					)

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

									_UpperCAmelCase									=  MarkupText(F"""The offloaded weights are all sent to the CPU."""					,					font_size=24   )
									step_a.move_to([2, 2, 0]   )

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

									for i in range(6   ):
															_UpperCAmelCase									=  cpu_disk_arr[i]
															_UpperCAmelCase									=  rect.copy().set_fill(snake_case__					,					opacity=0.8   ).scale(2.0   )
															cpa.generate_target()
															cpa.target.move_to(model_base[i]   )

															if i == 0:
																					rect.set_fill(snake_case__					,					opacity=0.8   )
																					rect.generate_target()
																					rect.target.move_to(cpu_left_col_base[0]   ).scale(2.0   )

																					self.remove(
																					    *snake_case__					,					*snake_case__					,					)

															else:
																					rect.generate_target()
																					rect.target.move_to(cpu_left_col_base[i]   ).scale(2.0   )
															self.play(MoveToTarget(snake_case__   )					,					MoveToTarget(snake_case__   )					,					model_base[i].animate.set_stroke(snake_case__   )   )
									self.play(FadeOut(snake_case__   )   )

									_UpperCAmelCase									=  MarkupText(
									    F"""Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed."""					,					font_size=24					,					)
									step_a.move_to([2, 2, 0]   )

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

									_UpperCAmelCase									=  []
									_UpperCAmelCase									=  []
									for i in range(6   ):
															_UpperCAmelCase									=  Arrow(start=snake_case__					,					end=snake_case__					,					color=snake_case__					,					buff=0.5   )
															a.next_to(model_base[i].get_left()					,					snake_case__					,					buff=0.2   )
															arrows.append(snake_case__   )
															animations.append(Write(snake_case__   )   )
									self.play(*snake_case__   )
									self.wait()










import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


lowercase_			:       Tuple						       =				{5_12: 'DiT-XL-2-512x512.pt', 2_56: 'DiT-XL-2-256x256.pt'}


def 							__SCREAMING_SNAKE_CASE						(    snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase									=  f"""pretrained_models/{model_name}"""
						if not os.path.isfile(snake_case_		):
												os.makedirs("pretrained_models"			,					exist_ok=snake_case_		)
												_UpperCAmelCase									=  f"""https://dl.fbaipublicfiles.com/DiT/models/{model_name}"""
												download_url(snake_case_			,					"pretrained_models"		)
						_UpperCAmelCase									=  torch.load(snake_case_			,					map_location=lambda snake_case_			,					snake_case_		: storage		)
						return model


def 							__SCREAMING_SNAKE_CASE						(    snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase									=  download_model(pretrained_models[args.image_size]		)

						_UpperCAmelCase									=  state_dict["x_embedder.proj.weight"]
						_UpperCAmelCase									=  state_dict["x_embedder.proj.bias"]
						state_dict.pop("x_embedder.proj.weight"		)
						state_dict.pop("x_embedder.proj.bias"		)

						for depth in range(28		):
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.0.weight"
												]
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.0.bias"
												]
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.2.weight"
												]
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.2.bias"
												]
												_UpperCAmelCase									=  state_dict[
												    "y_embedder.embedding_table.weight"
												]

												_UpperCAmelCase									=  state_dict[
												    f"""blocks.{depth}.adaLN_modulation.1.weight"""
												]
												_UpperCAmelCase									=  state_dict[
												    f"""blocks.{depth}.adaLN_modulation.1.bias"""
												]

												_UpperCAmelCase							,				_UpperCAmelCase							,				_UpperCAmelCase									=  torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.weight"""]			,					3			,					dim=0		)
												_UpperCAmelCase							,				_UpperCAmelCase							,				_UpperCAmelCase									=  torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.bias"""]			,					3			,					dim=0		)

												_UpperCAmelCase									=  q
												_UpperCAmelCase									=  q_bias
												_UpperCAmelCase									=  k
												_UpperCAmelCase									=  k_bias
												_UpperCAmelCase									=  v
												_UpperCAmelCase									=  v_bias

												_UpperCAmelCase									=  state_dict[
												    f"""blocks.{depth}.attn.proj.weight"""
												]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.attn.proj.bias"""]

												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc1.weight"""]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc1.bias"""]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc2.weight"""]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc2.bias"""]

												state_dict.pop(f"""blocks.{depth}.attn.qkv.weight"""		)
												state_dict.pop(f"""blocks.{depth}.attn.qkv.bias"""		)
												state_dict.pop(f"""blocks.{depth}.attn.proj.weight"""		)
												state_dict.pop(f"""blocks.{depth}.attn.proj.bias"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc1.weight"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc1.bias"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc2.weight"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc2.bias"""		)
												state_dict.pop(f"""blocks.{depth}.adaLN_modulation.1.weight"""		)
												state_dict.pop(f"""blocks.{depth}.adaLN_modulation.1.bias"""		)

						state_dict.pop("t_embedder.mlp.0.weight"		)
						state_dict.pop("t_embedder.mlp.0.bias"		)
						state_dict.pop("t_embedder.mlp.2.weight"		)
						state_dict.pop("t_embedder.mlp.2.bias"		)
						state_dict.pop("y_embedder.embedding_table.weight"		)

						_UpperCAmelCase									=  state_dict["final_layer.adaLN_modulation.1.weight"]
						_UpperCAmelCase									=  state_dict["final_layer.adaLN_modulation.1.bias"]
						_UpperCAmelCase									=  state_dict["final_layer.linear.weight"]
						_UpperCAmelCase									=  state_dict["final_layer.linear.bias"]

						state_dict.pop("final_layer.linear.weight"		)
						state_dict.pop("final_layer.linear.bias"		)
						state_dict.pop("final_layer.adaLN_modulation.1.weight"		)
						state_dict.pop("final_layer.adaLN_modulation.1.bias"		)

						# DiT XL/2
						_UpperCAmelCase									=  TransformeraDModel(
						    sample_size=args.image_size // 8			,					num_layers=28			,					attention_head_dim=72			,					in_channels=4			,					out_channels=8			,					patch_size=2			,					attention_bias=snake_case_			,					num_attention_heads=16			,					activation_fn="gelu-approximate"			,					num_embeds_ada_norm=1000			,					norm_type="ada_norm_zero"			,					norm_elementwise_affine=snake_case_			,					)
						transformer.load_state_dict(snake_case_			,					strict=snake_case_		)

						_UpperCAmelCase									=  DDIMScheduler(
						    num_train_timesteps=1000			,					beta_schedule="linear"			,					prediction_type="epsilon"			,					clip_sample=snake_case_			,					)

						_UpperCAmelCase									=  AutoencoderKL.from_pretrained(args.vae_model		)

						_UpperCAmelCase									=  DiTPipeline(transformer=snake_case_			,					vae=snake_case_			,					scheduler=snake_case_		)

						if args.save:
												pipeline.save_pretrained(args.checkpoint_path		)


if __name__ == "__main__":
				lowercase_			:       Union[str, Any]						       =				argparse.ArgumentParser()

				parser.add_argument(
				    '--image_size',
				    default=2_56,
				    type=int,
				    required=False,
				    help='Image size of pretrained model, either 256 or 512.',
				)
				parser.add_argument(
				    '--vae_model',
				    default='stabilityai/sd-vae-ft-ema',
				    type=str,
				    required=False,
				    help='Path to pretrained VAE model, either stabilityai/sd-vae-ft-mse or stabilityai/sd-vae-ft-ema.',
				)
				parser.add_argument(
				    '--save', default=True, type=bool, required=False, help='Whether to save the converted pipeline or not.'
				)
				parser.add_argument(
				    '--checkpoint_path', default=None, type=str, required=True, help='Path to the output pipeline.'
				)

				lowercase_			:       Tuple						       =				parser.parse_args()
				main(args)




