response
stringlengths 1
33.1k
| instruction
stringlengths 22
582k
|
|---|---|
Train the model | def train(args, train_dataset, model, tokenizer):
""" Train the model """
#build dataloader
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size,num_workers=4)
args.max_steps=args.epochs*len( train_dataloader)
args.save_steps=len( train_dataloader)//10
args.warmup_steps=args.max_steps//5
model.to(args.device)
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
{'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
'weight_decay': args.weight_decay},
{'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.warmup_steps,
num_training_steps=args.max_steps)
# multi-gpu training
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.train_batch_size//max(args.n_gpu, 1))
logger.info(" Total train batch size = %d",args.train_batch_size*args.gradient_accumulation_steps)
logger.info(" Gradient Accumulation steps = %d", args.gradient_accumulation_steps)
logger.info(" Total optimization steps = %d", args.max_steps)
global_step=0
tr_loss, logging_loss,avg_loss,tr_nb,tr_num,train_loss = 0.0, 0.0,0.0,0,0,0
best_f1=0
model.zero_grad()
for idx in range(args.epochs):
bar = tqdm(train_dataloader,total=len(train_dataloader))
tr_num=0
train_loss=0
for step, batch in enumerate(bar):
(inputs_ids_1,position_idx_1,attn_mask_1,
inputs_ids_2,position_idx_2,attn_mask_2,
labels)=[x.to(args.device) for x in batch]
model.train()
loss,logits = model(inputs_ids_1,position_idx_1,attn_mask_1,inputs_ids_2,position_idx_2,attn_mask_2,labels)
if args.n_gpu > 1:
loss = loss.mean()
if args.gradient_accumulation_steps > 1:
loss = loss / args.gradient_accumulation_steps
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
tr_loss += loss.item()
tr_num+=1
train_loss+=loss.item()
if avg_loss==0:
avg_loss=tr_loss
avg_loss=round(train_loss/tr_num,5)
bar.set_description("epoch {} loss {}".format(idx,avg_loss))
if (step + 1) % args.gradient_accumulation_steps == 0:
optimizer.step()
optimizer.zero_grad()
scheduler.step()
global_step += 1
output_flag=True
avg_loss=round(np.exp((tr_loss - logging_loss) /(global_step- tr_nb)),4)
if global_step % args.save_steps == 0:
results = evaluate(args, model, tokenizer, eval_when_training=True)
# Save model checkpoint
if results['eval_f1']>best_f1:
best_f1=results['eval_f1']
logger.info(" "+"*"*20)
logger.info(" Best f1:%s",round(best_f1,4))
logger.info(" "+"*"*20)
checkpoint_prefix = 'checkpoint-best-f1'
output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = model.module if hasattr(model,'module') else model
output_dir = os.path.join(output_dir, '{}'.format('model.bin'))
torch.save(model_to_save.state_dict(), output_dir)
logger.info("Saving model checkpoint to %s", output_dir) |
Train the model | def train(args, model, tokenizer,pool):
""" Train the model """
#get training dataset
train_dataset=TextDataset(tokenizer, args, args.train_data_file, pool)
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size,num_workers=4)
#get optimizer and scheduler
optimizer = AdamW(model.parameters(), lr=args.learning_rate, eps=1e-8)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0,num_training_steps=len(train_dataloader)*args.num_train_epochs)
# multi-gpu training (should be after apex fp16 initialization)
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.train_batch_size//args.n_gpu)
logger.info(" Total train batch size = %d", args.train_batch_size)
logger.info(" Total optimization steps = %d", len(train_dataloader)*args.num_train_epochs)
# model.resize_token_embeddings(len(tokenizer))
model.zero_grad()
model.train()
tr_num,tr_loss,best_mrr=0,0,0
for idx in range(args.num_train_epochs):
for step,batch in enumerate(train_dataloader):
#get inputs
code_inputs = batch[0].to(args.device)
attn_mask = batch[1].to(args.device)
position_idx = batch[2].to(args.device)
nl_inputs = batch[3].to(args.device)
#get code and nl vectors
code_vec = model(code_inputs=code_inputs,attn_mask=attn_mask,position_idx=position_idx)
nl_vec = model(nl_inputs=nl_inputs)
#calculate scores and loss
scores=torch.einsum("ab,cb->ac",nl_vec,code_vec)
loss_fct = CrossEntropyLoss()
loss = loss_fct(scores, torch.arange(code_inputs.size(0), device=scores.device))
#report loss
tr_loss += loss.item()
tr_num+=1
if (step+1)% 100==0:
logger.info("epoch {} step {} loss {}".format(idx,step+1,round(tr_loss/tr_num,5)))
tr_loss=0
tr_num=0
#backward
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
#evaluate
results = evaluate(args, model, tokenizer,args.eval_data_file, pool, eval_when_training=True)
for key, value in results.items():
logger.info(" %s = %s", key, round(value,4))
#save best model
if results['eval_mrr']>best_mrr:
best_mrr=results['eval_mrr']
logger.info(" "+"*"*20)
logger.info(" Best mrr:%s",round(best_mrr,4))
logger.info(" "+"*"*20)
checkpoint_prefix = 'checkpoint-best-mrr'
output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = model.module if hasattr(model,'module') else model
output_dir = os.path.join(output_dir, '{}'.format('model.bin'))
torch.save(model_to_save.state_dict(), output_dir)
logger.info("Saving model checkpoint to %s", output_dir) |
Extracts all n-grams upto a given maximum order from an input segment.
Args:
segment: text segment from which n-grams will be extracted.
max_order: maximum length in tokens of the n-grams returned by this
methods.
Returns:
The Counter containing all n-grams upto max_order in segment
with a count of how many times each n-gram occurred. | def _get_ngrams(segment, max_order):
"""Extracts all n-grams upto a given maximum order from an input segment.
Args:
segment: text segment from which n-grams will be extracted.
max_order: maximum length in tokens of the n-grams returned by this
methods.
Returns:
The Counter containing all n-grams upto max_order in segment
with a count of how many times each n-gram occurred.
"""
ngram_counts = collections.Counter()
for order in range(1, max_order + 1):
for i in range(0, len(segment) - order + 1):
ngram = tuple(segment[i:i+order])
ngram_counts[ngram] += 1
return ngram_counts |
Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of tokens.
translation_corpus: list of translations to score. Each translation
should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
precisions and brevity penalty. | def compute_bleu(reference_corpus, translation_corpus, max_order=4,
smooth=False):
"""Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of tokens.
translation_corpus: list of translations to score. Each translation
should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
precisions and brevity penalty.
"""
matches_by_order = [0] * max_order
possible_matches_by_order = [0] * max_order
reference_length = 0
translation_length = 0
for (references, translation) in zip(reference_corpus,
translation_corpus):
reference_length += min(len(r) for r in references)
translation_length += len(translation)
merged_ref_ngram_counts = collections.Counter()
for reference in references:
merged_ref_ngram_counts |= _get_ngrams(reference, max_order)
translation_ngram_counts = _get_ngrams(translation, max_order)
overlap = translation_ngram_counts & merged_ref_ngram_counts
for ngram in overlap:
matches_by_order[len(ngram)-1] += overlap[ngram]
for order in range(1, max_order+1):
possible_matches = len(translation) - order + 1
if possible_matches > 0:
possible_matches_by_order[order-1] += possible_matches
precisions = [0] * max_order
for i in range(0, max_order):
if smooth:
precisions[i] = ((matches_by_order[i] + 1.) /
(possible_matches_by_order[i] + 1.))
else:
if possible_matches_by_order[i] > 0:
precisions[i] = (float(matches_by_order[i]) /
possible_matches_by_order[i])
else:
precisions[i] = 0.0
if min(precisions) > 0:
p_log_sum = sum((1. / max_order) * math.log(p) for p in precisions)
geo_mean = math.exp(p_log_sum)
else:
geo_mean = 0
ratio = float(translation_length) / reference_length
if ratio > 1.0:
bp = 1.
else:
bp = math.exp(1 - 1. / ratio)
bleu = geo_mean * bp
return (bleu, precisions, bp, ratio, translation_length, reference_length) |
Read examples from filename. | def read_examples(filename):
"""Read examples from filename."""
examples=[]
source,target=filename.split(',')
with open(source,encoding="utf-8") as f1,open(target,encoding="utf-8") as f2:
for line1,line2 in zip(f1,f2):
line1=line1.strip()
line2=line2.strip()
examples.append(
Example(
source=line1,
target=line2,
)
)
return examples |
Extracts all n-grams upto a given maximum order from an input segment.
Args:
segment: text segment from which n-grams will be extracted.
max_order: maximum length in tokens of the n-grams returned by this
methods.
Returns:
The Counter containing all n-grams upto max_order in segment
with a count of how many times each n-gram occurred. | def _get_ngrams(segment, max_order):
"""Extracts all n-grams upto a given maximum order from an input segment.
Args:
segment: text segment from which n-grams will be extracted.
max_order: maximum length in tokens of the n-grams returned by this
methods.
Returns:
The Counter containing all n-grams upto max_order in segment
with a count of how many times each n-gram occurred.
"""
ngram_counts = collections.Counter()
for order in range(1, max_order + 1):
for i in range(0, len(segment) - order + 1):
ngram = tuple(segment[i:i+order])
ngram_counts[ngram] += 1
return ngram_counts |
Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of tokens.
translation_corpus: list of translations to score. Each translation
should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
precisions and brevity penalty. | def compute_bleu(reference_corpus, translation_corpus, max_order=4,
smooth=False):
"""Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of tokens.
translation_corpus: list of translations to score. Each translation
should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
precisions and brevity penalty.
"""
matches_by_order = [0] * max_order
possible_matches_by_order = [0] * max_order
reference_length = 0
translation_length = 0
for (references, translation) in zip(reference_corpus,
translation_corpus):
reference_length += min(len(r) for r in references)
translation_length += len(translation)
merged_ref_ngram_counts = collections.Counter()
for reference in references:
merged_ref_ngram_counts |= _get_ngrams(reference, max_order)
translation_ngram_counts = _get_ngrams(translation, max_order)
overlap = translation_ngram_counts & merged_ref_ngram_counts
for ngram in overlap:
matches_by_order[len(ngram)-1] += overlap[ngram]
for order in range(1, max_order+1):
possible_matches = len(translation) - order + 1
if possible_matches > 0:
possible_matches_by_order[order-1] += possible_matches
precisions = [0] * max_order
for i in range(0, max_order):
if smooth:
precisions[i] = ((matches_by_order[i] + 1.) /
(possible_matches_by_order[i] + 1.))
else:
if possible_matches_by_order[i] > 0:
precisions[i] = (float(matches_by_order[i]) /
possible_matches_by_order[i])
else:
precisions[i] = 0.0
if min(precisions) > 0:
p_log_sum = sum((1. / max_order) * math.log(p) for p in precisions)
geo_mean = math.exp(p_log_sum)
else:
geo_mean = 0
ratio = float(translation_length) / reference_length
if ratio > 1.0:
bp = 1.
else:
bp = math.exp(1 - 1. / ratio)
bleu = geo_mean * bp
return (bleu, precisions, bp, ratio, translation_length, reference_length) |
Read examples from filename. | def read_examples(filename):
"""Read examples from filename."""
examples=[]
source,target=filename.split(',')
lang='java'
if source[-1]=='s':
lang='c_sharp'
with open(source,encoding="utf-8") as f1,open(target,encoding="utf-8") as f2:
for line1,line2 in zip(f1,f2):
line1=line1.strip()
line2=line2.strip()
examples.append(
Example(
source=line1,
target=line2,
lang=lang
)
)
return examples |
Computes global attention mask by putting attention on all tokens before `sep_token_id` if `before_sep_token is
True` else after `sep_token_id`. | def _compute_global_attention_mask(input_ids, sep_token_id, before_sep_token=True):
"""
Computes global attention mask by putting attention on all tokens before `sep_token_id` if `before_sep_token is
True` else after `sep_token_id`.
"""
question_end_index = _get_question_end_index(input_ids, sep_token_id)
question_end_index = question_end_index.unsqueeze(dim=1) # size: batch_size x 1
# bool attention mask with True in locations of global attention
attention_mask = torch.arange(input_ids.shape[1], device=input_ids.device)
if before_sep_token is True:
attention_mask = (attention_mask.expand_as(input_ids) < question_end_index).to(torch.uint8)
else:
# last token is separation token and should not be counted and in the middle are two separation tokens
attention_mask = (attention_mask.expand_as(input_ids) > (question_end_index + 1)).to(torch.uint8) * (
attention_mask.expand_as(input_ids) < input_ids.shape[-1]
).to(torch.uint8)
return attention_mask |
Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols
are ignored. This is modified from fairseq's `utils.make_positions`.
Args:
x: torch.Tensor x:
Returns: torch.Tensor | def create_position_ids_from_input_ids(input_ids, padding_idx, past_key_values_length=0):
"""
Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols
are ignored. This is modified from fairseq's `utils.make_positions`.
Args:
x: torch.Tensor x:
Returns: torch.Tensor
"""
# The series of casts and type-conversions here are carefully balanced to both work with ONNX export and XLA.
mask = input_ids.ne(padding_idx).int()
incremental_indices = (torch.cumsum(mask, dim=1).type_as(mask) + past_key_values_length) * mask
return incremental_indices.long() + padding_idx |
Train the model | def train(args, model, tokenizer):
""" Train the model """
#get training dataset
train_dataset = TextDataset(tokenizer, args,"train")
train_dataloader = DataLoader(train_dataset, sampler=RandomSampler(train_dataset), batch_size=args.train_batch_size,num_workers=4)
#get optimizer and scheduler
optimizer = AdamW(model.parameters(), lr=args.learning_rate, eps=1e-8)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps = 0, num_training_steps = len(train_dataloader) * args.num_train_epochs)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.train_batch_size//args.n_gpu)
logger.info(" Total train batch size = %d", args.train_batch_size)
logger.info(" Optimization steps per epoch = %d", len(train_dataloader))
# model.resize_token_embeddings(len(tokenizer))
model.zero_grad()
model.train()
losses, best_acc = [], 0.0
for idx in range(args.num_train_epochs):
losses = []
for step,batch in enumerate(train_dataloader):
#get inputs
source_ids,global_mask = [x.to(args.device) for x in batch]
# forward and return loss
loss = model(source_ids,global_mask,True)
if args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu.
#report loss
losses.append(loss.item())
if len(losses)%100 == 0:
logger.info("epoch {} step {} loss {}".format(idx,step+1,round(np.mean(losses[-100:]),5)))
#backward
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
#evaluate
results = evaluate(args, model, tokenizer,"validation", output_file_prefix = "dev")
for key, value in results.items():
logger.info(" %s = %s", key, round(value,4))
#save best model
if results['eval_acc']>best_acc:
best_acc = results['eval_acc']
logger.info(" "+"*"*20)
logger.info(" Best acc:%s",best_acc)
logger.info(" "+"*"*20)
checkpoint_prefix = 'checkpoint-best-acc'
output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = model.module if hasattr(model,'module') else model
output_dir = os.path.join(output_dir, '{}'.format('model.bin'))
torch.save(model_to_save.state_dict(), output_dir)
logger.info("Saving model checkpoint to %s", output_dir) |
convert examples to token ids | def convert_examples_to_features(code1_tokens,code2_tokens,label,url1,url2,tokenizer,args,cache):
"""convert examples to token ids"""
code1_tokens = code1_tokens[:args.block_size-4]
code1_tokens = [tokenizer.cls_token,"<encoder-only>",tokenizer.sep_token]+code1_tokens+[tokenizer.sep_token]
code2_tokens = code2_tokens[:args.block_size-4]
code2_tokens = [tokenizer.cls_token,"<encoder-only>",tokenizer.sep_token]+code2_tokens+[tokenizer.sep_token]
code1_ids = tokenizer.convert_tokens_to_ids(code1_tokens)
padding_length = args.block_size - len(code1_ids)
code1_ids += [tokenizer.pad_token_id]*padding_length
code2_ids = tokenizer.convert_tokens_to_ids(code2_tokens)
padding_length = args.block_size - len(code2_ids)
code2_ids += [tokenizer.pad_token_id]*padding_length
source_tokens = code1_tokens+code2_tokens
source_ids = code1_ids+code2_ids
return InputFeatures(source_tokens,source_ids,label,url1,url2) |
Train the model | def train(args, train_dataset, model, tokenizer,pool):
""" Train the model """
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler,
batch_size=args.train_batch_size,num_workers=4,pin_memory=True)
args.max_steps = args.num_train_epochs * len( train_dataloader)
args.save_steps = args.max_steps // 10
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
{'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
'weight_decay': args.weight_decay},
{'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.max_steps*0.1,
num_training_steps=args.max_steps)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.train_batch_size // args.n_gpu )
logger.info(" Total train batch size = %d", args.train_batch_size)
logger.info(" Total optimization steps = %d", args.max_steps)
losses, best_f1 = [], 0
model.zero_grad()
for idx in range(args.num_train_epochs):
for step, batch in enumerate(train_dataloader):
inputs = batch[0].to(args.device)
labels = batch[1].to(args.device)
model.train()
loss,logits = model(inputs,labels)
if args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
losses.append(loss.item())
if (step+1)% 100==0:
logger.info("epoch {} step {} loss {}".format(idx,step+1,round(np.mean(losses[-100:]),4)))
optimizer.step()
optimizer.zero_grad()
scheduler.step()
if len(losses) % args.save_steps == 0:
results = evaluate(args, model, tokenizer,args.eval_data_file,pool)
for key, value in results.items():
logger.info(" %s = %s", key, round(value,4))
if results['eval_f1'] > best_f1:
best_f1 = results['eval_f1']
logger.info(" "+"*"*20)
logger.info(" Best f1:%s",round(best_f1,4))
logger.info(" "+"*"*20)
checkpoint_prefix = 'checkpoint-best-f1'
output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = model.module if hasattr(model,'module') else model
output_dir = os.path.join(output_dir, '{}'.format('model.bin'))
torch.save(model_to_save.state_dict(), output_dir)
logger.info("Saving model checkpoint to %s", output_dir) |
Evaluate the model | def evaluate(args, model, tokenizer, data_file, pool):
""" Evaluate the model """
eval_output_dir = args.output_dir
eval_dataset = TextDataset(tokenizer, args, data_file,pool)
if not os.path.exists(eval_output_dir):
os.makedirs(eval_output_dir)
eval_sampler = SequentialSampler(eval_dataset)
eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=args.eval_batch_size,num_workers=4)
# Eval!
logger.info("***** Running evaluation *****")
logger.info(" Num examples = %d", len(eval_dataset))
logger.info(" Batch size = %d", args.eval_batch_size)
eval_loss = 0.0
nb_eval_steps = 0
model.eval()
logits = []
y_trues = []
for batch in eval_dataloader:
inputs = batch[0].to(args.device)
labels = batch[1].to(args.device)
with torch.no_grad():
lm_loss,cos_sim = model(inputs,labels)
eval_loss += lm_loss.mean().item()
logits.append(cos_sim.cpu().numpy())
y_trues.append(labels.cpu().numpy())
nb_eval_steps += 1
logits = np.concatenate(logits,0)
y_trues = np.concatenate(y_trues,0)
y_preds = logits>0.5
recall=recall_score(y_trues, y_preds)
precision=precision_score(y_trues, y_preds)
f1=f1_score(y_trues, y_preds)
result = {
"eval_recall": float(recall),
"eval_precision": float(precision),
"eval_f1": float(f1),
}
return result |
convert examples to token ids | def convert_examples_to_features(js,tokenizer,args):
"""convert examples to token ids"""
code = ' '.join(js['code'].split())
code_tokens = tokenizer.tokenize(code)[:args.block_size-4]
source_tokens = [tokenizer.cls_token,"<encoder_only>",tokenizer.sep_token] + code_tokens + [tokenizer.sep_token]
source_ids = tokenizer.convert_tokens_to_ids(source_tokens)
padding_length = args.block_size - len(source_ids)
source_ids += [tokenizer.pad_token_id]*padding_length
return InputFeatures(source_tokens,source_ids,js['index'],int(js['label'])) |
Train the model | def train(args, train_dataset, model, tokenizer):
""" Train the model """
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler,
batch_size=args.train_batch_size,num_workers=4,pin_memory=True)
args.max_steps = args.num_train_epochs*len( train_dataloader)
# Prepare optimizer and schedule (linear warmup and decay)
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
{'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
'weight_decay': args.weight_decay},
{'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]
optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.max_steps*0.1,
num_training_steps=args.max_steps)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.train_batch_size // args.n_gpu )
logger.info(" Total train batch size = %d", args.train_batch_size)
logger.info(" Total optimization steps = %d", args.max_steps)
losses, best_map = [], 0
model.zero_grad()
for idx in range(args.num_train_epochs):
for step, batch in enumerate(train_dataloader):
inputs = batch[0].to(args.device)
p_inputs = batch[1].to(args.device)
n_inputs = batch[2].to(args.device)
labels = batch[3].to(args.device)
model.train()
loss,vec = model(inputs,p_inputs,n_inputs,labels)
if args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
losses.append(loss.item())
if (step+1)% 100==0:
logger.info("epoch {} step {} loss {}".format(idx,step+1,round(np.mean(losses[-100:]),4)))
optimizer.step()
optimizer.zero_grad()
scheduler.step()
results = evaluate(args, model, tokenizer, args.eval_data_file)
for key, value in results.items():
logger.info(" %s = %s", key, round(value,4))
if results['eval_map'] > best_map:
best_map = results['eval_map']
logger.info(" "+"*"*20)
logger.info(" Best map:%s",round(best_map,4))
logger.info(" "+"*"*20)
checkpoint_prefix = 'checkpoint-best-map'
output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_dir = os.path.join(output_dir, '{}'.format('model.bin'))
model_to_save = model.module if hasattr(model,'module') else model
torch.save(model_to_save.state_dict(), output_dir)
logger.info("Saving model checkpoint to %s", output_dir) |
Evaluate the model | def evaluate(args, model, tokenizer, data_file):
""" Evaluate the model """
eval_dataset = TextDataset(tokenizer, args, data_file)
eval_sampler = SequentialSampler(eval_dataset)
eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler,batch_size=args.eval_batch_size, num_workers=4)
eval_output_dir = args.output_dir
if not os.path.exists(eval_output_dir):
os.makedirs(eval_output_dir)
# Eval!
logger.info("***** Running evaluation *****")
logger.info(" Num examples = %d", len(eval_dataset))
logger.info(" Batch size = %d", args.eval_batch_size)
eval_loss = 0.0
nb_eval_steps = 0
model.eval()
vecs=[]
labels=[]
for batch in eval_dataloader:
inputs = batch[0].to(args.device)
p_inputs = batch[1].to(args.device)
n_inputs = batch[2].to(args.device)
label = batch[3].to(args.device)
with torch.no_grad():
lm_loss,vec = model(inputs,p_inputs,n_inputs,label)
eval_loss += lm_loss.mean().item()
vecs.append(vec.cpu().numpy())
labels.append(label.cpu().numpy())
nb_eval_steps += 1
vecs = np.concatenate(vecs,0)
labels = np.concatenate(labels,0)
eval_loss = eval_loss / nb_eval_steps
perplexity = torch.tensor(eval_loss)
scores=np.matmul(vecs,vecs.T)
dic={}
for i in range(scores.shape[0]):
scores[i,i] = -1000000
if int(labels[i]) not in dic:
dic[int(labels[i])] = -1
dic[int(labels[i])] += 1
sort_ids = np.argsort(scores, axis=-1, kind='quicksort', order=None)[:,::-1]
MAP = []
for i in range(scores.shape[0]):
cont = 0
label = int(labels[i])
Avep = []
for j in range(dic[label]):
index = sort_ids[i,j]
if int(labels[index]) == label:
Avep.append((len(Avep)+1)/(j+1))
MAP.append(sum(Avep)/dic[label])
result = {
"eval_loss": float(perplexity),
"eval_map":float(np.mean(MAP))
}
return result |
Read examples from filename. | def read_examples(filename):
"""Read examples from filename."""
examples=[]
lang = filename.split("/")[-2]
with open(filename,encoding="utf-8") as f:
for idx, line in enumerate(f):
if ".txt" in filename:
inputs=line.strip().replace("<EOL>","</s>").split()
inputs=inputs[1:]
inputs=" ".join(inputs)
outputs=[]
else:
js=json.loads(line)
inputs=js["input"].replace("<EOL>","</s>").split()
inputs=inputs[1:]
inputs=" ".join(inputs)
outputs=js["gt"]
if 'id' in js:
idx = js['id']
examples.append(
Example(
idx = idx,
source = inputs,
target = outputs,
)
)
return examples |
Extracts all n-grams upto a given maximum order from an input segment.
Args:
segment: text segment from which n-grams will be extracted.
max_order: maximum length in tokens of the n-grams returned by this
methods.
Returns:
The Counter containing all n-grams upto max_order in segment
with a count of how many times each n-gram occurred. | def _get_ngrams(segment, max_order):
"""Extracts all n-grams upto a given maximum order from an input segment.
Args:
segment: text segment from which n-grams will be extracted.
max_order: maximum length in tokens of the n-grams returned by this
methods.
Returns:
The Counter containing all n-grams upto max_order in segment
with a count of how many times each n-gram occurred.
"""
ngram_counts = collections.Counter()
for order in range(1, max_order + 1):
for i in range(0, len(segment) - order + 1):
ngram = tuple(segment[i:i+order])
ngram_counts[ngram] += 1
return ngram_counts |
Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of tokens.
translation_corpus: list of translations to score. Each translation
should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
precisions and brevity penalty. | def compute_bleu(reference_corpus, translation_corpus, max_order=4,
smooth=False):
"""Computes BLEU score of translated segments against one or more references.
Args:
reference_corpus: list of lists of references for each translation. Each
reference should be tokenized into a list of tokens.
translation_corpus: list of translations to score. Each translation
should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram
precisions and brevity penalty.
"""
matches_by_order = [0] * max_order
possible_matches_by_order = [0] * max_order
reference_length = 0
translation_length = 0
for (references, translation) in zip(reference_corpus,
translation_corpus):
reference_length += min(len(r) for r in references)
translation_length += len(translation)
merged_ref_ngram_counts = collections.Counter()
for reference in references:
merged_ref_ngram_counts |= _get_ngrams(reference, max_order)
translation_ngram_counts = _get_ngrams(translation, max_order)
overlap = translation_ngram_counts & merged_ref_ngram_counts
for ngram in overlap:
matches_by_order[len(ngram)-1] += overlap[ngram]
for order in range(1, max_order+1):
possible_matches = len(translation) - order + 1
if possible_matches > 0:
possible_matches_by_order[order-1] += possible_matches
precisions = [0] * max_order
for i in range(0, max_order):
if smooth:
precisions[i] = ((matches_by_order[i] + 1.) /
(possible_matches_by_order[i] + 1.))
else:
if possible_matches_by_order[i] > 0:
precisions[i] = (float(matches_by_order[i]) /
possible_matches_by_order[i])
else:
precisions[i] = 0.0
if min(precisions) > 0:
p_log_sum = sum((1. / max_order) * math.log(p) for p in precisions)
geo_mean = math.exp(p_log_sum)
else:
geo_mean = 0
ratio = float(translation_length) / reference_length
if ratio > 1.0:
bp = 1.
else:
bp = math.exp(1 - 1. / ratio)
bleu = geo_mean * bp
return (bleu, precisions, bp, ratio, translation_length, reference_length) |
Read examples from filename. | def read_examples(filename):
"""Read examples from filename."""
examples=[]
with open(filename,encoding="utf-8") as f:
for idx, line in enumerate(f):
line=line.strip()
js=json.loads(line)
examples.append(
Example(
idx = idx,
source=" ".join(js['nl'].split()),
target = " ".join(js["code"].split()),
)
)
return examples |
convert examples to token ids | def convert_examples_to_features(js,tokenizer,args):
"""convert examples to token ids"""
code = ' '.join(js['code_tokens']) if type(js['code_tokens']) is list else ' '.join(js['code_tokens'].split())
code_tokens = tokenizer.tokenize(code)[:args.code_length-4]
code_tokens =[tokenizer.cls_token,"<encoder-only>",tokenizer.sep_token]+code_tokens+[tokenizer.sep_token]
code_ids = tokenizer.convert_tokens_to_ids(code_tokens)
padding_length = args.code_length - len(code_ids)
code_ids += [tokenizer.pad_token_id]*padding_length
nl = ' '.join(js['docstring_tokens']) if type(js['docstring_tokens']) is list else ' '.join(js['doc'].split())
nl_tokens = tokenizer.tokenize(nl)[:args.nl_length-4]
nl_tokens = [tokenizer.cls_token,"<encoder-only>",tokenizer.sep_token]+nl_tokens+[tokenizer.sep_token]
nl_ids = tokenizer.convert_tokens_to_ids(nl_tokens)
padding_length = args.nl_length - len(nl_ids)
nl_ids += [tokenizer.pad_token_id]*padding_length
return InputFeatures(code_tokens,code_ids,nl_tokens,nl_ids,js['url'] if "url" in js else js["retrieval_idx"]) |
Train the model | def train(args, model, tokenizer):
""" Train the model """
#get training dataset
train_dataset = TextDataset(tokenizer, args, args.train_data_file)
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args.train_batch_size,num_workers=4)
#get optimizer and scheduler
optimizer = AdamW(model.parameters(), lr=args.learning_rate, eps=1e-8)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps = 0, num_training_steps = len(train_dataloader) * args.num_train_epochs)
# Train!
logger.info("***** Running training *****")
logger.info(" Num examples = %d", len(train_dataset))
logger.info(" Num Epochs = %d", args.num_train_epochs)
logger.info(" Instantaneous batch size per GPU = %d", args.train_batch_size//args.n_gpu)
logger.info(" Total train batch size = %d", args.train_batch_size)
logger.info(" Total optimization steps = %d", len(train_dataloader)*args.num_train_epochs)
# model.resize_token_embeddings(len(tokenizer))
model.zero_grad()
model.train()
tr_num,tr_loss,best_mrr = 0,0,0
for idx in range(args.num_train_epochs):
for step,batch in enumerate(train_dataloader):
#get inputs
code_inputs = batch[0].to(args.device)
nl_inputs = batch[1].to(args.device)
#get code and nl vectors
code_vec = model(code_inputs=code_inputs)
nl_vec = model(nl_inputs=nl_inputs)
#calculate scores and loss
scores = torch.einsum("ab,cb->ac",nl_vec,code_vec)
loss_fct = CrossEntropyLoss()
loss = loss_fct(scores*20, torch.arange(code_inputs.size(0), device=scores.device))
#report loss
tr_loss += loss.item()
tr_num += 1
if (step+1)%100 == 0:
logger.info("epoch {} step {} loss {}".format(idx,step+1,round(tr_loss/tr_num,5)))
tr_loss = 0
tr_num = 0
#backward
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
optimizer.zero_grad()
scheduler.step()
#evaluate
results = evaluate(args, model, tokenizer,args.eval_data_file, eval_when_training=True)
for key, value in results.items():
logger.info(" %s = %s", key, round(value,4))
#save best model
if results['eval_mrr']>best_mrr:
best_mrr = results['eval_mrr']
logger.info(" "+"*"*20)
logger.info(" Best mrr:%s",round(best_mrr,4))
logger.info(" "+"*"*20)
checkpoint_prefix = 'checkpoint-best-mrr'
output_dir = os.path.join(args.output_dir, '{}'.format(checkpoint_prefix))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
model_to_save = model.module if hasattr(model,'module') else model
output_dir = os.path.join(output_dir, '{}'.format('model.bin'))
torch.save(model_to_save.state_dict(), output_dir)
logger.info("Saving model checkpoint to %s", output_dir) |
Normalize and tokenize text. This is lifted from NIST mteval-v11a.pl. | def normalize(s):
'''Normalize and tokenize text. This is lifted from NIST mteval-v11a.pl.'''
# Added to bypass NIST-style pre-processing of hyp and ref files -- wade
if (nonorm):
return s.split()
if type(s) is not str:
s = " ".join(s)
# language-independent part:
for (pattern, replace) in normalize1:
s = re.sub(pattern, replace, s)
s = xml.sax.saxutils.unescape(s, {'"':'"'})
# language-dependent part (assuming Western languages):
s = " %s " % s
if not preserve_case:
s = s.lower() # this might not be identical to the original
for (pattern, replace) in normalize2:
s = re.sub(pattern, replace, s)
return s.split() |
Takes a list of reference sentences for a single segment
and returns an object that encapsulates everything that BLEU
needs to know about them. | def cook_refs(refs, n=4):
'''Takes a list of reference sentences for a single segment
and returns an object that encapsulates everything that BLEU
needs to know about them.'''
refs = [normalize(ref) for ref in refs]
maxcounts = {}
for ref in refs:
counts = count_ngrams(ref, n)
for (ngram,count) in counts.items():
maxcounts[ngram] = max(maxcounts.get(ngram,0), count)
return ([len(ref) for ref in refs], maxcounts) |
Takes a test sentence and returns an object that
encapsulates everything that BLEU needs to know about it. | def cook_test(test, item, n=4):
'''Takes a test sentence and returns an object that
encapsulates everything that BLEU needs to know about it.'''
(reflens, refmaxcounts)=item
test = normalize(test)
result = {}
result["testlen"] = len(test)
# Calculate effective reference sentence length.
if eff_ref_len == "shortest":
result["reflen"] = min(reflens)
elif eff_ref_len == "average":
result["reflen"] = float(sum(reflens))/len(reflens)
elif eff_ref_len == "closest":
min_diff = None
for reflen in reflens:
if min_diff is None or abs(reflen-len(test)) < min_diff:
min_diff = abs(reflen-len(test))
result['reflen'] = reflen
result["guess"] = [max(len(test)-k+1,0) for k in range(1,n+1)]
result['correct'] = [0]*n
counts = count_ngrams(test, n)
for (ngram, count) in counts.items():
result["correct"][len(ngram)-1] += min(refmaxcounts.get(ngram,0), count)
return result |
Read examples from filename. | def read_examples(filename):
"""Read examples from filename."""
examples = []
with open(filename,encoding="utf-8") as f:
for idx, line in enumerate(f):
line = line.strip()
js = json.loads(line)
if 'idx' not in js:
js['idx']=idx
code = ' '.join(js['code_tokens']).replace('\n',' ')
code = ' '.join(code.strip().split())
nl = ' '.join(js['docstring_tokens']).replace('\n','')
nl = ' '.join(nl.strip().split())
examples.append(
Example(
idx = idx,
source = code,
target = nl,
)
)
return examples |
convert examples to token ids | def convert_examples_to_features(examples, tokenizer, args,stage=None):
"""convert examples to token ids"""
features = []
for example_index, example in enumerate(examples):
#source
source_tokens = tokenizer.tokenize(example.source)[:args.max_source_length-5]
source_tokens = [tokenizer.cls_token,"<encoder-decoder>",tokenizer.sep_token,"<mask0>"]+source_tokens+[tokenizer.sep_token]
source_ids = tokenizer.convert_tokens_to_ids(source_tokens)
padding_length = args.max_source_length - len(source_ids)
source_ids += [tokenizer.pad_token_id]*padding_length
#target
if stage=="test":
target_tokens = tokenizer.tokenize("None")
else:
target_tokens = tokenizer.tokenize(example.target)[:args.max_target_length-2]
target_tokens = ["<mask0>"] + target_tokens + [tokenizer.sep_token]
target_ids = tokenizer.convert_tokens_to_ids(target_tokens)
padding_length = args.max_target_length - len(target_ids)
target_ids += [tokenizer.pad_token_id] * padding_length
if example_index < 5:
if stage=='train':
logger.info("*** Example ***")
logger.info("idx: {}".format(example.idx))
logger.info("source_tokens: {}".format([x.replace('\u0120','_') for x in source_tokens]))
logger.info("source_ids: {}".format(' '.join(map(str, source_ids))))
logger.info("target_tokens: {}".format([x.replace('\u0120','_') for x in target_tokens]))
logger.info("target_ids: {}".format(' '.join(map(str, target_ids))))
features.append(
InputFeatures(
example_index,
source_ids,
target_ids,
)
)
return features |
convert examples to token ids | def convert_examples_to_features(js,tokenizer,args,lang):
"""convert examples to token ids"""
if "func" in js:
code = " ".join(remove_comments_and_docstrings(js['func'],lang).split())
else:
code = " ".join(remove_comments_and_docstrings(js['code'],lang).split())
code_tokens = tokenizer.tokenize(code)[:args.code_length-4]
code_tokens =[tokenizer.cls_token,"<encoder-only>",tokenizer.sep_token]+code_tokens+[tokenizer.sep_token]
code_ids = tokenizer.convert_tokens_to_ids(code_tokens)
padding_length = args.code_length - len(code_ids)
code_ids += [tokenizer.pad_token_id]*padding_length
return InputFeatures(code_tokens,code_ids,js["index"],int(js['label'])) |
Method saves list of dicts into jsonl file.
:param data: (list) list of dicts to be stored,
:param filename: (str) path to the output file. If suffix .jsonl is not given then methods appends
.jsonl suffix into the file.
:param compress: (bool) should file be compressed into a gzip archive? | def dicts_to_jsonl(data_list: list, filename: str, compress: bool = True) -> None:
"""
Method saves list of dicts into jsonl file.
:param data: (list) list of dicts to be stored,
:param filename: (str) path to the output file. If suffix .jsonl is not given then methods appends
.jsonl suffix into the file.
:param compress: (bool) should file be compressed into a gzip archive?
"""
sjsonl = '.jsonl'
sgz = '.gz'
# Check filename
if not filename.endswith(sjsonl):
filename = filename + sjsonl
# Save data
if compress:
filename = filename + sgz
with gzip.open(filename, 'w') as compressed:
for ddict in data_list:
jout = json.dumps(ddict) + '\n'
jout = jout.encode('utf-8')
compressed.write(jout)
else:
with open(filename, 'w') as out:
for ddict in data_list:
jout = json.dumps(ddict) + '\n'
out.write(jout) |
Evaluates the functional correctness of a completion by running the test
suite provided in the problem. | def check_correctness(
task_id: str,
sample: dict,
language_type: str,
timeout: float = 3.0,
tmp_dir: str = None,
completion_id: Optional[int] = None,
) -> Dict:
"""
Evaluates the functional correctness of a completion by running the test
suite provided in the problem.
"""
def unsafe_execute(tmp_dir):
random_id = random.uniform(1, 1000)
if "python" in language_type.lower():
with create_tempdir():
# These system calls are needed when cleaning up tempdir.
import os
import shutil
rmtree = shutil.rmtree
rmdir = os.rmdir
chdir = os.chdir
# Disable functionalities that can make destructive changes to the test.
reliability_guard()
try:
exec_globals = {}
with swallow_io():
with time_limit(timeout):
# WARNING
# This program exists to execute untrusted model-generated code. Although
# it is highly unlikely that model-generated code will do something overtly
# malicious in response to this test suite, model-generated code may act
# destructively due to a lack of model capability or alignment.
# Users are strongly encouraged to sandbox this evaluation suite so that it
# does not perform destructive actions on their host or network.
# Once you have read this disclaimer and taken appropriate precautions,
# uncomment the following line and proceed at your own risk:
exec(sample["test_code"], exec_globals)
result.append("passed")
except TimeoutException:
result.append("timed out")
except AssertionError as e:
result.append(f"failed: AssertionError")
except BaseException as e:
result.append(f"failed: {e}")
# Needed for cleaning up.
shutil.rmtree = rmtree
os.rmdir = rmdir
os.chdir = chdir
elif "go" in language_type.lower():
assert tmp_dir is not None, "Go should be evaluated in a dir where necessary module files installed."
import os
import shutil
if "tmp" not in tmp_dir:
tmp_dir = os.path.join(tmp_dir, "tmp")
tmp_dir = os.path.join(tmp_dir, f"{task_id.replace('/', '-')}-{random_id}")
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
os.chdir(tmp_dir)
open(f"main_test.go", 'w').write(sample["test_code"])
try:
exec_result = None
with time_limit(timeout):
# WARNING
# This program exists to execute untrusted model-generated code. Although
# it is highly unlikely that model-generated code will do something overtly
# malicious in response to this test suite, model-generated code may act
# destructively due to a lack of model capability or alignment.
# Users are strongly encouraged to sandbox this evaluation suite so that it
# does not perform destructive actions on their host or network.
# Once you have read this disclaimer and taken appropriate precautions,
# uncomment the following line and proceed at your own risk:
exec_result = subprocess.run(["go", "test", f"-timeout={timeout}s", "main_test.go"], timeout=timeout, capture_output=True)
if exec_result.returncode == 0:
result.append("passed")
else:
if exec_result.stderr:
try:
err = exec_result.stderr.decode()
except:
err = exec_result.stderr
else:
try:
err = exec_result.stdout.decode()
except:
err = exec_result.stdout
result.append(f"failed: {err}")
except TimeoutException:
result.append("timed out")
shutil.rmtree(tmp_dir)
elif "js" in language_type.lower():
import os
import shutil
if "tmp" not in tmp_dir:
tmp_dir = os.path.join(tmp_dir, "tmp")
tmp_dir = os.path.join(tmp_dir, f"{task_id.replace('/', '-')}-{random_id}")
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
os.chdir(tmp_dir)
open(f"test.js", 'w').write(sample["test_code"])
try:
exec_result = None
with time_limit(timeout):
# WARNING
# This program exists to execute untrusted model-generated code. Although
# it is highly unlikely that model-generated code will do something overtly
# malicious in response to this test suite, model-generated code may act
# destructively due to a lack of model capability or alignment.
# Users are strongly encouraged to sandbox this evaluation suite so that it
# does not perform destructive actions on their host or network.
# Once you have read this disclaimer and taken appropriate precautions,
# uncomment the following line and proceed at your own risk:
exec_result = subprocess.run(["node", "test.js"], timeout=timeout, capture_output=True)
if exec_result.stderr.decode():
err = exec_result.stderr.decode()
result.append(f"failed: {err}")
elif exec_result.stdout.decode():
err = exec_result.stdout.decode()
result.append(f"failed: {err}")
else:
result.append("passed")
except TimeoutException:
result.append("timed out")
shutil.rmtree(tmp_dir)
elif "cpp" in language_type.lower():
import os
import shutil
if "tmp" not in tmp_dir:
tmp_dir = os.path.join(tmp_dir, "tmp")
tmp_dir = os.path.join(tmp_dir, f"{task_id.replace('/', '-')}-{random_id}")
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
os.chdir(tmp_dir)
open(f"test.cpp", 'w').write(sample["test_code"])
if "162" in task_id:
compilation_result = subprocess.run(["/usr/bin/g++", "-std=c++11", "test.cpp", "-lcrypto", "-lssl"],
timeout=timeout,
capture_output=True)
else:
compilation_result = subprocess.run(["/usr/bin/g++", "-std=c++11", "test.cpp"], timeout=timeout,
capture_output=True)
if compilation_result.returncode != 0:
if compilation_result.stderr:
err = compilation_result.stderr.decode()
else:
err = compilation_result.stdout.decode()
result.append(f"failed: compilation error: {err}")
else:
try:
exec_result = None
with time_limit(timeout):
# WARNING
# This program exists to execute untrusted model-generated code. Although
# it is highly unlikely that model-generated code will do something overtly
# malicious in response to this test suite, model-generated code may act
# destructively due to a lack of model capability or alignment.
# Users are strongly encouraged to sandbox this evaluation suite so that it
# does not perform destructive actions on their host or network.
# Once you have read this disclaimer and taken appropriate precautions,
# uncomment the following line and proceed at your own risk:
exec_result = subprocess.run(["./a.out"], timeout=timeout, capture_output=True)
if exec_result.returncode == 0:
result.append("passed")
else:
if exec_result.stderr:
try:
err = exec_result.stderr.decode()
except:
err = exec_result.stderr
else:
try:
err = exec_result.stdout.decode()
except:
err = exec_result.stdout
result.append(f"failed: {err}")
except TimeoutException:
result.append("timed out")
shutil.rmtree(tmp_dir)
elif "rust" in language_type.lower():
import os
WD: str = os.path.dirname(os.path.abspath(__file__))
RUST_DIR: str = os.path.join(WD, "rust")
RUST_SRC: str = os.path.join(RUST_DIR, "src")
RUST_BIN: str = os.path.join(RUST_SRC, "bin")
RUST_TMP_DIR: str = os.path.join(RUST_DIR, "tmp")
RUST_LOGS: str = os.path.join(RUST_TMP_DIR, "logs")
RUST_EXT: str = ".rs"
# Create mandatory tmp directories
os.makedirs(RUST_TMP_DIR, exist_ok=True)
os.makedirs(RUST_LOGS, exist_ok=True)
os.makedirs(RUST_SRC, exist_ok=True)
os.makedirs(RUST_BIN, exist_ok=True)
with tempfile.NamedTemporaryFile(dir = RUST_BIN, delete=False) as f:
#temporal file name
file_prefix = sample["task_id"].lower().replace("/", "_")
file_name:str = file_prefix +RUST_EXT
os.rename(f.name, os.path.join(RUST_BIN, file_name))
# Sample to pure Rust function
rust_code: str = sample["test_code"]
# dump the rust source code in the target temporal file
f.write(rust_code.encode('utf-8'))
# Proceed towards Rust binaries compilation. Therefore move to Rust module root dir.
os.chdir(RUST_DIR)
# Two possible outcomes
# Pass OR Fail compilation
log_filename: str = file_prefix + ".jsonl"
log_path: str = os.path.join(RUST_LOGS, log_filename)
cargo_check: str = "cargo check --bin " + file_prefix + " --message-format json >> " + log_path
# Compilation build status
returned_val_compilation: int
# Overwrite file content
if os.path.exists(log_path):
if(file_size := os.path.getsize(log_path)) >= 0:
os.remove(log_path)
returned_val_compilation = os.system(cargo_check)
else:
returned_val_compilation = os.system(cargo_check)
# 0 means success
if returned_val_compilation == 0:
#Execution pipeline
cargo_test: str = "cargo test --bin " +file_prefix+ " --message-format json >> " + log_path
returned_val_execution = os.system(cargo_test)
if returned_val_execution == 0:
result.append("passed")
else:
result.append(f"failed: execution error")
else:
result.append(f"failed: compilation error")
elif "java" in language_type.lower():
assert tmp_dir is not None, "Java should be evaluated in a temporary dir."
import os
import shutil
if "tmp" not in tmp_dir:
tmp_dir = os.path.join(tmp_dir, "tmp")
tmp_dir = os.path.join(tmp_dir, f"{task_id.replace('/', '-')}-{random_id}")
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
os.chdir(tmp_dir)
open(os.path.join(tmp_dir, "Main.java"), 'w').write(sample["test_code"])
res = "failed: unknown error"
compile_returncode = -1
for _ in range(5):
try:
compilation_result = subprocess.run(['javac', os.path.join(tmp_dir, "Main.java")], timeout=5,
capture_output=True)
compile_returncode = compilation_result.returncode
break
except subprocess.TimeoutExpired as e:
continue
if compile_returncode != 0:
res = "failed: compilation error"
else:
exec_result = None
try:
# WARNING
# This program exists to execute untrusted model-generated code. Although
# it is highly unlikely that model-generated code will do something overtly
# malicious in response to this test suite, model-generated code may act
# destructively due to a lack of model capability or alignment.
# Users are strongly encouraged to sandbox this evaluation suite so that it
# does not perform destructive actions on their host or network.
# Once you have read this disclaimer and taken appropriate precautions,
# uncomment the following line and proceed at your own risk:
# exec_result = subprocess.run([f'java', '-cp', tmp_dir, 'Main'], timeout=timeout, capture_output=True)
if exec_result.returncode == 0:
res = "passed"
elif exec_result.returncode == 1:
if "AssertionError" in exec_result.stderr.decode('unicode-escape'):
res = "failed: wrong answer"
else:
res = f"failed: {exec_result.stderr.decode()}"
except subprocess.TimeoutExpired as e:
res = "time out"
except BaseException as e:
res = f"failed: {e}"
result.append(res)
shutil.rmtree(tmp_dir)
manager = multiprocessing.Manager()
result = manager.list()
p = multiprocessing.Process(target=unsafe_execute, args=(tmp_dir,))
p.start()
p.join(timeout=timeout + 1)
if p.is_alive():
p.kill()
if not result:
result.append("timed out")
return {
"task_id" : task_id,
"completion_id": completion_id,
"test_code" : sample["test_code"],
"prompt" : sample["prompt"],
"generation" : sample["generation"],
"result" : result[0],
"passed" : result[0] == "passed",
"finish" : -1 if "finish" not in sample else sample["finish"],
"file" : "" if "file" not in sample else sample["file"],
"output" : [] if "output" not in sample else sample["output"],
} |
This disables various destructive functions and prevents the generated code
from interfering with the test (e.g. fork bomb, killing other processes,
removing filesystem files, etc.)
WARNING
This function is NOT a security sandbox. Untrusted code, including, model-
generated code, should not be blindly executed outside of one. See the
Codex paper for more information about OpenAI's code sandbox, and proceed
with caution. | def reliability_guard(maximum_memory_bytes: Optional[int] = None):
"""
This disables various destructive functions and prevents the generated code
from interfering with the test (e.g. fork bomb, killing other processes,
removing filesystem files, etc.)
WARNING
This function is NOT a security sandbox. Untrusted code, including, model-
generated code, should not be blindly executed outside of one. See the
Codex paper for more information about OpenAI's code sandbox, and proceed
with caution.
"""
if maximum_memory_bytes is not None:
import resource
resource.setrlimit(resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes))
resource.setrlimit(resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes))
if not platform.uname().system == 'Darwin':
resource.setrlimit(resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes))
faulthandler.disable()
import builtins
builtins.exit = None
builtins.quit = None
import os
os.environ['OMP_NUM_THREADS'] = '1'
os.kill = None
os.system = None
os.putenv = None
os.remove = None
os.removedirs = None
os.rmdir = None
os.fchdir = None
os.setuid = None
os.fork = None
os.forkpty = None
os.killpg = None
os.rename = None
os.renames = None
os.truncate = None
os.replace = None
os.unlink = None
os.fchmod = None
os.fchown = None
os.chmod = None
os.chown = None
os.chroot = None
os.fchdir = None
os.lchflags = None
os.lchmod = None
os.lchown = None
os.getcwd = None
os.chdir = None
import shutil
shutil.rmtree = None
shutil.move = None
shutil.chown = None
import subprocess
subprocess.Popen = None # type: ignore
__builtins__['help'] = None
import sys
sys.modules['ipdb'] = None
sys.modules['joblib'] = None
sys.modules['resource'] = None
sys.modules['psutil'] = None
sys.modules['tkinter'] = None |
Estimates pass@k of each problem and returns them in an array. | def estimate_pass_at_k(
num_samples: Union[int, List[int], np.ndarray],
num_correct: Union[List[int], np.ndarray],
k: int
) -> np.ndarray:
"""
Estimates pass@k of each problem and returns them in an array.
"""
def estimator(n: int, c: int, k: int) -> float:
"""
Calculates 1 - comb(n - c, k) / comb(n, k).
"""
if n - c < k:
return 1.0
return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
if isinstance(num_samples, int):
num_samples_it = itertools.repeat(num_samples, len(num_correct))
else:
assert len(num_samples) == len(num_correct)
num_samples_it = iter(num_samples)
return np.array([estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)]) |
Processes the extra prompt. | def process_extra_prompt(prompt: str, language_type: str = None) -> str:
"""
Processes the extra prompt.
"""
language = language_type.lower()
if language in LANGUAGE_TAG:
extra_prompt = LANGUAGE_TAG[language] + "\n"
else:
extra_prompt = ""
return extra_prompt + prompt |
Checks whether the generated code is finished. | def is_code_generation_finished(
code: str,
language_type: str = None,
dataset: str = None,
):
"""
Checks whether the generated code is finished.
"""
if language_type is None or dataset is None:
return False
if "humaneval" in dataset.lower():
if language_type.lower() == "python":
for line in code.split("\n"):
if len(line.strip()) > 0 and line[0] != ' ' and line[0] != '\t':
return True
end_words = ["\ndef", "\nclass", "\nif", "\n#", "\nprint"]
for w in end_words:
if w in code:
return True
elif language_type.lower() == "java":
if code.count("{") + 1 == code.count("}"):
return True
elif language_type.lower() == "go":
if code.count("{") + 1 == code.count("}"):
return True
elif language_type.lower() == "js":
if code.count("{") + 1 == code.count("}"):
return True
elif language_type.lower() == "cpp":
if code.count("{") + 1 == code.count("}"):
return True
return False |
Cleans up the generated code. | def cleanup_code(
code: str,
language_type: str = None,
dataset: str = None,
):
"""
Cleans up the generated code.
"""
if language_type is None or dataset is None:
return code
if "humaneval" in dataset.lower():
if language_type.lower() == "python":
end_words = ["\ndef", "\nclass", "\nif", "\n#", "\nprint", "\nassert"]
for w in end_words:
if w in code:
code = code[:code.rfind(w)]
elif language_type.lower() == "java":
main_pos = code.find("public static void main")
if main_pos != -1:
code = code[:main_pos] + '}'
if '}' in code:
code = code[:code.rfind('}')] + '}'
if code.count('{') + 1 == code.count('}'):
code += "\n}"
elif language_type.lower() == "go":
end_words = ["\n//", "\nfunc main("]
for w in end_words:
if w in code:
code = code[:code.rfind(w)]
if '}' in code:
code = code[:code.rfind('}')] + '}'
elif language_type.lower() == "cpp":
if '}' in code:
code = code[:code.rfind('}')] + '}'
elif language_type.lower() == "js":
if '}' in code:
code = code[:code.rfind('}')] + '}'
return code |
Code generation arguments. | def add_code_generation_args(parser):
"""Code generation arguments."""
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--hostfile",
type=str,
default="./hostfile",
)
group.add_argument(
"--channel-ip",
type=str,
default=None,
help="IP for ZeroMQ channel",
)
group.add_argument(
"--channel-port",
type=int,
default=5555,
help="Port for ZeroMQ channel",
)
group.add_argument(
"--master-port",
type=int,
default=6666,
help="Port for torch distributed",
)
group.add_argument(
"--temperature",
type=float,
default=1.0,
help="Sampling temperature.",
)
group.add_argument(
"--greedy",
action="store_true",
default=False,
help="Use greedy sampling.",
)
group.add_argument(
"--top-p",
type=float,
default=0.0,
help="Top p sampling.",
)
group.add_argument(
"--top-k",
type=int,
default=0,
help="Top k sampling.",
)
group.add_argument(
"--out-seq-length",
type=int,
default=1024,
help="Size of the output generated text.",
)
group.add_argument(
"--input-path",
type=str,
default="./benchmark/humaneval/HumanEval.jsonl",
help="Get input path",
)
group.add_argument(
"--num-samples",
type=int,
default=0,
help="Number of samples to generate",
)
group.add_argument(
"--recompute",
action="store_true",
help="During generation recompute all attention "
"instead of using previously computed keys/values.",
)
group.add_argument(
"--load-deepspeed",
action="store_true",
help="Load DeepSpeed checkpoint",
)
group.add_argument(
"--ws-encoding-start-id",
type=int,
default=None,
help="Start id for whitespace encoding",
)
group.add_argument(
"--ws-encoding-length",
type=int,
default=None,
help="Length of whitespace encoding",
)
group.add_argument(
"--dataset",
type=str,
default="humaneval",
)
group.add_argument(
"--samples-per-problem",
type=int,
default=200,
help="Number of samples to generate for each problem",
)
group.add_argument(
"--output-prefix",
type=str,
default="./output/humaneval",
help="Prefix for output files",
)
group.add_argument(
"--gen-node-rank",
type=int,
default=None,
)
group.add_argument(
"--gen-node-world-size",
type=int,
default=None,
)
group.add_argument(
"--gen-world-size",
type=int,
default=1,
help="Number of machines to use for generation",
)
group.add_argument(
"--gen-rank",
type=int,
default=0,
help="Machine rank for human eval generation",
)
group.add_argument(
"--extra-prompt",
type=str,
default=None,
help="Extra prompt to use for human eval generation",
)
group.add_argument(
"--verbose-interval",
type=int,
default=100,
)
group.add_argument(
"--problem-split",
type=str,
default="test",
)
group.add_argument(
"--prompt-type",
type=str,
default="notag",
)
group.add_argument(
"--num-devices-per-node",
type=int,
default=None,
)
group.add_argument(
"--return-scores",
action="store_true",
)
group.add_argument(
'--language-type',
default=None,
help='Identify the type of programming language to generate',
)
group.add_argument(
'--bad-ids',
nargs="*",
type=int,
default=None,
help='Specify bad ids that will not be used',
)
group.add_argument(
"--quantize",
action="store_true",
)
return parser |
Main program. | def main(node_rank: int, local_rank: int, master_port: int, num_devices: int):
"""Main program."""
os.environ["WORLD_SIZE"] = str(num_devices)
os.environ["RANK"] = str(local_rank)
os.environ["MASTER_ADDR"] = "0.0.0.0"
os.environ["MASTER_PORT"] = f"{master_port}"
initialize_megatron(
extra_args_provider=add_code_generation_args,
args_defaults={
"tokenizer_type": "GPT2BPETokenizer",
"no_load_rng" : True,
"no_load_optim" : True,
},
)
# set_random_seed(node_rank * num_devices + local_rank)
args = get_args()
if args.num_layers_per_virtual_pipeline_stage is not None:
print("Interleaved pipeline schedule is not yet supported for text generation.")
exit()
world_size = args.gen_node_world_size * num_devices
args.gen_rank = num_devices * node_rank + local_rank
args.gen_world_size = world_size
print(f"Generating on rank {args.gen_rank} of {args.gen_world_size}")
# Set up model and load checkpoint.
state_dict = torch.load(args.load, map_location="cpu")
state_dict = state_dict["module"]
print("Building CodeGeeX model ...")
model = model_provider()
model.load_state_dict(state_dict)
model.eval()
if args.fp16 and args.ln_fp16:
model.half()
if args.quantize:
model = quantize(model, weight_bit_width=8, backend="megatron")
model.cuda()
# Generate samples.
run_generation_distributed(model)
print(f"(gen_rank={args.gen_rank}, rank={local_rank}) finished, waiting ...")
torch.distributed.barrier() |
Code generation arguments. | def add_code_generate_args(parser):
"""Code generation arguments."""
group = parser.add_argument_group(title="code generation")
group.add_argument(
"--hostfile",
type=str,
default="./hostfile",
)
group.add_argument(
"--channel-ip",
type=str,
default=None,
help="IP for ZeroMQ channel",
)
group.add_argument(
"--channel-port",
type=int,
default=5555,
help="Port for ZeroMQ channel",
)
group.add_argument(
"--master-port",
type=int,
default=5666,
)
group.add_argument(
"--temperature",
type=float,
default=1.0,
help="Sampling temperature.",
)
group.add_argument(
"--greedy",
action="store_true",
default=False,
help="Use greedy sampling.",
)
group.add_argument(
"--top-p",
type=float,
default=0.0,
help="Top p sampling.",
)
group.add_argument(
"--top-k",
type=int,
default=0,
help="Top k sampling.",
)
group.add_argument(
"--out-seq-length",
type=int,
default=1024,
help="Size of the output generated text.",
)
group.add_argument(
"--input-path",
type=str,
default="./benchmark/humaneval/HumanEval.jsonl",
help="Get input path",
)
group.add_argument(
"--num-samples",
type=int,
default=0,
help="Number of samples to generate",
)
group.add_argument(
"--recompute",
action="store_true",
help="During generation recompute all attention "
"instead of using previously computed keys/values.",
)
group.add_argument(
"--load-deepspeed",
action="store_true",
help="Load DeepSpeed checkpoint",
)
group.add_argument(
"--ws-encoding-start-id",
type=int,
default=None,
help="Start id for whitespace encoding",
)
group.add_argument(
"--ws-encoding-length",
type=int,
default=None,
help="Length of whitespace encoding",
)
group.add_argument(
"--dataset",
type=str,
default="humaneval",
)
group.add_argument(
"--samples-per-problem",
type=int,
default=200,
help="Number of samples to generate for each problem",
)
group.add_argument(
"--output-prefix",
type=str,
default="./output/humaneval",
help="Prefix for output files",
)
group.add_argument(
"--gen-node-rank",
type=int,
default=None,
)
group.add_argument(
"--gen-node-world-size",
type=int,
default=None,
)
group.add_argument(
"--gen-world-size",
type=int,
default=1,
help="Number of machines to use for generation",
)
group.add_argument(
"--gen-rank",
type=int,
default=0,
help="Machine rank for human eval generation",
)
group.add_argument(
"--extra-prompt",
type=str,
default=None,
help="Extra prompt to use for human eval generation",
)
group.add_argument(
"--verbose-interval",
type=int,
default=100,
)
group.add_argument(
"--problem-split",
type=str,
default="test",
)
group.add_argument(
"--prompt-type",
type=str,
default="notag",
)
group.add_argument(
"--num-devices-per-node",
type=int,
default=None,
)
group.add_argument(
"--return-scores",
action="store_true",
)
group.add_argument(
"--free-guidance",
action="store_true",
)
group.add_argument(
"--guide-temp",
type=float,
default=1.5,
)
group.add_argument(
"--attention-upweight",
type=float,
default=None,
)
group.add_argument(
'--bad-ids',
nargs="*",
type=int,
default=None,
help='Identify the type of programming language to generate',
)
group.add_argument(
"--src-path",
type=str,
default="",
help="Get source path",
)
group.add_argument(
"--tgt-path",
type=str,
default="",
help="Get target path",
)
group.add_argument(
'--language-src-type',
type=str,
default=None,
help='Identify the type of programming language',
)
group.add_argument(
'--language-tgt-type',
type=str,
default=None,
help='Identify the type of programming language to translate',
)
return parser |
Main program. | def main(node_rank: int, local_rank: int, master_port: int, num_devices: int):
"""Main program."""
os.environ["WORLD_SIZE"] = str(num_devices)
os.environ["RANK"] = str(local_rank)
os.environ["MASTER_ADDR"] = "0.0.0.0"
os.environ["MASTER_PORT"] = f"{master_port}"
initialize_megatron(
extra_args_provider=add_code_generate_args,
args_defaults={
"tokenizer_type": "GPT2BPETokenizer",
"no_load_rng" : True,
"no_load_optim" : True,
},
)
# set_random_seed(node_rank * num_devices + local_rank)
args = get_args()
if args.num_layers_per_virtual_pipeline_stage is not None:
print("Interleaved pipeline schedule is not yet supported for text generation.")
exit()
world_size = args.gen_node_world_size * num_devices
args.gen_rank = num_devices * node_rank + local_rank
args.gen_world_size = world_size
print(f"Generating on rank {args.gen_rank} of {args.gen_world_size}")
# Set up model and load checkpoint.
state_dict = torch.load(args.load, map_location="cpu")
state_dict = state_dict["module"]
print("Building CodeGeeX model ...")
model = model_provider()
model.load_state_dict(state_dict)
model.eval()
if args.fp16 and args.ln_fp16:
model.half()
model.cuda()
# Generate samples.
run_generation_distributed(model)
print(f"(gen_rank={args.gen_rank}, rank={local_rank}) finished, waiting ...")
torch.distributed.barrier() |
Parses each jsonl line and yields it as a dictionary | def stream_jsonl(filename: str) -> Iterable[Dict]:
"""
Parses each jsonl line and yields it as a dictionary
"""
if filename.endswith(".gz"):
with open(filename, "rb") as gzfp:
with gzip.open(gzfp, "rt") as fp:
for line in fp:
if any(not x.isspace() for x in line):
yield json.loads(line)
else:
with open(filename, "r") as fp:
for line in fp:
if any(not x.isspace() for x in line):
yield json.loads(line) |
Writes an iterable of dictionaries to jsonl | def write_jsonl(filename: str, data: Iterable[Dict], append: bool = False):
"""
Writes an iterable of dictionaries to jsonl
"""
if append:
mode = "ab"
else:
mode = "wb"
filename = os.path.expanduser(filename)
if filename.endswith(".gz"):
with open(filename, mode) as fp:
with gzip.GzipFile(fileobj=fp, mode="wb") as gzfp:
for x in data:
gzfp.write((json.dumps(x) + "\n").encode("utf-8"))
else:
with open(filename, mode) as fp:
for x in data:
fp.write((json.dumps(x) + "\n").encode("utf-8")) |
Generate a series of (prompt, code) pairs by sliding the window over the code. | def sliding_window(
prompt_tokens: list,
code_tokens: list,
seq_len: int,
sliding_stride: int,
minimum_code_len: int = 1,
) -> Iterable[Tuple[list, list]]:
"""
Generate a series of (prompt, code) pairs by sliding the window over the code.
"""
prompt_len = len(prompt_tokens)
code_len = len(code_tokens)
total_len = prompt_len + code_len
start_idx = max(0, prompt_len - seq_len + minimum_code_len) # at least `minimum_code_len` code token should be in the window
end_idx = max(0, total_len - seq_len)
start_idx = min(start_idx, end_idx)
for i in range(start_idx, end_idx + 1, sliding_stride):
current_prompt = prompt_tokens[i:i + seq_len]
current_code = code_tokens[max(i - prompt_len, 0):i - prompt_len + seq_len]
yield current_prompt, current_code
if (end_idx - start_idx) % sliding_stride != 0:
current_prompt = prompt_tokens[end_idx:end_idx + seq_len]
current_code = code_tokens[max(end_idx - prompt_len, 0):end_idx - prompt_len + seq_len]
yield current_prompt, current_code |
Parse all arguments. | def parse_args(extra_args_provider=None, defaults={}, ignore_unknown_args=False):
"""Parse all arguments."""
parser = argparse.ArgumentParser(
description="Megatron-LM Arguments", allow_abbrev=False
)
# Standard arguments.
parser = _add_network_size_args(parser)
parser = _add_regularization_args(parser)
parser = _add_training_args(parser)
parser = _add_initialization_args(parser)
parser = _add_learning_rate_args(parser)
parser = _add_checkpointing_args(parser)
parser = _add_mixed_precision_args(parser)
parser = _add_distributed_args(parser)
parser = _add_validation_args(parser)
parser = _add_data_args(parser)
parser = _add_autoresume_args(parser)
parser = _add_biencoder_args(parser)
parser = _add_vit_args(parser)
parser = _add_logging_args(parser)
parser = _add_zero_args(parser)
parser = _add_memoryopt_args(parser)
parser = _add_activation_checkpoint_args(parser)
parser = _add_inference_args(parser)
# Custom arguments.
if extra_args_provider is not None:
parser = extra_args_provider(parser)
parser = deepspeed.add_config_arguments(parser)
# Parse.
if ignore_unknown_args:
args, _ = parser.parse_known_args()
else:
args = parser.parse_args()
# helper argument to set deepspeed pipeline parallel or not
args.ds_pipeline_enabled = not args.no_pipeline_parallel
# Distributed args.
args.rank = int(os.getenv("RANK", "0"))
args.world_size = int(os.getenv("WORLD_SIZE", "1"))
# Tensor model parallel size.
args.tensor_model_parallel_size = min(
args.tensor_model_parallel_size, args.world_size
)
assert (
args.world_size % args.tensor_model_parallel_size == 0
), "world size" " ({}) is not divisible by tensor model parallel size ({})".format(
args.world_size, args.tensor_model_parallel_size
)
# Pipeline model parallel size.
args.pipeline_model_parallel_size = min(
args.pipeline_model_parallel_size,
(args.world_size // args.tensor_model_parallel_size),
)
# Checks.
if args.no_pipeline_parallel:
assert (
args.pipeline_model_parallel_size == 1
), "pipeline_model_parallel_size must be 1 if pipeline parallel is disabled"
model_parallel_size = (
args.pipeline_model_parallel_size * args.tensor_model_parallel_size
)
assert args.world_size % model_parallel_size == 0, (
"world size is not"
" divisible by tensor parallel size ({}) times pipeline parallel "
"size ({})".format(
args.world_size,
args.tensor_model_parallel_size,
args.pipeline_model_parallel_size,
)
)
args.data_parallel_size = args.world_size // model_parallel_size
if args.rank == 0:
print(
"using world size: {}, data-parallel-size: {}, "
"tensor-model-parallel size: {}, "
"pipeline-model-parallel size: {} ".format(
args.world_size,
args.data_parallel_size,
args.tensor_model_parallel_size,
args.pipeline_model_parallel_size,
),
flush=True,
)
# Deprecated arguments
assert args.batch_size is None, (
"--batch-size argument is no longer " "valid, use --micro-batch-size instead"
)
del args.batch_size
assert args.warmup is None, (
"--warmup argument is no longer valid, use " "--lr-warmup-fraction instead"
)
del args.warmup
assert args.model_parallel_size is None, (
"--model-parallel-size is no "
"longer valid, use --tensor-model-parallel-size instead"
)
del args.model_parallel_size
# Set input defaults.
for key in defaults:
# For default to be valid, it should not be provided in the
# arguments that are passed to the program. We check this by
# ensuring the arg is set to None.
if getattr(args, key) is not None:
if args.force_default:
print(
"WARNING: overriding arguments for {key}:{v2} \
with default {key}:{v}".format(
key=key, v=defaults[key], v2=getattr(args, key)
),
flush=True,
)
setattr(args, key, defaults[key])
else:
if args.rank == 0:
print(
"WARNING: overriding default arguments for {key}:{v} \
with {key}:{v2}".format(
key=key, v=defaults[key], v2=getattr(args, key)
),
flush=True,
)
else:
setattr(args, key, defaults[key])
# Batch size.
assert args.micro_batch_size is not None
assert args.micro_batch_size > 0
if args.global_batch_size is None:
args.global_batch_size = args.micro_batch_size * args.data_parallel_size
if args.rank == 0:
print(
"setting global batch size to {}".format(args.global_batch_size),
flush=True,
)
assert args.global_batch_size > 0
if args.num_layers_per_virtual_pipeline_stage is not None:
assert args.pipeline_model_parallel_size > 2, (
"pipeline-model-parallel size should be greater than 2 with "
"interleaved schedule"
)
assert args.num_layers % args.num_layers_per_virtual_pipeline_stage == 0, (
"number of layers is not divisible by number of layers per virtual "
"pipeline stage"
)
args.virtual_pipeline_model_parallel_size = (
args.num_layers // args.pipeline_model_parallel_size
) // args.num_layers_per_virtual_pipeline_stage
else:
args.virtual_pipeline_model_parallel_size = None
# Parameters dtype.
args.params_dtype = torch.float
if args.fp16:
assert not args.bf16
args.params_dtype = torch.half
if args.bf16:
assert not args.fp16
args.params_dtype = torch.bfloat16
# bfloat16 requires gradient accumulation and all-reduce to
# be done in fp32.
if not args.accumulate_allreduce_grads_in_fp32:
args.accumulate_allreduce_grads_in_fp32 = True
if args.rank == 0:
print(
"accumulate and all-reduce gradients in fp32 for "
"bfloat16 data type.",
flush=True,
)
if args.rank == 0:
print("using {} for parameters ...".format(args.params_dtype), flush=True)
# If we do accumulation and all-reduces in fp32, we need to have
# local DDP and we should set the use-contiguous-buffers-in-ddp.
if args.accumulate_allreduce_grads_in_fp32:
assert args.DDP_impl == "local"
args.use_contiguous_buffers_in_ddp = True
if args.dataloader_type is None:
args.dataloader_type = "single"
# Consumed tokens.
args.consumed_train_samples = 0
args.consumed_valid_samples = 0
args.consumed_train_tokens = 0
# Iteration-based training.
if args.train_iters:
# If we use iteration-based training, make sure the
# sample-based options are off.
assert args.train_samples is None, "expected iteration-based training"
assert (
args.lr_decay_samples is None
), "expected iteration-based learning rate decay"
assert (
args.lr_warmup_samples == 0
), "expected iteration-based learning rate warmup"
assert (
args.rampup_batch_size is None
), "expected no batch-size rampup for iteration-based training"
if args.lr_warmup_fraction is not None:
assert (
args.lr_warmup_iters == 0
), "can only specify one of lr-warmup-fraction and lr-warmup-iters"
# Sample-based training.
if args.train_samples:
# If we use sample-based training, make sure the
# iteration-based options are off.
assert args.train_iters is None, "expected sample-based training"
assert args.lr_decay_iters is None, "expected sample-based learning rate decay"
assert args.lr_warmup_iters == 0, "expected sample-based learnig rate warmup"
if args.lr_warmup_fraction is not None:
assert args.lr_warmup_samples == 0, (
"can only specify one of lr-warmup-fraction " "and lr-warmup-samples"
)
# Check required arguments.
required_args = [
"num_layers",
"hidden_size",
"num_attention_heads",
"max_position_embeddings",
]
for req_arg in required_args:
_check_arg_is_not_none(args, req_arg)
# args.learned_position_embeddings = args.learned_position_embeddings > 0
# Checks.
if args.ffn_hidden_size is None:
args.ffn_hidden_size = 4 * args.hidden_size
if args.kv_channels is None:
assert args.hidden_size % args.num_attention_heads == 0
args.kv_channels = args.hidden_size // args.num_attention_heads
if args.seq_length is not None:
assert args.encoder_seq_length is None
args.encoder_seq_length = args.seq_length
else:
assert args.encoder_seq_length is not None
args.seq_length = args.encoder_seq_length
if args.seq_length is not None:
assert args.max_position_embeddings >= args.seq_length
if args.decoder_seq_length is not None:
assert args.max_position_embeddings >= args.decoder_seq_length
if args.lr is not None:
assert args.min_lr <= args.lr
if args.save is not None:
assert args.save_interval is not None
# Mixed precision checks.
if args.fp16_lm_cross_entropy:
assert args.fp16, "lm cross entropy in fp16 only support in fp16 mode."
if args.fp32_residual_connection:
assert (
args.fp16 or args.bf16
), "residual connection in fp32 only supported when using fp16 or bf16."
# Activation checkpointing.
if args.distribute_checkpointed_activations:
assert args.checkpoint_activations, (
"for distribute-checkpointed-activations to work you "
"need to enable checkpoint-activations"
)
_print_args(args)
return args |
Print arguments. | def _print_args(args):
"""Print arguments."""
if args.rank == 0:
print("------------------------ arguments ------------------------", flush=True)
str_list = []
for arg in vars(args):
dots = "." * (48 - len(arg))
str_list.append(" {} {} {}".format(arg, dots, getattr(args, arg)))
for arg in sorted(str_list, key=lambda x: x.lower()):
print(arg, flush=True)
print("-------------------- end of arguments ---------------------", flush=True) |
Text generate arguments. | def _add_zero_args(parser):
"""Text generate arguments."""
group = parser.add_argument_group("ZeRO configurations", "configurations")
group.add_argument("--zero-stage", type=int, default=1.0)
group.add_argument(
"--zero-reduce-scatter",
action="store_true",
help="Use reduce scatter if specified",
)
group.add_argument(
"--zero-contigious-gradients",
action="store_true",
help="Use contigious memory optimizaiton if specified",
)
group.add_argument("--zero-reduce-bucket-size", type=int, default=0.0)
group.add_argument("--zero-allgather-bucket-size", type=int, default=0.0)
group.add_argument(
"--remote-device",
type=str,
default="none",
choices=["none", "cpu", "nvme"],
help="Remote device for ZeRO-3 initialized parameters.",
)
group.add_argument(
"--use-pin-memory",
action="store_true",
help="Use pinned CPU memory for ZeRO-3 initialized model parameters.",
)
return parser |
Memory optimization arguments. | def _add_memoryopt_args(parser):
"""Memory optimization arguments."""
group = parser.add_argument_group("Memory optimizations", "configurations")
group.add_argument(
"--scattered-embeddings",
action="store_true",
help="Save memory by scattering embedding activations. "
"Introduces dropout differences across MP configurations.",
)
group.add_argument(
"--split-transformers",
action="store_true",
help="Save memory by splitting transformer layers into two parts, "
"allowing for more frequent activation checkpoint savings.",
)
group.add_argument(
"--memory-centric-tiled-linear",
action="store_true",
help="Save memory by tiling with deepspeed.zero.TiledLinear.",
)
group.add_argument(
"--tile-factor",
type=int,
default=1,
help="Make all linear layers the same size of [hidden/tile_factor, hidden/tile_factor]. "
"Must be enabled with --memory-centric-tiled-linear. "
"Example A: if tile_factor=1, the qkv layer [hidden, 3* hidden] would be converted into [1,3] tiles of size [hidden,hidden]. "
"Example B: if tile_factor=2, the intermediate layer [4*hidden, hidden] will be converted into [8, 2] tiles of size [hidden/2, hidden/2]. "
"Default is 1.",
)
return parser |
Ensure fixed arguments for a model are the same for the input
arguments and the one retrieved from checkpoint. | def check_checkpoint_args(checkpoint_args):
"""Ensure fixed arguments for a model are the same for the input
arguments and the one retrieved from checkpoint."""
args = get_args()
def _compare(arg_name, old_arg_name=None):
if old_arg_name is not None:
checkpoint_value = getattr(checkpoint_args, old_arg_name)
else:
checkpoint_value = getattr(checkpoint_args, arg_name)
args_value = getattr(args, arg_name)
error_message = (
"{} value from checkpoint ({}) is not equal to the "
"input argument value ({}).".format(arg_name, checkpoint_value, args_value)
)
assert checkpoint_value == args_value, error_message
_compare("num_layers")
_compare("hidden_size")
_compare("num_attention_heads")
_compare("max_position_embeddings")
if args.vocab_file:
_compare("make_vocab_size_divisible_by")
_compare("padded_vocab_size")
_compare("tokenizer_type")
if get_checkpoint_version() < 3.0:
_compare("tensor_model_parallel_size", old_arg_name="model_parallel_size")
if get_checkpoint_version() >= 3.0:
_compare("tensor_model_parallel_size")
_compare("pipeline_model_parallel_size") |
Build filename's path if it does not already exists. | def ensure_directory_exists(filename):
"""Build filename's path if it does not already exists."""
dirname = os.path.dirname(filename)
if not os.path.exists(dirname):
os.makedirs(dirname) |
A unified checkpoint name. | def get_checkpoint_name(checkpoints_path, iteration, release=False):
"""A unified checkpoint name."""
if release:
directory = ""
else:
directory = f"global_step{iteration}"
# Use both the tensor and pipeline MP rank.
if mpu.get_pipeline_model_parallel_world_size() == 1:
return os.path.join(
checkpoints_path,
directory,
"mp_rank_{:02d}_model_states.pt".format(mpu.get_tensor_model_parallel_rank()),
)
return os.path.join(
checkpoints_path,
directory,
"mp_rank_{:02d}_{:03d}_model_states.pt".format(
mpu.get_tensor_model_parallel_rank(), mpu.get_pipeline_model_parallel_rank()
),
) |
Tracker file rescords the latest chckpoint during
training to restart from. | def get_checkpoint_tracker_filename(checkpoints_path):
"""Tracker file rescords the latest chckpoint during
training to restart from."""
return os.path.join(checkpoints_path, "latest_checkpointed_iteration.txt") |
Save a model checkpoint. | def save_checkpoint(iteration, model, optimizer, lr_scheduler):
"""Save a model checkpoint."""
args = get_args()
# Only rank zero of the data parallel writes to the disk.
if not args.deepspeed:
model = utils.unwrap_model(model)
print_rank_0(
"saving checkpoint at iteration {:7d} to {}".format(iteration, args.save)
)
if (
not torch.distributed.is_initialized()
or mpu.get_data_parallel_rank() == 0
or args.deepspeed
):
# Arguments, iteration, and model.
state_dict = {}
state_dict["args"] = args
state_dict["checkpoint_version"] = 3.0
state_dict["iteration"] = iteration
state_dict["tokens"] = args.consumed_train_tokens
# DeepSpeed saves the model/optimizer/scheduler
if not args.deepspeed:
if len(model) == 1:
state_dict["model"] = model[0].state_dict_for_save_checkpoint()
else:
for i in range(len(model)):
mpu.set_virtual_pipeline_model_parallel_rank(i)
state_dict["model%d" % i] = model[
i
].state_dict_for_save_checkpoint()
# Optimizer stuff.
if not args.no_save_optim:
if optimizer is not None:
state_dict["optimizer"] = optimizer.state_dict()
if lr_scheduler is not None:
state_dict["lr_scheduler"] = lr_scheduler.state_dict()
# RNG states.
if not args.no_save_rng:
state_dict["random_rng_state"] = random.getstate()
state_dict["np_rng_state"] = np.random.get_state()
state_dict["torch_rng_state"] = torch.get_rng_state()
state_dict["cuda_rng_state"] = torch.cuda.get_rng_state()
state_dict["rng_tracker_states"] = mpu.get_cuda_rng_tracker().get_states()
# Save.
checkpoint_name = get_checkpoint_name(args.save, iteration)
if not args.deepspeed:
ensure_directory_exists(checkpoint_name)
torch.save(state_dict, checkpoint_name)
if args.deepspeed:
# megatron model uses state_dict_for_save_checkpointing instead of the standard state_dict
# state_dict is used by deepspeed for module saving so it needs to point to the right function
if args.no_pipeline_parallel:
original_state_dict = model[0].module.state_dict
model[0].module.state_dict = model[0].module.state_dict_for_save_checkpoint
# Saving is a collective communication
checkpoint_name = get_checkpoint_name(args.save, iteration)
# Trim off the filename and mp_rank_* directory.
for _ in range(2):
checkpoint_name = os.path.dirname(checkpoint_name)
model[0].save_checkpoint(checkpoint_name, client_state=state_dict)
if args.no_pipeline_parallel:
model[0].module.state_dict = original_state_dict
# Wait so everyone is done (necessary)
if torch.distributed.is_initialized():
torch.distributed.barrier()
print_rank_0(
" successfully saved checkpoint at iteration {:7d} to {}".format(
iteration, args.save
)
)
# And update the latest iteration
if not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0:
tracker_filename = get_checkpoint_tracker_filename(args.save)
with open(tracker_filename, "w") as f:
f.write(str(iteration))
# Wait so everyone is done (not necessary)
if torch.distributed.is_initialized():
torch.distributed.barrier() |
Fix up query/key/value matrix ordering if checkpoint
version is smaller than 2.0 | def fix_query_key_value_ordering(model, checkpoint_version):
"""Fix up query/key/value matrix ordering if checkpoint
version is smaller than 2.0
"""
if checkpoint_version < 2.0:
if isinstance(model, list):
assert len(model) == 1
model = model[0]
for name, param in model.named_parameters():
if name.endswith((".query_key_value.weight", ".query_key_value.bias")):
if checkpoint_version == 0:
fixed_param = _transpose_first_dim(param.data, 3, True, model)
elif checkpoint_version == 1.0:
fixed_param = _transpose_first_dim(param.data, 3, False, model)
else:
print_rank_0(f"Invalid checkpoint version {checkpoint_version}.")
sys.exit()
param.data.copy_(fixed_param)
if name.endswith((".key_value.weight", ".key_value.bias")):
if checkpoint_version == 0:
fixed_param = _transpose_first_dim(param.data, 2, True, model)
elif checkpoint_version == 1.0:
fixed_param = _transpose_first_dim(param.data, 2, False, model)
else:
print_rank_0(f"Invalid checkpoint version {checkpoint_version}.")
sys.exit()
param.data.copy_(fixed_param)
print_rank_0(
" successfully fixed query-key-values ordering for"
" checkpoint version {}".format(checkpoint_version)
) |
Load a model checkpoint and return the iteration.
strict (bool): whether to strictly enforce that the keys in
:attr:`state_dict` of the checkpoint match the names of
parameters and buffers in model. | def load_checkpoint(
model,
optimizer,
lr_scheduler,
load_arg="load",
strict=True,
):
"""Load a model checkpoint and return the iteration.
strict (bool): whether to strictly enforce that the keys in
:attr:`state_dict` of the checkpoint match the names of
parameters and buffers in model.
"""
args = get_args()
load_dir = getattr(args, load_arg)
if args.deepspeed:
loaded_dir, state_dict = model[0].load_checkpoint(load_dir)
if loaded_dir is None:
print_rank_0(
"WARNING: could not find the metadata file {} ".format(load_dir)
)
print_rank_0(
" will not load any checkpoints and will start from " "random"
)
return 0
release = False
else:
model = utils.unwrap_model(model)
if load_dir.endswith(".pt"):
checkpoint_name = load_dir
release = True
else:
# Read the tracker file and set the iteration.
tracker_filename = get_checkpoint_tracker_filename(load_dir)
# If no tracker file, return iretation zero.
if not os.path.isfile(tracker_filename):
print_rank_0(
"WARNING: could not find the metadata file {} ".format(tracker_filename)
)
iteration = 0
release = True
checkpoint_name = get_checkpoint_name(load_dir, iteration, release)
if not os.path.isfile(checkpoint_name):
print_rank_0(
" will not load any checkpoints and will start from random"
)
return 0
else:
# Otherwise, read the tracker file and either set the iteration or
# mark it as a release checkpoint.
iteration = 0
release = False
with open(tracker_filename, "r") as f:
metastring = f.read().strip()
try:
iteration = int(metastring)
except ValueError:
release = metastring == "release"
if not release:
print_rank_0(
"ERROR: Invalid metadata file {}. Exiting".format(
tracker_filename
)
)
sys.exit()
assert iteration > 0 or release, "error parsing metadata file {}".format(
tracker_filename
)
# Checkpoint.
checkpoint_name = get_checkpoint_name(load_dir, iteration, release)
print_rank_0(f" loading checkpoint from {args.load} at iteration {iteration}")
# Load the checkpoint.
try:
state_dict = torch.load(checkpoint_name, map_location="cpu")
except ModuleNotFoundError:
from megatron.fp16_deprecated import loss_scaler
# For backward compatibility.
print_rank_0(" > deserializing using the old code structure ...")
sys.modules["fp16.loss_scaler"] = sys.modules[
"megatron.fp16_deprecated.loss_scaler"
]
sys.modules["megatron.fp16.loss_scaler"] = sys.modules[
"megatron.fp16_deprecated.loss_scaler"
]
state_dict = torch.load(checkpoint_name, map_location="cpu")
sys.modules.pop("fp16.loss_scaler", None)
sys.modules.pop("megatron.fp16.loss_scaler", None)
except BaseException as e:
print_rank_0("could not load the checkpoint")
print_rank_0(e)
sys.exit()
# set checkpoint version
set_checkpoint_version(state_dict.get("checkpoint_version", 0))
# Set iteration.
if args.finetune or release:
iteration = 0
else:
try:
iteration = state_dict["iteration"]
if "tokens" in state_dict:
args.consumed_train_tokens = state_dict["tokens"]
except KeyError:
try: # Backward compatible with older checkpoints
iteration = state_dict["total_iters"]
except KeyError:
print_rank_0(
"A metadata file exists but unable to load "
"iteration from checkpoint {}, exiting".format(checkpoint_name)
)
sys.exit()
# Check arguments.
assert args.consumed_train_samples == 0
assert args.consumed_valid_samples == 0
if "args" in state_dict:
checkpoint_args = state_dict["args"]
check_checkpoint_args(checkpoint_args)
args.consumed_train_samples = getattr(
checkpoint_args, "consumed_train_samples", 0
)
update_num_microbatches(consumed_samples=args.consumed_train_samples)
args.consumed_valid_samples = getattr(
checkpoint_args, "consumed_valid_samples", 0
)
else:
print_rank_0("could not find arguments in the checkpoint ...")
# Model.
if not args.deepspeed:
if release:
if len(model) == 1:
model[0].load_state_dict(state_dict["module"], strict=strict)
else:
for i in range(len(model)):
mpu.set_virtual_pipeline_model_parallel_rank(i)
model[i].load_state_dict(state_dict["model%d" % i], strict=strict)
else:
if len(model) == 1:
model[0].load_state_dict(state_dict["module"], strict=strict)
else:
for i in range(len(model)):
mpu.set_virtual_pipeline_model_parallel_rank(i)
model[i].load_state_dict(state_dict["model%d" % i], strict=strict)
# Fix up query/key/value matrix ordering if needed
checkpoint_version = get_checkpoint_version()
print_rank_0(f" checkpoint version {checkpoint_version}")
fix_query_key_value_ordering(model, checkpoint_version)
# Optimizer.
if not args.deepspeed:
if not release and not args.finetune and not args.no_load_optim:
try:
if optimizer is not None:
optimizer.load_state_dict(state_dict["optimizer"])
if lr_scheduler is not None:
lr_scheduler.load_state_dict(state_dict["lr_scheduler"])
except KeyError:
print_rank_0(
"Unable to load optimizer from checkpoint {}. "
"Specify --no-load-optim or --finetune to prevent "
"attempting to load the optimizer state, "
"exiting ...".format(checkpoint_name)
)
sys.exit()
# rng states.
if not release and not args.finetune and not args.no_load_rng:
try:
random.setstate(state_dict["random_rng_state"])
np.random.set_state(state_dict["np_rng_state"])
torch.set_rng_state(state_dict["torch_rng_state"])
torch.cuda.set_rng_state(state_dict["cuda_rng_state"])
# Check for empty states array
if not state_dict["rng_tracker_states"]:
raise KeyError
mpu.get_cuda_rng_tracker().set_states(state_dict["rng_tracker_states"])
except KeyError:
print_rank_0(
"Unable to load rng state from checkpoint {}. "
"Specify --no-load-rng or --finetune to prevent "
"attempting to load the rng state, "
"exiting ...".format(checkpoint_name)
)
sys.exit()
# Some utilities want to load a checkpoint without distributed being initialized
# if torch.distributed.is_initialized():
# torch.distributed.barrier()
print_rank_0(
f" successfully loaded checkpoint from {args.load} "
f"at iteration {iteration}"
)
return iteration |
selectively load retrieval models for indexing/retrieving
from saved checkpoints | def load_biencoder_checkpoint(
model, only_query_model=False, only_context_model=False, custom_load_path=None
):
"""
selectively load retrieval models for indexing/retrieving
from saved checkpoints
"""
args = get_args()
model = utils.unwrap_model(model)
load_path = custom_load_path if custom_load_path is not None else args.load
tracker_filename = get_checkpoint_tracker_filename(load_path)
with open(tracker_filename, "r") as f:
iteration = int(f.read().strip())
checkpoint_name = get_checkpoint_name(load_path, iteration, False)
if mpu.get_data_parallel_rank() == 0:
print(
"global rank {} is loading checkpoint {}".format(
torch.distributed.get_rank(), checkpoint_name
)
)
state_dict = torch.load(checkpoint_name, map_location="cpu")
ret_state_dict = state_dict["model"]
if only_query_model:
ret_state_dict.pop("context_model")
if only_context_model:
ret_state_dict.pop("query_model")
assert len(model) == 1
model[0].load_state_dict(ret_state_dict)
torch.distributed.barrier()
if mpu.get_data_parallel_rank() == 0:
print(" successfully loaded {}".format(checkpoint_name))
return model |
Generate batch from context tokens. | def get_batch(context_tokens, micro_batch_size=None):
"""Generate batch from context tokens."""
args = get_args()
tokenizer = get_tokenizer()
# Move to GPU.
if micro_batch_size is None:
micro_batch_size = args.micro_batch_size
tokens = context_tokens.view(micro_batch_size, -1).contiguous().cuda()
# Get the attention mask and postition ids.
attention_mask, _, position_ids = get_ltor_masks_and_position_ids(
tokens,
tokenizer.eod,
args.reset_position_ids,
args.reset_attention_mask,
args.eod_mask_loss,
)
return tokens, attention_mask, position_ids |
Generate batch from context tokens. | def get_batch_(context_tokens):
"""Generate batch from context tokens."""
args = get_args()
tokenizer = get_tokenizer()
# Move to GPU.
tokens = context_tokens.contiguous().cuda()
# Get the attention mask and postition ids.
attention_mask, _, position_ids = get_ltor_masks_and_position_ids(
tokens,
tokenizer.eod,
args.reset_position_ids,
args.reset_attention_mask,
args.eod_mask_loss,
)
return tokens, attention_mask, position_ids |
This function has been mostly taken from huggingface conversational
ai code at
https://medium.com/huggingface/how-to-build-a-state-of-the-art-
conversational-ai-with-transfer-learning-2d818ac26313 | def top_k_logits(logits, top_k=0, top_p=0.0, filter_value=-float("Inf")):
"""This function has been mostly taken from huggingface conversational
ai code at
https://medium.com/huggingface/how-to-build-a-state-of-the-art-
conversational-ai-with-transfer-learning-2d818ac26313"""
if top_k > 0:
# Remove all tokens with a probability less than the
# last token of the top-k
indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
logits[indices_to_remove] = filter_value
if top_p > 0.0:
# Cconvert to 1D
sorted_logits, sorted_indices = torch.sort(logits, descending=True, dim=-1)
cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
# Remove tokens with cumulative probability above the threshold
sorted_indices_to_remove = cumulative_probs > top_p
# Shift the indices to the right to keep also the first token
# above the threshold
sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
sorted_indices_to_remove[..., 0] = 0
for i in range(sorted_indices.size(0)):
indices_to_remove = sorted_indices[i][sorted_indices_to_remove[i]]
logits[i][indices_to_remove] = filter_value
return logits |
Samples from a multinomial distribution using the top-k sampling strategy.
Args:
logits: A tensor of shape (batch_size, vocab_size) containing the logits.
num_samples: The number of samples to draw. | def topk_sampling(logits: torch.FloatTensor, num_samples: int):
"""
Samples from a multinomial distribution using the top-k sampling strategy.
Args:
logits: A tensor of shape (batch_size, vocab_size) containing the logits.
num_samples: The number of samples to draw.
"""
log_prob = F.log_softmax(logits, dim=-1)
topk = torch.topk(log_prob, num_samples, dim=-1)
topk_tokens = topk.indices
topk_log_prob = topk.values
return topk_tokens, topk_log_prob |
Beam search.
Note that this function does not support model parallel! | def beam_search(model, context_tokens, num_beams: int):
"""Beam search.
Note that this function does not support model parallel!
"""
args = get_args()
tokenizer = get_tokenizer()
assert not isinstance(context_tokens[0], list), "batched beam search not supported"
initial_beam = Beam(context_tokens, 0.0)
context_len = len(context_tokens)
org_context_len = context_len
finished_beams = []
# first expansion
beams = expand_beams([initial_beam], num_beams, model)
context_len += 1
# print(f"initial beam: {initial_beam}")
while len(beams) > 0 and context_len < args.seq_length:
expanded_beams = expand_beams(beams, num_beams, model)
next_beams = []
for beam in expanded_beams:
if args.beam_warmup:
if len(beam.tokens) >= org_context_len + args.beam_warmup_length or beam.tokens[-1] == tokenizer.eod:
finished_beams.append(beam)
else:
next_beams.append(beam)
else:
if args.evaluation:
generated_code = tokenizer.detokenize(beam.tokens[org_context_len:])
if is_code_generation_finished(generated_code):
finished_beams.append(beam)
continue
if beam.tokens[-1] == tokenizer.eod:
finished_beams.append(beam)
else:
next_beams.append(beam)
# only keep top-k beams
next_beams.sort(key=lambda b: b.score, reverse=True)
beams = next_beams[:num_beams]
context_len += 1
if len(finished_beams) >= num_beams:
# first, only keep top-k beams
finished_beams.sort(key=lambda b: b.score, reverse=True)
finished_beams = finished_beams[:num_beams]
return finished_beams # return finished beams with highest scores
# stop if all currently expanding beams has a score lower than the minimal score of finished ones
min_score = min([b.score for b in finished_beams])
if min_score >= beams[0].score:
break
else:
print(f"we have got enough finished beams, but the minimal score is {min_score}")
print(f"and the maximum searching score is {beams[0].score}")
# return top-k finished and unfinished beams
all_beams = finished_beams + beams
all_beams.sort(key=lambda b: b.score, reverse=True)
return all_beams[:num_beams] |
Beam search.
Note that this function does not support model parallel! | def generate_nuclear_sampling(model, context_tokens, num_samples: int, temperature: float, top_p: float, top_k: int):
"""Beam search.
Note that this function does not support model parallel!
"""
args = get_args()
tokenizer = get_tokenizer()
assert not isinstance(context_tokens[0], list), "batched beam search not supported"
handles = [Handle(tokens=context_tokens, score=0) for _ in range(num_samples)]
context_len = len(context_tokens)
finished_handles = []
while len(handles) > 0 and context_len < args.seq_length:
expanded_handles = expand_handles(handles, temperature, top_p, top_k, model)
new_handles = []
for h in expanded_handles:
if h.is_finished():
finished_handles.append(h)
else:
new_handles.append(h)
context_len += 1
handles = new_handles
return handles + finished_handles |
Provide extra arguments required for merging. | def get_change_ckpt_args(parser):
"""Provide extra arguments required for merging."""
group = parser.add_argument_group(title='Mindspore to megatron')
group.add_argument(
'--load-ckpt-path',
type=str,
required=True,
help='path to load ".pt" checkpoint.',
)
group.add_argument(
'--save-ckpt-path',
type=str,
required=True,
help='dir to save converted checkpoints.',
)
group.add_argument(
'--target-tensor-model-parallel-size',
type=int,
default=2,
help='target tensor model parallel size',
)
return parser |
Get element from dictionary by path. If element is not present, recursively add empty dictionaries.
Args:
d (dict): the dictionary to get the element from
path (list): the path to the element which is delimited by "." | def get_element_from_dict_by_path(d, path):
"""
Get element from dictionary by path. If element is not present, recursively add empty dictionaries.
Args:
d (dict): the dictionary to get the element from
path (list): the path to the element which is delimited by "."
"""
path = path.split(".")
for k in path:
if k not in d:
d[k] = {}
d = d[k]
return d |
Return arguments. | def get_args():
"""Return arguments."""
_ensure_var_is_initialized(_GLOBAL_ARGS, "args")
return _GLOBAL_ARGS |
Return tokenizer. | def get_tokenizer():
"""Return tokenizer."""
_ensure_var_is_initialized(_GLOBAL_TOKENIZER, "tokenizer")
return _GLOBAL_TOKENIZER |
Return tensorboard writer. It can be None so no need
to check if it is initialized. | def get_tensorboard_writer():
"""Return tensorboard writer. It can be None so no need
to check if it is initialized."""
return _GLOBAL_TENSORBOARD_WRITER |
ADLR autoresume object. It can be None so no need
to check if it is initialized. | def get_adlr_autoresume():
"""ADLR autoresume object. It can be None so no need
to check if it is initialized."""
return _GLOBAL_ADLR_AUTORESUME |
Return timers. | def get_timers():
"""Return timers."""
_ensure_var_is_initialized(_GLOBAL_TIMERS, "timers")
return _GLOBAL_TIMERS |
Set args, tokenizer, tensorboard-writer, adlr-autoresume, and timers. | def set_global_variables(
extra_args_provider=None, args_defaults={}, ignore_unknown_args=False
):
"""Set args, tokenizer, tensorboard-writer, adlr-autoresume, and timers."""
args = _parse_args(
extra_args_provider=extra_args_provider,
defaults=args_defaults,
ignore_unknown_args=ignore_unknown_args,
)
_build_num_microbatches_calculator(args)
if args.vocab_file or args.tokenizer_path:
_ = _build_tokenizer(args)
_set_tensorboard_writer(args)
_set_adlr_autoresume(args)
_set_timers() |
Parse entire arguments. | def _parse_args(extra_args_provider=None, defaults={}, ignore_unknown_args=False):
"""Parse entire arguments."""
global _GLOBAL_ARGS
_ensure_var_is_not_initialized(_GLOBAL_ARGS, "args")
_GLOBAL_ARGS = parse_args(
extra_args_provider=extra_args_provider,
defaults=defaults,
ignore_unknown_args=ignore_unknown_args,
)
return _GLOBAL_ARGS |
Initialize tokenizer. | def _build_tokenizer(args):
"""Initialize tokenizer."""
global _GLOBAL_TOKENIZER
_ensure_var_is_not_initialized(_GLOBAL_TOKENIZER, "tokenizer")
_GLOBAL_TOKENIZER = build_tokenizer(args)
return _GLOBAL_TOKENIZER |
Set tensorboard writer. | def _set_tensorboard_writer(args):
"""Set tensorboard writer."""
global _GLOBAL_TENSORBOARD_WRITER
_ensure_var_is_not_initialized(_GLOBAL_TENSORBOARD_WRITER, "tensorboard writer")
if (
hasattr(args, "tensorboard_dir")
and args.tensorboard_dir
and args.rank == (args.world_size - 1)
):
try:
from torch.utils.tensorboard import SummaryWriter
print("> setting tensorboard ...")
_GLOBAL_TENSORBOARD_WRITER = SummaryWriter(
log_dir=args.tensorboard_dir, max_queue=args.tensorboard_queue_size
)
except ModuleNotFoundError:
print(
"WARNING: TensorBoard writing requested but is not "
"available (are you using PyTorch 1.1.0 or later?), "
"no TensorBoard logs will be written.",
flush=True,
) |
Initialize ADLR autoresume. | def _set_adlr_autoresume(args):
"""Initialize ADLR autoresume."""
global _GLOBAL_ADLR_AUTORESUME
_ensure_var_is_not_initialized(_GLOBAL_ADLR_AUTORESUME, "adlr autoresume")
if args.adlr_autoresume:
if args.rank == 0:
print("enabling autoresume ...", flush=True)
sys.path.append(os.environ.get("SUBMIT_SCRIPTS", "."))
try:
from userlib.auto_resume import AutoResume
except BaseException:
print("ADLR autoresume is not available, exiting ...")
sys.exit()
_GLOBAL_ADLR_AUTORESUME = AutoResume |
Initialize timers. | def _set_timers():
"""Initialize timers."""
global _GLOBAL_TIMERS
_ensure_var_is_not_initialized(_GLOBAL_TIMERS, "timers")
_GLOBAL_TIMERS = Timers() |
Make sure the input variable is not None. | def _ensure_var_is_initialized(var, name):
"""Make sure the input variable is not None."""
assert var is not None, "{} is not initialized.".format(name) |
Make sure the input variable is not None. | def _ensure_var_is_not_initialized(var, name):
"""Make sure the input variable is not None."""
assert var is None, "{} is already initialized.".format(name) |
Build the model. | def model_provider():
"""Build the model."""
model = CodeGeeXModel(num_tokentypes=0,
parallel_output=False)
return model |
Set random seed for reproducability. | def set_random_seed(seed):
"""Set random seed for reproducability."""
random.seed(seed)
numpy.random.seed(seed)
torch.manual_seed(seed)
mpu.model_parallel_cuda_manual_seed(seed) |
Set global variables, initialize distributed, and
set autoresume and random seeds.
`allow_no_cuda` should not be set unless using megatron for cpu only
data processing. In general this arg should not be set unless you know
what you are doing.
Returns a function to finalize distributed env initialization
(optionally, only when args.lazy_mpu_init == True) | def initialize_megatron(
extra_args_provider=None,
args_defaults={},
ignore_unknown_args=False,
allow_no_cuda=False,
):
"""Set global variables, initialize distributed, and
set autoresume and random seeds.
`allow_no_cuda` should not be set unless using megatron for cpu only
data processing. In general this arg should not be set unless you know
what you are doing.
Returns a function to finalize distributed env initialization
(optionally, only when args.lazy_mpu_init == True)
"""
if not allow_no_cuda:
# Make sure cuda is available.
assert torch.cuda.is_available(), "Megatron requires CUDA."
# Parse args, build tokenizer, and set adlr-autoresume,
# tensorboard-writer, and timers.
set_global_variables(
extra_args_provider=extra_args_provider,
args_defaults=args_defaults,
ignore_unknown_args=ignore_unknown_args,
)
# torch.distributed initialization
def finish_mpu_init():
args = get_args()
# Pytorch distributed.
_initialize_distributed()
# Random seeds for reproducibility.
if args.rank == 0:
print("> setting random seeds to {} ...".format(args.seed))
_set_random_seed(args.seed)
args = get_args()
if args.lazy_mpu_init:
args.use_cpu_initialization = True
# delayed initialization of DDP-related stuff
# We only set basic DDP globals
set_tensor_model_parallel_world_size(args.tensor_model_parallel_size)
# and return function for external DDP manager
# to call when it has DDP initialized
set_tensor_model_parallel_rank(args.rank)
return finish_mpu_init
else:
# Megatron's MPU is the master. Complete initialization right away.
finish_mpu_init()
# Initialize memory buffers.
_initialize_mem_buffs()
# Autoresume.
_init_autoresume()
# No continuation function
return None |
Optional DeepSpeed Activation Checkpointing features.
Gives access to partition activations, contiguous memory optimizations
and cpu checkpointing.
Activation checkpoint requires keep track of the random states
and setting the random seed for each MP process. Megatron uses
mpu.get_cuda_rng_tracker and mpu.model_parallel_cuda_manual_seed
for keeping track of the random states and setting the random seeds.
Since they are used in places outside of activation checkpointing,
we overwrite them to maintain consistency.
This must be called before all the calls to mpu.model_parallel_cuda_manual_seed | def setup_deepspeed_random_and_activation_checkpointing(args):
"""Optional DeepSpeed Activation Checkpointing features.
Gives access to partition activations, contiguous memory optimizations
and cpu checkpointing.
Activation checkpoint requires keep track of the random states
and setting the random seed for each MP process. Megatron uses
mpu.get_cuda_rng_tracker and mpu.model_parallel_cuda_manual_seed
for keeping track of the random states and setting the random seeds.
Since they are used in places outside of activation checkpointing,
we overwrite them to maintain consistency.
This must be called before all the calls to mpu.model_parallel_cuda_manual_seed
"""
num_layers = args.num_layers // args.checkpoint_num_layers
num_layers = (
num_layers
if args.num_layers % args.checkpoint_num_layers == 0
else num_layers + 1
)
if args.split_transformers:
num_layers *= 2
deepspeed.checkpointing.configure(
mpu,
partition_activations=args.partition_activations,
contiguous_checkpointing=args.contigious_checkpointing,
num_checkpoints=num_layers,
checkpoint_in_cpu=args.checkpoint_in_cpu,
synchronize=args.synchronize_each_layer,
profile=args.profile_backward,
)
mpu.checkpoint = deepspeed.checkpointing.checkpoint
mpu.get_cuda_rng_tracker = deepspeed.checkpointing.get_cuda_rng_tracker
mpu.model_parallel_cuda_manual_seed = (
deepspeed.checkpointing.model_parallel_cuda_manual_seed
) |
Initialize torch.distributed and mpu. | def _initialize_distributed():
"""Initialize torch.distributed and mpu."""
args = get_args()
device_count = torch.cuda.device_count()
if torch.distributed.is_initialized():
if args.rank == 0:
print(
"torch distributed is already initialized, "
"skipping initialization ...",
flush=True,
)
args.rank = torch.distributed.get_rank()
args.world_size = torch.distributed.get_world_size()
else:
if args.rank == 0:
print("> initializing torch distributed ...", flush=True)
# Manually set the device ids.
if device_count > 0:
device = args.rank % device_count
if args.local_rank is not None:
assert (
args.local_rank == device
), "expected local-rank to be the same as rank % device-count."
else:
args.local_rank = device
if args.force_device is not None:
print(
f" > forcefully set the device to {args.force_device}, originally {device}"
)
device = args.force_device
torch.cuda.set_device(device)
# Call the init process
init_method = "tcp://"
master_ip = os.getenv("MASTER_ADDR", "localhost")
master_port = os.getenv("MASTER_PORT", "6000")
init_method += master_ip + ":" + master_port
print(
f" > (rank={args.rank}) initializing process group: "
f"world_size={args.world_size} "
f"backend={args.distributed_backend} "
f"init_method={init_method}",
flush=True,
)
timeout = datetime.timedelta(minutes=args.dist_timeout)
torch.distributed.init_process_group(
backend=args.distributed_backend,
world_size=args.world_size,
rank=args.rank,
init_method=init_method,
timeout=timeout
)
print(f" > (rank={args.rank}) process group initialized")
# Set the tensor model-parallel, pipeline model-parallel, and
# data-parallel communicators.
if device_count > 0:
if mpu.model_parallel_is_initialized():
print("model parallel is already initialized")
else:
mpu.initialize_model_parallel(
args.tensor_model_parallel_size,
args.pipeline_model_parallel_size,
args.virtual_pipeline_model_parallel_size,
)
if args.deepspeed and args.deepspeed_activation_checkpointing:
setup_deepspeed_random_and_activation_checkpointing(args) |
Set autoresume start time. | def _init_autoresume():
"""Set autoresume start time."""
autoresume = get_adlr_autoresume()
if autoresume:
torch.distributed.barrier()
autoresume.init()
torch.distributed.barrier() |
Set random seed for reproducability. | def _set_random_seed(seed_):
"""Set random seed for reproducability."""
if seed_ is not None and seed_ > 0:
# Ensure that different pipeline MP stages get different seeds.
seed = seed_ + (100 * mpu.get_pipeline_model_parallel_rank())
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.device_count() > 0:
mpu.model_parallel_cuda_manual_seed(seed)
else:
raise ValueError("Seed ({}) should be a positive integer.".format(seed)) |
Write arguments to tensorboard. | def write_args_to_tensorboard():
"""Write arguments to tensorboard."""
args = get_args()
writer = get_tensorboard_writer()
if writer:
for arg in vars(args):
writer.add_text(arg, str(getattr(args, arg)), global_step=args.iteration) |
Initialize wandb experiment. | def initialize_wandb_experiment():
"""Initialize wandb experiment."""
assert wandb is not None, "Fail to import wandb"
args = get_args()
config = args.__dict__
wandb_id_path = os.path.join(args.save, "wandb_id.txt")
if os.path.exists(wandb_id_path):
wandb_id = open(wandb_id_path, "r").read().strip()
else:
wandb_id = wandb.util.generate_id()
open(wandb_id_path, "w").write(wandb_id)
wandb.init(id=wandb_id, project="megatron", config=config, resume="allow") |
Initialize manually allocated static memory. | def _initialize_mem_buffs():
"""Initialize manually allocated static memory."""
args = get_args()
# Initialize memory for checkpointed activations.
if args.distribute_checkpointed_activations:
mpu.init_checkpointed_activations_memory_buffer() |
Allocate a memory buffer. | def allocate_mem_buff(name, numel, dtype, track_usage):
"""Allocate a memory buffer."""
assert name not in _MEM_BUFFS, "memory buffer {} already allocated.".format(name)
_MEM_BUFFS[name] = MemoryBuffer(name, numel, dtype, track_usage)
return _MEM_BUFFS[name] |
Get the memory buffer. | def get_mem_buff(name):
"""Get the memory buffer."""
return _MEM_BUFFS[name] |
Provide extra arguments required for merging. | def get_change_ckpt_args(parser):
"""Provide extra arguments required for merging."""
group = parser.add_argument_group(title='Mindspore to megatron')
group.add_argument(
'--load-ckpt-path',
type=str,
required=True,
help='dir to load model parallel partitions.',
)
group.add_argument(
'--save-ckpt-path',
type=str,
required=True,
help='path to save ".pt" checkpoint.',
)
group.add_argument(
'--save-name',
type=str,
help='name of checkpoint.',
)
group.add_argument(
'--source-tensor-model-parallel-size',
type=int,
default=2,
help='original tensor model parallel size',
)
return parser |
Provide extra arguments required for merging. | def get_change_ckpt_args(parser):
"""Provide extra arguments required for merging."""
group = parser.add_argument_group(title='Mindspore to megatron')
group.add_argument(
'--npy-ckpt-path',
type=str,
required=True,
help='path of npy checkpoint.',
)
group.add_argument(
'--save-ckpt-path',
type=str,
required=True,
help='path to save checkpoint.',
)
return parser |
Communicate tensors between stages. Used as helper method in other
communication methods that are used in megatron/schedules.py.
Takes the following arguments:
tensor_send_next: tensor to send to next rank (no tensor sent if
set to None).
tensor_send_prev: tensor to send to prev rank (no tensor sent if
set to None).
recv_prev: boolean for whether tensor should be received from
previous rank.
recv_next: boolean for whether tensor should be received from
next rank.
use_ring_exchange: boolean for whether torch.distributed.ring_exchange()
API should be used.
Returns:
(tensor_recv_prev, tensor_recv_next) | def _communicate(
tensor_send_next, tensor_send_prev, recv_prev, recv_next, use_ring_exchange=False
):
"""Communicate tensors between stages. Used as helper method in other
communication methods that are used in megatron/schedules.py.
Takes the following arguments:
tensor_send_next: tensor to send to next rank (no tensor sent if
set to None).
tensor_send_prev: tensor to send to prev rank (no tensor sent if
set to None).
recv_prev: boolean for whether tensor should be received from
previous rank.
recv_next: boolean for whether tensor should be received from
next rank.
use_ring_exchange: boolean for whether torch.distributed.ring_exchange()
API should be used.
Returns:
(tensor_recv_prev, tensor_recv_next)
"""
args = get_args()
# Create placeholder tensors for receive in forward and backward directions
# if needed.
tensor_recv_prev = None
tensor_recv_next = None
tensor_shape = (args.seq_length, args.micro_batch_size, args.hidden_size)
if args.scatter_gather_tensors_in_pipeline:
tensor_chunk_shape = (
reduce(operator.mul, tensor_shape, 1)
// mpu.get_tensor_model_parallel_world_size()
)
else:
tensor_chunk_shape = tensor_shape
dtype = args.params_dtype
if args.fp32_residual_connection:
dtype = torch.float
if recv_prev:
tensor_recv_prev = torch.empty(
tensor_chunk_shape,
requires_grad=True,
device=torch.cuda.current_device(),
dtype=dtype,
)
if recv_next:
tensor_recv_next = torch.empty(
tensor_chunk_shape,
requires_grad=True,
device=torch.cuda.current_device(),
dtype=dtype,
)
# Split tensor into smaller chunks if using scatter-gather optimization.
if args.scatter_gather_tensors_in_pipeline:
if tensor_send_next is not None:
tensor_send_next = mpu.split_tensor_into_1d_equal_chunks(tensor_send_next)
if tensor_send_prev is not None:
tensor_send_prev = mpu.split_tensor_into_1d_equal_chunks(tensor_send_prev)
# Send tensors in both the forward and backward directions as appropriate.
if use_ring_exchange:
torch.distributed.ring_exchange(
tensor_send_prev=tensor_send_prev,
tensor_recv_prev=tensor_recv_prev,
tensor_send_next=tensor_send_next,
tensor_recv_next=tensor_recv_next,
group=mpu.get_pipeline_model_parallel_group(),
)
else:
ops = []
if tensor_send_prev is not None:
send_prev_op = torch.distributed.P2POp(
torch.distributed.isend,
tensor_send_prev,
mpu.get_pipeline_model_parallel_prev_rank(),
)
ops.append(send_prev_op)
if tensor_recv_prev is not None:
recv_prev_op = torch.distributed.P2POp(
torch.distributed.irecv,
tensor_recv_prev,
mpu.get_pipeline_model_parallel_prev_rank(),
)
ops.append(recv_prev_op)
if tensor_send_next is not None:
send_next_op = torch.distributed.P2POp(
torch.distributed.isend,
tensor_send_next,
mpu.get_pipeline_model_parallel_next_rank(),
)
ops.append(send_next_op)
if tensor_recv_next is not None:
recv_next_op = torch.distributed.P2POp(
torch.distributed.irecv,
tensor_recv_next,
mpu.get_pipeline_model_parallel_next_rank(),
)
ops.append(recv_next_op)
if len(ops) > 0:
reqs = torch.distributed.batch_isend_irecv(ops)
for req in reqs:
req.wait()
# To protect against race condition when using batch_isend_irecv().
torch.cuda.synchronize()
# If using scatter-gather optimization, gather smaller chunks.
if args.scatter_gather_tensors_in_pipeline:
if recv_prev:
tensor_recv_prev = (
mpu.gather_split_1d_tensor(tensor_recv_prev)
.view(tensor_shape)
.requires_grad_()
)
if recv_next:
tensor_recv_next = (
mpu.gather_split_1d_tensor(tensor_recv_next)
.view(tensor_shape)
.requires_grad_()
)
return tensor_recv_prev, tensor_recv_next |
Receive tensor from previous rank in pipeline (forward receive). | def recv_forward(timers=None):
"""Receive tensor from previous rank in pipeline (forward receive)."""
if mpu.is_pipeline_first_stage():
input_tensor = None
else:
if timers is not None:
timers("forward-recv").start()
input_tensor, _ = _communicate(
tensor_send_next=None,
tensor_send_prev=None,
recv_prev=True,
recv_next=False,
)
if timers is not None:
timers("forward-recv").stop()
return input_tensor |
Receive tensor from next rank in pipeline (backward receive). | def recv_backward(timers=None):
"""Receive tensor from next rank in pipeline (backward receive)."""
if mpu.is_pipeline_last_stage():
output_tensor_grad = None
else:
if timers is not None:
timers("backward-recv").start()
_, output_tensor_grad = _communicate(
tensor_send_next=None,
tensor_send_prev=None,
recv_prev=False,
recv_next=True,
)
if timers is not None:
timers("backward-recv").stop()
return output_tensor_grad |
Send tensor to next rank in pipeline (forward send). | def send_forward(output_tensor, timers=None):
"""Send tensor to next rank in pipeline (forward send)."""
if not mpu.is_pipeline_last_stage():
if timers is not None:
timers("forward-send").start()
_communicate(
tensor_send_next=output_tensor,
tensor_send_prev=None,
recv_prev=False,
recv_next=False,
)
if timers is not None:
timers("forward-send").stop() |
Send tensor to previous rank in pipeline (backward send). | def send_backward(input_tensor_grad, timers=None):
"""Send tensor to previous rank in pipeline (backward send)."""
if not mpu.is_pipeline_first_stage():
if timers is not None:
timers("backward-send").start()
_communicate(
tensor_send_next=None,
tensor_send_prev=input_tensor_grad,
recv_prev=False,
recv_next=False,
)
if timers is not None:
timers("backward-send").stop() |
Batched send and recv with next rank in pipeline. | def send_forward_recv_backward(output_tensor, timers=None):
"""Batched send and recv with next rank in pipeline."""
if mpu.is_pipeline_last_stage():
output_tensor_grad = None
else:
if timers is not None:
timers("forward-send-backward-recv").start()
_, output_tensor_grad = _communicate(
tensor_send_next=output_tensor,
tensor_send_prev=None,
recv_prev=False,
recv_next=True,
)
if timers is not None:
timers("forward-send-backward-recv").stop()
return output_tensor_grad |
Batched send and recv with previous rank in pipeline. | def send_backward_recv_forward(input_tensor_grad, timers=None):
"""Batched send and recv with previous rank in pipeline."""
if mpu.is_pipeline_first_stage():
input_tensor = None
else:
if timers is not None:
timers("backward-send-forward-recv").start()
input_tensor, _ = _communicate(
tensor_send_next=None,
tensor_send_prev=input_tensor_grad,
recv_prev=True,
recv_next=False,
)
if timers is not None:
timers("backward-send-forward-recv").stop()
return input_tensor |
Batched recv from previous rank and send to next rank in pipeline. | def send_forward_recv_forward(output_tensor, recv_prev, timers=None):
"""Batched recv from previous rank and send to next rank in pipeline."""
if timers is not None:
timers("forward-send-forward-recv").start()
input_tensor, _ = _communicate(
tensor_send_next=output_tensor,
tensor_send_prev=None,
recv_prev=recv_prev,
recv_next=False,
)
if timers is not None:
timers("forward-send-forward-recv").stop()
return input_tensor |
Batched recv from next rank and send to previous rank in pipeline. | def send_backward_recv_backward(input_tensor_grad, recv_next, timers=None):
"""Batched recv from next rank and send to previous rank in pipeline."""
if timers is not None:
timers("backward-send-backward-recv").start()
_, output_tensor_grad = _communicate(
tensor_send_next=None,
tensor_send_prev=input_tensor_grad,
recv_prev=False,
recv_next=recv_next,
)
if timers is not None:
timers("backward-send-backward-recv").stop()
return output_tensor_grad |
Batched send and recv with previous and next ranks in pipeline. | def send_forward_backward_recv_forward_backward(
output_tensor, input_tensor_grad, recv_prev, recv_next, timers=None
):
"""Batched send and recv with previous and next ranks in pipeline."""
if timers is not None:
timers("forward-backward-send-forward-backward-recv").start()
input_tensor, output_tensor_grad = _communicate(
tensor_send_next=output_tensor,
tensor_send_prev=input_tensor_grad,
recv_prev=recv_prev,
recv_next=recv_next,
)
if timers is not None:
timers("forward-backward-send-forward-backward-recv").stop()
return input_tensor, output_tensor_grad |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.