
import re





def        lowerCAmelCase       (				snake_case__   :      List[str] )->			Optional[int]:
    def docstring_decorator(snake_case__   :      Any ):
        A_								=					fn.__doc__
        A_								=					func_doc.split("\n" )
        A_								=					0
        while i < len(snake_case__ ) and re.search(r"^\s*Examples?:\s*$"				,					lines[i] ) is None:
            i += 1
        if i < len(snake_case__ ):
            A_								=					example_docstring
            A_								=					"\n".join(snake_case__ )
        else:
            raise ValueError(
                f'The function {fn} should have an empty \'Examples:\' in its docstring as placeholder, '
                f'current docstring is:\n{func_doc}' )
        A_								=					func_doc
        return fn

    return docstring_decorator








import argparse
import os
from os.path import isfile

import torch

from transformers import GPTaConfig





def        lowerCAmelCase       (				snake_case__   :      List[str]				,					snake_case__   :      List[str]				,					snake_case__   :      Optional[int]=0 )->			Union[str, Any]:
    # Format the message.
    if name is None:
        A_								=					None
    else:
        A_								=					"." * max(0				,					spaces - 2 ) + "# {:" + str(50 - spaces ) + "s}"
        A_								=					fmt.format(snake_case__ )

    # Print and recurse (if needed).
    if isinstance(snake_case__				,					snake_case__ ):
        if msg is not None:
            print(snake_case__ )
        for k in val.keys():
            recursive_print(snake_case__				,					val[k]				,					spaces + 2 )
    elif isinstance(snake_case__				,					torch.Tensor ):
        print(snake_case__				,					":"				,					val.size() )
    else:
        print(snake_case__				,					":"				,					snake_case__ )





def        lowerCAmelCase       (				snake_case__   :      Any				,					snake_case__   :      List[Any]				,					snake_case__   :      str				,					snake_case__   :      str )->			Union[str, Any]:
    # Permutes layout of param tensor to [num_splits * num_heads * hidden_size, :]
    # for compatibility with later versions of NVIDIA Megatron-LM.
    # The inverse operation is performed inside Megatron-LM to read checkpoints:
    # https://github.com/NVIDIA/Megatron-LM/blob/v2.4/megatron/checkpointing.py#L209
    # If param is the weight tensor of the self-attention block, the returned tensor
    # will have to be transposed one more time to be read by HuggingFace GPT2.
    A_								=					param.size()
    # other versions store [num_heads * num_splits * hidden_size, :]
    A_								=					(num_heads, num_splits, hidden_size) + input_shape[1:]
    A_								=					param.view(*snake_case__ )
    A_								=					param.transpose(0				,					1 ).contiguous()
    A_								=					param.view(*snake_case__ )
    return param





def        lowerCAmelCase       (				snake_case__   :      Dict				,					snake_case__   :      str )->			Optional[int]:
    A_								=					config.n_positions
    A_								=					config.n_layer
    A_								=					config.vocab_size
    A_								=					config.n_head
    A_								=					config.n_embd // config.n_head

    A_								=					sd_megatron["model.language_model.embedding.word_embeddings.weight"][:vocab_size, :]
    A_								=					{
        "transformer.wte.weight": word_embeddings,
        "transformer.wpe.weight": sd_megatron["model.language_model.embedding.position_embeddings.weight"],
        "transformer.ln_f.weight": sd_megatron["model.language_model.encoder.final_layernorm.weight"],
        "transformer.ln_f.bias": sd_megatron["model.language_model.encoder.final_layernorm.bias"],
    }

    A_								=					"model.language_model.encoder.layers."
    for i in range(snake_case__ ):
        A_								=					torch.tril(torch.ones((n_positions, n_positions)				,					dtype=torch.bool ) )
        A_								=					causal_mask.view(1				,					1				,					snake_case__				,					snake_case__ )
        A_								=					causal_mask
        A_								=					torch.tensor(-1e4				,					dtype=torch.bfloataa )

        A_								=					sd_megatron[f'{pf}{i}.input_layernorm.weight']
        A_								=					sd_megatron[f'{pf}{i}.input_layernorm.bias']

        A_								=					sd_megatron[f'{pf}{i}.self_attention.query_key_value.weight']
        A_								=					fix_query_key_value_ordering(snake_case__				,					3				,					snake_case__				,					snake_case__ )
        A_								=					vala.transpose(0				,					1 ).contiguous()

        A_								=					sd_megatron[f'{pf}{i}.self_attention.query_key_value.bias']
        A_								=					fix_query_key_value_ordering(snake_case__				,					3				,					snake_case__				,					snake_case__ )
        A_								=					vala

        A_								=					sd_megatron[f'{pf}{i}.self_attention.dense.weight'].transpose(
            0				,					1 )
        A_								=					sd_megatron[f'{pf}{i}.self_attention.dense.bias']
        A_								=					sd_megatron[f'{pf}{i}.post_attention_layernorm.weight']
        A_								=					sd_megatron[f'{pf}{i}.post_attention_layernorm.bias']
        A_								=					sd_megatron[f'{pf}{i}.mlp.dense_h_to_4h.weight'].transpose(0				,					1 )
        A_								=					sd_megatron[f'{pf}{i}.mlp.dense_h_to_4h.bias']
        A_								=					sd_megatron[f'{pf}{i}.mlp.dense_4h_to_h.weight'].transpose(
            0				,					1 )
        A_								=					sd_megatron[f'{pf}{i}.mlp.dense_4h_to_h.bias']

    # For LM head, transformers' wants the matrix to weight embeddings.
    A_								=					word_embeddings

    return sd_hf





