def main():
args = parse_arguments()
n_vocab = params.n_vocab
n_layer = params.n_layer
n_hidden = params.n_hidden
n_embed = params.n_embed
n_batch = args.n_batch
temperature = params.temperature
train_path = params.train_path
assert torch.cuda.is_available()
print("loading_data...")
# 训练时加载处理好的词典（如果有的话）
if os.path.exists("vocab.json"):
vocab = Vocabulary()
with open('vocab.json', 'r') as fp:
vocab.stoi = json.load(fp)
for key, value in vocab.stoi.items():
vocab.itos.append(key)
else:
vocab = build_vocab(train_path, n_vocab)
# save vocab
with open('vocab.json', 'w') as fp:
json.dump(vocab.stoi, fp)
train_X, train_y, train_K = load_data(train_path, vocab)
train_loader = get_data_loader(train_X, train_y, train_K, n_batch)
print("successfully loaded")
encoder = Encoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
Kencoder = KnowledgeEncoder(n_vocab, n_embed, n_hidden, n_layer,
vocab).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
if args.restore:
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
# ToDo：目前的代码所有的embedding都是独立的，可以参考transformer源码使用直接赋值的方法共享参数：
#if emb_src_trg_weight_sharing:
# self.encoder.src_word_emb.weight = self.decoder.trg_word_emb.weight
model = [encoder, Kencoder, manager, decoder]
parameters = list(encoder.parameters()) + list(Kencoder.parameters()) + \
list(manager.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(parameters, lr=args.lr)
# pre_train knowledge manager
print("start pre-training")
pre_train(model, optimizer, train_loader, args)
print("start training")
train(model, optimizer, train_loader, args)
# save final model
save_models(model, params.all_restore)
def main():
args = parse_arguments()
n_vocab = params.n_vocab
n_layer = params.n_layer
n_hidden = params.n_hidden
n_embed = params.n_embed
n_batch = args.n_batch
temperature = params.temperature
train_path = params.train_path
assert torch.cuda.is_available()
print("loading_data...")
vocab = build_vocab(train_path, n_vocab)
# save vocab
with open('vocab.json', 'w') as fp:
json.dump(vocab.stoi, fp)
train_X, train_y, train_K = load_data(train_path, vocab)
train_loader = get_data_loader(train_X, train_y, train_K, n_batch)
print("successfully loaded")
encoder = Encoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
Kencoder = KnowledgeEncoder(n_vocab, n_embed, n_hidden, n_layer,
vocab).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
if args.restore:
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
model = [encoder, Kencoder, manager, decoder]
parameters = list(encoder.parameters()) + list(Kencoder.parameters()) + \
list(manager.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(parameters, lr=args.lr)
# pre_train knowledge manager
print("start pre-training")
pre_train(model, optimizer, train_loader, args)
print("start training")
train(model, optimizer, train_loader, args)
# save final model
save_models(model, params.all_restore)
def main():
args = parse_arguments()
n_vocab = params.n_vocab
n_layer = params.n_layer
n_hidden = params.n_hidden
n_embed = params.n_embed
n_batch = args.n_batch
temperature = params.temperature
test_path = params.test_path
vocab_path = params.vocab_path
assert torch.cuda.is_available()
print("loading the vocab...")
vocab = Vocabulary()
with open(vocab_path, 'r',encoding='utf-8') as fp:
vocab.stoi = json.load(fp)
for key, value in vocab.stoi.items():
vocab.itos.append(key)
# load data and change to id
print("loading_data...")
test_X, test_y, test_K = load_data(test_path, vocab)
test_loader = get_data_loader(test_X, test_y, test_K, n_batch,False)
print("successfully loaded test data")
encoder = Encoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
Kencoder = KnowledgeEncoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
print("models successfully loaded!\n")
model = [encoder, Kencoder, manager, decoder]
#evaluate_loss(model, 0, test_loader)
evaluate_sample(model, vocab,test_X, test_y, test_K, test_loader)
def main():
args = parse_arguments()
n_vocab = params.n_vocab
n_layer = params.n_layer
n_hidden = params.n_hidden
n_embed = params.n_embed
n_batch = args.n_batch
temperature = params.temperature
test_path = params.test_path
assert torch.cuda.is_available()
print("loading_data...")
if os.path.exists("vocab.json"):
vocab = Vocabulary()
with open('vocab.json', 'r') as fp:
vocab.stoi = json.load(fp)
for key, value in vocab.stoi.items():
vocab.itos.append(key)
else:
train_path = params.train_path
vocab = build_vocab(train_path, n_vocab)
test_X, test_y, test_K = load_data(test_path, vocab)
test_loader = get_data_loader(test_X, test_y, test_K, n_batch)
print("successfully loaded")
encoder = Encoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
Kencoder = KnowledgeEncoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
model = [encoder, Kencoder, manager, decoder]
print("start evaluating")
evaluate(model, test_loader)
def main():
max_len = 50
n_vocab = params.n_vocab
n_layer = params.n_layer
n_hidden = params.n_hidden
n_embed = params.n_embed
temperature = params.temperature
assert torch.cuda.is_available()
if os.path.exists("data/vocab.json"):
vocab = Vocabulary()
with open('data/vocab.json', 'r') as fp:
vocab.stoi = json.load(fp)
for key, value in vocab.stoi.items():
vocab.itos.append(key)
else:
print("vocabulary doesn't exist!")
return
print("loading model...")
encoder = Encoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
Kencoder = KnowledgeEncoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_vocab, n_embed, n_hidden, n_layer).cuda()
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
print("successfully loaded!\n")
utterance = ""
while True:
if utterance == "exit":
break
k1 = input("Type first Knowledge: ").lower()
while not k1:
print("Please type first Knowledge.\n")
k1 = input("Type first Knowledge: ").lower()
k2 = input("Type second Knowledge: ").lower()
while not k2:
print("Please type second Knowledge.\n")
k2 = input("Type second Knowledge: ").lower()
k3 = input("Type third Knowledge: ").lower()
while not k3:
print("Please type third Knowledge.\n")
k3 = input("Type third Knowledge: ").lower()
K = [k1, k2, k3]
K = knowledgeToIndex(K, vocab)
K = Kencoder(K)
print()
while True:
utterance = input("you: ").lower()
while not utterance:
print("Please type utterance.\n")
utterance = input("you: ")
if utterance == "change knowledge" or utterance == "exit":
print()
break
X = []
tokens = nltk.word_tokenize(utterance)
for word in tokens:
if word in vocab.stoi:
X.append(vocab.stoi[word])
else:
X.append(vocab.stoi["<UNK>"])
X = torch.LongTensor(X).unsqueeze(0).cuda() # X: [1, x_seq_len]
encoder_outputs, hidden, x = encoder(X)
k_i = manager(x, None, K)
outputs = torch.zeros(
max_len, 1, n_vocab).cuda() # outputs: [max_len, 1, n_vocab]
hidden = hidden[decoder.n_layer:]
output = torch.LongTensor([params.SOS]).cuda()
for t in range(max_len):
output, hidden, attn_weights = decoder(output, k_i, hidden,
encoder_outputs)
outputs[t] = output
output = output.data.max(1)[1]
outputs = outputs.max(2)[1]
answer = ""
for idx in outputs:
if idx == params.EOS:
break
answer += vocab.itos[idx] + " "
print("bot:", answer[:-1], "\n")
def main():
args = parse_arguments()
n_vocab = params.n_vocab
n_layer = params.n_layer
n_hidden = params.n_hidden
n_embed = params.n_embed
n_batch = args.n_batch
temperature = params.temperature
train_path = params.train_path
#test_path = params.test_path
valid_path = params.valid_path
vocab_path = params.vocab_path
assert torch.cuda.is_available()
# print("building the vocab...")
# vocab = build_vocab_music(train_path, n_vocab)
# # save vocab
# print("saving the vocab...")
# with open(vocab_path, 'w',encoding='utf-8') as fp:
# json.dump(vocab.stoi, fp, ensure_ascii=False)
# load vocab
print("loading the vocab...")
vocab = Vocabulary()
with open(vocab_path, 'r',encoding='utf-8') as fp:
vocab.stoi = json.load(fp)
# load data and change to id
print("loading_data...")
train_X, train_y, train_K = load_data(train_path, vocab)
train_loader = get_data_loader(train_X, train_y, train_K, n_batch,True)
print("successfully loaded train data")
valid_X, valid_y, valid_K = load_data(valid_path, vocab)
valid_loader = get_data_loader(valid_X, valid_y, valid_K, n_batch,False)
print("successfully loaded valid data")
encoder = Encoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
Kencoder = KnowledgeEncoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_vocab, n_embed, n_hidden, n_layer, vocab).cuda()
if args.restore:
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
model = [encoder, Kencoder, manager, decoder]
parameters = list(encoder.parameters()) + list(Kencoder.parameters()) + \
list(manager.parameters()) + list(decoder.parameters())
optimizer = optim.Adam(parameters, lr=args.lr)
# pre_train knowledge manager
print("start pre-training")
pre_train(model, optimizer, train_loader,args)
print("start training")
train(model, optimizer, train_loader,valid_loader , args)
# save final model
save_models(model, params.all_restore)
def main():
max_len = 50
n_vocab = params.n_vocab
n_embed = params.n_embed
n_hidden = params.n_hidden
temperature = params.temperature
assert torch.cuda.is_available()
print("loading model...")
encoder = Encoder().cuda()
Kencoder = KnowledgeEncoder(n_hidden).cuda()
manager = Manager(n_hidden, n_vocab, temperature).cuda()
decoder = Decoder(n_hidden, n_embed, n_vocab).cuda()
encoder = init_model(encoder, restore=params.encoder_restore)
Kencoder = init_model(Kencoder, restore=params.Kencoder_restore)
manager = init_model(manager, restore=params.manager_restore)
decoder = init_model(decoder, restore=params.decoder_restore)
print("successfully loaded!\n")
utterance = ""
while True:
if utterance == "exit":
break
k1 = input("Type first Knowledge: ")
while not k1:
print("Please type first Knowledge.\n")
k1 = input("Type first Knowledge: ")
k2 = input("Type second Knowledge: ")
while not k2:
print("Please type second Knowledge.\n")
k2 = input("Type second Knowledge: ")
k3 = input("Type third Knowledge: ")
while not k3:
print("Please type third Knowledge.\n")
k3 = input("Type third Knowledge: ")
K = [k1, k2, k3]
K = knowledgeToIndex(K)
K = Kencoder(K)
print()
while True:
utterance = input("you: ")
while not utterance:
print("Please type utterance.\n")
utterance = input("you: ")
if utterance == "change knowledge" or utterance == "exit":
print()
break
tokens = tokenizer.tokenize(utterance)
seqs = tokenizer.convert_tokens_to_ids(tokens)
seqs.insert(0, params.CLS)
seqs.append(params.SEP)
X = torch.LongTensor(seqs).unsqueeze(0).cuda() # X: [1, x_seq_len]
mask = (X != 0).long()
encoder_outputs, hidden = encoder(X, mask)
k_i = manager(hidden, None, K)
outputs = torch.zeros(
max_len, 1, n_vocab).cuda() # outputs: [max_len, 1, n_vocab]
output = torch.LongTensor([params.SOS]).cuda()
hidden = hidden.unsqueeze(0)
for t in range(max_len):
output, hidden, attn_weights = decoder(output, k_i, hidden,
encoder_outputs)
outputs[t] = output
output = output.data.max(1)[1]
outputs = outputs.max(2)[1]
tokens = []
for idx in outputs:
idx = idx.item()
if idx == params.EOS:
break
tokens.append(tokenizer.convert_ids_to_tokens([idx])[0])
text = ' '.join([x for x in tokens])
answer = text.replace(' ##', '')
print("bot:", answer, "\n")