


import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
			from transformers import LlamaTokenizerFast
except ImportError as e:
			warnings.warn(e)
			warnings.warn(
			    "The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion"
			)
			_snake_case  :	Tuple			      =       None
_snake_case  :	Dict			      =       {
    "7B": 11_008,
    "13B": 13_824,
    "30B": 17_920,
    "65B": 22_016,
    "70B": 28_672,
}
_snake_case  :	Any			      =       {
    "7B": 1,
    "7Bf": 1,
    "13B": 2,
    "13Bf": 2,
    "30B": 4,
    "65B": 8,
    "70B": 8,
    "70Bf": 8,
}







def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase=1							,			__lowerCamelCase=2_5_6			):
							return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3			)			) + multiple_of - 1) // multiple_of)







def        lowerCAmelCase_  (      __lowerCamelCase			):
							with open(__lowerCamelCase							,			"r"			) as f:
														return json.load(__lowerCamelCase			)







def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):
							with open(__lowerCamelCase							,			"w"			) as f:
														json.dump(__lowerCamelCase							,			__lowerCamelCase			)







def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase=True			):
							os.makedirs(__lowerCamelCase							,			exist_ok=__lowerCamelCase			)
							__snake_case	:    Union[str, Any]											=     os.path.join(__lowerCamelCase							,			"tmp"			)
							os.makedirs(__lowerCamelCase							,			exist_ok=__lowerCamelCase			)

							__snake_case	:    Union[str, Any]											=     read_json(os.path.join(__lowerCamelCase							,			"params.json"			)			)
							__snake_case	:    Any											=     NUM_SHARDS[model_size]
							__snake_case	:    List[Any]											=     params["n_layers"]
							__snake_case	:    Any											=     params["n_heads"]
							__snake_case	:    Optional[Any]											=     n_heads // num_shards
							__snake_case	:    Dict											=     params["dim"]
							__snake_case	:    Dict											=     dim // n_heads
							__snake_case	:    Any											=     1_0_0_0_0.0
							__snake_case	:    List[Any]											=     1.0 / (base ** (torch.arange(0							,			__lowerCamelCase							,			2			).float() / dims_per_head))

							if "n_kv_heads" in params:
														__snake_case	:    Tuple											=     params["n_kv_heads"]  # for GQA / MQA
														__snake_case	:    Optional[int]											=     n_heads_per_shard // num_key_value_heads
														__snake_case	:    List[Any]											=     dim // num_key_value_heads
							else:  # compatibility with other checkpoints
														__snake_case	:    Optional[Any]											=     n_heads
														__snake_case	:    Tuple											=     n_heads_per_shard
														__snake_case	:    Optional[Any]											=     dim

							# permute for sliced rotary
							def permute(__lowerCamelCase							,			__lowerCamelCase=n_heads							,			__lowerCamelCase=dim							,			__lowerCamelCase=dim			):
														return w.view(__lowerCamelCase							,			dima // n_heads // 2							,			2							,			__lowerCamelCase			).transpose(1							,			2			).reshape(__lowerCamelCase							,			__lowerCamelCase			)

							print(F'Fetching all parameters from the checkpoint at {input_base_path}.'			)
							# Load weights
							if model_size == "7B":
														# Not sharded
														# (The sharded implementation would also work, but this is simpler.)
														__snake_case	:    Optional[Any]											=     torch.load(os.path.join(__lowerCamelCase							,			"consolidated.00.pth"			)							,			map_location="cpu"			)
							else:
														# Sharded
														__snake_case	:    int											=     [
														    torch.load(os.path.join(__lowerCamelCase							,			F'consolidated.{i:02d}.pth'			)							,			map_location="cpu"			)
														    for i in range(__lowerCamelCase			)
														]
							__snake_case	:    Dict											=     0
							__snake_case	:    Optional[int]											=     {"weight_map": {}}
							for layer_i in range(__lowerCamelCase			):
														__snake_case	:    str											=     F'pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'
														if model_size == "7B":
																					# Unsharded
																					__snake_case	:    List[Any]											=     {
																					    F'model.layers.{layer_i}.self_attn.q_proj.weight': permute(
																					        loaded[F'layers.{layer_i}.attention.wq.weight']			),
																					    F'model.layers.{layer_i}.self_attn.k_proj.weight': permute(
																					        loaded[F'layers.{layer_i}.attention.wk.weight']			),
																					    F'model.layers.{layer_i}.self_attn.v_proj.weight': loaded[F'layers.{layer_i}.attention.wv.weight'],
																					    F'model.layers.{layer_i}.self_attn.o_proj.weight': loaded[F'layers.{layer_i}.attention.wo.weight'],
																					    F'model.layers.{layer_i}.mlp.gate_proj.weight': loaded[F'layers.{layer_i}.feed_forward.w1.weight'],
																					    F'model.layers.{layer_i}.mlp.down_proj.weight': loaded[F'layers.{layer_i}.feed_forward.w2.weight'],
																					    F'model.layers.{layer_i}.mlp.up_proj.weight': loaded[F'layers.{layer_i}.feed_forward.w3.weight'],
																					    F'model.layers.{layer_i}.input_layernorm.weight': loaded[F'layers.{layer_i}.attention_norm.weight'],
																					    F'model.layers.{layer_i}.post_attention_layernorm.weight': loaded[F'layers.{layer_i}.ffn_norm.weight'],
																					}
														else:
																					# Sharded
																					# Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
																					# the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
																					# redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

																					__snake_case	:    Tuple											=     {
																					    F'model.layers.{layer_i}.input_layernorm.weight': loaded[0][
																					        F'layers.{layer_i}.attention_norm.weight'
																					    ].clone(),
																					    F'model.layers.{layer_i}.post_attention_layernorm.weight': loaded[0][
																					        F'layers.{layer_i}.ffn_norm.weight'
																					    ].clone(),
																					}
																					__snake_case	:    Dict											=     permute(
																					    torch.cat(
																					        [
																					            loaded[i][F'layers.{layer_i}.attention.wq.weight'].view(__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase			)
																					            for i in range(__lowerCamelCase			)
																					        ]							,			dim=0							,			).reshape(__lowerCamelCase							,			__lowerCamelCase			)			)
																					__snake_case	:    List[Any]											=     permute(
																					    torch.cat(
																					        [
																					            loaded[i][F'layers.{layer_i}.attention.wk.weight'].view(
																					                __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase			)
																					            for i in range(__lowerCamelCase			)
																					        ]							,			dim=0							,			).reshape(__lowerCamelCase							,			__lowerCamelCase			)							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			)
																					__snake_case	:    List[Any]											=     torch.cat(
																					    [
																					        loaded[i][F'layers.{layer_i}.attention.wv.weight'].view(
																					            __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase			)
																					        for i in range(__lowerCamelCase			)
																					    ]							,			dim=0							,			).reshape(__lowerCamelCase							,			__lowerCamelCase			)

																					__snake_case	:    Dict											=     torch.cat(
																					    [loaded[i][F'layers.{layer_i}.attention.wo.weight'] for i in range(__lowerCamelCase			)]							,			dim=1			)
																					__snake_case	:    List[Any]											=     torch.cat(
																					    [loaded[i][F'layers.{layer_i}.feed_forward.w1.weight'] for i in range(__lowerCamelCase			)]							,			dim=0			)
																					__snake_case	:    Tuple											=     torch.cat(
																					    [loaded[i][F'layers.{layer_i}.feed_forward.w2.weight'] for i in range(__lowerCamelCase			)]							,			dim=1			)
																					__snake_case	:    List[str]											=     torch.cat(
																					    [loaded[i][F'layers.{layer_i}.feed_forward.w3.weight'] for i in range(__lowerCamelCase			)]							,			dim=0			)

														__snake_case	:    Tuple											=     inv_freq
														for k, v in state_dict.items():
																					__snake_case	:    Tuple											=     filename
																					param_count += v.numel()
														torch.save(__lowerCamelCase							,			os.path.join(__lowerCamelCase							,			__lowerCamelCase			)			)

							__snake_case	:    Optional[int]											=     F'pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'
							if model_size == "7B":
														# Unsharded
														__snake_case	:    Optional[Any]											=     {
														    "model.embed_tokens.weight": loaded["tok_embeddings.weight"],
														    "model.norm.weight": loaded["norm.weight"],
														    "lm_head.weight": loaded["output.weight"],
														}
							else:
														__snake_case	:    Optional[int]											=     {
														    "model.norm.weight": loaded[0]["norm.weight"],
														    "model.embed_tokens.weight": torch.cat(
														        [loaded[i]["tok_embeddings.weight"] for i in range(__lowerCamelCase			)]							,			dim=1			),
														    "lm_head.weight": torch.cat([loaded[i]["output.weight"] for i in range(__lowerCamelCase			)]							,			dim=0			),
														}

							for k, v in state_dict.items():
														__snake_case	:    str											=     filename
														param_count += v.numel()
							torch.save(__lowerCamelCase							,			os.path.join(__lowerCamelCase							,			__lowerCamelCase			)			)

							# Write configs
							__snake_case	:    str											=     {"total_size": param_count * 2}
							write_json(__lowerCamelCase							,			os.path.join(__lowerCamelCase							,			"pytorch_model.bin.index.json"			)			)
							__snake_case	:    str											=     params["ffn_dim_multiplier"] if "ffn_dim_multiplier" in params else 1
							__snake_case	:    Dict											=     params["multiple_of"] if "multiple_of" in params else 2_5_6
							__snake_case	:    List[str]											=     LlamaConfig(
							    hidden_size=__lowerCamelCase							,			intermediate_size=compute_intermediate_size(__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase			)							,			num_attention_heads=params["n_heads"]							,			num_hidden_layers=params["n_layers"]							,			rms_norm_eps=params["norm_eps"]							,			num_key_value_heads=__lowerCamelCase							,			)
							config.save_pretrained(__lowerCamelCase			)

							# Make space so we can load the model properly now.
							del state_dict
							del loaded
							gc.collect()

							print("Loading the checkpoint in a Llama model."			)
							__snake_case	:    Union[str, Any]											=     LlamaForCausalLM.from_pretrained(__lowerCamelCase							,			torch_dtype=torch.floataa							,			low_cpu_mem_usage=__lowerCamelCase			)
							# Avoid saving this as part of the config.
							del model.config._name_or_path

							print("Saving in the Transformers format."			)
							model.save_pretrained(__lowerCamelCase							,			safe_serialization=__lowerCamelCase			)
							shutil.rmtree(__lowerCamelCase			)







def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase			):
							# Initialize the tokenizer based on the `spm` model
							__snake_case	:    int											=     LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
							print(F'Saving a {tokenizer_class.__name__} to {tokenizer_path}.'			)
							__snake_case	:    List[Any]											=     tokenizer_class(__lowerCamelCase			)
							tokenizer.save_pretrained(__lowerCamelCase			)







