



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'''
				)
				_lowercase     							=						None
_lowercase     							=						{
    '''7B''': 1_10_08,
    '''13B''': 1_38_24,
    '''30B''': 1_79_20,
    '''65B''': 2_20_16,
    '''70B''': 2_86_72,
}
_lowercase     							=						{
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}






def      _A				(UpperCamelCase		:      List[Any]      ,			UpperCamelCase		:      int=1      ,			UpperCamelCase		:      Optional[Any]=256 )  ->int:



			'''simple docstring'''







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






def      _A				(UpperCamelCase		:      Tuple )  ->Any:



			'''simple docstring'''







			with open(UpperCamelCase      ,			"""r""" ) as f:
						return json.load(UpperCamelCase )






def      _A				(UpperCamelCase		:      Any      ,			UpperCamelCase		:      Optional[int] )  ->int:



			'''simple docstring'''







			with open(UpperCamelCase      ,			"""w""" ) as f:
						json.dump(UpperCamelCase      ,			UpperCamelCase )






def      _A				(UpperCamelCase		:      Tuple      ,			UpperCamelCase		:      Dict      ,			UpperCamelCase		:      Tuple      ,			UpperCamelCase		:      str=True )  ->Optional[Any]:



			'''simple docstring'''







			os.makedirs(UpperCamelCase      ,			exist_ok=UpperCamelCase )
			lowerCamelCase__ :      Tuple								=		os.path.join(UpperCamelCase      ,			"""tmp""" )
			os.makedirs(UpperCamelCase      ,			exist_ok=UpperCamelCase )

			lowerCamelCase__ :      Tuple								=		read_json(os.path.join(UpperCamelCase      ,			"""params.json""" ) )
			lowerCamelCase__ :      Union[str, Any]								=		NUM_SHARDS[model_size]
			lowerCamelCase__ :      str								=		params["""n_layers"""]
			lowerCamelCase__ :      Any								=		params["""n_heads"""]
			lowerCamelCase__ :      List[str]								=		n_heads // num_shards
			lowerCamelCase__ :      Optional[int]								=		params["""dim"""]
			lowerCamelCase__ :      Optional[Any]								=		dim // n_heads
			lowerCamelCase__ :      Any								=		10000.0
			lowerCamelCase__ :      Any								=		1.0 / (base ** (torch.arange(0      ,			UpperCamelCase      ,			2 ).float() / dims_per_head))

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

			# permute for sliced rotary
			def permute(UpperCamelCase		:      Dict      ,			UpperCamelCase		:      Any=n_heads      ,			UpperCamelCase		:      int=dim      ,			UpperCamelCase		:      Tuple=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.)
						lowerCamelCase__ :      str								=		torch.load(os.path.join(UpperCamelCase      ,			"""consolidated.00.pth""" )      ,			map_location="""cpu""" )
			else:
						# Sharded
						lowerCamelCase__ :      int								=		[
						    torch.load(os.path.join(UpperCamelCase      ,			f"consolidated.{i:02d}.pth" )      ,			map_location="""cpu""" )
						    for i in range(UpperCamelCase )
						]
			lowerCamelCase__ :      Optional[int]								=		0
			lowerCamelCase__ :      int								=		{"""weight_map""": {}}
			for layer_i in range(UpperCamelCase ):
						lowerCamelCase__ :      List[Any]								=		f"pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"
						if model_size == "7B":
									# Unsharded
									lowerCamelCase__ :      str								=		{
									    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.

									lowerCamelCase__ :      str								=		{
									    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(),
									}
									lowerCamelCase__ :      Union[str, Any]								=		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 ) )
									lowerCamelCase__ :      Any								=		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      ,			)
									lowerCamelCase__ :      Dict								=		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 )

									lowerCamelCase__ :      Any								=		torch.cat(
									    [loaded[i][f"layers.{layer_i}.attention.wo.weight"] for i in range(UpperCamelCase )]      ,			dim=1 )
									lowerCamelCase__ :      int								=		torch.cat(
									    [loaded[i][f"layers.{layer_i}.feed_forward.w1.weight"] for i in range(UpperCamelCase )]      ,			dim=0 )
									lowerCamelCase__ :      int								=		torch.cat(
									    [loaded[i][f"layers.{layer_i}.feed_forward.w2.weight"] for i in range(UpperCamelCase )]      ,			dim=1 )
									lowerCamelCase__ :      Union[str, Any]								=		torch.cat(
									    [loaded[i][f"layers.{layer_i}.feed_forward.w3.weight"] for i in range(UpperCamelCase )]      ,			dim=0 )

						lowerCamelCase__ :      List[str]								=		inv_freq
						for k, v in state_dict.items():
									lowerCamelCase__ :      List[Any]								=		filename
									param_count += v.numel()
						torch.save(UpperCamelCase      ,			os.path.join(UpperCamelCase      ,			UpperCamelCase ) )

			lowerCamelCase__ :      List[str]								=		f"pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"
			if model_size == "7B":
						# Unsharded
						lowerCamelCase__ :      str								=		{
						    """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
						    """model.norm.weight""": loaded["""norm.weight"""],
						    """lm_head.weight""": loaded["""output.weight"""],
						}
			else:
						lowerCamelCase__ :      Optional[Any]								=		{
						    """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():
						lowerCamelCase__ :      Optional[int]								=		filename
						param_count += v.numel()
			torch.save(UpperCamelCase      ,			os.path.join(UpperCamelCase      ,			UpperCamelCase ) )

			# Write configs
			lowerCamelCase__ :      Any								=		{"""total_size""": param_count * 2}
			write_json(UpperCamelCase      ,			os.path.join(UpperCamelCase      ,			"""pytorch_model.bin.index.json""" ) )
			lowerCamelCase__ :      List[Any]								=		params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
			lowerCamelCase__ :      int								=		params["""multiple_of"""] if """multiple_of""" in params else 256
			lowerCamelCase__ :      Union[str, Any]								=		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.""" )
			lowerCamelCase__ :      Optional[int]								=		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      _A				(UpperCamelCase		:      List[Any]      ,			UpperCamelCase		:      Optional[int] )  ->Any:



			'''simple docstring'''







			lowerCamelCase__ :      Optional[int]								=		LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
			print(f"Saving a {tokenizer_class.__name__} to {tokenizer_path}." )
			lowerCamelCase__ :      List[Any]								=		tokenizer_class(UpperCamelCase )
			tokenizer.save_pretrained(UpperCamelCase )






def      _A				()  ->str:



			'''simple docstring'''







			lowerCamelCase__ :      int								=		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`.""" )
			lowerCamelCase__ :      Union[str, Any]								=		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      ,			)
			lowerCamelCase__ :      Dict								=		os.path.join(args.input_dir      ,			"""tokenizer.model""" )
			write_tokenizer(args.output_dir      ,			UpperCamelCase )


if __name__ == "__main__":
				main()






import argparse

from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
from transformers.utils import logging


logging.set_verbosity_info()






def      _A				(UpperCamelCase		:      Any      ,			UpperCamelCase		:      Union[str, Any]      ,			UpperCamelCase		:      Optional[Any] )  ->Any:



			'''simple docstring'''







			lowerCamelCase__ :      Optional[Any]								=		TaConfig.from_json_file(UpperCamelCase )
			print(f"Building PyTorch model from configuration: {config}" )
			lowerCamelCase__ :      Optional[int]								=		TaForConditionalGeneration(UpperCamelCase )

			# Load weights from tf checkpoint
			load_tf_weights_in_ta(UpperCamelCase      ,			UpperCamelCase      ,			UpperCamelCase )

			# Save pytorch-model
			print(f"Save PyTorch model to {pytorch_dump_path}" )
			model.save_pretrained(UpperCamelCase )


if __name__ == "__main__":
				_lowercase     							=						argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
				)
				parser.add_argument(
				    '''--config_file''',
				    default=None,
				    type=str,
				    required=True,
				    help=(
				        '''The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture.'''
				    ),
				)
				parser.add_argument(
				    '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
				)
				_lowercase     							=						parser.parse_args()
				convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)



