def run_model():
parser = argparse.ArgumentParser()
parser.add_argument('--model_name_or_path', type=str, default='', help='pretrained model name or path to local checkpoint')
parser.add_argument("--seed", type=int, default=42)
parser.add_argument("--load_checkpoint", '-c', type=str, default='')
parser.add_argument("--fp16", type=boolean_string, default=False)
parser.add_argument("--max_seq_length", type=int, default=128)
parser.add_argument("--generation_length", type=int, default=20)
parser.add_argument("--max_history", type=int, default=2)
parser.add_argument("--temperature", type=float, default=1)
parser.add_argument("--top_k", type=int, default=0)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument('--use_gpu', action='store_true')
parser.add_argument("--gpu", type=int, default=0)
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
device = torch.device("cuda" if torch.cuda.is_available() and args.use_gpu else "cpu")
n_gpu = torch.cuda.device_count()
args.device, args.n_gpu = device, n_gpu
np.random.seed(args.seed)
torch.random.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
#### load the GPT-2 model
config = GPT2Config.from_json_file(os.path.join(args.model_name_or_path, 'config.json'))
enc = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
model = load_model(GPT2LMHeadModel(config), args.load_checkpoint, args, verbose=True)
model.to(device)
model.eval()
history = []
while True:
raw_text = input("USR >>> ")
while not raw_text:
print('Prompt should not be empty!')
raw_text = input("USR >>> ")
if raw_text.lower() == 'quit':
print('SYS >>> Goodbye!')
break
history.append(raw_text)
context_tokens = sum([enc.encode(h) + [EOS_ID] for h in history],[]) #+ [EOS_ID]
context_tokens = torch.tensor(context_tokens, device=device, dtype=torch.long).unsqueeze(0)
position_ids = torch.arange(0, context_tokens.size(-1), dtype=torch.long, device=context_tokens.device)
out = generate_sequence(model, context_tokens, position_ids=position_ids,
length=args.generation_length, temperature=args.temperature,
top_k=args.top_k, top_p= args.top_p)
out = out.tolist()
text = enc.decode(cut_seq_to_eos(out[0])).encode('ascii','ignore').decode('ascii')
print("SYS >>> ", text)
history.append(text)
history = history[-(2*args.max_history+1):]
def evaluate_models_from(GPT_saved_models_folder, eval_file, enc, args):
# Prepare eval data
eval_dataloader_loss = DynamicBatchingLoader(eval_file, enc,
args.normalize_data,
args.eval_batch_size,
args.max_seq_length)
eval_dataloader_gen = get_eval_list_same_length(eval_file, enc,
args.eval_batch_size, True)
# read eval_loss log file
eval_loss_log_file = os.path.join(GPT_saved_models_folder, "eval_log.txt")
min_ckpt_old_perplexity = None
min_ckpt_new_perplexity = None
min_old_perplexity = 1000000.0
min_new_perplexity = 1000000.0
with open(eval_loss_log_file, "r") as reader:
head_row = next(reader)
for line in reader:
line = line.strip()
epoch, ckpt_no, _, loss, perplexity = line.split(",")
epoch = int(epoch)
ckpt_no = int(ckpt_no) - 1
loss = float(loss)
perplexity = float(perplexity)
print(ckpt_no, loss, perplexity, end="")
if min_old_perplexity > perplexity:
min_old_perplexity = perplexity
min_ckpt_old_perplexity = ckpt_no
# calculate new loss and perplexity
model_filename = "GP2-pretrain-step-{}.pkl"
model = load_model(GPT2LMHeadModel(config),
os.path.join(GPT_saved_models_folder,
model_filename.format(ckpt_no)),
args,
verbose=True)
eval_loss, eval_ppl = eval_model_loss(model, enc,
eval_dataloader_loss, epoch,
args)
if min_new_perplexity > eval_ppl:
min_new_perplexity = eval_ppl
min_ckpt_new_perplexity = ckpt_no
print("Old best ckpt and perplexity:", min_ckpt_old_perplexity,
min_old_perplexity)
print("New best ckpt and perplexity:", min_ckpt_new_perplexity,
min_new_perplexity)
return min_ckpt_old_perplexity, min_old_perplexity, min_ckpt_new_perplexity, min_new_perplexity
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--telegram_token', type=str, help='Telegram token')
parser.add_argument('--model_name_or_path', type=str, default='', help='pretrained model name or path to local checkpoint')
parser.add_argument('--tokenizer-path', type=str, help='Path to vocabulary')
parser.add_argument("--seed", type=int, default=42)
parser.add_argument("--load_checkpoint", '-c', type=str, default='')
parser.add_argument("--fp16", type=boolean_string, default=False)
parser.add_argument("--max_seq_length", type=int, default=128)
parser.add_argument("--generation_length", type=int, default=20)
parser.add_argument("--max_history", type=int, default=3)
parser.add_argument("--temperature", type=float, default=1)
parser.add_argument("--top_k", type=int, default=0)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument('--use_gpu', action='store_true')
parser.add_argument("--gpu", type=int, default=0)
parser.add_argument('--proxy_url', type=str, help='Proxy URL')
parser.add_argument('--proxy_user', type=str, help='Proxy user')
parser.add_argument('--proxy_password', type=str, help='Proxy password')
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
device = torch.device("cuda" if torch.cuda.is_available() and args.use_gpu else "cpu")
n_gpu = torch.cuda.device_count()
args.device, args.n_gpu = device, n_gpu
np.random.seed(args.seed)
torch.random.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
#### load the GPT-2 model
model_config = GPT2Config.from_json_file(os.path.join(args.model_name_or_path, 'config.json'))
tokenizer = RubertaTokenizer(vocab_file=args.tokenizer_path)
model = load_model(GPT2LMHeadModel(model_config), args.load_checkpoint, args, verbose=True)
model.to(device)
model.eval()
# Run Telegram bot
bot = TelegramBot(model, tokenizer, args)
bot.run_chat()
def convert_to_dialogpt(args):
config = GPT2Config.from_json_file(args.config_path)
model = load_model(GPT2LMHeadModel(config), None, args, verbose=True)
model_state_dict = torch.load(args.megatron_checkpoint_path)
model_state_dict = fix_state_dict_namespace(model_state_dict['model'])
model_state_dict = fix_model_shapes(model_state_dict)
start_model = model
if (hasattr(model, "transformer")
and all(not s.startswith('transformer.')
for s in model_state_dict.keys())):
logger.info('loading transfomer only')
start_model = model.transformer
start_model.load_state_dict(model_state_dict)
torch.save(start_model.state_dict(), args.dialogpt_output_path)
# args.train_input_file, args.train_batch_size,
# args.max_seq_length)
eval_dataloader_loss = DynamicBatchingLoader(args.eval_input_file, enc,
args.normalize_data,
args.eval_batch_size,
args.max_seq_length)
eval_dataloader_gen = get_eval_list_same_length(args.eval_input_file, enc,
args.eval_batch_size, True)
#########################################################################
# Prepare Model and Optimizer
##########################################################################
model = load_model(GPT2LMHeadModel(config),
args.init_checkpoint,
args,
verbose=True)
if args.local_rank != -1:
# when from scratch make sure initial models are the same
params = [p.data for p in model.parameters()]
all_reduce_and_rescale_tensors(params,
float(torch.distributed.get_world_size()))
model_parameters = filter(lambda p: p.requires_grad, model.parameters())
total_params = sum([np.prod(p.size()) for p in model_parameters])
logger.info('Number of parameter = {}'.format(total_params))
param_optimizer = list(model.named_parameters())
no_decay = ['bias', 'ln'] # no decay for bias and LayerNorm (ln)
optimizer_grouped_parameters = [{
'params':
def run_model():
print(socket.gethostname())
parser = argparse.ArgumentParser()
parser.add_argument(
'--model_name_or_path',
type=str,
default='',
help='pretrained model name or path to local checkpoint')
parser.add_argument("--seed", type=int, default=42)
parser.add_argument("--load_checkpoint", '-c', type=str, default='')
parser.add_argument("--fp16", type=boolean_string, default=False)
parser.add_argument("--test_file",
'-t',
type=str,
default=None,
help='input file for testing')
parser.add_argument("--output_file",
'-o',
type=str,
default=None,
help='output file for testing')
parser.add_argument("--normalize_data", type=boolean_string, default=True)
parser.add_argument("--batch_size", '-b', type=int, default=256)
parser.add_argument("--max_seq_length", type=int, default=512)
parser.add_argument("--no_token_id", action='store_true')
parser.add_argument("--no_attn_mask", action='store_true')
parser.add_argument("--no_eos", action='store_true')
parser.add_argument("--generation_length", type=int, default=20)
parser.add_argument("--temperature", type=float, default=1)
parser.add_argument("--top_k", type=int, default=0)
parser.add_argument('--unconditional',
action='store_true',
help='If true, unconditional generation.')
parser.add_argument('--is_sampling',
action='store_true',
help='If true, sampling for generation.')
parser.add_argument('--output_ref',
action='store_true',
help='If true, output ref')
#BEAM
parser.add_argument("--beam",
action='store_true',
help='If true, beam search')
parser.add_argument("--beam_width", type=int, default=1)
parser.add_argument('--use_gpu', action='store_true')
parser.add_argument("--gpu", type=int, default=0)
parser.add_argument('--config', help='JSON config file')
parser.add_argument('--eval', action='store_true')
parser.add_argument('--cstr_decode', action='store_true')
parser.add_argument("--bonus", type=float, default=0.0)
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
if args.config is not None:
# override argparse defaults by config JSON
opts = json.load(open(args.config))
for k, v in opts.items():
if isinstance(v, str):
# PHILLY ENV special cases
if 'PHILLY_JOB_DIRECTORY' in v:
v = v.replace('PHILLY_JOB_DIRECTORY',
os.environ['PHILLY_JOB_DIRECTORY'])
elif 'PHILLY_LOG_DIRECTORY' in v:
v = v.replace('PHILLY_LOG_DIRECTORY',
os.environ['PHILLY_LOG_DIRECTORY'])
setattr(args, k, v)
# command line should override config JSON
argv = sys.argv[1:]
overrides, _ = parser.parse_known_args(argv)
for k, v in vars(overrides).items():
if f'--{k}' in argv:
setattr(args, k, v)
# setattr(args, 'local_rank', overrides.local_rank)
# do normal parsing
device = torch.device(
"cuda" if torch.cuda.is_available() and args.use_gpu else "cpu")
n_gpu = torch.cuda.device_count()
args.device, args.n_gpu = device, n_gpu
print(args)
np.random.seed(args.seed)
torch.random.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
config = GPT2Config.from_json_file(
os.path.join(args.model_name_or_path, 'config.json'))
enc = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
model = load_model(GPT2LMHeadModel(config),
args.load_checkpoint,
args,
verbose=True)
model.to(device)
model.eval()
if args.test_file:
eval_dataloader = get_eval_list_same_length_with_order(
args.test_file, enc, args.batch_size, True)
model.eval()
outs = []
targets = []
loss_all = []
ppl_all = []
sources = []
conv_ids = []
with torch.no_grad():
with tqdm.tqdm(total=len(eval_dataloader), desc=f"Test") as pbar:
for step, batch in enumerate(
tqdm.tqdm(eval_dataloader, desc="Iteration")):
new_batch = []
for t in batch:
if isinstance(t, list):
new_batch.append(t)
else:
new_batch.append(t.to(device))
input_ids, position_ids, token_ids, attn_masks, label_ids, context_len, conv_id = new_batch
if args.no_token_id:
token_ids = None
if args.no_eos:
input_ids = input_ids[:, :-1]
if args.no_attn_mask:
attn_masks = None
if args.beam:
out = beam_search_naive(model,
input_ids,
position_ids=position_ids,
token_type_ids=token_ids,
attn_masks=attn_masks,
length=args.generation_length,
beam_width=args.beam_width,
device=args.device,
use_bonus=args.cstr_decode,
bonus=args.bonus,
enc=enc)
else:
out = generate_sequence(model,
input_ids,
position_ids=position_ids,
token_type_ids=token_ids,
attn_masks=attn_masks,
length=args.generation_length,
start_token=None,
temperature=args.temperature,
top_k=args.top_k,
sample=args.is_sampling,
use_bonus=args.cstr_decode,
bonus=args.bonus,
enc=enc)
sources.extend(input_ids.cpu().numpy())
out = out.tolist()
outs.extend(out)
targets.extend(label_ids)
conv_ids.extend(conv_id.cpu().numpy())
conv_id_map = {conv_ids[i]: i for i in range(len(conv_ids))}
val_src = [
enc.decode(
cut_seq_to_eos(s)).encode('utf-8').decode('utf-8')
for s in sources
]
#print(len(val_src),len(targets))
val_set = [
enc.decode(s).encode('utf-8').decode('utf-8')
for s in targets
]
gen = [
enc.decode(
cut_seq_to_eos(s)).encode('utf-8').decode('utf-8')
for s in outs
]
val_src_orders = [
val_src[conv_id_map[i]] for i in sorted(conv_id_map)
]
val_set_orders = [
val_set[conv_id_map[i]] for i in sorted(conv_id_map)
]
gen_orders = [gen[conv_id_map[i]] for i in sorted(conv_id_map)]
print("=" * 40 + " SAMPLE " + "=" * 40)
src = enc.decode([
x for x in input_ids[-1].cpu().numpy() if x != 0
]).encode('utf-8').decode('utf-8')
gt = val_set[-1]
resp = gen[-1]
print(
f"Source: \t {src} \n Oracle: \t {gt} \n Resp: \t {resp}\n"
)
if args.output_file:
with open(args.output_file + '.resp.txt', "w") as resp_f:
for i, r in enumerate(gen_orders):
r = re.sub("\n", "", r)
if args.output_ref:
# import pdb; pdb.set_trace()
resp_f.write(val_src_orders[i] + '\t' +
val_set_orders[i] + '\t' + r +
'\n')
else:
resp_f.write(r + '\n')
print("=" * 80)
sys.stdout.flush()
else:
generated = 0
while True:
raw_text = input("Model prompt >>> ")
while not raw_text:
print('Prompt should not be empty!')
raw_text = input("Model prompt >>> ")
context_tokens = enc.encode(raw_text) + [EOS_ID]
context_tokens = torch.tensor(context_tokens,
device=device,
dtype=torch.long).unsqueeze(
0) #.repeat(batch_size, 1)
generated += 1
position_ids = torch.arange(0,
context_tokens.size(-1),
dtype=torch.long,
device=context_tokens.device)
token_ids = None if args.no_token_id else torch.zeros_like(
context_tokens, dtype=torch.long, device=context_tokens.device)
if args.beam:
out = beam_search_naive(model,
context_tokens,
position_ids=None,
token_type_ids=token_ids,
length=args.generation_length,
beam_width=args.beam_width,
device=args.device)
else:
out = generate_sequence(model,
context_tokens,
position_ids=None,
token_type_ids=token_ids,
length=args.generation_length,
start_token=None,
temperature=args.temperature,
top_k=args.top_k,
sample=args.is_sampling)
out = out.tolist()
text = enc.decode(cut_seq_to_eos(
out[0])).encode('utf-8').decode('utf-8')
print("=" * 40 + " RESPONSE " + str(generated) + " " + "=" * 40)
print(text)
print("=" * 80)
tokenizer = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
# load
config = GPT2Config.from_json_file(
os.path.join(args.model_name_or_path, 'config.json'))
config.no_token_id = args.no_token_id
config.persona_emb_type = args.persona_emb_type
config.PersonaNum = args.PersonaNum
config.do_persona_linear = args.do_persona_linear
config.persona_n_embd = args.persona_n_embd
args.n_gpu = 1
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
args.device = device
model = load_model(GPT2LMHeadModel(config), model_file, args, verbose=True)
# fix misused key value
model.eval()
model.to('cuda')
# decode_size = len(open(decode_file,'rU').readlines())
output_lines = []
# with open(decode_file,'r') as fin:
with codecs.open(decode_file, 'r', encoding='utf-8') as fin:
print(decode_file)
lines = fin.readlines()
assert args.decode_num <= len(lines)
if args.decode_num == -1:
decode_size = len(lines)
else:
def run_model():
parser = argparse.ArgumentParser()
parser.add_argument(
'--model_name_or_path',
type=str,
default='',
help='pretrained model name or path to local checkpoint')
parser.add_argument("--seed", type=int, default=42)
parser.add_argument("--load_checkpoint", '-c', type=str, default='')
parser.add_argument("--fp16", type=boolean_string, default=False)
parser.add_argument("--max_seq_length", type=int, default=128)
parser.add_argument("--generation_length", type=int, default=20)
parser.add_argument("--max_history", type=int, default=2)
parser.add_argument("--temperature", type=float, default=1)
parser.add_argument("--top_k", type=int, default=0)
parser.add_argument("--top_p", type=float, default=0.9)
parser.add_argument('--use_gpu', action='store_true')
parser.add_argument("--gpu", type=int, default=0)
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
device = torch.device(
"cuda" if torch.cuda.is_available() and args.use_gpu else "cpu")
n_gpu = torch.cuda.device_count()
args.device, args.n_gpu = device, n_gpu
np.random.seed(args.seed)
torch.random.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
#### load the GPT-2 model
config = GPT2Config.from_json_file(
os.path.join(args.model_name_or_path, 'config.json'))
enc = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
model = load_model(GPT2LMHeadModel(config),
args.load_checkpoint,
args,
verbose=True)
model.to(device)
model.eval()
bot = DialogptIrcBot(CHANNEL, NICKNAME, REALNAME, SERVER, PORT)
thread_dialog = threading.Thread(target=bot.start)
thread_dialog.setDaemon(True)
thread_dialog.start()
history = []
sleep(1)
while bot.alive:
a = 0
num = bot.num
if bot.quest_rep:
if len(bot.quest_rep) == num + 1:
if len(bot.quest_rep[num]) == 1:
a = 1
question = bot.quest_rep[num][0]
if a == 1:
try:
history.append(question)
context_tokens = sum(
[enc.encode(h) + [EOS_ID] for h in history], [])
context_tokens = torch.tensor(context_tokens,
device=device,
dtype=torch.long).unsqueeze(0)
position_ids = torch.arange(0,
context_tokens.size(-1),
dtype=torch.long,
device=context_tokens.device)
out = generate_sequence(model,
context_tokens,
position_ids=position_ids,
length=args.generation_length,
temperature=args.temperature,
top_k=args.top_k,
top_p=args.top_p)
out = out.tolist()
text = enc.decode(cut_seq_to_eos(out[0])).encode(
'ascii', 'ignore').decode('ascii')
history.append(text)
history = history[-(2 * args.max_history + 1):]
except:
text = "Je ne comprends pas la question!"
# Envoi de la réponse
print("\nQuestion n°:", num)
print("Question:", bot.quest_rep[num])
print("Response:", text)
bot.quest_rep[num].append(text)
# eval_dataloader_loss = DynamicBatchingLoader(
# args.eval_input_file, enc, args.normalize_data,
# args.eval_batch_size, args.max_seq_length)
# eval_dataloader_gen = get_eval_list_same_length(
# args.eval_input_file, enc, args.eval_batch_size, True)
#########################################################################
# Prepare Model and Optimizer
##########################################################################
gpt2_model = GPT2LMHeadModel.from_pretrained(args.model_name_or_path)
gpt2_model.resize_token_embeddings(len(enc))
model = load_model(gpt2_model, args.init_checkpoint, args, verbose=True)
if args.local_rank != -1:
# when from scratch make sure initial models are the same
params = [p.data for p in model.parameters()]
all_reduce_and_rescale_tensors(params,
float(torch.distributed.get_world_size()))
model_parameters = filter(lambda p: p.requires_grad, model.parameters())
total_params = sum([np.prod(p.size()) for p in model_parameters])
logger.info('Number of parameter = {}'.format(total_params))
param_optimizer = list(model.named_parameters())
no_decay = ['bias', 'ln'] # no decay for bias and LayerNorm (ln)
optimizer_grouped_parameters = [{
'params':
[p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],
device = torch.device(
"cuda" if torch.cuda.is_available() and use_gpu else "cpu")
n_gpu = torch.cuda.device_count()
fp16 = False
np.random.seed(42)
torch.random.manual_seed(42)
torch.cuda.manual_seed(42)
#### load the GPT-2 model
config = GPT2Config.from_json_file(
os.path.join(model_name_or_path, 'config.json'))
enc = GPT2Tokenizer.from_pretrained(model_name_or_path)
model = load_model(GPT2LMHeadModel(config),
load_checkpoint,
n_gpu,
device,
fp16,
verbose=True)
model.to(device)
model.eval()
history = []
while True:
raw_text = input("USR >>> ")
while not raw_text:
print('Prompt should not be empty!')
raw_text = input("USR >>> ")
history.append(raw_text)
context_tokens = sum([enc.encode(h) + [EOS_ID] for h in history],
[]) #+ [EOS_ID]
context_tokens = torch.tensor(context_tokens,