def        lowerCAmelCase_  (      ):
							__snake_case	:    List[Any]											=     argparse.ArgumentParser()
							parser.add_argument(
							    "--input_dir"							,			help="Location of LLaMA weights, which contains tokenizer.model and model folders"							,			)
							parser.add_argument(
							    "--model_size"							,			choices=["7B", "7Bf", "13B", "13Bf", "30B", "65B", "70B", "70Bf", "tokenizer_only"]							,			)
							parser.add_argument(
							    "--output_dir"							,			help="Location to write HF model and tokenizer"							,			)
							parser.add_argument("--safe_serialization"							,			type=__lowerCamelCase							,			help="Whether or not to save using `safetensors`."			)
							__snake_case	:    int											=     parser.parse_args()
							if args.model_size != "tokenizer_only":
														write_model(
														    model_path=args.output_dir							,			input_base_path=os.path.join(args.input_dir							,			args.model_size			)							,			model_size=args.model_size							,			safe_serialization=args.safe_serialization							,			)
							__snake_case	:    Union[str, Any]											=     os.path.join(args.input_dir							,			"tokenizer.model"			)
							write_tokenizer(args.output_dir							,			__lowerCamelCase			)


if __name__ == "__main__":
			main()





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class        a	(_lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Optional[Any]  						=						LDMTextToImagePipeline
							__UpperCAmelCase					:							List[Any]  						=						TEXT_TO_IMAGE_PARAMS - {
							    "negative_prompt",
							    "negative_prompt_embeds",
							    "cross_attention_kwargs",
							    "prompt_embeds",
							}
							__UpperCAmelCase					:							int  						=						PipelineTesterMixin.required_optional_params - {
							    "num_images_per_prompt",
							    "callback",
							    "callback_steps",
							}
							__UpperCAmelCase					:							Any  						=						TEXT_TO_IMAGE_BATCH_PARAMS
							__UpperCAmelCase					:							int  						=						False

							def 					__snake_case      (							self :						Union[str, Any]       )			->					str:
														torch.manual_seed(0       )
														__snake_case	:    List[Any]											=     UNetaDConditionModel(
														    block_out_channels=(32, 64)					,			layers_per_block=2					,			sample_size=32					,			in_channels=4					,			out_channels=4					,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,			cross_attention_dim=32					,			)
														__snake_case	:    Any											=     DDIMScheduler(
														    beta_start=0.0_00_85					,			beta_end=0.0_12					,			beta_schedule="scaled_linear"					,			clip_sample=lowerCamelCase					,			set_alpha_to_one=lowerCamelCase					,			)
														torch.manual_seed(0       )
														__snake_case	:    Dict											=     AutoencoderKL(
														    block_out_channels=(32, 64)					,			in_channels=3					,			out_channels=3					,			down_block_types=("DownEncoderBlock2D", "DownEncoderBlock2D")					,			up_block_types=("UpDecoderBlock2D", "UpDecoderBlock2D")					,			latent_channels=4					,			)
														torch.manual_seed(0       )
														__snake_case	:    Any											=     CLIPTextConfig(
														    bos_token_id=0					,			eos_token_id=2					,			hidden_size=32					,			intermediate_size=37					,			layer_norm_eps=1E-05					,			num_attention_heads=4					,			num_hidden_layers=5					,			pad_token_id=1					,			vocab_size=1000					,			)
														__snake_case	:    Any											=     CLIPTextModel(lowerCamelCase       )
														__snake_case	:    Dict											=     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

														__snake_case	:    List[str]											=     {
														    "unet": unet,
														    "scheduler": scheduler,
														    "vqvae": vae,
														    "bert": text_encoder,
														    "tokenizer": tokenizer,
														}
														return components

							def 					__snake_case      (							self :						List[Any]					,			lowerCamelCase :						str					,			lowerCamelCase :						Any=0       )			->					str:
														if str(lowerCamelCase       ).startswith("mps"       ):
																					__snake_case	:    Union[str, Any]											=     torch.manual_seed(lowerCamelCase       )
														else:
																					__snake_case	:    str											=     torch.Generator(device=lowerCamelCase       ).manual_seed(lowerCamelCase       )
														__snake_case	:    Dict											=     {
														    "prompt": "A painting of a squirrel eating a burger",
														    "generator": generator,
														    "num_inference_steps": 2,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs






							def 					__snake_case      (							self :						Dict       )			->					Optional[Any]:
														__snake_case	:    List[Any]											=     "cpu"  # ensure determinism for the device-dependent torch.Generator

														__snake_case	:    Union[str, Any]											=     self.get_dummy_components()
														__snake_case	:    int											=     LDMTextToImagePipeline(**lowerCamelCase       )
														pipe.to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Optional[Any]											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    Optional[Any]											=     pipe(**lowerCamelCase       ).images
														__snake_case	:    Optional[int]											=     image[0, -3:, -3:, -1]

														assert image.shape == (1, 16, 16, 3)
														__snake_case	:    int											=     np.array([0.61_01, 0.61_56, 0.56_22, 0.48_95, 0.66_61, 0.38_04, 0.57_48, 0.61_36, 0.50_14]       )

														assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-3

@slow
@require_torch_gpu
class        a	(unittest.TestCase   ):




							"""simple docstring"""


							def 					__snake_case      (							self :						int       )			->					str:
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()

							def 					__snake_case      (							self :						Optional[int]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Any=torch.floataa					,			lowerCamelCase :						List[Any]=0       )			->					Dict:
														__snake_case	:    List[Any]											=     torch.manual_seed(lowerCamelCase       )
														__snake_case	:    Tuple											=     np.random.RandomState(lowerCamelCase       ).standard_normal((1, 4, 32, 32)       )
														__snake_case	:    int											=     torch.from_numpy(lowerCamelCase       ).to(device=lowerCamelCase					,			dtype=lowerCamelCase       )
														__snake_case	:    List[str]											=     {
														    "prompt": "A painting of a squirrel eating a burger",
														    "latents": latents,
														    "generator": generator,
														    "num_inference_steps": 3,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs






							def 					__snake_case      (							self :						Tuple       )			->					Optional[Any]:
														__snake_case	:    str											=     LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"       ).to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    List[str]											=     self.get_inputs(lowerCamelCase       )
														__snake_case	:    str											=     pipe(**lowerCamelCase       ).images
														__snake_case	:    Dict											=     image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 256, 256, 3)
														__snake_case	:    int											=     np.array([0.5_18_25, 0.5_28_50, 0.5_25_43, 0.5_42_58, 0.5_23_04, 0.5_25_69, 0.5_43_63, 0.5_52_76, 0.5_68_78]       )
														__snake_case	:    List[str]											=     np.abs(expected_slice - image_slice       ).max()
														assert max_diff < 1E-3

@nightly
@require_torch_gpu
class        a	(unittest.TestCase   ):




							"""simple docstring"""


							def 					__snake_case      (							self :						List[Any]       )			->					List[Any]:
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()

							def 					__snake_case      (							self :						Any					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Any=torch.floataa					,			lowerCamelCase :						List[Any]=0       )			->					Optional[Any]:
														__snake_case	:    int											=     torch.manual_seed(lowerCamelCase       )
														__snake_case	:    Tuple											=     np.random.RandomState(lowerCamelCase       ).standard_normal((1, 4, 32, 32)       )
														__snake_case	:    Optional[Any]											=     torch.from_numpy(lowerCamelCase       ).to(device=lowerCamelCase					,			dtype=lowerCamelCase       )
														__snake_case	:    List[Any]											=     {
														    "prompt": "A painting of a squirrel eating a burger",
														    "latents": latents,
														    "generator": generator,
														    "num_inference_steps": 50,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs






							def 					__snake_case      (							self :						List[str]       )			->					int:
														__snake_case	:    Union[str, Any]											=     LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"       ).to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Optional[Any]											=     self.get_inputs(lowerCamelCase       )
														__snake_case	:    str											=     pipe(**lowerCamelCase       ).images[0]

														__snake_case	:    Tuple											=     load_numpy(
														    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy"       )
														__snake_case	:    str											=     np.abs(expected_image - image       ).max()
														assert max_diff < 1E-3

