in toolkits/model_checkpoints_convertor/qwen/hf2megatron_qwen1.0.py [0:0]
def convert_checkpoint_from_megatron_to_transformers(args):
"""
Convert NVIDIA Megatron-LM checkpoint to HuggingFace Transformers checkpoint. This handles Megatron checkpoints
with different tensor parallelism and pipeline parallelism sizes. It saves the converted checkpoint into shards
using HuggingFace Transformers checkpoint sharding functionality. This greatly extends the functionality of
`convert_megatron_gpt2_checkpoint.py`
Args:
args (argparse.Namespace): the arguments to the script
"""
os.makedirs(args.save_path, exist_ok=True)
# Load Megatron-LM checkpoint arguments from the state dict
sub_dirs = os.listdir(args.load_path)
possible_sub_dirs = ["mp_rank_00", "mp_rank_00_000"]
for sub_dir in possible_sub_dirs:
if sub_dir in sub_dirs:
rank0_checkpoint_name = [i for i in os.listdir(os.path.join(args.load_path, sub_dir)) if 'rng' in i][0]
rank0_checkpoint_path = os.path.join(args.load_path, sub_dir, rank0_checkpoint_name)
break
print(f"Loading Megatron-LM checkpoint arguments from: {rank0_checkpoint_path}")
state_dict = torch.load(rank0_checkpoint_path, map_location="cpu")
megatron_args = state_dict.get("args", None)
if megatron_args is None:
raise ValueError(
"Megatron-LM checkpoint does not contain arguments. This utility only supports Megatron-LM checkpoints"
" containing all the megatron arguments. This is because it loads all config related to model"
" architecture, the tensor and pipeline model parallel size from the checkpoint insead of user having to"
" manually specify all the details. Please save Megatron-LM checkpoint along with all the megatron"
" arguments to use this utility."
)
# Saving config and tokenzier files
config_path = '/'.join(args.load_path.split('/')[:-2]) if args.load_path.endswith('/') else '/'.join(args.load_path.split('/')[:-1])
print(config_path, "\ncp -rf "+config_path+"/*.json " + args.save_path)
os.system("cp -rf "+config_path+"/*.json " + args.save_path)
os.system("cp -rf " + config_path + "/tokenizer* " + args.save_path)
os.system("cp -rf " + config_path + "/*.py " + args.save_path)
os.system("cp -rf " + config_path + "/qwen.* " + args.save_path)
os.system("rm -rf "+args.load_path+"/mp_rank*/distrib*")
activation_function = "gelu"
vocab_size = (
megatron_args.padded_vocab_size
if getattr(megatron_args, "orig_vocab_size", None) is None
else megatron_args.orig_vocab_size
)
# params dtype
if args.target_params_dtype == "fp16":
dtype = torch.float16
elif args.target_params_dtype == "bf16":
dtype = torch.bfloat16
else:
dtype = torch.float32
if megatron_args.hidden_size == 2048:
config = QWenConfig_14b(
auto_map={
"AutoConfig": "configuration_qwen.QWenConfig",
"AutoModelForCausalLM": "modeling_qwen.QWenLMHeadModel"},
architectures="QWenLMHeadModel",
vocab_size=151936,
hidden_size=2048,
num_hidden_layers=24,
num_attention_heads=16,
intermediate_size=11008,
seq_length=8192,
)
elif megatron_args.hidden_size == 4096:
config = QWenConfig(
auto_map={
"AutoConfig": "configuration_qwen.QWenConfig",
"AutoModelForCausalLM": "modeling_qwen.QWenLMHeadModel"},
architectures="QWenLMHeadModel",
padded_vocab_size=151936,
n_positions=6144,
pos_emb="rotary",
params_dtype="torch.bfloat16",
seq_length=2048,
tokenizer_type="QWenTokenizer",
layer_norm_epsilon=1e-06,
resid_pdrop=0.1,
)
elif megatron_args.hidden_size == 5120:
config = QWenConfig_14b(
auto_map={
"AutoConfig": "configuration_qwen.QWenConfig",
"AutoModelForCausalLM": "modeling_qwen.QWenLMHeadModel"},
architectures="QWenLMHeadModel",
vocab_size=152064,
hidden_size=5120,
num_hidden_layers=40,
num_attention_heads=40,
intermediate_size=27392,
seq_length=2048,
)
elif megatron_args.hidden_size == 8192:
config = QWenConfig_14b(
auto_map={
"AutoConfig": "configuration_qwen.QWenConfig",
"AutoModelForCausalLM": "modeling_qwen.QWenLMHeadModel"},
architectures="QWenLMHeadModel",
vocab_size=152064,
hidden_size=8192,
num_hidden_layers=80,
num_attention_heads=64,
intermediate_size=24576,
seq_length=2048,
)
output_state_dict = {}
checkpoint_version = state_dict.get("checkpoint_version", 3.0)
tp_size = megatron_args.tensor_model_parallel_size
pp_size = megatron_args.pipeline_model_parallel_size
# The regex to extract layer names.
layer_re = re.compile("layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)")
# Convert.
print("Converting")
# Embeddings
print("Converting embeddings")
tp_state_dicts = get_megatron_sharded_states(args, tp_size, pp_size, 0)
# Convert and store the word embeddings.
word_embeddings = []
word_embeddings_layernorm_weight = []
word_embeddings_layernorm_bias = []
for tp_rank in range(tp_size):
embeddings = get_element_from_dict_by_path(
tp_state_dicts[tp_rank], "model.word_embeddings_for_head.weight"
)
# After training with megatron, word_embeddings is stored differently
if type(embeddings) is dict:
embeddings = get_element_from_dict_by_path(
tp_state_dicts[tp_rank], "model.language_model.embedding.word_embeddings.weight"
)
word_embeddings.append(embeddings)
word_embeddings = torch.cat(word_embeddings, dim=0)
word_embeddings = word_embeddings.to(dtype)
output_state_dict["transformer.wte.weight"] = word_embeddings.clone()
# Reset the vocab size
config.vocab_size = word_embeddings.shape[0]
# Transformer Layers
print("Converting transformer layers")
# The number of heads.
heads = config.num_attention_heads
# The hidden_size per head.
hidden_size_per_head = config.hidden_size // config.num_attention_heads
num_layers = config.num_hidden_layers // pp_size
for pp_rank in range(pp_size):
if pp_size > 0:
print(f"Converting pipeline parallel rank {pp_rank}")
tp_state_dicts = get_megatron_sharded_states(args, tp_size, pp_size, pp_rank)
# The transformer.
path = (
"model.language_model.transformer"
if "transformer" in get_element_from_dict_by_path(tp_state_dicts[0], "model.language_model").keys()
else "model.language_model.encoder"
)
# Extract the layers.
for key, val in get_element_from_dict_by_path(tp_state_dicts[0], path).items():
# Match the name.
m = layer_re.match(key)
# Stop if that's not a layer
if m is None:
break
# The index of the layer.
layer_idx = int(m.group(1)) + pp_rank * num_layers
# The name of the operation.
op_name = m.group(2)
# Is it a weight or a bias?
weight_or_bias = m.group(3)
# The name of the layer.
layer_name = f"transformer.h.{layer_idx}"
print(layer_name, op_name, weight_or_bias)
if op_name + "." + weight_or_bias not in tensor_parallel_params_mg:
params = val.to(dtype)
else:
# import pdb
# pdb.set_trace()
dim = 1 if op_name in ["self_attention.dense", "mlp.dense_4h_to_h"] else 0
params = torch.cat(
[val]
+ [
get_element_from_dict_by_path(tp_state_dicts[tp_rank], f"{path}")[key]
for tp_rank in range(1, tp_size)
],
dim=dim,
).to(dtype)
# For layernorm(s), simply store the layer norm.
if op_name.endswith("layernorm") and weight_or_bias == 'weight':
ln_name = "ln_1" if op_name.startswith("input") else "ln_2"
output_state_dict[layer_name + "." + ln_name + "." + weight_or_bias] = params.clone()
# Transpose the QKV matrix.
elif (
op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
) and weight_or_bias == "weight":
out_val = megatron_to_transformers_fix_query_key_value_ordering(
params,
checkpoint_version,
3,
heads,
hidden_size_per_head,
)
# Megatron stores (3*D) x D but transformers-GPT2 expects D x 3*D.
# out_val = out_val.transpose(0, 1).contiguous()
# Store.
output_state_dict[layer_name + f".attn.c_attn.weight"] = out_val.clone()
# Transpose the bias.
# Not applicable
elif (
op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
) and weight_or_bias == "bias":
out_val = megatron_to_transformers_fix_query_key_value_ordering(
params, checkpoint_version, 3, heads, hidden_size_per_head
)
# Store. No change of shape.
output_state_dict[layer_name + ".attn.c_attn.bias"] = out_val.clone()
# Transpose the weights.
elif weight_or_bias == "weight":
if 'dense_h_to_4h' in op_name:
out_name = megatron_to_transformers[op_name]
para_dict = {i:[] for i in out_name}
for index, mat in enumerate(torch.split(params, params.shape[0]//tp_size)):
for index_new, mat_sep in enumerate(torch.split(mat, mat.shape[0]//2)):
para_dict[out_name[index_new]].append(mat_sep.clone())
for name, para in para_dict.items():
output_state_dict[layer_name + name + "weight"] = torch.cat(para)
else:
out_name = megatron_to_transformers[op_name]
output_state_dict[layer_name + out_name + "weight"] = params.clone()
# Copy the bias.
# Ignore them
elif weight_or_bias == "bias":
pass
# Copy the Rotary Embedding
else:
out_name = megatron_to_transformers[op_name]
output_state_dict[layer_name + out_name] = params.clone()
if config.num_hidden_layers != (layer_idx + 1):
raise ValueError(f"Expected {config.num_hidden_layers} layers but found {layer_idx + 1}")
# The final layernorm.
print("Converting final layernorm")
params = get_element_from_dict_by_path(tp_state_dicts[0], str(path))
try:
output_state_dict["transformer.ln_f.weight"] = params["final_layernorm.weight"].to(dtype).clone()
except:
output_state_dict["transformer.ln_f.weight"] = params["final_norm.weight"].to(dtype).clone()
# For LM head, transformers' wants the matrix to weight embeddings.
print("Converting LM head")
params = torch.cat([
get_element_from_dict_by_path(tp_state_dicts[i], 'model.language_model.output_layer.weight')
for i in range(tp_size)]
)
output_state_dict["lm_head.weight"] = params.to(dtype).clone()
# It should be done!
print("Conversion from Megatron-LM to Transformers is done!")
# Print the structure of converted state dict.
if args.print_checkpoint_structure:
recursive_print(None, output_state_dict)
# Store the config to file.
print("Saving config")
config.save_pretrained(args.save_path)
# Store the state_dict to file.
max_shard_size = int(args.max_shard_size) if args.max_shard_size.isdigit() else args.max_shard_size
shards, index = shard_checkpoint(output_state_dict, max_shard_size=max_shard_size)
# Save the model
if not os.path.exists(args.save_path):
os.system(f'mkdir -p {args.save_path}')
for shard_file, shard in shards.items():
torch.save(clone_state_dict(shard), os.path.join(args.save_path, shard_file))
if index is None:
print(f"Model weights saved in {os.path.join(args.save_path, WEIGHTS_NAME)}")
else:
save_index_file = os.path.join(args.save_path, WEIGHTS_INDEX_NAME)
# Save the index as well
with open(save_index_file, "w", encoding="utf-8") as f:
content = json.dumps(index, indent=2, sort_keys=True) + "\n"
f.write(content)
print(
f"The model is bigger than the maximum size per checkpoint ({args.max_shard_size}) and is going to be "
f"split in {len(shards)} checkpoint shards. You can find where each parameters has been saved in the "
f"index located at {save_index_file}."
)