




import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


__a			:	Optional[int]							     =		{5_12: """DiT-XL-2-512x512.pt""", 2_56: """DiT-XL-2-256x256.pt"""}




def  a_		(							__snake_case					)	->			Tuple:

			'''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  a_		(							__snake_case					)	->			Optional[Any]:

			'''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(2_8					):
						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=2_8     ,		attention_head_dim=7_2     ,		in_channels=4     ,		out_channels=8     ,		patch_size=2     ,		attention_bias=__snake_case     ,		num_attention_heads=1_6     ,		activation_fn='gelu-approximate'     ,		num_embeds_ada_norm=1_0_0_0     ,		norm_type='ada_norm_zero'     ,		norm_elementwise_affine=__snake_case     ,		)
			transformer.load_state_dict(__snake_case     ,		strict=__snake_case					)

			UpperCamelCase_     				= DDIMScheduler(
			    num_train_timesteps=1_0_0_0     ,		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__":
				__a			:	str							     =		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."""
				)

				__a			:	Optional[int]							     =		parser.parse_args()
				main(args)






from collections import Counter




def  a_		(							__snake_case					)	->			int:

			'''simple docstring'''


			return sum(socks_by_color // 2 for socks_by_color in Counter(__snake_case					).values()					)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				__a			:	List[Any]							     =		[int(x) for x in input("""Enter socks by color :""").rstrip().split()]
				print(f"""sock_merchant({colors}) = {sock_merchant(colors)}""")