def        lowerCAmelCase       (				snake_case__   :      Optional[int]				,					snake_case__   :      List[Any] )->			Dict:
    A_								=					64000
    A_								=					config_megatron["encoder_seq_length"]
    A_								=					config_megatron["hidden_size"]
    A_								=					config_megatron["num_layers"]
    A_								=					config_megatron["num_attention_heads"]
    A_								=					config_megatron["ffn_hidden_size"]
    A_								=					"gelu"
    A_								=					0.1
    A_								=					0.1
    A_								=					0.1
    A_								=					config_megatron["layernorm_epsilon"]  # 1e-5
    A_								=					config_megatron["init_method_std"]  # 0.02
    A_								=					config_megatron["apply_query_key_layer_scaling"]  # True
    A_								=					True
    A_								=					True

    # This identifies the 6.7B (7B) model which uses a different tokenizer
    if config_megatron["hidden_size"] == 4096:
        A_								=					1  # <|endoftext|>
        A_								=					1  # <|endoftext|>
        A_								=					0  # <unk>
    else:
        A_								=					2  # <s>
        A_								=					3  # <|endoftext|>
        A_								=					0  # <pad>

    return config_hf





def        lowerCAmelCase       (				snake_case__   :      Tuple )->			Dict:
    print(snake_case__ )

    A_								=					args.checkpoint_path
    A_								=					args.save_path
    if isfile(snake_case__ ):
        raise FileNotFoundError(f'ERROR! could not find file {checkpoint_path}' )

    # Load the model.
    A_								=					torch.load(snake_case__				,					map_location="cpu" )

    # Load the config.
    A_								=					checkpoint["hyper_parameters"]["cfg"]
    A_								=					GPTaConfig()
    A_								=					copy_config(config_hf=snake_case__				,					config_megatron=snake_case__ )
    A_								=					["GPT2LMHeadModel"]

    A_								=					checkpoint["state_dict"]

    # Convert.
    print("Converting" )
    A_								=					convert_megatron_checkpoint(snake_case__				,					snake_case__ )

    # Print the structure of converted state dict.
    if args.print_checkpoint_structure:
        recursive_print(snake_case__				,					snake_case__ )

    A_								=					"GPTSw3Tokenizer"

    # Store the config to file.
    print("Saving config" )
    config_hf.save_pretrained(snake_case__ )

    # Store the state_dict to file.
    A_								=					os.path.join(snake_case__				,					"pytorch_model.bin" )
    print(f'Saving checkpoint to "{output_checkpoint_file}"' )
    torch.save(snake_case__				,					snake_case__ )


if __name__ == "__main__":
     __magic_name__  :  Union[str, Any]     			=   argparse.ArgumentParser()
     parser.add_argument(
         '--checkpoint_path',
         type=str,
         required=True,
         help='e.g. megatron_gpt--val_loss=2.42-step=38000-consumed_samples=54720000',
     )
     parser.add_argument('--save_path', type=str, required=True, help='e.g. /home/user/gpt-sw3/hf')
     parser.add_argument('--print-checkpoint-structure', action='store_true')
     __magic_name__  :  str     			=   parser.parse_args()
     main(_args)






