






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    :   str        =			None
_a    :   Dict        =			{
    """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 				snake_case__							(							UpperCAmelCase							:  Any    ,			UpperCAmelCase							:  Optional[Any]=1    ,			UpperCAmelCase							:  List[str]=2_5_6       ):
    return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3       )       ) + multiple_of - 1) // multiple_of)


def 				snake_case__							(							UpperCAmelCase							:  Dict       ):
    with open(UpperCAmelCase    ,			"r"       ) as f:
        return json.load(UpperCAmelCase       )


def 				snake_case__							(							UpperCAmelCase							:  str    ,			UpperCAmelCase							:  int       ):
    with open(UpperCAmelCase    ,			"w"       ) as f:
        json.dump(UpperCAmelCase    ,			UpperCAmelCase       )


def 				snake_case__							(							UpperCAmelCase							:  int    ,			UpperCAmelCase							:  Dict    ,			UpperCAmelCase							:  List[str]    ,			UpperCAmelCase							:  Tuple=True       ):
    os.makedirs(UpperCAmelCase    ,			exist_ok=UpperCAmelCase       )
    lowerCAmelCase__   :Dict      							=				os.path.join(UpperCAmelCase    ,			"tmp"       )
    os.makedirs(UpperCAmelCase    ,			exist_ok=UpperCAmelCase       )

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

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

    # permute for sliced rotary
    def permute(UpperCAmelCase							:  str    ,			UpperCAmelCase							:  List[str]=n_heads    ,			UpperCAmelCase							:  str=dim    ,			UpperCAmelCase							:  Any=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__   :Dict      							=				torch.load(os.path.join(UpperCAmelCase    ,			"consolidated.00.pth"       )    ,			map_location="cpu"       )
    else:
        # Sharded
        lowerCAmelCase__   :Any      							=				[
            torch.load(os.path.join(UpperCAmelCase    ,			F'''consolidated.{i:02d}.pth'''       )    ,			map_location="cpu"       )
            for i in range(UpperCAmelCase       )
        ]
    lowerCAmelCase__   :Union[str, Any]      							=				0
    lowerCAmelCase__   :List[Any]      							=				{"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__   :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.

            lowerCAmelCase__   :Dict      							=				{
                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__   :Optional[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__   :Union[str, 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__   :int      							=				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__   :List[str]      							=				torch.cat(
                [loaded[i][F'''layers.{layer_i}.attention.wo.weight'''] for i in range(UpperCAmelCase       )]    ,			dim=1       )
            lowerCAmelCase__   :List[str]      							=				torch.cat(
                [loaded[i][F'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(UpperCAmelCase       )]    ,			dim=0       )
            lowerCAmelCase__   :str      							=				torch.cat(
                [loaded[i][F'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(UpperCAmelCase       )]    ,			dim=1       )
            lowerCAmelCase__   :Optional[int]      							=				torch.cat(
                [loaded[i][F'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(UpperCAmelCase       )]    ,			dim=0       )

        lowerCAmelCase__   :Tuple      							=				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__   :Optional[int]      							=				{
            "model.embed_tokens.weight": loaded["tok_embeddings.weight"],
            "model.norm.weight": loaded["norm.weight"],
            "lm_head.weight": loaded["output.weight"],
        }
    else:
        lowerCAmelCase__   :str      							=				{
            "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__   :int      							=				filename
        param_count += v.numel()
    torch.save(UpperCAmelCase    ,			os.path.join(UpperCAmelCase    ,			UpperCAmelCase       )       )

    # Write configs
    lowerCAmelCase__   :Dict      							=				{"total_size": param_count * 2}
    write_json(UpperCAmelCase    ,			os.path.join(UpperCAmelCase    ,			"pytorch_model.bin.index.json"       )       )
    lowerCAmelCase__   :Dict      							=				params["ffn_dim_multiplier"] if "ffn_dim_multiplier" in params else 1
    lowerCAmelCase__   :List[str]      							=				params["multiple_of"] if "multiple_of" in params else 2_5_6
    lowerCAmelCase__   :Optional[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 				snake_case__							(							UpperCAmelCase							:  Optional[int]    ,			UpperCAmelCase							:  Optional[int]       ):
    # Initialize the tokenizer based on the `spm` model
    lowerCAmelCase__   :Optional[Any]      							=				LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
    print(F'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''       )
    lowerCAmelCase__   :int      							=				tokenizer_class(UpperCAmelCase       )
    tokenizer.save_pretrained(UpperCAmelCase       )


def 				snake_case__							(							):
    lowerCAmelCase__   :str      							=				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__   :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    ,			)
    lowerCAmelCase__   :Optional[Any]      							=				os.path.join(args.input_dir    ,			"tokenizer.model"       )
    write_tokenizer(args.output_dir    ,			UpperCAmelCase       )


if __name__ == "__main__":
 main()











from argparse import ArgumentParser

from datasets.commands.convert import ConvertCommand
from datasets.commands.dummy_data import DummyDataCommand
from datasets.commands.env import EnvironmentCommand
from datasets.commands.run_beam import RunBeamCommand
from datasets.commands.test import TestCommand
from datasets.utils.logging import set_verbosity_info


def 				snake_case__							(							UpperCAmelCase							:  Dict       ):
    return {key.lstrip("-"       ): value for key, value in zip(unknown_args[::2]    ,			unknown_args[1::2]       )}


def 				snake_case__							(							):
    lowerCAmelCase__   :str      							=				ArgumentParser(
        "HuggingFace Datasets CLI tool"    ,			usage="datasets-cli <command> [<args>]"    ,			allow_abbrev=UpperCAmelCase       )
    lowerCAmelCase__   :Any      							=				parser.add_subparsers(help="datasets-cli command helpers"       )
    set_verbosity_info()

    # Register commands
    ConvertCommand.register_subcommand(UpperCAmelCase       )
    EnvironmentCommand.register_subcommand(UpperCAmelCase       )
    TestCommand.register_subcommand(UpperCAmelCase       )
    RunBeamCommand.register_subcommand(UpperCAmelCase       )
    DummyDataCommand.register_subcommand(UpperCAmelCase       )

    # Parse args
    lowerCAmelCase__							,lowerCAmelCase__   :int      							=				parser.parse_known_args()
    if not hasattr(UpperCAmelCase    ,			"func"       ):
        parser.print_help()
        exit(1       )
    lowerCAmelCase__   :Optional[int]      							=				parse_unknown_args(UpperCAmelCase       )

    # Run
    lowerCAmelCase__   :str      							=				args.func(UpperCAmelCase    ,			**UpperCAmelCase       )
    service.run()


if __name__ == "__main__":
 main()



