




'''simple docstring'''

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'
							)
							a  :				Dict									=  None
a  :				Optional[int]									=  {
    '7B': 1_1008,
    '13B': 1_3824,
    '30B': 1_7920,
    '65B': 2_2016,
    '70B': 2_8672,
}
a  :				Union[str, Any]									=  {
    '7B': 1,
    '7Bf': 1,
    '13B': 2,
    '13Bf': 2,
    '30B': 4,
    '65B': 8,
    '70B': 8,
    '70Bf': 8,
}


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase=1,      __UpperCAmelCase=256	)		->					Dict:

					'''simple docstring'''

					return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3	)	) + multiple_of - 1) // multiple_of)


def 		__magic_name__    (	__UpperCAmelCase	)		->					Optional[int]:

					'''simple docstring'''

					with open(__UpperCAmelCase,      '''r'''	) as f:
										return json.load(__UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase	)		->					Any:

					'''simple docstring'''

					with open(__UpperCAmelCase,      '''w'''	) as f:
										json.dump(__UpperCAmelCase,      __UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase=True	)		->					Optional[int]:

					'''simple docstring'''

					os.makedirs(__UpperCAmelCase,      exist_ok=__UpperCAmelCase	)
					snake_case_									=				os.path.join(__UpperCAmelCase,      '''tmp'''	)
					os.makedirs(__UpperCAmelCase,      exist_ok=__UpperCAmelCase	)

					snake_case_									=				read_json(os.path.join(__UpperCAmelCase,      '''params.json'''	)	)
					snake_case_									=				NUM_SHARDS[model_size]
					snake_case_									=				params['''n_layers''']
					snake_case_									=				params['''n_heads''']
					snake_case_									=				n_heads // num_shards
					snake_case_									=				params['''dim''']
					snake_case_									=				dim // n_heads
					snake_case_									=				1_0_0_0_0.0
					snake_case_									=				1.0 / (base ** (torch.arange(0,      __UpperCAmelCase,      2	).float() / dims_per_head))

					if "n_kv_heads" in params:
										snake_case_									=				params['''n_kv_heads''']  # for GQA / MQA
										snake_case_									=				n_heads_per_shard // num_key_value_heads
										snake_case_									=				dim // num_key_value_heads
					else:  # compatibility with other checkpoints
										snake_case_									=				n_heads
										snake_case_									=				n_heads_per_shard
										snake_case_									=				dim

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

					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_									=				torch.load(os.path.join(__UpperCAmelCase,      '''consolidated.00.pth'''	),      map_location='''cpu'''	)
					else:
										# Sharded
										snake_case_									=				[
										    torch.load(os.path.join(__UpperCAmelCase,      F"consolidated.{i:02d}.pth"	),      map_location='''cpu'''	)
										    for i in range(__UpperCAmelCase	)
										]
					snake_case_									=				0
					snake_case_									=				{'''weight_map''': {}}
					for layer_i in range(__UpperCAmelCase	):
										snake_case_									=				F"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
										if model_size == "7B":
															# Unsharded
															snake_case_									=				{
															    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_									=				{
															    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_									=				permute(
															    torch.cat(
															        [
															            loaded[i][F"layers.{layer_i}.attention.wq.weight"].view(__UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase	)
															            for i in range(__UpperCAmelCase	)
															        ],      dim=0,      ).reshape(__UpperCAmelCase,      __UpperCAmelCase	)	)
															snake_case_									=				permute(
															    torch.cat(
															        [
															            loaded[i][F"layers.{layer_i}.attention.wk.weight"].view(
															                __UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase	)
															            for i in range(__UpperCAmelCase	)
															        ],      dim=0,      ).reshape(__UpperCAmelCase,      __UpperCAmelCase	),      __UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase,      )
															snake_case_									=				torch.cat(
															    [
															        loaded[i][F"layers.{layer_i}.attention.wv.weight"].view(
															            __UpperCAmelCase,      __UpperCAmelCase,      __UpperCAmelCase	)
															        for i in range(__UpperCAmelCase	)
															    ],      dim=0,      ).reshape(__UpperCAmelCase,      __UpperCAmelCase	)

															snake_case_									=				torch.cat(
															    [loaded[i][F"layers.{layer_i}.attention.wo.weight"] for i in range(__UpperCAmelCase	)],      dim=1	)
															snake_case_									=				torch.cat(
															    [loaded[i][F"layers.{layer_i}.feed_forward.w1.weight"] for i in range(__UpperCAmelCase	)],      dim=0	)
															snake_case_									=				torch.cat(
															    [loaded[i][F"layers.{layer_i}.feed_forward.w2.weight"] for i in range(__UpperCAmelCase	)],      dim=1	)
															snake_case_									=				torch.cat(
															    [loaded[i][F"layers.{layer_i}.feed_forward.w3.weight"] for i in range(__UpperCAmelCase	)],      dim=0	)

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

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

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

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

					# 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_									=				LlamaForCausalLM.from_pretrained(__UpperCAmelCase,      torch_dtype=torch.floataa,      low_cpu_mem_usage=__UpperCAmelCase	)
					# Avoid saving this as part of the config.
					del model.config._name_or_path

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


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase	)		->					str:

					'''simple docstring'''

					snake_case_									=				LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
					print(F"Saving a {tokenizer_class.__name__} to {tokenizer_path}."	)
					snake_case_									=				tokenizer_class(__UpperCAmelCase	)
					tokenizer.save_pretrained(__UpperCAmelCase	)


def 		__magic_name__    (	)		->					Union[str, Any]:

					'''simple docstring'''

					snake_case_									=				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=__UpperCAmelCase,      help='''Whether or not to save using `safetensors`.'''	)
					snake_case_									=				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_									=				os.path.join(args.input_dir,      '''tokenizer.model'''	)
					write_tokenizer(args.output_dir,      __UpperCAmelCase	)


if __name__ == "__main__":
							main()







from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)






