def predict_token(tokens_tensors):
# Load pre-trained model (weights)
model = TransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103')
model.eval()
# If you have a GPU, put everything on cuda
if torch.cuda.is_available():
for i, tt in enumerate(tokens_tensors):
tokens_tensors[i] = tokens_tensors[i].to('cuda')
model.to('cuda')
with torch.no_grad():
# Predict all tokens
mems = None
all_predictions = []
for i, tt in enumerate(tokens_tensors):
#predictions, mems = model(tt)
# We can re-use the memory cells in a subsequent call to attend a longer context
#predictions_2, mems_2 = model(tokens_tensor_2, mems=mems_1)
predictions, mems = model(tt, mems=mems)
all_predictions.append(predictions)
# get the predicted last token
predicted_index = torch.argmax(all_predictions[-1][0, -1, :]).item()
predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0]
#assert predicted_token == 'who'
return predicted_token
def create_transfo_xl_lm_head(self, config, input_ids_1, input_ids_2,
lm_labels):
model = TransfoXLLMHeadModel(config)
model.eval()
loss_1, mems_1a = model(input_ids_1, target=lm_labels)
lm_logits_1, mems_1b = model(input_ids_1)
loss_2, mems_2a = model(input_ids_2,
target=lm_labels,
mems=mems_1a)
lm_logits_2, mems_2b = model(input_ids_2, mems=mems_1b)
outputs = {
"loss_1": loss_1,
"mems_1a": mems_1a,
"lm_logits_1": lm_logits_1,
"mems_1b": mems_1b,
"loss_2": loss_2,
"mems_2a": mems_2a,
"lm_logits_2": lm_logits_2,
"mems_2b": mems_2b,
}
return outputs
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--batch_size',default=1,type=int,help='Batch size for inference')
parser.add_argument('--model_name',default='transfo-xl-wt103',type=str,
help='Pre-trained model name')
parser.add_argument('--max_seq_length',default=128,type=int,
help='Maximum total input sequence length after tokenization')
args = parser.parse_args()
input_ids = torch.zeros([args.batch_size,args.max_seq_length],dtype=torch.long)
model = TransfoXLLMHeadModel.from_pretrained(args.model_name)
torch.onnx.export(model,input_ids,'transfoxll_'+'batch'+str(args.batch_size)+'.onnx')
def TextGenerator(line):
tokenizer = TransfoXLTokenizer.from_pretrained('transfo-xl-wt103')
model = TransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103')
line_tokenized = tokenizer.tokenize(line)
line_indexed = tokenizer.convert_tokens_to_ids(line_tokenized)
tokens_tensor = torch.tensor([line_indexed])
max_predictions = 30
mems = None
l = []
for i in range(max_predictions):
predictions, mems = model(tokens_tensor, mems=mems)
predicted_index_tensor = torch.topk(predictions[0, -1, :], 5)[1][1]
predicted_index = predicted_index_tensor.item()
predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0]
print(predicted_token)
l.append(predicted_token)
tokens_tensor = torch.cat(
(tokens_tensor, predicted_index_tensor.reshape(1, 1)), dim=1)
s = " ".join(l)
return s
def __init__(self, args):
super().__init__()
if args.transformerxl_model_dir is not None:
model_name = args.transformerxl_model_dir
dict_file = model_name
print("Loading Transformer XL model from {}".format(model_name))
else:
model_name = args.transformerxl_model_name
dict_file = model_name
# Load pre-trained model tokenizer (vocabulary)
self.tokenizer = TransfoXLTokenizer.from_pretrained(dict_file)
self.vocab = list(self.tokenizer.idx2sym)
self._init_inverse_vocab()
self.eos_id = self.inverse_vocab[self.EOS_SYMBOL]
self.unk_symbol = self.UNK_SYMBOL
# Load pre-trained model (weights)
self.txl_model = TransfoXLLMHeadModel.from_pretrained(model_name)
self.txl_model.eval()
print(self.txl_model.config)
def main():
parser = argparse.ArgumentParser(
description='PyTorch Transformer Language Model')
parser.add_argument('--model_name',
type=str,
default='transfo-xl-wt103',
help='pretrained model name')
parser.add_argument('--split',
type=str,
default='test',
choices=['all', 'valid', 'test'],
help='which split to evaluate')
parser.add_argument('--batch_size',
type=int,
default=10,
help='batch size')
parser.add_argument('--tgt_len',
type=int,
default=128,
help='number of tokens to predict')
parser.add_argument('--ext_len',
type=int,
default=0,
help='length of the extended context')
parser.add_argument('--mem_len',
type=int,
default=1600,
help='length of the retained previous heads')
parser.add_argument('--clamp_len',
type=int,
default=1000,
help='max positional embedding index')
parser.add_argument('--no_cuda',
action='store_true',
help='Do not use CUDA even though CUA is available')
parser.add_argument('--work_dir',
type=str,
required=True,
help='path to the work_dir')
parser.add_argument('--no_log',
action='store_true',
help='do not log the eval result')
parser.add_argument('--same_length',
action='store_true',
help='set same length attention with masking')
parser.add_argument('--server_ip',
type=str,
default='',
help="Can be used for distant debugging.")
parser.add_argument('--server_port',
type=str,
default='',
help="Can be used for distant debugging.")
args = parser.parse_args()
assert args.ext_len >= 0, 'extended context length must be non-negative'
if args.server_ip and args.server_port:
# Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
import ptvsd
print("Waiting for debugger attach")
ptvsd.enable_attach(address=(args.server_ip, args.server_port),
redirect_output=True)
ptvsd.wait_for_attach()
device = torch.device(
"cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
logger.info("device: {}".format(device))
# Load a pre-processed dataset
# You can also build the corpus yourself using TransfoXLCorpus methods
# The pre-processing involve computing word frequencies to prepare the Adaptive input and SoftMax
# and tokenizing the dataset
# The pre-processed corpus is a convertion (using the conversion script )
corpus = TransfoXLCorpus.from_pretrained(args.model_name)
ntokens = len(corpus.vocab)
va_iter = corpus.get_iterator('valid',
args.batch_size,
args.tgt_len,
device=device,
ext_len=args.ext_len)
te_iter = corpus.get_iterator('test',
args.batch_size,
args.tgt_len,
device=device,
ext_len=args.ext_len)
# Load a pre-trained model
model = TransfoXLLMHeadModel.from_pretrained(args.model_name)
model = model.to(device)
logger.info(
'Evaluating with bsz {} tgt_len {} ext_len {} mem_len {} clamp_len {}'.
format(args.batch_size, args.tgt_len, args.ext_len, args.mem_len,
args.clamp_len))
model.reset_length(args.tgt_len, args.ext_len, args.mem_len)
if args.clamp_len > 0:
model.clamp_len = args.clamp_len
if args.same_length:
model.same_length = True
###############################################################################
# Evaluation code
###############################################################################
def evaluate(eval_iter):
# Turn on evaluation mode which disables dropout.
model.eval()
total_len, total_loss = 0, 0.
start_time = time.time()
with torch.no_grad():
mems = None
for idx, (data, target, seq_len) in enumerate(eval_iter):
ret = model(data, target, mems)
loss, mems = ret
loss = loss.mean()
total_loss += seq_len * loss.item()
total_len += seq_len
total_time = time.time() - start_time
logger.info('Time : {:.2f}s, {:.2f}ms/segment'.format(
total_time, 1000 * total_time / (idx + 1)))
return total_loss / total_len
# Run on test data.
if args.split == 'all':
test_loss = evaluate(te_iter)
valid_loss = evaluate(va_iter)
elif args.split == 'valid':
valid_loss = evaluate(va_iter)
test_loss = None
elif args.split == 'test':
test_loss = evaluate(te_iter)
valid_loss = None
def format_log(loss, split):
log_str = '| {0} loss {1:5.2f} | {0} ppl {2:9.3f} '.format(
split, loss, math.exp(loss))
return log_str
log_str = ''
if valid_loss is not None:
log_str += format_log(valid_loss, 'valid')
if test_loss is not None:
log_str += format_log(test_loss, 'test')
logger.info('=' * 100)
logger.info(log_str)
logger.info('=' * 100)
print(tokenizer.tokenize("who was jim henson ?"))
tokenized_text_2 = tokenizer.tokenize(text_2)
indexed_tokens_1 = tokenizer.convert_tokens_to_ids(tokenized_text_1); print(indexed_tokens_1) # [2517, 11, 1666, 12034, 788]
print(tokenizer.convert_tokens_to_ids(tokenizer.tokenize("who was jim henson ?"))) # [52, 11, 24, 24, 788]; 也是 case sensitive
indexed_tokens_2 = tokenizer.convert_tokens_to_ids(tokenized_text_2)
tokens_tensor_1 = torch.tensor([indexed_tokens_1])
tokens_tensor_2 = torch.tensor([indexed_tokens_2])
##################################################################
## TransfoXLModel
model = TransfoXLModel.from_pretrained('/Users/coder352/datasets/WordVec/pytorch_pretrained_bert/transfo-xl-wt103')
model.eval()
with torch.no_grad():
hidden_states_1, mems_1 = model(tokens_tensor_1) # Predict hidden states features for each layer
hidden_states_2, mems_2 = model(tokens_tensor_2, mems=mems_1) # We can re-use the memory cells in a subsequent call to attend a longer context
##################################################################
## TransfoXLLMHeadModel
model = TransfoXLLMHeadModel.from_pretrained('/Users/coder352/datasets/WordVec/pytorch_pretrained_bert/transfo-xl-wt103/')
model.eval()
with torch.no_grad():
predictions_1, mems_1 = model(tokens_tensor_1) # Predict all tokens
predictions_2, mems_2 = model(tokens_tensor_2, mems=mems_1) # We can re-use the memory cells in a subsequent call to attend a longer context
## get the predicted last token
predicted_index = torch.argmax(predictions_2[0, -1, :]).item(); print(predicted_index) # 52
predicted_token = tokenizer.convert_ids_to_tokens([predicted_index]); print(predicted_token) # ['who']
indexed_tokens_1 = tokenizer.convert_tokens_to_ids(tokenized_text_1)
indexed_tokens_2 = tokenizer.convert_tokens_to_ids(tokenized_text_2)
# Convert inputs to PyTorch tensors
tokens_tensor_1 = torch.tensor([indexed_tokens_1])
tokens_tensor_2 = torch.tensor([indexed_tokens_2])
# Load pre-trained model (weights)
model = TransfoXLModel.from_pretrained('transfo-xl-wt103')
model.eval()
with torch.no_grad():
# Predict hidden states features for each layer
hidden_states_1, mems_1 = model(tokens_tensor_1)
# We can re-use the memory cells in a subsequent call to attend a longer context
hidden_states_2, mems_2 = model(tokens_tensor_2, mems=mems_1)
# Load pre-trained model (weights)
model = TransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103')
model.eval()
with torch.no_grad():
# Predict all tokens
predictions_1, mems_1 = model(tokens_tensor_1)
# We can re-use the memory cells in a subsequent call to attend a longer context
predictions_2, mems_2 = model(tokens_tensor_2, mems=mems_1)
# get the predicted last token
predicted_index = torch.argmax(predictions_2[0, -1, :]).item()
predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0]
# assert predicted_token == 'who'