def __init__(self, model_path, model_name):
print("................................................")
print("LOADING Biaffine Model")
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
self.word_alpha, self.char_alpha, self.tag_alpha, self.type_alpha = conllx_data.create_alphabets(alphabet_path, None, data_paths=[None, None], max_vocabulary_size=50000, embedd_dict=None)
self.id2word = {v: k for k, v in self.word_alpha.instance2index.iteritems()}
num_words = self.word_alpha.size()
num_chars = self.char_alpha.size()
num_pos = self.tag_alpha.size()
num_types = self.type_alpha.size()
print("Word Alphabet Size: %d" % num_words)
print("Character Alphabet Size: %d" % num_chars)
print("POS Alphabet Size: %d" % num_pos)
print("Type Alphabet Size: %d" % num_types)
def load_model_arguments_from_json():
arguments = json.load(open(arg_path, 'r'))
return arguments['args'], arguments['kwargs']
arg_path = model_name + '.arg.json'
args, kwargs = load_model_arguments_from_json()
self.network = BiRecurrentConvBiAffine(*args, **kwargs)
self.network.load_state_dict(torch.load(model_name))
self.network.id2word = self.id2word
self.network.cuda()
self.network.eval()
def main():
args_parser = argparse.ArgumentParser(description='Tuning with graph-based parsing')
args_parser.add_argument('--test_phase', action='store_true', help='Load trained model and run testing phase.')
args_parser.add_argument('--mode', choices=['RNN', 'LSTM', 'GRU', 'FastLSTM'], help='architecture of rnn', required=True)
args_parser.add_argument('--cuda', action='store_true', help='using GPU')
args_parser.add_argument('--num_epochs', type=int, default=200, help='Number of training epochs')
args_parser.add_argument('--batch_size', type=int, default=64, help='Number of sentences in each batch')
args_parser.add_argument('--hidden_size', type=int, default=256, help='Number of hidden units in RNN')
args_parser.add_argument('--arc_space', type=int, default=128, help='Dimension of tag space')
args_parser.add_argument('--type_space', type=int, default=128, help='Dimension of tag space')
args_parser.add_argument('--num_layers', type=int, default=1, help='Number of layers of RNN')
args_parser.add_argument('--num_filters', type=int, default=50, help='Number of filters in CNN')
args_parser.add_argument('--pos', action='store_true', help='use part-of-speech embedding.')
args_parser.add_argument('--char', action='store_true', help='use character embedding and CNN.')
args_parser.add_argument('--pos_dim', type=int, default=50, help='Dimension of POS embeddings')
args_parser.add_argument('--char_dim', type=int, default=50, help='Dimension of Character embeddings')
args_parser.add_argument('--opt', choices=['adam', 'sgd', 'adamax'], help='optimization algorithm')
args_parser.add_argument('--objective', choices=['cross_entropy', 'crf'], default='cross_entropy', help='objective function of training procedure.')
args_parser.add_argument('--decode', choices=['mst', 'greedy'], help='decoding algorithm', required=True)
args_parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate')
args_parser.add_argument('--decay_rate', type=float, default=0.05, help='Decay rate of learning rate')
args_parser.add_argument('--clip', type=float, default=5.0, help='gradient clipping')
args_parser.add_argument('--gamma', type=float, default=0.0, help='weight for regularization')
args_parser.add_argument('--epsilon', type=float, default=1e-8, help='epsilon for adam or adamax')
args_parser.add_argument('--p_rnn', nargs=2, type=float, required=True, help='dropout rate for RNN')
args_parser.add_argument('--p_in', type=float, default=0.33, help='dropout rate for input embeddings')
args_parser.add_argument('--p_out', type=float, default=0.33, help='dropout rate for output layer')
args_parser.add_argument('--schedule', type=int, help='schedule for learning rate decay')
args_parser.add_argument('--unk_replace', type=float, default=0., help='The rate to replace a singleton word with UNK')
args_parser.add_argument('--punctuation', nargs='+', type=str, help='List of punctuations')
args_parser.add_argument('--word_embedding', choices=['glove', 'senna', 'sskip', 'polyglot'], help='Embedding for words', required=True)
args_parser.add_argument('--word_path', help='path for word embedding dict')
args_parser.add_argument('--freeze', action='store_true', help='frozen the word embedding (disable fine-tuning).')
args_parser.add_argument('--char_embedding', choices=['random', 'polyglot'], help='Embedding for characters', required=True)
args_parser.add_argument('--char_path', help='path for character embedding dict')
args_parser.add_argument('--train') # "data/POS-penn/wsj/split1/wsj1.train.original"
args_parser.add_argument('--dev') # "data/POS-penn/wsj/split1/wsj1.dev.original"
args_parser.add_argument('--test') # "data/POS-penn/wsj/split1/wsj1.test.original"
args_parser.add_argument('--model_path', help='path for saving model file.', required=True)
args_parser.add_argument('--model_name', help='name for saving model file.', required=True)
args = args_parser.parse_args()
logger = get_logger("GraphParser")
mode = args.mode
obj = args.objective
decoding = args.decode
train_path = args.train
dev_path = args.dev
test_path = args.test
model_path = args.model_path
model_name = args.model_name
num_epochs = args.num_epochs
batch_size = args.batch_size
hidden_size = args.hidden_size
arc_space = args.arc_space
type_space = args.type_space
num_layers = args.num_layers
num_filters = args.num_filters
learning_rate = args.learning_rate
opt = args.opt
momentum = 0.9
betas = (0.9, 0.9)
eps = args.epsilon
decay_rate = args.decay_rate
clip = args.clip
gamma = args.gamma
schedule = args.schedule
p_rnn = tuple(args.p_rnn)
p_in = args.p_in
p_out = args.p_out
unk_replace = args.unk_replace
punctuation = args.punctuation
freeze = args.freeze
word_embedding = args.word_embedding
word_path = args.word_path
use_char = args.char
char_embedding = args.char_embedding
char_path = args.char_path
use_pos = args.pos
pos_dim = args.pos_dim
word_dict, word_dim = utils.load_embedding_dict(word_embedding, word_path)
char_dict = None
char_dim = args.char_dim
if char_embedding != 'random':
char_dict, char_dim = utils.load_embedding_dict(char_embedding, char_path)
logger.info("Creating Alphabets")
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
word_alphabet, char_alphabet, pos_alphabet, type_alphabet = conllx_data.create_alphabets(alphabet_path, train_path, data_paths=[dev_path, test_path],
max_vocabulary_size=100000, embedd_dict=word_dict)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
logger.info("Reading Data")
device = torch.device('cuda') if args.cuda else torch.device('cpu')
data_train = conllx_data.read_data_to_tensor(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, symbolic_root=True, device=device)
# data_train = conllx_data.read_data(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
# num_data = sum([len(bucket) for bucket in data_train])
num_data = sum(data_train[1])
data_dev = conllx_data.read_data_to_tensor(dev_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, symbolic_root=True, device=device)
data_test = conllx_data.read_data_to_tensor(test_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, symbolic_root=True, device=device)
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" % (len(punct_set), ' '.join(punct_set)))
def construct_word_embedding_table():
scale = np.sqrt(3.0 / word_dim)
table = np.empty([word_alphabet.size(), word_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.zeros([1, word_dim]).astype(np.float32) if freeze else np.random.uniform(-scale, scale, [1, word_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in word_dict:
embedding = word_dict[word]
elif word.lower() in word_dict:
embedding = word_dict[word.lower()]
else:
embedding = np.zeros([1, word_dim]).astype(np.float32) if freeze else np.random.uniform(-scale, scale, [1, word_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('word OOV: %d' % oov)
return torch.from_numpy(table)
def construct_char_embedding_table():
if char_dict is None:
return None
scale = np.sqrt(3.0 / char_dim)
table = np.empty([num_chars, char_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(-scale, scale, [1, char_dim]).astype(np.float32)
oov = 0
for char, index, in char_alphabet.items():
if char in char_dict:
embedding = char_dict[char]
else:
embedding = np.random.uniform(-scale, scale, [1, char_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('character OOV: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
char_table = construct_char_embedding_table()
window = 3
if obj == 'cross_entropy':
network = BiRecurrentConvBiAffine(word_dim, num_words, char_dim, num_chars, pos_dim, num_pos, num_filters, window,
mode, hidden_size, num_layers, num_types, arc_space, type_space,
embedd_word=word_table, embedd_char=char_table,
p_in=p_in, p_out=p_out, p_rnn=p_rnn, biaffine=True, pos=use_pos, char=use_char)
elif obj == 'crf':
raise NotImplementedError
else:
raise RuntimeError('Unknown objective: %s' % obj)
def save_args():
arg_path = model_name + '.arg.json'
arguments = [word_dim, num_words, char_dim, num_chars, pos_dim, num_pos, num_filters, window,
mode, hidden_size, num_layers, num_types, arc_space, type_space]
kwargs = {'p_in': p_in, 'p_out': p_out, 'p_rnn': p_rnn, 'biaffine': True, 'pos': use_pos, 'char': use_char}
json.dump({'args': arguments, 'kwargs': kwargs}, open(arg_path, 'w'), indent=4)
if freeze:
freeze_embedding(network.word_embedd)
network = network.to(device)
save_args()
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
def generate_optimizer(opt, lr, params):
params = filter(lambda param: param.requires_grad, params)
if opt == 'adam':
return Adam(params, lr=lr, betas=betas, weight_decay=gamma, eps=eps)
elif opt == 'sgd':
return SGD(params, lr=lr, momentum=momentum, weight_decay=gamma, nesterov=True)
elif opt == 'adamax':
return Adamax(params, lr=lr, betas=betas, weight_decay=gamma, eps=eps)
else:
raise ValueError('Unknown optimization algorithm: %s' % opt)
lr = learning_rate
optim = generate_optimizer(opt, lr, network.parameters())
opt_info = 'opt: %s, ' % opt
if opt == 'adam':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
elif opt == 'sgd':
opt_info += 'momentum=%.2f' % momentum
elif opt == 'adamax':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
word_status = 'frozen' if freeze else 'fine tune'
char_status = 'enabled' if use_char else 'disabled'
pos_status = 'enabled' if use_pos else 'disabled'
logger.info("Embedding dim: word=%d (%s), char=%d (%s), pos=%d (%s)" % (word_dim, word_status, char_dim, char_status, pos_dim, pos_status))
logger.info("CNN: filter=%d, kernel=%d" % (num_filters, window))
logger.info("RNN: %s, num_layer=%d, hidden=%d, arc_space=%d, type_space=%d" % (mode, num_layers, hidden_size, arc_space, type_space))
logger.info("train: obj: %s, l2: %f, (#data: %d, batch: %d, clip: %.2f, unk replace: %.2f)" % (obj, gamma, num_data, batch_size, clip, unk_replace))
logger.info("dropout(in, out, rnn): (%.2f, %.2f, %s)" % (p_in, p_out, p_rnn))
logger.info("decoding algorithm: %s" % decoding)
logger.info(opt_info)
num_batches = num_data / batch_size + 1
dev_ucorrect = 0.0
dev_lcorrect = 0.0
dev_ucomlpete_match = 0.0
dev_lcomplete_match = 0.0
dev_ucorrect_nopunc = 0.0
dev_lcorrect_nopunc = 0.0
dev_ucomlpete_match_nopunc = 0.0
dev_lcomplete_match_nopunc = 0.0
dev_root_correct = 0.0
best_epoch = 0
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_root_correct = 0.0
test_total = 0
test_total_nopunc = 0
test_total_inst = 0
test_total_root = 0
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
patient = 0
decay = 0
max_decay = 9
double_schedule_decay = 5
for epoch in range(1, num_epochs + 1):
print('Epoch %d (%s, optim: %s, learning rate=%.6f, eps=%.1e, decay rate=%.2f (schedule=%d, patient=%d, decay=%d)): ' % (epoch, mode, opt, lr, eps, decay_rate, schedule, patient, decay))
train_err = 0.
train_err_arc = 0.
train_err_type = 0.
train_total = 0.
start_time = time.time()
num_back = 0
network.train()
for batch in range(1, num_batches + 1):
word, char, pos, heads, types, masks, lengths = conllx_data.get_batch_tensor(data_train, batch_size, unk_replace=unk_replace)
optim.zero_grad()
loss_arc, loss_type = network.loss(word, char, pos, heads, types, mask=masks, length=lengths)
loss = loss_arc + loss_type
loss.backward()
clip_grad_norm_(network.parameters(), clip)
optim.step()
with torch.no_grad():
num_inst = word.size(0) if obj == 'crf' else masks.sum() - word.size(0)
train_err += loss * num_inst
train_err_arc += loss_arc * num_inst
train_err_type += loss_type * num_inst
train_total += num_inst
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
# update log
if batch % 10 == 0:
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
log_info = 'train: %d/%d loss: %.4f, arc: %.4f, type: %.4f, time left: %.2fs' % (batch, num_batches, train_err / train_total,
train_err_arc / train_total, train_err_type / train_total, time_left)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print('train: %d loss: %.4f, arc: %.4f, type: %.4f, time: %.2fs' % (num_batches, train_err / train_total,
train_err_arc / train_total, train_err_type / train_total, time.time() - start_time))
# evaluate performance on dev data
with torch.no_grad():
network.eval()
pred_filename = 'tmp/%spred_dev%d' % (str(uid), epoch)
pred_writer.start(pred_filename)
gold_filename = 'tmp/%sgold_dev%d' % (str(uid), epoch)
gold_writer.start(gold_filename)
dev_ucorr = 0.0
dev_lcorr = 0.0
dev_total = 0
dev_ucomlpete = 0.0
dev_lcomplete = 0.0
dev_ucorr_nopunc = 0.0
dev_lcorr_nopunc = 0.0
dev_total_nopunc = 0
dev_ucomlpete_nopunc = 0.0
dev_lcomplete_nopunc = 0.0
dev_root_corr = 0.0
dev_total_root = 0.0
dev_total_inst = 0.0
for batch in conllx_data.iterate_batch_tensor(data_dev, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.cpu().numpy()
pos = pos.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.cpu().numpy()
types = types.cpu().numpy()
pred_writer.write(word, pos, heads_pred, types_pred, lengths, symbolic_root=True)
gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types,
word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
dev_ucorr += ucorr
dev_lcorr += lcorr
dev_total += total
dev_ucomlpete += ucm
dev_lcomplete += lcm
dev_ucorr_nopunc += ucorr_nopunc
dev_lcorr_nopunc += lcorr_nopunc
dev_total_nopunc += total_nopunc
dev_ucomlpete_nopunc += ucm_nopunc
dev_lcomplete_nopunc += lcm_nopunc
dev_root_corr += corr_root
dev_total_root += total_root
dev_total_inst += num_inst
pred_writer.close()
gold_writer.close()
print('W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
dev_ucorr, dev_lcorr, dev_total, dev_ucorr * 100 / dev_total, dev_lcorr * 100 / dev_total,
dev_ucomlpete * 100 / dev_total_inst, dev_lcomplete * 100 / dev_total_inst))
print('Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
dev_ucorr_nopunc, dev_lcorr_nopunc, dev_total_nopunc, dev_ucorr_nopunc * 100 / dev_total_nopunc,
dev_lcorr_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_nopunc * 100 / dev_total_inst, dev_lcomplete_nopunc * 100 / dev_total_inst))
print('Root: corr: %d, total: %d, acc: %.2f%%' %(dev_root_corr, dev_total_root, dev_root_corr * 100 / dev_total_root))
if dev_lcorrect_nopunc < dev_lcorr_nopunc or (dev_lcorrect_nopunc == dev_lcorr_nopunc and dev_ucorrect_nopunc < dev_ucorr_nopunc):
dev_ucorrect_nopunc = dev_ucorr_nopunc
dev_lcorrect_nopunc = dev_lcorr_nopunc
dev_ucomlpete_match_nopunc = dev_ucomlpete_nopunc
dev_lcomplete_match_nopunc = dev_lcomplete_nopunc
dev_ucorrect = dev_ucorr
dev_lcorrect = dev_lcorr
dev_ucomlpete_match = dev_ucomlpete
dev_lcomplete_match = dev_lcomplete
dev_root_correct = dev_root_corr
best_epoch = epoch
patient = 0
# torch.save(network, model_name)
torch.save(network.state_dict(), model_name)
pred_filename = 'tmp/%spred_test%d' % (str(uid), epoch)
pred_writer.start(pred_filename)
gold_filename = 'tmp/%sgold_test%d' % (str(uid), epoch)
gold_writer.start(gold_filename)
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_total = 0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_total_nopunc = 0
test_total_inst = 0
test_root_correct = 0.0
test_total_root = 0
for batch in conllx_data.iterate_batch_tensor(data_test, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.cpu().numpy()
pos = pos.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.cpu().numpy()
types = types.cpu().numpy()
pred_writer.write(word, pos, heads_pred, types_pred, lengths, symbolic_root=True)
gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types,
word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
test_ucorrect += ucorr
test_lcorrect += lcorr
test_total += total
test_ucomlpete_match += ucm
test_lcomplete_match += lcm
test_ucorrect_nopunc += ucorr_nopunc
test_lcorrect_nopunc += lcorr_nopunc
test_total_nopunc += total_nopunc
test_ucomlpete_match_nopunc += ucm_nopunc
test_lcomplete_match_nopunc += lcm_nopunc
test_root_correct += corr_root
test_total_root += total_root
test_total_inst += num_inst
pred_writer.close()
gold_writer.close()
else:
if dev_ucorr_nopunc * 100 / dev_total_nopunc < dev_ucorrect_nopunc * 100 / dev_total_nopunc - 5 or patient >= schedule:
# network = torch.load(model_name)
network.load_state_dict(torch.load(model_name))
lr = lr * decay_rate
optim = generate_optimizer(opt, lr, network.parameters())
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
patient = 0
decay += 1
if decay % double_schedule_decay == 0:
schedule *= 2
else:
patient += 1
print('----------------------------------------------------------------------------------------------------------------------------')
print('best dev W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
dev_ucorrect, dev_lcorrect, dev_total, dev_ucorrect * 100 / dev_total, dev_lcorrect * 100 / dev_total,
dev_ucomlpete_match * 100 / dev_total_inst, dev_lcomplete_match * 100 / dev_total_inst,
best_epoch))
print('best dev Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
dev_ucorrect_nopunc, dev_lcorrect_nopunc, dev_total_nopunc,
dev_ucorrect_nopunc * 100 / dev_total_nopunc, dev_lcorrect_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_match_nopunc * 100 / dev_total_inst, dev_lcomplete_match_nopunc * 100 / dev_total_inst,
best_epoch))
print('best dev Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' % (
dev_root_correct, dev_total_root, dev_root_correct * 100 / dev_total_root, best_epoch))
print('----------------------------------------------------------------------------------------------------------------------------')
print('best test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
test_ucorrect, test_lcorrect, test_total, test_ucorrect * 100 / test_total, test_lcorrect * 100 / test_total,
test_ucomlpete_match * 100 / test_total_inst, test_lcomplete_match * 100 / test_total_inst,
best_epoch))
print('best test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
test_ucorrect_nopunc, test_lcorrect_nopunc, test_total_nopunc,
test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc * 100 / test_total_nopunc,
test_ucomlpete_match_nopunc * 100 / test_total_inst, test_lcomplete_match_nopunc * 100 / test_total_inst,
best_epoch))
print('best test Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' % (
test_root_correct, test_total_root, test_root_correct * 100 / test_total_root, best_epoch))
print('============================================================================================================================')
if decay == max_decay:
break
def parse(args):
logger = get_logger("Parsing")
args.cuda = torch.cuda.is_available()
device = torch.device('cuda', 0) if args.cuda else torch.device('cpu')
test_path = args.test
model_path = args.model_path
model_name = os.path.join(model_path, 'model.pt')
punctuation = args.punctuation
print(args)
logger.info("Creating Alphabets")
alphabet_path = os.path.join(model_path, 'alphabets')
assert os.path.exists(alphabet_path)
word_alphabet, char_alphabet, pos_alphabet, type_alphabet = conllx_data.create_alphabets(
alphabet_path, None)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
result_path = os.path.join(model_path, 'tmp')
if not os.path.exists(result_path):
os.makedirs(result_path)
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" %
(len(punct_set), ' '.join(punct_set)))
logger.info("loading network...")
hyps = json.load(open(os.path.join(model_path, 'config.json'), 'r'))
model_type = hyps['model']
assert model_type in ['DeepBiAffine', 'NeuroMST', 'StackPtr']
word_dim = hyps['word_dim']
char_dim = hyps['char_dim']
use_pos = hyps['pos']
pos_dim = hyps['pos_dim']
mode = hyps['rnn_mode']
hidden_size = hyps['hidden_size']
arc_space = hyps['arc_space']
type_space = hyps['type_space']
p_in = hyps['p_in']
p_out = hyps['p_out']
p_rnn = hyps['p_rnn']
activation = hyps['activation']
prior_order = None
alg = 'transition' if model_type == 'StackPtr' else 'graph'
if model_type == 'DeepBiAffine':
num_layers = hyps['num_layers']
network = DeepBiAffine(word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
mode,
hidden_size,
num_layers,
num_types,
arc_space,
type_space,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
pos=use_pos,
activation=activation)
elif model_type == 'NeuroMST':
num_layers = hyps['num_layers']
network = NeuroMST(word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
mode,
hidden_size,
num_layers,
num_types,
arc_space,
type_space,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
pos=use_pos,
activation=activation)
elif model_type == 'StackPtr':
encoder_layers = hyps['encoder_layers']
decoder_layers = hyps['decoder_layers']
num_layers = (encoder_layers, decoder_layers)
prior_order = hyps['prior_order']
grandPar = hyps['grandPar']
sibling = hyps['sibling']
network = StackPtrNet(word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
mode,
hidden_size,
encoder_layers,
decoder_layers,
num_types,
arc_space,
type_space,
prior_order=prior_order,
activation=activation,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
pos=use_pos,
grandPar=grandPar,
sibling=sibling)
else:
raise RuntimeError('Unknown model type: %s' % model_type)
network = network.to(device)
network.load_state_dict(torch.load(model_name, map_location=device))
model = "{}-{}".format(model_type, mode)
logger.info("Network: %s, num_layer=%s, hidden=%d, act=%s" %
(model, num_layers, hidden_size, activation))
logger.info("Reading Data")
if alg == 'graph':
data_test = conllx_data.read_data(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
symbolic_root=True)
else:
data_test = conllx_stacked_data.read_data(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
prior_order=prior_order)
beam = args.beam
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
pred_filename = os.path.join(result_path, 'pred.txt')
pred_writer.start(pred_filename)
gold_filename = os.path.join(result_path, 'gold.txt')
gold_writer.start(gold_filename)
with torch.no_grad():
print('Parsing...')
start_time = time.time()
eval(alg,
data_test,
network,
pred_writer,
gold_writer,
punct_set,
word_alphabet,
pos_alphabet,
device,
beam,
batch_size=args.test_batch_size)
print('Time: %.2fs' % (time.time() - start_time))
pred_writer.close()
gold_writer.close()
def train(args):
logger = get_logger("Parsing")
args.cuda = torch.cuda.is_available()
device = torch.device('cuda', 0) if args.cuda else torch.device('cpu')
train_path = args.train
dev_path = args.dev
test_path = args.test
num_epochs = args.num_epochs
batch_size = args.batch_size
optim = args.optim
learning_rate = args.learning_rate
lr_decay = args.lr_decay
amsgrad = args.amsgrad
eps = args.eps
betas = (args.beta1, args.beta2)
warmup_steps = args.warmup_steps
weight_decay = args.weight_decay
grad_clip = args.grad_clip
loss_ty_token = args.loss_type == 'token'
unk_replace = args.unk_replace
freeze = args.freeze
model_path = args.model_path
model_name = os.path.join(model_path, 'model.pt')
punctuation = args.punctuation
word_embedding = args.word_embedding
word_path = args.word_path
char_embedding = args.char_embedding
char_path = args.char_path
print(args)
word_dict, word_dim = utils.load_embedding_dict(word_embedding, word_path)
char_dict = None
if char_embedding != 'random':
char_dict, char_dim = utils.load_embedding_dict(
char_embedding, char_path)
else:
char_dict = None
char_dim = None
logger.info("Creating Alphabets")
alphabet_path = os.path.join(model_path, 'alphabets')
word_alphabet, char_alphabet, pos_alphabet, type_alphabet = conllx_data.create_alphabets(
alphabet_path,
train_path,
data_paths=[dev_path, test_path],
embedd_dict=word_dict,
max_vocabulary_size=200000)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
result_path = os.path.join(model_path, 'tmp')
if not os.path.exists(result_path):
os.makedirs(result_path)
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" %
(len(punct_set), ' '.join(punct_set)))
def construct_word_embedding_table():
scale = np.sqrt(3.0 / word_dim)
table = np.empty([word_alphabet.size(), word_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.zeros([1, word_dim]).astype(
np.float32) if freeze else np.random.uniform(
-scale, scale, [1, word_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in word_dict:
embedding = word_dict[word]
elif word.lower() in word_dict:
embedding = word_dict[word.lower()]
else:
embedding = np.zeros([1, word_dim]).astype(
np.float32) if freeze else np.random.uniform(
-scale, scale, [1, word_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('word OOV: %d' % oov)
return torch.from_numpy(table)
def construct_char_embedding_table():
if char_dict is None:
return None
scale = np.sqrt(3.0 / char_dim)
table = np.empty([num_chars, char_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(
-scale, scale, [1, char_dim]).astype(np.float32)
oov = 0
for char, index, in char_alphabet.items():
if char in char_dict:
embedding = char_dict[char]
else:
embedding = np.random.uniform(-scale, scale,
[1, char_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('character OOV: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
char_table = construct_char_embedding_table()
logger.info("constructing network...")
hyps = json.load(open(args.config, 'r'))
json.dump(hyps,
open(os.path.join(model_path, 'config.json'), 'w'),
indent=2)
model_type = hyps['model']
assert model_type in ['DeepBiAffine', 'NeuroMST', 'StackPtr']
assert word_dim == hyps['word_dim']
if char_dim is not None:
assert char_dim == hyps['char_dim']
else:
char_dim = hyps['char_dim']
use_pos = hyps['pos']
pos_dim = hyps['pos_dim']
mode = hyps['rnn_mode']
hidden_size = hyps['hidden_size']
arc_space = hyps['arc_space']
type_space = hyps['type_space']
p_in = hyps['p_in']
p_out = hyps['p_out']
p_rnn = hyps['p_rnn']
activation = hyps['activation']
prior_order = None
alg = 'transition' if model_type == 'StackPtr' else 'graph'
if model_type == 'DeepBiAffine':
num_layers = hyps['num_layers']
network = DeepBiAffine(word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
mode,
hidden_size,
num_layers,
num_types,
arc_space,
type_space,
embedd_word=word_table,
embedd_char=char_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
pos=use_pos,
activation=activation)
elif model_type == 'NeuroMST':
num_layers = hyps['num_layers']
network = NeuroMST(word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
mode,
hidden_size,
num_layers,
num_types,
arc_space,
type_space,
embedd_word=word_table,
embedd_char=char_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
pos=use_pos,
activation=activation)
elif model_type == 'StackPtr':
encoder_layers = hyps['encoder_layers']
decoder_layers = hyps['decoder_layers']
num_layers = (encoder_layers, decoder_layers)
prior_order = hyps['prior_order']
grandPar = hyps['grandPar']
sibling = hyps['sibling']
network = StackPtrNet(word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
mode,
hidden_size,
encoder_layers,
decoder_layers,
num_types,
arc_space,
type_space,
embedd_word=word_table,
embedd_char=char_table,
prior_order=prior_order,
activation=activation,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
pos=use_pos,
grandPar=grandPar,
sibling=sibling)
else:
raise RuntimeError('Unknown model type: %s' % model_type)
if freeze:
freeze_embedding(network.word_embed)
network = network.to(device)
model = "{}-{}".format(model_type, mode)
logger.info("Network: %s, num_layer=%s, hidden=%d, act=%s" %
(model, num_layers, hidden_size, activation))
logger.info("dropout(in, out, rnn): %s(%.2f, %.2f, %s)" %
('variational', p_in, p_out, p_rnn))
logger.info('# of Parameters: %d' %
(sum([param.numel() for param in network.parameters()])))
logger.info("Reading Data")
if alg == 'graph':
data_train = conllx_data.read_bucketed_data(train_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
symbolic_root=True)
data_dev = conllx_data.read_data(dev_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
symbolic_root=True)
data_test = conllx_data.read_data(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
symbolic_root=True)
else:
data_train = conllx_stacked_data.read_bucketed_data(
train_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
prior_order=prior_order)
data_dev = conllx_stacked_data.read_data(dev_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
prior_order=prior_order)
data_test = conllx_stacked_data.read_data(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
prior_order=prior_order)
num_data = sum(data_train[1])
logger.info("training: #training data: %d, batch: %d, unk replace: %.2f" %
(num_data, batch_size, unk_replace))
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
optimizer, scheduler = get_optimizer(network.parameters(), optim,
learning_rate, lr_decay, betas, eps,
amsgrad, weight_decay, warmup_steps)
best_ucorrect = 0.0
best_lcorrect = 0.0
best_ucomlpete = 0.0
best_lcomplete = 0.0
best_ucorrect_nopunc = 0.0
best_lcorrect_nopunc = 0.0
best_ucomlpete_nopunc = 0.0
best_lcomplete_nopunc = 0.0
best_root_correct = 0.0
best_total = 0
best_total_nopunc = 0
best_total_inst = 0
best_total_root = 0
best_epoch = 0
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete = 0.0
test_lcomplete = 0.0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_nopunc = 0.0
test_lcomplete_nopunc = 0.0
test_root_correct = 0.0
test_total = 0
test_total_nopunc = 0
test_total_inst = 0
test_total_root = 0
patient = 0
beam = args.beam
reset = args.reset
num_batches = num_data // batch_size + 1
if optim == 'adam':
opt_info = 'adam, betas=(%.1f, %.3f), eps=%.1e, amsgrad=%s' % (
betas[0], betas[1], eps, amsgrad)
else:
opt_info = 'sgd, momentum=0.9, nesterov=True'
for epoch in range(1, num_epochs + 1):
start_time = time.time()
train_loss = 0.
train_arc_loss = 0.
train_type_loss = 0.
num_insts = 0
num_words = 0
num_back = 0
num_nans = 0
network.train()
lr = scheduler.get_lr()[0]
print(
'Epoch %d (%s, lr=%.6f, lr decay=%.6f, grad clip=%.1f, l2=%.1e): '
% (epoch, opt_info, lr, lr_decay, grad_clip, weight_decay))
if args.cuda:
torch.cuda.empty_cache()
gc.collect()
with torch.autograd.set_detect_anomaly(True):
for step, data in enumerate(
iterate_data(data_train,
batch_size,
bucketed=True,
unk_replace=unk_replace,
shuffle=True)):
optimizer.zero_grad()
bert_words = data["BERT_WORD"].to(device)
sub_word_idx = data["SUB_IDX"].to(device)
words = data['WORD'].to(device)
chars = data['CHAR'].to(device)
postags = data['POS'].to(device)
heads = data['HEAD'].to(device)
nbatch = words.size(0)
if alg == 'graph':
types = data['TYPE'].to(device)
masks = data['MASK'].to(device)
nwords = masks.sum() - nbatch
BERT = True
if BERT:
loss_arc, loss_type = network.loss(bert_words,
sub_word_idx,
words,
chars,
postags,
heads,
types,
mask=masks)
else:
loss_arc, loss_type = network.loss(words,
chars,
postags,
heads,
types,
mask=masks)
else:
masks_enc = data['MASK_ENC'].to(device)
masks_dec = data['MASK_DEC'].to(device)
stacked_heads = data['STACK_HEAD'].to(device)
children = data['CHILD'].to(device)
siblings = data['SIBLING'].to(device)
stacked_types = data['STACK_TYPE'].to(device)
nwords = masks_enc.sum() - nbatch
loss_arc, loss_type = network.loss(words,
chars,
postags,
heads,
stacked_heads,
children,
siblings,
stacked_types,
mask_e=masks_enc,
mask_d=masks_dec)
loss_arc = loss_arc.sum()
loss_type = loss_type.sum()
loss_total = loss_arc + loss_type
# print("loss", loss_arc, loss_type, loss_total)
if loss_ty_token:
loss = loss_total.div(nwords)
else:
loss = loss_total.div(nbatch)
loss.backward()
if grad_clip > 0:
grad_norm = clip_grad_norm_(network.parameters(),
grad_clip)
else:
grad_norm = total_grad_norm(network.parameters())
if math.isnan(grad_norm):
num_nans += 1
else:
optimizer.step()
scheduler.step()
with torch.no_grad():
num_insts += nbatch
num_words += nwords
train_loss += loss_total.item()
train_arc_loss += loss_arc.item()
train_type_loss += loss_type.item()
# update log
if step % 100 == 0:
torch.cuda.empty_cache()
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
curr_lr = scheduler.get_lr()[0]
num_insts = max(num_insts, 1)
num_words = max(num_words, 1)
log_info = '[%d/%d (%.0f%%) lr=%.6f (%d)] loss: %.4f (%.4f), arc: %.4f (%.4f), type: %.4f (%.4f)' % (
step, num_batches, 100. * step / num_batches, curr_lr,
num_nans, train_loss / num_insts,
train_loss / num_words, train_arc_loss / num_insts,
train_arc_loss / num_words, train_type_loss /
num_insts, train_type_loss / num_words)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print(
'total: %d (%d), loss: %.4f (%.4f), arc: %.4f (%.4f), type: %.4f (%.4f), time: %.2fs'
% (num_insts, num_words, train_loss / num_insts,
train_loss / num_words, train_arc_loss / num_insts,
train_arc_loss / num_words, train_type_loss / num_insts,
train_type_loss / num_words, time.time() - start_time))
print('-' * 125)
# evaluate performance on dev data
with torch.no_grad():
pred_filename = os.path.join(result_path, 'pred_dev%d' % epoch)
pred_writer.start(pred_filename)
gold_filename = os.path.join(result_path, 'gold_dev%d' % epoch)
gold_writer.start(gold_filename)
print('Evaluating dev:')
dev_stats, dev_stats_nopunct, dev_stats_root = eval(
alg,
data_dev,
network,
pred_writer,
gold_writer,
punct_set,
word_alphabet,
pos_alphabet,
device,
beam=beam)
pred_writer.close()
gold_writer.close()
dev_ucorr, dev_lcorr, dev_ucomlpete, dev_lcomplete, dev_total = dev_stats
dev_ucorr_nopunc, dev_lcorr_nopunc, dev_ucomlpete_nopunc, dev_lcomplete_nopunc, dev_total_nopunc = dev_stats_nopunct
dev_root_corr, dev_total_root, dev_total_inst = dev_stats_root
if best_ucorrect_nopunc + best_lcorrect_nopunc < dev_ucorr_nopunc + dev_lcorr_nopunc:
best_ucorrect_nopunc = dev_ucorr_nopunc
best_lcorrect_nopunc = dev_lcorr_nopunc
best_ucomlpete_nopunc = dev_ucomlpete_nopunc
best_lcomplete_nopunc = dev_lcomplete_nopunc
best_ucorrect = dev_ucorr
best_lcorrect = dev_lcorr
best_ucomlpete = dev_ucomlpete
best_lcomplete = dev_lcomplete
best_root_correct = dev_root_corr
best_total = dev_total
best_total_nopunc = dev_total_nopunc
best_total_root = dev_total_root
best_total_inst = dev_total_inst
best_epoch = epoch
patient = 0
torch.save(network.state_dict(), model_name)
pred_filename = os.path.join(result_path,
'pred_test%d' % epoch)
pred_writer.start(pred_filename)
gold_filename = os.path.join(result_path,
'gold_test%d' % epoch)
gold_writer.start(gold_filename)
print('Evaluating test:')
test_stats, test_stats_nopunct, test_stats_root = eval(
alg,
data_test,
network,
pred_writer,
gold_writer,
punct_set,
word_alphabet,
pos_alphabet,
device,
beam=beam)
test_ucorrect, test_lcorrect, test_ucomlpete, test_lcomplete, test_total = test_stats
test_ucorrect_nopunc, test_lcorrect_nopunc, test_ucomlpete_nopunc, test_lcomplete_nopunc, test_total_nopunc = test_stats_nopunct
test_root_correct, test_total_root, test_total_inst = test_stats_root
pred_writer.close()
gold_writer.close()
else:
patient += 1
print('-' * 125)
print(
'best dev W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (best_ucorrect, best_lcorrect, best_total,
best_ucorrect * 100 / best_total, best_lcorrect * 100 /
best_total, best_ucomlpete * 100 / dev_total_inst,
best_lcomplete * 100 / dev_total_inst, best_epoch))
print(
'best dev Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (best_ucorrect_nopunc, best_lcorrect_nopunc,
best_total_nopunc, best_ucorrect_nopunc * 100 /
best_total_nopunc, best_lcorrect_nopunc * 100 /
best_total_nopunc, best_ucomlpete_nopunc * 100 /
best_total_inst, best_lcomplete_nopunc * 100 /
best_total_inst, best_epoch))
print(
'best dev Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)'
% (best_root_correct, best_total_root,
best_root_correct * 100 / best_total_root, best_epoch))
print('-' * 125)
print(
'best test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (test_ucorrect, test_lcorrect, test_total,
test_ucorrect * 100 / test_total, test_lcorrect * 100 /
test_total, test_ucomlpete * 100 / test_total_inst,
test_lcomplete * 100 / test_total_inst, best_epoch))
print(
'best test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (test_ucorrect_nopunc, test_lcorrect_nopunc,
test_total_nopunc, test_ucorrect_nopunc * 100 /
test_total_nopunc, test_lcorrect_nopunc * 100 /
test_total_nopunc, test_ucomlpete_nopunc * 100 /
test_total_inst, test_lcomplete_nopunc * 100 /
test_total_inst, best_epoch))
print(
'best test Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)'
% (test_root_correct, test_total_root,
test_root_correct * 100 / test_total_root, best_epoch))
print('=' * 125)
if patient >= reset:
logger.info('reset optimizer momentums')
network.load_state_dict(
torch.load(model_name, map_location=device))
scheduler.reset_state()
patient = 0
def main():
parser = argparse.ArgumentParser(
description='Tuning with bi-directional RNN-CNN-CRF')
parser.add_argument('--mode',
choices=['RNN', 'LSTM', 'GRU'],
help='architecture of rnn',
required=True)
parser.add_argument('--num_epochs',
type=int,
default=1000,
help='Number of training epochs')
parser.add_argument('--batch_size',
type=int,
default=16,
help='Number of sentences in each batch')
parser.add_argument('--hidden_size',
type=int,
default=128,
help='Number of hidden units in RNN')
parser.add_argument('--num_filters',
type=int,
default=30,
help='Number of filters in CNN')
parser.add_argument('--char_dim',
type=int,
default=30,
help='Dimension of Character embeddings')
parser.add_argument('--learning_rate',
type=float,
default=0.01,
help='Learning rate')
parser.add_argument('--decay_rate',
type=float,
default=0.1,
help='Decay rate of learning rate')
parser.add_argument('--gamma',
type=float,
default=0.0,
help='weight for regularization')
parser.add_argument('--dropout',
choices=['std', 'variational'],
help='type of dropout',
required=True)
parser.add_argument('--p', type=float, default=0.5, help='dropout rate')
parser.add_argument('--bigram',
action='store_true',
help='bi-gram parameter for CRF')
parser.add_argument('--schedule',
type=int,
help='schedule for learning rate decay')
parser.add_argument('--unk_replace',
type=float,
default=0.,
help='The rate to replace a singleton word with UNK')
parser.add_argument(
'--train') # "data/POS-penn/wsj/split1/wsj1.train.original"
parser.add_argument(
'--dev') # "data/POS-penn/wsj/split1/wsj1.dev.original"
parser.add_argument(
'--test') # "data/POS-penn/wsj/split1/wsj1.test.original"
args = parser.parse_args()
logger = get_logger("POSCRFTagger")
mode = args.mode
train_path = args.train
dev_path = args.dev
test_path = args.test
num_epochs = args.num_epochs
batch_size = args.batch_size
hidden_size = args.hidden_size
num_filters = args.num_filters
learning_rate = args.learning_rate
momentum = 0.9
decay_rate = args.decay_rate
gamma = args.gamma
schedule = args.schedule
p = args.p
unk_replace = args.unk_replace
bigram = args.bigram
embedd_dict, embedd_dim = utils.load_embedding_dict(
'glove', "data/glove/glove.6B/glove.6B.100d.gz")
logger.info("Creating Alphabets")
word_alphabet, char_alphabet, pos_alphabet, \
type_alphabet = conllx_data.create_alphabets("data/alphabets/pos_crf/", train_path,
data_paths=[dev_path, test_path],
max_vocabulary_size=50000, embedd_dict=embedd_dict)
logger.info("Word Alphabet Size: %d" % word_alphabet.size())
logger.info("Character Alphabet Size: %d" % char_alphabet.size())
logger.info("POS Alphabet Size: %d" % pos_alphabet.size())
logger.info("Reading Data")
use_gpu = torch.cuda.is_available()
data_train = conllx_data.read_data_to_variable(train_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
use_gpu=use_gpu)
# data_train = conllx_data.read_data(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
# num_data = sum([len(bucket) for bucket in data_train])
num_data = sum(data_train[1])
num_labels = pos_alphabet.size()
data_dev = conllx_data.read_data_to_variable(dev_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
use_gpu=use_gpu,
volatile=True)
data_test = conllx_data.read_data_to_variable(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
use_gpu=use_gpu,
volatile=True)
def construct_word_embedding_table():
scale = np.sqrt(3.0 / embedd_dim)
table = np.empty([word_alphabet.size(), embedd_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(
-scale, scale, [1, embedd_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in embedd_dict:
embedding = embedd_dict[word]
elif word.lower() in embedd_dict:
embedding = embedd_dict[word.lower()]
else:
embedding = np.random.uniform(
-scale, scale, [1, embedd_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('oov: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
logger.info("constructing network...")
char_dim = args.char_dim
window = 3
num_layers = 1
if args.dropout == 'std':
network = BiRecurrentConvCRF(embedd_dim,
word_alphabet.size(),
char_dim,
char_alphabet.size(),
num_filters,
window,
mode,
hidden_size,
num_layers,
num_labels,
embedd_word=word_table,
p_rnn=p,
bigram=bigram)
else:
raise NotImplementedError
if use_gpu:
network.cuda()
lr = learning_rate
optim = SGD(network.parameters(),
lr=lr,
momentum=momentum,
weight_decay=gamma)
logger.info("Network: %s, num_layer=%d, hidden=%d, filter=%d, crf=%s" %
(mode, num_layers, hidden_size, num_filters,
'bigram' if bigram else 'unigram'))
logger.info(
"training: l2: %f, (#training data: %d, batch: %d, dropout: %.2f, unk replace: %.2f)"
% (gamma, num_data, batch_size, p, unk_replace))
num_batches = num_data / batch_size + 1
dev_correct = 0.0
best_epoch = 0
test_correct = 0.0
test_total = 0
for epoch in range(1, num_epochs + 1):
print(
'Epoch %d (%s(%s), learning rate=%.4f, decay rate=%.4f (schedule=%d)): '
% (epoch, mode, args.dropout, lr, decay_rate, schedule))
train_err = 0.
train_total = 0.
start_time = time.time()
num_back = 0
network.train()
for batch in range(1, num_batches + 1):
word, char, labels, _, _, masks, lengths = conllx_data.get_batch_variable(
data_train, batch_size, unk_replace=unk_replace)
optim.zero_grad()
loss = network.loss(word, char, labels, mask=masks)
loss.backward()
optim.step()
num_inst = word.size(0)
train_err += loss.data[0] * num_inst
train_total += num_inst
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
# update log
if batch % 100 == 0:
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
log_info = 'train: %d/%d loss: %.4f, time left (estimated): %.2fs' % (
batch, num_batches, train_err / train_total, time_left)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print('train: %d loss: %.4f, time: %.2fs' %
(num_batches, train_err / train_total, time.time() - start_time))
# evaluate performance on dev data
network.eval()
dev_corr = 0.0
dev_total = 0
for batch in conllx_data.iterate_batch_variable(data_dev, batch_size):
word, char, labels, _, _, masks, lengths = batch
preds, corr = network.decode(
word,
char,
target=labels,
mask=masks,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
num_tokens = masks.data.sum()
dev_corr += corr
dev_total += num_tokens
print('dev corr: %d, total: %d, acc: %.2f%%' %
(dev_corr, dev_total, dev_corr * 100 / dev_total))
if dev_correct < dev_corr:
dev_correct = dev_corr
best_epoch = epoch
# evaluate on test data when better performance detected
test_corr = 0.0
test_total = 0
for batch in conllx_data.iterate_batch_variable(
data_test, batch_size):
word, char, labels, _, _, masks, lengths = batch
preds, corr = network.decode(
word,
char,
target=labels,
mask=masks,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
num_tokens = masks.data.sum()
test_corr += corr
test_total += num_tokens
test_correct = test_corr
print("best dev corr: %d, total: %d, acc: %.2f%% (epoch: %d)" %
(dev_correct, dev_total, dev_correct * 100 / dev_total,
best_epoch))
print("best test corr: %d, total: %d, acc: %.2f%% (epoch: %d)" %
(test_correct, test_total, test_correct * 100 / test_total,
best_epoch))
if epoch % schedule == 0:
lr = learning_rate / (1.0 + epoch * decay_rate)
optim = SGD(network.parameters(),
lr=lr,
momentum=momentum,
weight_decay=gamma,
nesterov=True)
custom_args.dataset_name)
train_path, dev_path, test_path, _, _, _ = datasets.DATASET_FILES[
custom_args.dataset_name]
if custom_args.bio_embeddings != 'none':
if 'bio' in custom_args.bio_embeddings:
embedding_vocab_dict = datasets.load_bio_word_embedding_vocab(
custom_args.bio_embeddings)
elif 'glove' in custom_args.bio_embeddings:
embedding_vocab_dict = datasets.load_glove_word_embedding_vocab(
custom_args.bio_embeddings)
else:
embedding_vocab_dict = None
graph_word_alphabet, graph_char_alphabet, _, _, graph_ner_alphabet = conllx_data.create_alphabets(
alphabet_path,
train_path,
data_paths=[dev_path, test_path],
max_vocabulary_size=100000,
embedd_dict=embedding_vocab_dict,
normalize_digits=False,
suffix='graph_')
parser_data, graph_data, mentions, labels = datasets.load_data(
(word_alphabet, graph_word_alphabet), (char_alphabet, graph_char_alphabet),
pos_alphabet, type_alphabet, graph_ner_alphabet, custom_args)
data_train, data_dev, data_test = parser_data
graph_data_train, graph_data_dev, graph_data_test = graph_data
mentions_train, mentions_dev, mentions_test = mentions
labels_train, labels_dev, labels_test = labels
all_labels = list(
set(x.lower() for x in set(labels_train + labels_dev + labels_test)))
all_labels.sort()
def main():
args_parser = argparse.ArgumentParser(
description='Tuning with graph-based parsing')
args_parser.register('type', 'bool', str2bool)
args_parser.add_argument('--seed',
type=int,
default=1234,
help='random seed for reproducibility')
args_parser.add_argument('--mode',
choices=['RNN', 'LSTM', 'GRU', 'FastLSTM'],
help='architecture of rnn',
required=True)
args_parser.add_argument('--num_epochs',
type=int,
default=1000,
help='Number of training epochs')
args_parser.add_argument('--batch_size',
type=int,
default=64,
help='Number of sentences in each batch')
args_parser.add_argument('--hidden_size',
type=int,
default=256,
help='Number of hidden units in RNN')
args_parser.add_argument('--arc_space',
type=int,
default=128,
help='Dimension of tag space')
args_parser.add_argument('--type_space',
type=int,
default=128,
help='Dimension of tag space')
args_parser.add_argument('--num_layers',
type=int,
default=1,
help='Number of layers of encoder.')
args_parser.add_argument('--num_filters',
type=int,
default=50,
help='Number of filters in CNN')
args_parser.add_argument('--pos',
action='store_true',
help='use part-of-speech embedding.')
args_parser.add_argument('--char',
action='store_true',
help='use character embedding and CNN.')
args_parser.add_argument('--pos_dim',
type=int,
default=50,
help='Dimension of POS embeddings')
args_parser.add_argument('--char_dim',
type=int,
default=50,
help='Dimension of Character embeddings')
args_parser.add_argument('--opt',
choices=['adam', 'sgd', 'adamax'],
help='optimization algorithm')
args_parser.add_argument('--objective',
choices=['cross_entropy', 'crf'],
default='cross_entropy',
help='objective function of training procedure.')
args_parser.add_argument('--decode',
choices=['mst', 'greedy'],
default='mst',
help='decoding algorithm')
args_parser.add_argument('--learning_rate',
type=float,
default=0.01,
help='Learning rate')
# args_parser.add_argument('--decay_rate', type=float, default=0.05, help='Decay rate of learning rate')
args_parser.add_argument('--clip',
type=float,
default=5.0,
help='gradient clipping')
args_parser.add_argument('--gamma',
type=float,
default=0.0,
help='weight for regularization')
args_parser.add_argument('--epsilon',
type=float,
default=1e-8,
help='epsilon for adam or adamax')
args_parser.add_argument('--p_rnn',
nargs='+',
type=float,
required=True,
help='dropout rate for RNN')
args_parser.add_argument('--p_in',
type=float,
default=0.33,
help='dropout rate for input embeddings')
args_parser.add_argument('--p_out',
type=float,
default=0.33,
help='dropout rate for output layer')
# args_parser.add_argument('--schedule', type=int, help='schedule for learning rate decay')
args_parser.add_argument(
'--unk_replace',
type=float,
default=0.,
help='The rate to replace a singleton word with UNK')
args_parser.add_argument('--punctuation',
nargs='+',
type=str,
help='List of punctuations')
args_parser.add_argument(
'--word_embedding',
choices=['word2vec', 'glove', 'senna', 'sskip', 'polyglot'],
help='Embedding for words',
required=True)
args_parser.add_argument('--word_path',
help='path for word embedding dict')
args_parser.add_argument(
'--freeze',
action='store_true',
help='frozen the word embedding (disable fine-tuning).')
args_parser.add_argument('--char_embedding',
choices=['random', 'polyglot'],
help='Embedding for characters',
required=True)
args_parser.add_argument('--char_path',
help='path for character embedding dict')
args_parser.add_argument('--data_dir', help='Data directory path')
args_parser.add_argument(
'--src_lang',
required=True,
help='Src language to train dependency parsing model')
args_parser.add_argument('--aux_lang',
nargs='+',
help='Language names for adversarial training')
args_parser.add_argument('--vocab_path',
help='path for prebuilt alphabets.',
default=None)
args_parser.add_argument('--model_path',
help='path for saving model file.',
required=True)
args_parser.add_argument('--model_name',
help='name for saving model file.',
required=True)
#
args_parser.add_argument('--attn_on_rnn',
action='store_true',
help='use self-attention on top of context RNN.')
args_parser.add_argument('--no_word',
type='bool',
default=False,
help='do not use word embedding.')
args_parser.add_argument('--use_bert',
type='bool',
default=False,
help='use multilingual BERT.')
#
# lrate schedule with warmup in the first iter.
args_parser.add_argument('--use_warmup_schedule',
type='bool',
default=False,
help="Use warmup lrate schedule.")
args_parser.add_argument('--decay_rate',
type=float,
default=0.75,
help='Decay rate of learning rate')
args_parser.add_argument('--max_decay',
type=int,
default=9,
help='Number of decays before stop')
args_parser.add_argument('--schedule',
type=int,
help='schedule for learning rate decay')
args_parser.add_argument('--double_schedule_decay',
type=int,
default=5,
help='Number of decays to double schedule')
args_parser.add_argument(
'--check_dev',
type=int,
default=5,
help='Check development performance in every n\'th iteration')
# encoder selection
args_parser.add_argument('--encoder_type',
choices=['Transformer', 'RNN', 'SelfAttn'],
default='RNN',
help='do not use context RNN.')
args_parser.add_argument(
'--pool_type',
default='mean',
choices=['max', 'mean', 'weight'],
help='pool type to form fixed length vector from word embeddings')
# Tansformer encoder
args_parser.add_argument(
'--trans_hid_size',
type=int,
default=1024,
help='#hidden units in point-wise feed-forward in transformer')
args_parser.add_argument(
'--d_k',
type=int,
default=64,
help='d_k for multi-head-attention in transformer encoder')
args_parser.add_argument(
'--d_v',
type=int,
default=64,
help='d_v for multi-head-attention in transformer encoder')
args_parser.add_argument('--num_head',
type=int,
default=8,
help='Value of h in multi-head attention')
args_parser.add_argument(
'--use_all_encoder_layers',
type='bool',
default=False,
help='Use a weighted representations of all encoder layers')
# - positional
args_parser.add_argument(
'--enc_use_neg_dist',
action='store_true',
help="Use negative distance for enc's relational-distance embedding.")
args_parser.add_argument(
'--enc_clip_dist',
type=int,
default=0,
help="The clipping distance for relative position features.")
args_parser.add_argument('--position_dim',
type=int,
default=50,
help='Dimension of Position embeddings.')
args_parser.add_argument(
'--position_embed_num',
type=int,
default=200,
help=
'Minimum value of position embedding num, which usually is max-sent-length.'
)
args_parser.add_argument('--train_position',
action='store_true',
help='train positional encoding for transformer.')
args_parser.add_argument('--input_concat_embeds',
action='store_true',
help="Concat input embeddings, otherwise add.")
args_parser.add_argument('--input_concat_position',
action='store_true',
help="Concat position embeddings, otherwise add.")
args_parser.add_argument(
'--partitioned',
type='bool',
default=False,
help=
"Partition the content and positional attention for multi-head attention."
)
args_parser.add_argument(
'--partition_type',
choices=['content-position', 'lexical-delexical'],
default='content-position',
help="How to apply partition in the self-attention.")
#
args_parser.add_argument(
'--train_len_thresh',
type=int,
default=100,
help='In training, discard sentences longer than this.')
#
# regarding adversarial training
args_parser.add_argument('--pre_model_path',
type=str,
default=None,
help='Path of the pretrained model.')
args_parser.add_argument('--pre_model_name',
type=str,
default=None,
help='Name of the pretrained model.')
args_parser.add_argument('--adv_training',
type='bool',
default=False,
help='Use adversarial training.')
args_parser.add_argument(
'--lambdaG',
type=float,
default=0.001,
help='Scaling parameter to control generator loss.')
args_parser.add_argument('--discriminator',
choices=['weak', 'not-so-weak', 'strong'],
default='weak',
help='architecture of the discriminator')
args_parser.add_argument(
'--delay',
type=int,
default=0,
help='Number of epochs to be run first for the source task')
args_parser.add_argument(
'--n_critic',
type=int,
default=5,
help='Number of training steps for discriminator per iter')
args_parser.add_argument(
'--clip_disc',
type=float,
default=5.0,
help='Lower and upper clip value for disc. weights')
args_parser.add_argument('--debug',
type='bool',
default=False,
help='Use debug portion of the training data')
args_parser.add_argument('--train_level',
type=str,
default='word',
choices=['word', 'sent'],
help='Use X-level adversarial training')
args_parser.add_argument('--train_type',
type=str,
default='GAN',
choices=['GR', 'GAN', 'WGAN'],
help='Type of adversarial training')
#
# regarding motivational training
args_parser.add_argument(
'--motivate',
type='bool',
default=False,
help='This is opposite of the adversarial training')
#
args = args_parser.parse_args()
# fix data-prepare seed
random.seed(1234)
np.random.seed(1234)
# model's seed
torch.manual_seed(args.seed)
# if output directory doesn't exist, create it
if not os.path.exists(args.model_path):
os.makedirs(args.model_path)
logger = get_logger("GraphParser")
logger.info('\ncommand-line params : {0}\n'.format(sys.argv[1:]))
logger.info('{0}\n'.format(args))
logger.info("Visible GPUs: %s", str(os.environ["CUDA_VISIBLE_DEVICES"]))
args.parallel = False
if torch.cuda.device_count() > 1:
args.parallel = True
mode = args.mode
obj = args.objective
decoding = args.decode
train_path = args.data_dir + args.src_lang + "_train.debug.1_10.conllu" \
if args.debug else args.data_dir + args.src_lang + '_train.conllu'
dev_path = args.data_dir + args.src_lang + "_dev.conllu"
test_path = args.data_dir + args.src_lang + "_test.conllu"
#
vocab_path = args.vocab_path if args.vocab_path is not None else args.model_path
model_path = args.model_path
model_name = args.model_name
num_epochs = args.num_epochs
batch_size = args.batch_size
hidden_size = args.hidden_size
arc_space = args.arc_space
type_space = args.type_space
num_layers = args.num_layers
num_filters = args.num_filters
learning_rate = args.learning_rate
opt = args.opt
momentum = 0.9
betas = (0.9, 0.9)
eps = args.epsilon
decay_rate = args.decay_rate
clip = args.clip
gamma = args.gamma
schedule = args.schedule
p_rnn = tuple(args.p_rnn)
p_in = args.p_in
p_out = args.p_out
unk_replace = args.unk_replace
punctuation = args.punctuation
freeze = args.freeze
use_word_emb = not args.no_word
word_embedding = args.word_embedding
word_path = args.word_path
use_char = args.char
char_embedding = args.char_embedding
char_path = args.char_path
attn_on_rnn = args.attn_on_rnn
encoder_type = args.encoder_type
if attn_on_rnn:
assert encoder_type == 'RNN'
t_types = (args.adv_training, args.motivate)
t_count = sum(1 for tt in t_types if tt)
if t_count > 1:
assert False, "Only one of: adv_training or motivate can be true"
# ------------------- Loading/initializing embeddings -------------------- #
use_pos = args.pos
pos_dim = args.pos_dim
word_dict, word_dim = utils.load_embedding_dict(word_embedding, word_path)
char_dict = None
char_dim = args.char_dim
if char_embedding != 'random':
char_dict, char_dim = utils.load_embedding_dict(
char_embedding, char_path)
logger.info("Creating Alphabets")
alphabet_path = os.path.join(vocab_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
# TODO (WARNING): must build vocabs previously
assert os.path.isdir(alphabet_path), "should have build vocabs previously"
word_alphabet, char_alphabet, pos_alphabet, type_alphabet, max_sent_length = conllx_data.create_alphabets(
alphabet_path,
train_path,
data_paths=[dev_path, test_path],
max_vocabulary_size=50000,
embedd_dict=word_dict)
max_sent_length = max(max_sent_length, args.position_embed_num)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
# ------------------------------------------------------------------------- #
# --------------------- Loading/building the model ------------------------ #
logger.info("Reading Data")
use_gpu = torch.cuda.is_available()
def construct_word_embedding_table():
scale = np.sqrt(3.0 / word_dim)
table = np.empty([word_alphabet.size(), word_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.zeros([1, word_dim]).astype(
np.float32) if freeze else np.random.uniform(
-scale, scale, [1, word_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in word_dict:
embedding = word_dict[word]
elif word.lower() in word_dict:
embedding = word_dict[word.lower()]
else:
embedding = np.zeros([1, word_dim]).astype(
np.float32) if freeze else np.random.uniform(
-scale, scale, [1, word_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('word OOV: %d' % oov)
return torch.from_numpy(table)
def construct_char_embedding_table():
if char_dict is None:
return None
scale = np.sqrt(3.0 / char_dim)
table = np.empty([num_chars, char_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(
-scale, scale, [1, char_dim]).astype(np.float32)
oov = 0
for char, index, in char_alphabet.items():
if char in char_dict:
embedding = char_dict[char]
else:
embedding = np.random.uniform(-scale, scale,
[1, char_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('character OOV: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table() if use_word_emb else None
char_table = construct_char_embedding_table() if use_char else None
def load_model_arguments_from_json():
arguments = json.load(open(pre_model_path, 'r'))
return arguments['args'], arguments['kwargs']
window = 3
if obj == 'cross_entropy':
if args.pre_model_path and args.pre_model_name:
pre_model_name = os.path.join(args.pre_model_path,
args.pre_model_name)
pre_model_path = pre_model_name + '.arg.json'
model_args, kwargs = load_model_arguments_from_json()
network = BiRecurrentConvBiAffine(use_gpu=use_gpu,
*model_args,
**kwargs)
network.load_state_dict(torch.load(pre_model_name))
logger.info("Model reloaded from %s" % pre_model_path)
# Adjust the word embedding layer
if network.embedder.word_embedd is not None:
network.embedder.word_embedd = nn.Embedding(num_words,
word_dim,
_weight=word_table)
else:
network = BiRecurrentConvBiAffine(
word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
num_filters,
window,
mode,
hidden_size,
num_layers,
num_types,
arc_space,
type_space,
embedd_word=word_table,
embedd_char=char_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
biaffine=True,
pos=use_pos,
char=use_char,
train_position=args.train_position,
encoder_type=encoder_type,
trans_hid_size=args.trans_hid_size,
d_k=args.d_k,
d_v=args.d_v,
num_head=args.num_head,
enc_use_neg_dist=args.enc_use_neg_dist,
enc_clip_dist=args.enc_clip_dist,
position_dim=args.position_dim,
max_sent_length=max_sent_length,
use_gpu=use_gpu,
use_word_emb=use_word_emb,
input_concat_embeds=args.input_concat_embeds,
input_concat_position=args.input_concat_position,
attn_on_rnn=attn_on_rnn,
partitioned=args.partitioned,
partition_type=args.partition_type,
use_all_encoder_layers=args.use_all_encoder_layers,
use_bert=args.use_bert)
elif obj == 'crf':
raise NotImplementedError
else:
raise RuntimeError('Unknown objective: %s' % obj)
# ------------------------------------------------------------------------- #
# --------------------- Loading data -------------------------------------- #
train_data = dict()
dev_data = dict()
test_data = dict()
num_data = dict()
lang_ids = dict()
reverse_lang_ids = dict()
# ===== the reading =============================================
def _read_one(path, is_train):
lang_id = guess_language_id(path)
logger.info("Reading: guess that the language of file %s is %s." %
(path, lang_id))
one_data = conllx_data.read_data_to_variable(
path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
use_gpu=False,
volatile=(not is_train),
symbolic_root=True,
lang_id=lang_id,
use_bert=args.use_bert,
len_thresh=(args.train_len_thresh if is_train else 100000))
return one_data
data_train = _read_one(train_path, True)
train_data[args.src_lang] = data_train
num_data[args.src_lang] = sum(data_train[1])
lang_ids[args.src_lang] = len(lang_ids)
reverse_lang_ids[lang_ids[args.src_lang]] = args.src_lang
data_dev = _read_one(dev_path, False)
data_test = _read_one(test_path, False)
dev_data[args.src_lang] = data_dev
test_data[args.src_lang] = data_test
# ===============================================================
# ===== reading data for adversarial training ===================
if t_count > 0:
for language in args.aux_lang:
aux_train_path = args.data_dir + language + "_train.debug.1_10.conllu" \
if args.debug else args.data_dir + language + '_train.conllu'
aux_train_data = _read_one(aux_train_path, True)
num_data[language] = sum(aux_train_data[1])
train_data[language] = aux_train_data
lang_ids[language] = len(lang_ids)
reverse_lang_ids[lang_ids[language]] = language
# ===============================================================
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" %
(len(punct_set), ' '.join(punct_set)))
def save_args():
arg_path = model_name + '.arg.json'
arguments = [
word_dim, num_words, char_dim, num_chars, pos_dim, num_pos,
num_filters, window, mode, hidden_size, num_layers, num_types,
arc_space, type_space
]
kwargs = {
'p_in': p_in,
'p_out': p_out,
'p_rnn': p_rnn,
'biaffine': True,
'pos': use_pos,
'char': use_char,
'train_position': args.train_position,
'encoder_type': args.encoder_type,
'trans_hid_size': args.trans_hid_size,
'd_k': args.d_k,
'd_v': args.d_v,
'num_head': args.num_head,
'enc_use_neg_dist': args.enc_use_neg_dist,
'enc_clip_dist': args.enc_clip_dist,
'position_dim': args.position_dim,
'max_sent_length': max_sent_length,
'use_word_emb': use_word_emb,
'input_concat_embeds': args.input_concat_embeds,
'input_concat_position': args.input_concat_position,
'attn_on_rnn': attn_on_rnn,
'partitioned': args.partitioned,
'partition_type': args.partition_type,
'use_all_encoder_layers': args.use_all_encoder_layers,
'use_bert': args.use_bert
}
json.dump({
'args': arguments,
'kwargs': kwargs
},
open(arg_path, 'w'),
indent=4)
if use_word_emb and freeze:
freeze_embedding(network.embedder.word_embedd)
if args.parallel:
network = torch.nn.DataParallel(network)
if use_gpu:
network = network.cuda()
save_args()
param_dict = {}
encoder = network.module.encoder if args.parallel else network.encoder
for name, param in encoder.named_parameters():
if param.requires_grad:
param_dict[name] = np.prod(param.size())
total_params = np.sum(list(param_dict.values()))
logger.info('Total Encoder Parameters = %d' % total_params)
# ------------------------------------------------------------------------- #
# =============================================
if args.adv_training:
disc_feat_size = network.module.encoder.output_dim if args.parallel else network.encoder.output_dim
reverse_grad = args.train_type == 'GR'
nclass = len(lang_ids) if args.train_type == 'GR' else 1
kwargs = {
'input_size': disc_feat_size,
'disc_type': args.discriminator,
'train_level': args.train_level,
'train_type': args.train_type,
'reverse_grad': reverse_grad,
'soft_label': True,
'nclass': nclass,
'scale': args.lambdaG,
'use_gpu': use_gpu,
'opt': 'adam',
'lr': 0.001,
'betas': (0.9, 0.999),
'gamma': 0,
'eps': 1e-8,
'momentum': 0,
'clip_disc': args.clip_disc
}
AdvAgent = Adversarial(**kwargs)
if use_gpu:
AdvAgent.cuda()
elif args.motivate:
disc_feat_size = network.module.encoder.output_dim if args.parallel else network.encoder.output_dim
nclass = len(lang_ids)
kwargs = {
'input_size': disc_feat_size,
'disc_type': args.discriminator,
'train_level': args.train_level,
'nclass': nclass,
'scale': args.lambdaG,
'use_gpu': use_gpu,
'opt': 'adam',
'lr': 0.001,
'betas': (0.9, 0.999),
'gamma': 0,
'eps': 1e-8,
'momentum': 0,
'clip_disc': args.clip_disc
}
MtvAgent = Motivator(**kwargs)
if use_gpu:
MtvAgent.cuda()
# =============================================
# --------------------- Initializing the optimizer ------------------------ #
lr = learning_rate
optim = generate_optimizer(opt, lr, network.parameters(), betas, gamma,
eps, momentum)
opt_info = 'opt: %s, ' % opt
if opt == 'adam':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
elif opt == 'sgd':
opt_info += 'momentum=%.2f' % momentum
elif opt == 'adamax':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
# =============================================
total_data = min(num_data.values())
word_status = 'frozen' if freeze else 'fine tune'
char_status = 'enabled' if use_char else 'disabled'
pos_status = 'enabled' if use_pos else 'disabled'
logger.info(
"Embedding dim: word=%d (%s), char=%d (%s), pos=%d (%s)" %
(word_dim, word_status, char_dim, char_status, pos_dim, pos_status))
logger.info("CNN: filter=%d, kernel=%d" % (num_filters, window))
logger.info(
"RNN: %s, num_layer=%d, hidden=%d, arc_space=%d, type_space=%d" %
(mode, num_layers, hidden_size, arc_space, type_space))
logger.info(
"train: obj: %s, l2: %f, (#data: %d, batch: %d, clip: %.2f, unk replace: %.2f)"
% (obj, gamma, total_data, batch_size, clip, unk_replace))
logger.info("dropout(in, out, rnn): (%.2f, %.2f, %s)" %
(p_in, p_out, p_rnn))
logger.info("decoding algorithm: %s" % decoding)
logger.info(opt_info)
# ------------------------------------------------------------------------- #
# --------------------- Form the mini-batches ----------------------------- #
num_batches = total_data // batch_size + 1
aux_lang = []
if t_count > 0:
for language in args.aux_lang:
aux_lang.extend([language] * num_data[language])
assert num_data[args.src_lang] <= len(aux_lang)
# ------------------------------------------------------------------------- #
dev_ucorrect = 0.0
dev_lcorrect = 0.0
dev_ucomlpete_match = 0.0
dev_lcomplete_match = 0.0
dev_ucorrect_nopunc = 0.0
dev_lcorrect_nopunc = 0.0
dev_ucomlpete_match_nopunc = 0.0
dev_lcomplete_match_nopunc = 0.0
dev_root_correct = 0.0
best_epoch = 0
if decoding == 'greedy':
decode = network.module.decode if args.parallel else network.decode
elif decoding == 'mst':
decode = network.module.decode_mst if args.parallel else network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
patient = 0
decay = 0
max_decay = args.max_decay
double_schedule_decay = args.double_schedule_decay
# lrate schedule
step_num = 0
use_warmup_schedule = args.use_warmup_schedule
if use_warmup_schedule:
logger.info("Use warmup lrate for the first epoch, from 0 up to %s." %
(lr, ))
skip_adv_tuning = 0
loss_fn = network.module.loss if args.parallel else network.loss
for epoch in range(1, num_epochs + 1):
print(
'Epoch %d (%s, optim: %s, learning rate=%.6f, eps=%.1e, decay rate=%.2f (schedule=%d, patient=%d, decay=%d)): '
%
(epoch, mode, opt, lr, eps, decay_rate, schedule, patient, decay))
train_err = 0.
train_err_arc = 0.
train_err_type = 0.
train_total = 0.
start_time = time.time()
num_back = 0
skip_adv_tuning += 1
loss_d_real, loss_d_fake = [], []
acc_d_real, acc_d_fake, = [], []
gen_loss, parsing_loss = [], []
disent_loss = []
if t_count > 0 and skip_adv_tuning > args.delay:
batch_size = args.batch_size // 2
num_batches = total_data // batch_size + 1
# ---------------------- Sample the mini-batches -------------------------- #
if t_count > 0:
sampled_aux_lang = random.sample(aux_lang, num_batches)
lang_in_batch = [(args.src_lang, sampled_aux_lang[k])
for k in range(num_batches)]
else:
lang_in_batch = [(args.src_lang, None) for _ in range(num_batches)]
assert len(lang_in_batch) == num_batches
# ------------------------------------------------------------------------- #
network.train()
warmup_factor = (lr + 0.) / num_batches
for batch in range(1, num_batches + 1):
update_generator = True
update_discriminator = False
# lrate schedule (before each step)
step_num += 1
if use_warmup_schedule and epoch <= 1:
cur_lrate = warmup_factor * step_num
# set lr
for param_group in optim.param_groups:
param_group['lr'] = cur_lrate
# considering source language as real and auxiliary languages as fake
real_lang, fake_lang = lang_in_batch[batch - 1]
real_idx, fake_idx = lang_ids.get(real_lang), lang_ids.get(
fake_lang, -1)
#
word, char, pos, heads, types, masks, lengths, bert_inputs = conllx_data.get_batch_variable(
train_data[real_lang], batch_size, unk_replace=unk_replace)
if use_gpu:
word = word.cuda()
char = char.cuda()
pos = pos.cuda()
heads = heads.cuda()
types = types.cuda()
masks = masks.cuda()
lengths = lengths.cuda()
if bert_inputs[0] is not None:
bert_inputs[0] = bert_inputs[0].cuda()
bert_inputs[1] = bert_inputs[1].cuda()
bert_inputs[2] = bert_inputs[2].cuda()
real_enc = network(word,
char,
pos,
input_bert=bert_inputs,
mask=masks,
length=lengths,
hx=None)
# ========== Update the discriminator ==========
if t_count > 0 and skip_adv_tuning > args.delay:
# fake examples = 0
word_f, char_f, pos_f, heads_f, types_f, masks_f, lengths_f, bert_inputs = conllx_data.get_batch_variable(
train_data[fake_lang], batch_size, unk_replace=unk_replace)
if use_gpu:
word_f = word_f.cuda()
char_f = char_f.cuda()
pos_f = pos_f.cuda()
heads_f = heads_f.cuda()
types_f = types_f.cuda()
masks_f = masks_f.cuda()
lengths_f = lengths_f.cuda()
if bert_inputs[0] is not None:
bert_inputs[0] = bert_inputs[0].cuda()
bert_inputs[1] = bert_inputs[1].cuda()
bert_inputs[2] = bert_inputs[2].cuda()
fake_enc = network(word_f,
char_f,
pos_f,
input_bert=bert_inputs,
mask=masks_f,
length=lengths_f,
hx=None)
# TODO: temporary crack
if t_count > 0 and skip_adv_tuning > args.delay:
# skip discriminator training for '|n_critic|' iterations if 'n_critic' < 0
if args.n_critic > 0 or (batch - 1) % (-1 *
args.n_critic) == 0:
update_discriminator = True
if update_discriminator:
if args.adv_training:
real_loss, fake_loss, real_acc, fake_acc = AdvAgent.update(
real_enc['output'].detach(),
fake_enc['output'].detach(), real_idx, fake_idx)
loss_d_real.append(real_loss)
loss_d_fake.append(fake_loss)
acc_d_real.append(real_acc)
acc_d_fake.append(fake_acc)
elif args.motivate:
real_loss, fake_loss, real_acc, fake_acc = MtvAgent.update(
real_enc['output'].detach(),
fake_enc['output'].detach(), real_idx, fake_idx)
loss_d_real.append(real_loss)
loss_d_fake.append(fake_loss)
acc_d_real.append(real_acc)
acc_d_fake.append(fake_acc)
else:
raise NotImplementedError()
if args.n_critic > 0 and (batch - 1) % args.n_critic != 0:
update_generator = False
# ==============================================
# =========== Update the generator =============
if update_generator:
others_loss = None
if args.adv_training and skip_adv_tuning > args.delay:
# for GAN: L_G= L_parsing - (lambda_G * L_D)
# for GR : L_G= L_parsing + L_D
others_loss = AdvAgent.gen_loss(real_enc['output'],
fake_enc['output'],
real_idx, fake_idx)
gen_loss.append(others_loss.item())
elif args.motivate and skip_adv_tuning > args.delay:
others_loss = MtvAgent.gen_loss(real_enc['output'],
fake_enc['output'],
real_idx, fake_idx)
gen_loss.append(others_loss.item())
optim.zero_grad()
loss_arc, loss_type = loss_fn(real_enc['output'],
heads,
types,
mask=masks,
length=lengths)
loss = loss_arc + loss_type
num_inst = word.size(
0) if obj == 'crf' else masks.sum() - word.size(0)
train_err += loss.item() * num_inst
train_err_arc += loss_arc.item() * num_inst
train_err_type += loss_type.item() * num_inst
train_total += num_inst
parsing_loss.append(loss.item())
if others_loss is not None:
loss = loss + others_loss
loss.backward()
clip_grad_norm_(network.parameters(), clip)
optim.step()
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
if (args.adv_training
or args.motivate) and skip_adv_tuning > args.delay:
logger.info(
'epoch: %d train: %d loss: %.4f, arc: %.4f, type: %.4f, dis_loss: (%.2f, %.2f), dis_acc: (%.2f, %.2f), '
'gen_loss: %.2f, time: %.2fs' %
(epoch, num_batches, train_err / train_total,
train_err_arc / train_total, train_err_type / train_total,
sum(loss_d_real) / len(loss_d_real), sum(loss_d_fake) /
len(loss_d_fake), sum(acc_d_real) / len(acc_d_real),
sum(acc_d_fake) / len(acc_d_fake),
sum(gen_loss) / len(gen_loss), time.time() - start_time))
else:
logger.info(
'epoch: %d train: %d loss: %.4f, arc: %.4f, type: %.4f, time: %.2fs'
% (epoch, num_batches, train_err / train_total,
train_err_arc / train_total, train_err_type / train_total,
time.time() - start_time))
################# Validation on Dependency Parsing Only #################################
if epoch % args.check_dev != 0:
continue
with torch.no_grad():
# evaluate performance on dev data
network.eval()
dev_ucorr = 0.0
dev_lcorr = 0.0
dev_total = 0
dev_ucomlpete = 0.0
dev_lcomplete = 0.0
dev_ucorr_nopunc = 0.0
dev_lcorr_nopunc = 0.0
dev_total_nopunc = 0
dev_ucomlpete_nopunc = 0.0
dev_lcomplete_nopunc = 0.0
dev_root_corr = 0.0
dev_total_root = 0.0
dev_total_inst = 0.0
for lang, data_dev in dev_data.items():
for batch in conllx_data.iterate_batch_variable(
data_dev, batch_size):
word, char, pos, heads, types, masks, lengths, bert_inputs = batch
if use_gpu:
word = word.cuda()
char = char.cuda()
pos = pos.cuda()
heads = heads.cuda()
types = types.cuda()
masks = masks.cuda()
lengths = lengths.cuda()
if bert_inputs[0] is not None:
bert_inputs[0] = bert_inputs[0].cuda()
bert_inputs[1] = bert_inputs[1].cuda()
bert_inputs[2] = bert_inputs[2].cuda()
heads_pred, types_pred = decode(
word,
char,
pos,
input_bert=bert_inputs,
mask=masks,
length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.cpu().numpy()
pos = pos.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.cpu().numpy()
types = types.cpu().numpy()
stats, stats_nopunc, stats_root, num_inst = parser.eval(
word,
pos,
heads_pred,
types_pred,
heads,
types,
word_alphabet,
pos_alphabet,
lengths,
punct_set=punct_set,
symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
dev_ucorr += ucorr
dev_lcorr += lcorr
dev_total += total
dev_ucomlpete += ucm
dev_lcomplete += lcm
dev_ucorr_nopunc += ucorr_nopunc
dev_lcorr_nopunc += lcorr_nopunc
dev_total_nopunc += total_nopunc
dev_ucomlpete_nopunc += ucm_nopunc
dev_lcomplete_nopunc += lcm_nopunc
dev_root_corr += corr_root
dev_total_root += total_root
dev_total_inst += num_inst
print(
'W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%'
% (dev_ucorr, dev_lcorr, dev_total, dev_ucorr * 100 /
dev_total, dev_lcorr * 100 / dev_total, dev_ucomlpete *
100 / dev_total_inst, dev_lcomplete * 100 / dev_total_inst))
print(
'Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%'
%
(dev_ucorr_nopunc, dev_lcorr_nopunc, dev_total_nopunc,
dev_ucorr_nopunc * 100 / dev_total_nopunc, dev_lcorr_nopunc *
100 / dev_total_nopunc, dev_ucomlpete_nopunc * 100 /
dev_total_inst, dev_lcomplete_nopunc * 100 / dev_total_inst))
print('Root: corr: %d, total: %d, acc: %.2f%%' %
(dev_root_corr, dev_total_root,
dev_root_corr * 100 / dev_total_root))
if dev_lcorrect_nopunc < dev_lcorr_nopunc or (
dev_lcorrect_nopunc == dev_lcorr_nopunc
and dev_ucorrect_nopunc < dev_ucorr_nopunc):
dev_ucorrect_nopunc = dev_ucorr_nopunc
dev_lcorrect_nopunc = dev_lcorr_nopunc
dev_ucomlpete_match_nopunc = dev_ucomlpete_nopunc
dev_lcomplete_match_nopunc = dev_lcomplete_nopunc
dev_ucorrect = dev_ucorr
dev_lcorrect = dev_lcorr
dev_ucomlpete_match = dev_ucomlpete
dev_lcomplete_match = dev_lcomplete
dev_root_correct = dev_root_corr
best_epoch = epoch
patient = 0
state_dict = network.module.state_dict(
) if args.parallel else network.state_dict()
torch.save(state_dict, model_name)
else:
if dev_ucorr_nopunc * 100 / dev_total_nopunc < dev_ucorrect_nopunc * 100 / dev_total_nopunc - 5 or patient >= schedule:
state_dict = torch.load(model_name)
if args.parallel:
network.module.load_state_dict(state_dict)
else:
network.load_state_dict(state_dict)
lr = lr * decay_rate
optim = generate_optimizer(opt, lr, network.parameters(),
betas, gamma, eps, momentum)
if decoding == 'greedy':
decode = network.module.decode if args.parallel else network.decode
elif decoding == 'mst':
decode = network.module.decode_mst if args.parallel else network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' %
decoding)
patient = 0
decay += 1
if decay % double_schedule_decay == 0:
schedule *= 2
else:
patient += 1
print(
'----------------------------------------------------------------------------------------------------------------------------'
)
print(
'best dev W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (dev_ucorrect, dev_lcorrect, dev_total, dev_ucorrect * 100 /
dev_total, dev_lcorrect * 100 / dev_total,
dev_ucomlpete_match * 100 / dev_total_inst,
dev_lcomplete_match * 100 / dev_total_inst, best_epoch))
print(
'best dev Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (dev_ucorrect_nopunc, dev_lcorrect_nopunc, dev_total_nopunc,
dev_ucorrect_nopunc * 100 / dev_total_nopunc,
dev_lcorrect_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_match_nopunc * 100 / dev_total_inst,
dev_lcomplete_match_nopunc * 100 / dev_total_inst,
best_epoch))
print(
'best dev Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)'
% (dev_root_correct, dev_total_root,
dev_root_correct * 100 / dev_total_root, best_epoch))
print(
'----------------------------------------------------------------------------------------------------------------------------'
)
if decay == max_decay:
break
torch.cuda.empty_cache() # release memory that can be released
def main():
parser = argparse.ArgumentParser(description='Tuning with bi-directional RNN-CNN')
parser.add_argument('--mode', choices=['RNN', 'LSTM', 'GRU'], help='architecture of rnn', required=True)
parser.add_argument('--cuda', action='store_true', help='using GPU')
parser.add_argument('--num_epochs', type=int, default=1000, help='Number of training epochs')
parser.add_argument('--batch_size', type=int, default=16, help='Number of sentences in each batch')
parser.add_argument('--hidden_size', type=int, default=128, help='Number of hidden units in RNN')
parser.add_argument('--tag_space', type=int, default=0, help='Dimension of tag space')
parser.add_argument('--num_layers', type=int, default=1, help='Number of layers of RNN')
parser.add_argument('--num_filters', type=int, default=30, help='Number of filters in CNN')
parser.add_argument('--char_dim', type=int, default=30, help='Dimension of Character embeddings')
parser.add_argument('--learning_rate', type=float, default=0.1, help='Learning rate')
parser.add_argument('--decay_rate', type=float, default=0.1, help='Decay rate of learning rate')
parser.add_argument('--gamma', type=float, default=0.0, help='weight for regularization')
parser.add_argument('--dropout', choices=['std', 'variational'], help='type of dropout', required=True)
parser.add_argument('--p_rnn', nargs=2, type=float, required=True, help='dropout rate for RNN')
parser.add_argument('--p_in', type=float, default=0.33, help='dropout rate for input embeddings')
parser.add_argument('--p_out', type=float, default=0.33, help='dropout rate for output layer')
parser.add_argument('--schedule', type=int, help='schedule for learning rate decay')
parser.add_argument('--unk_replace', type=float, default=0., help='The rate to replace a singleton word with UNK')
parser.add_argument('--embedding', choices=['glove', 'senna', 'sskip', 'polyglot'], help='Embedding for words', required=True)
parser.add_argument('--embedding_dict', help='path for embedding dict')
parser.add_argument('--train') # "data/POS-penn/wsj/split1/wsj1.train.original"
parser.add_argument('--dev') # "data/POS-penn/wsj/split1/wsj1.dev.original"
parser.add_argument('--test') # "data/POS-penn/wsj/split1/wsj1.test.original"
args = parser.parse_args()
logger = get_logger("POSTagger")
mode = args.mode
train_path = args.train
dev_path = args.dev
test_path = args.test
num_epochs = args.num_epochs
batch_size = args.batch_size
hidden_size = args.hidden_size
num_filters = args.num_filters
learning_rate = args.learning_rate
momentum = 0.9
decay_rate = args.decay_rate
gamma = args.gamma
schedule = args.schedule
p_rnn = tuple(args.p_rnn)
p_in = args.p_in
p_out = args.p_out
unk_replace = args.unk_replace
embedding = args.embedding
embedding_path = args.embedding_dict
embedd_dict, embedd_dim = utils.load_embedding_dict(embedding, embedding_path)
logger.info("Creating Alphabets")
word_alphabet, char_alphabet, pos_alphabet, \
type_alphabet = conllx_data.create_alphabets("data/alphabets/pos/", train_path, data_paths=[dev_path,test_path],
max_vocabulary_size=50000, embedd_dict=embedd_dict)
logger.info("Word Alphabet Size: %d" % word_alphabet.size())
logger.info("Character Alphabet Size: %d" % char_alphabet.size())
logger.info("POS Alphabet Size: %d" % pos_alphabet.size())
logger.info("Reading Data")
device = torch.device('cuda') if args.cuda else torch.device('cpu')
data_train = conllx_data.read_data_to_tensor(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, device=device)
# data_train = conllx_data.read_data(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
# num_data = sum([len(bucket) for bucket in data_train])
num_data = sum(data_train[1])
num_labels = pos_alphabet.size()
data_dev = conllx_data.read_data_to_tensor(dev_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, device=device)
data_test = conllx_data.read_data_to_tensor(test_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, device=device)
def construct_word_embedding_table():
scale = np.sqrt(3.0 / embedd_dim)
table = np.empty([word_alphabet.size(), embedd_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(-scale, scale, [1, embedd_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in embedd_dict:
embedding = embedd_dict[word]
elif word.lower() in embedd_dict:
embedding = embedd_dict[word.lower()]
else:
embedding = np.random.uniform(-scale, scale, [1, embedd_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('oov: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
logger.info("constructing network...")
char_dim = args.char_dim
window = 3
num_layers = args.num_layers
tag_space = args.tag_space
initializer = nn.init.xavier_uniform_
if args.dropout == 'std':
network = BiRecurrentConv(embedd_dim, word_alphabet.size(), char_dim, char_alphabet.size(), num_filters, window, mode, hidden_size, num_layers, num_labels,
tag_space=tag_space, embedd_word=word_table, p_in=p_in, p_out=p_out, p_rnn=p_rnn, initializer=initializer)
else:
network = BiVarRecurrentConv(embedd_dim, word_alphabet.size(), char_dim, char_alphabet.size(), num_filters, window, mode, hidden_size, num_layers, num_labels,
tag_space=tag_space, embedd_word=word_table, p_in=p_in, p_out=p_out, p_rnn=p_rnn, initializer=initializer)
network = network.to(device)
lr = learning_rate
# optim = Adam(network.parameters(), lr=lr, betas=(0.9, 0.9), weight_decay=gamma)
optim = SGD(network.parameters(), lr=lr, momentum=momentum, weight_decay=gamma, nesterov=True)
logger.info("Network: %s, num_layer=%d, hidden=%d, filter=%d, tag_space=%d" % (mode, num_layers, hidden_size, num_filters, tag_space))
logger.info("training: l2: %f, (#training data: %d, batch: %d, unk replace: %.2f)" % (gamma, num_data, batch_size, unk_replace))
logger.info("dropout(in, out, rnn): (%.2f, %.2f, %s)" % (p_in, p_out, p_rnn))
num_batches = num_data / batch_size + 1
dev_correct = 0.0
best_epoch = 0
test_correct = 0.0
test_total = 0
for epoch in range(1, num_epochs + 1):
print('Epoch %d (%s(%s), learning rate=%.4f, decay rate=%.4f (schedule=%d)): ' % (epoch, mode, args.dropout, lr, decay_rate, schedule))
train_err = 0.
train_corr = 0.
train_total = 0.
start_time = time.time()
num_back = 0
network.train()
for batch in range(1, num_batches + 1):
word, char, labels, _, _, masks, lengths = conllx_data.get_batch_tensor(data_train, batch_size, unk_replace=unk_replace)
optim.zero_grad()
loss, corr, _ = network.loss(word, char, labels, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
loss.backward()
optim.step()
with torch.no_grad():
num_tokens = masks.sum()
train_err += loss * num_tokens
train_corr += corr
train_total += num_tokens
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
# update log
if batch % 100 == 0:
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
log_info = 'train: %d/%d loss: %.4f, acc: %.2f%%, time left (estimated): %.2fs' % (batch, num_batches, train_err / train_total, train_corr * 100 / train_total, time_left)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print('train: %d loss: %.4f, acc: %.2f%%, time: %.2fs' % (num_batches, train_err / train_total, train_corr * 100 / train_total, time.time() - start_time))
# evaluate performance on dev data
with torch.no_grad():
network.eval()
dev_corr = 0.0
dev_total = 0
for batch in conllx_data.iterate_batch_tensor(data_dev, batch_size):
word, char, labels, _, _, masks, lengths = batch
_, corr, preds = network.loss(word, char, labels, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
num_tokens = masks.sum()
dev_corr += corr
dev_total += num_tokens
print('dev corr: %d, total: %d, acc: %.2f%%' % (dev_corr, dev_total, dev_corr * 100 / dev_total))
if dev_correct < dev_corr:
dev_correct = dev_corr
best_epoch = epoch
# evaluate on test data when better performance detected
test_corr = 0.0
test_total = 0
for batch in conllx_data.iterate_batch_tensor(data_test, batch_size):
word, char, labels, _, _, masks, lengths = batch
_, corr, preds = network.loss(word, char, labels, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
num_tokens = masks.sum()
test_corr += corr
test_total += num_tokens
test_correct = test_corr
print("best dev corr: %d, total: %d, acc: %.2f%% (epoch: %d)" % (dev_correct, dev_total, dev_correct * 100 / dev_total, best_epoch))
print("best test corr: %d, total: %d, acc: %.2f%% (epoch: %d)" % (test_correct, test_total, test_correct * 100 / test_total, best_epoch))
if epoch % schedule == 0:
lr = learning_rate / (1.0 + epoch * decay_rate)
optim = SGD(network.parameters(), lr=lr, momentum=momentum, weight_decay=gamma, nesterov=True)
def parser():
try:
params = request.json
if params is None:
return http_sender.send_error_response(
http_response_message.ResponseCode.JSON_SYNTAX_ERROR)
if 'sentence' in params:
query = params['sentence'].strip()
logging.info("Input: " + query)
# check query null
if query.strip() == "":
return http_sender.send_error_response(
http_response_message.ResponseCode.EMPTY_REQUEST)
result_segment = ''
words, postags = word_segmentation(query)
for index, (word, pos) in enumerate(zip(words, postags)):
word = word.replace("_", " ")
if pos == 'CH':
pos = 'PUNCT'
elif pos == 'L':
pos = 'DET'
elif pos == 'A':
pos = 'ADJ'
elif pos == 'R':
pos = 'ADV'
elif pos == 'Np':
pos = 'NNP'
elif pos == 'M':
pos = 'NUM'
elif pos == 'E':
pos = 'PRE'
elif pos == 'P':
pos = 'PRO'
elif pos == 'Cc':
pos = 'CC'
elif pos == 'T':
pos = 'PART'
elif pos == 'Y':
pos = 'NNP'
elif pos == 'Cb':
pos = 'CC'
elif pos == 'Eb':
pos = 'FW'
elif pos == 'Ni':
pos = 'Ny'
elif pos == 'B':
pos = 'NNP'
elif pos == 'L':
pos = 'DET'
elif pos == 'Aux':
pos = 'AUX'
elif pos == 'NN':
pos = 'N'
result_segment += str(index + 1) + '\t' + word + '\t' + word.lower() + '\t' + pos + '\t' + pos + '\t' \
+ '_' + '\t' + '_' + '\t' + '_' + '\t' + '_' + '\t' + '_' + '\n'
result_segment = result_segment.strip()
# split data for test
test_folder = 'tmp'
if not os.path.exists(test_folder):
os.mkdir(test_folder)
else:
for file in os.listdir(test_folder):
os.remove(test_folder + '/' + file)
output_path = test_folder + '/test.txt'
fout = open(output_path, 'w')
fout.write(result_segment + '\n')
fout.close()
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, 'network.pt')
word_alphabet, char_alphabet, pos_alphabet, \
type_alphabet, max_sent_length = conllx_data.create_alphabets(alphabet_path, None,
data_paths=[None, None],
max_vocabulary_size=50000,
embedd_dict=None)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
tokenizer = AutoTokenizer.from_pretrained(phobert_path)
model_bert = AutoModel.from_pretrained(phobert_path)
processor = DPProcessor()
test_path = 'tmp/test.txt'
feature_bert_path = 'tmp/phobert_features.pth'
train_examples = processor.get_train_examples(test_path)
all_lengths = []
for t in train_examples:
all_lengths.append(len(t.text_a))
max_seq_len = max(all_lengths) + 1
if max_seq_len > 512:
max_seq_len = 512
logger.info("Max sequence length reset to 512")
device = torch.device("cuda")
model_bert.to(device)
train_features = convert_examples_to_features(
train_examples, max_seq_len, tokenizer)
all_input_ids = torch.tensor([f.input_ids for f in train_features],
dtype=torch.long)
all_input_mask = torch.tensor(
[f.input_mask for f in train_features], dtype=torch.long)
all_segment_ids = torch.tensor(
[f.token_type_ids for f in train_features], dtype=torch.long)
train_data = TensorDataset(all_input_ids, all_input_mask,
all_segment_ids)
train_sampler = SequentialSampler(train_data)
train_dataloader = DataLoader(train_data,
sampler=train_sampler,
batch_size=32)
model_bert.eval()
to_save = {}
# for step, batch in enumerate(tqdm(train_dataloader, desc="Iteration")):
for step, batch in enumerate(train_dataloader):
batch = tuple(t.to(device) for t in batch)
input_ids, input_mask, token_type_ids = batch
with torch.no_grad():
all_encoder_layers = model_bert(
input_ids,
attention_mask=input_mask,
token_type_ids=token_type_ids)
output_ = all_encoder_layers[0]
for j in range(len(input_ids)):
sent_id = j + step * 32
layer_output = output_[j, :input_mask[j].to('cpu').sum()]
to_save[sent_id] = layer_output.detach().cpu().numpy()
torch.save(to_save, feature_bert_path)
data_test = conllx_data.read_data_to_tensor(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
feature_bert_path,
elmo_path,
symbolic_root=True,
device=device,
use_elmo=False,
use_bert=False,
use_elmo_bert=True,
use_test=True)
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet,
pos_alphabet, type_alphabet)
logger.info('model: %s' % model_name)
def load_model_arguments_from_json():
arguments = json.load(open(arg_path, 'r'))
return arguments['args'], arguments['kwargs']
arg_path = model_name[0:-1] + '.arg.json'
if not os.path.isfile(arg_path):
arg_path = model_name + '.arg.json'
args_, kwargs = load_model_arguments_from_json()
network = DeepBiAffineTransform(*args_,
**kwargs,
use_elmo=False,
use_bert=False,
use_elmo_bert=True)
network.load_state_dict(torch.load(model_name))
if use_gpu:
network.cuda()
else:
network.cpu()
network.eval()
decode = network.decode_mst
out_filename = 'tmp/test'
pred_writer.start(out_filename + '_pred.conll')
for batch in conllx_data.iterate_batch_tensor(data_test,
1,
use_elmo=False,
use_bert=False,
use_elmo_bert=True):
sys.stdout.flush()
word, char, pos, heads, types, masks, lengths, elmos, berts = batch
heads_pred, types_pred = decode(
word,
char,
pos,
elmos,
berts,
mask=masks,
length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
pred_writer.write(word,
pos,
heads_pred,
types_pred,
lengths,
symbolic_root=True)
pred_writer.close()
sents_gold = result_segment.split('\n')
result = ''
test_path = 'tmp/test_pred.conll'
lines = open(test_path, 'r').readlines()
for i, line in enumerate(lines):
if line.strip() != '':
sent = sents_gold[i]
words_gold = sent.split('\t')
word = words_gold[1]
line = line.strip()
words = line.split('\t')
line = words[0] + '\t' + word + '\t' + word.lower(
) + '\t' + words[4] + '\t' + words[4] + '\t_\t' + words[
6] + '\t' + words[7] + '\t_\t_' + '\n'
if line != '':
result += line + '\n'
result = result.strip()
logging.info("Result: " + str(result))
return http_sender.send_http_result(result)
else:
return http_sender.send_error_response(
http_response_message.ResponseCode.INPUT_FORMAT_ERROR)
except BadRequest:
return http_sender.send_error_response(
http_response_message.ResponseCode.JSON_SYNTAX_ERROR)
def biaffine(model_path, model_name, test_path, punct_set, use_gpu, logger, args):
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
word_alphabet, char_alphabet, pos_alphabet, type_alphabet, max_sent_length = conllx_data.create_alphabets(alphabet_path,
None, data_paths=[None, None], max_vocabulary_size=50000, embedd_dict=None)
# word_alphabet, char_alphabet, pos_alphabet, type_alphabet = create_alphabets(alphabet_path,
# None, data_paths=[None, None], max_vocabulary_size=50000, embedd_dict=None)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
decoding = args.decode
out_filename = args.out_filename
constraints_method = args.constraints_method
constraintFile = args.constraint_file
ratioFile = args.ratio_file
tolerance = args.tolerance
gamma = args.gamma
the_language = args.mt_log[9:11]
mt_log = open(args.mt_log, 'a')
summary_log = open(args.summary_log, 'a')
logger.info('use gpu: %s, decoding: %s' % (use_gpu, decoding))
#
extra_embeds_arr = augment_with_extra_embedding(word_alphabet, args.extra_embed, args.extra_embed_src, test_path, logger)
# ===== the reading
def _read_one(path, is_train):
lang_id = guess_language_id(path)
logger.info("Reading: guess that the language of file %s is %s." % (path, lang_id))
one_data = conllx_data.read_data_to_variable(path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, volatile=(not is_train), symbolic_root=True, lang_id=lang_id)
return one_data
data_test = _read_one(test_path, False)
# data_test = conllx_data.read_data_to_variable(test_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet,
# use_gpu=use_gpu, volatile=True, symbolic_root=True)
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
logger.info('model: %s' % model_name)
def load_model_arguments_from_json():
arguments = json.load(open(arg_path, 'r'))
return arguments['args'], arguments['kwargs']
arg_path = model_name + '.arg.json'
args, kwargs = load_model_arguments_from_json()
network = BiRecurrentConvBiAffine(use_gpu=use_gpu, *args, **kwargs)
network.load_state_dict(torch.load(model_name))
#
augment_network_embed(word_alphabet.size(), network, extra_embeds_arr)
if use_gpu:
network.cuda()
else:
network.cpu()
network.eval()
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
elif decoding == 'proj':
decode = network.decode_proj
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
# pred_writer.start('tmp/analyze_pred_%s' % str(uid))
# gold_writer.start('tmp/analyze_gold_%s' % str(uid))
# pred_writer.start(model_path + out_filename + '_pred')
# gold_writer.start(model_path + out_filename + '_gold')
pred_writer.start(out_filename + '_pred')
gold_writer.start(out_filename + '_gold')
sent = 0
start_time = time.time()
constraints = []
mt_log.write("=====================%s, Ablation 2================\n"%(constraints_method))
summary_log.write("==========================%s, Ablation 2=============\n"%(constraints_method))
if ratioFile == 'WALS':
import pickle as pk
cFile = open(constraintFile, 'rb')
WALS_data = pk.load(cFile)
for idx in ['85A', '87A', '89A']:
constraint = Constraint(0,0,0)
extra_const = constraint.load_WALS(idx, WALS_data[the_language][idx], pos_alphabet, method=constraints_method)
constraints.append(constraint)
if extra_const:
constraints.append(extra_const)
constraint = Constraint(0,0,0)
extra_const = constraint.load_WALS_unary(WALS_data[the_language], pos_alphabet, method=constraints_method)
if extra_const:
constraints.append(extra_const)
constraints.append(constraint)
elif ratioFile == 'None':
summary_log.write("=================No it is baseline================\n")
mt_log.write("==================No it is baseline==============\n")
else:
cFile = open(constraintFile, 'r')
for line in cFile:
if len(line.strip()) < 2:
break
pos1, pos2 = line.strip().split('\t')
constraint = Constraint(0,0,0)
constraint.load(pos1, pos2, ratioFile, pos_alphabet)
constraints.append(constraint)
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_total = 0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_total_nopunc = 0
test_total_inst = 0
test_root_correct = 0.0
test_total_root = 0
arc_list = []
type_list = []
length_list = []
pos_list = []
for batch in conllx_data.iterate_batch_variable(data_test, 1):
word, char, pos, heads, types, masks, lengths = batch
out_arc, out_type, length = network.pretrain_constraint(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
arc_list += list(out_arc)
type_list += list(out_type)
length_list += list(length)
pos_list += list(pos)
if constraints_method == 'binary':
train_constraints = network.binary_constraints
if constraints_method == 'Lagrange':
train_constraints = network.Lagrange_constraints
if constraints_method == 'PR':
train_constraints = network.PR_constraints
train_constraints(arc_list, type_list, length_list, pos_list, constraints, tolerance, mt_log, gamma=gamma)
for batch in conllx_data.iterate_batch_variable(data_test, 1):
#sys.stdout.write('%d, ' % sent)
#sys.stdout.flush()
sent += 1
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS, constraints=constraints, method=constraints_method, gamma=gamma)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
pred_writer.write(word, pos, heads_pred, types_pred, lengths, symbolic_root=True)
gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types,
word_alphabet, pos_alphabet, lengths,
punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
test_ucorrect += ucorr
test_lcorrect += lcorr
test_total += total
test_ucomlpete_match += ucm
test_lcomplete_match += lcm
test_ucorrect_nopunc += ucorr_nopunc
test_lcorrect_nopunc += lcorr_nopunc
test_total_nopunc += total_nopunc
test_ucomlpete_match_nopunc += ucm_nopunc
test_lcomplete_match_nopunc += lcm_nopunc
test_root_correct += corr_root
test_total_root += total_root
test_total_inst += num_inst
print('\ntime: %.2fs' % (time.time() - start_time))
print('test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
test_ucorrect, test_lcorrect, test_total, test_ucorrect * 100 / test_total, test_lcorrect * 100 / test_total,
test_ucomlpete_match * 100 / test_total_inst, test_lcomplete_match * 100 / test_total_inst))
print('test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
test_ucorrect_nopunc, test_lcorrect_nopunc, test_total_nopunc,
test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc * 100 / test_total_nopunc,
test_ucomlpete_match_nopunc * 100 / test_total_inst, test_lcomplete_match_nopunc * 100 / test_total_inst))
print('test Root: corr: %d, total: %d, acc: %.2f%%' % (
test_root_correct, test_total_root, test_root_correct * 100 / test_total_root))
mt_log.write('uas: %.2f, las: %.2f\n'%(test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc * 100 / test_total_nopunc))
summary_log.write('%s: %.2f %.2f\n'%(the_language, test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc * 100 / test_total_nopunc))
pred_writer.close()
gold_writer.close()
def main():
parser = argparse.ArgumentParser(
description='NER with bi-directional RNN-CNN')
parser.add_argument('--config',
type=str,
help='config file',
required=True)
parser.add_argument('--num_epochs',
type=int,
default=100,
help='Number of training epochs')
parser.add_argument('--batch_size',
type=int,
default=16,
help='Number of sentences in each batch')
parser.add_argument('--loss_type',
choices=['sentence', 'token'],
default='sentence',
help='loss type (default: sentence)')
parser.add_argument('--optim',
choices=['sgd', 'adam'],
help='type of optimizer',
required=True)
parser.add_argument('--learning_rate',
type=float,
default=0.1,
help='Learning rate')
parser.add_argument('--lr_decay',
type=float,
default=0.999995,
help='Decay rate of learning rate')
parser.add_argument('--amsgrad', action='store_true', help='AMS Grad')
parser.add_argument('--grad_clip',
type=float,
default=0,
help='max norm for gradient clip (default 0: no clip')
parser.add_argument('--warmup_steps',
type=int,
default=0,
metavar='N',
help='number of steps to warm up (default: 0)')
parser.add_argument('--weight_decay',
type=float,
default=0.0,
help='weight for l2 norm decay')
parser.add_argument('--unk_replace',
type=float,
default=0.,
help='The rate to replace a singleton word with UNK')
parser.add_argument('--embedding',
choices=['glove', 'senna', 'sskip', 'polyglot'],
help='Embedding for words',
required=True)
parser.add_argument('--embedding_dict', help='path for embedding dict')
parser.add_argument('--train',
help='path for training file.',
required=True)
parser.add_argument('--dev', help='path for dev file.', required=True)
parser.add_argument('--test', help='path for test file.', required=True)
parser.add_argument('--model_path',
help='path for saving model file.',
required=True)
args = parser.parse_args()
logger = get_logger("POS")
args.cuda = torch.cuda.is_available()
device = torch.device('cuda', 0) if args.cuda else torch.device('cpu')
train_path = args.train
dev_path = args.dev
test_path = args.test
num_epochs = args.num_epochs
batch_size = args.batch_size
optim = args.optim
learning_rate = args.learning_rate
lr_decay = args.lr_decay
amsgrad = args.amsgrad
warmup_steps = args.warmup_steps
weight_decay = args.weight_decay
grad_clip = args.grad_clip
loss_ty_token = args.loss_type == 'token'
unk_replace = args.unk_replace
model_path = args.model_path
model_name = os.path.join(model_path, 'model.pt')
embedding = args.embedding
embedding_path = args.embedding_dict
print(args)
embedd_dict, embedd_dim = utils.load_embedding_dict(
embedding, embedding_path)
logger.info("Creating Alphabets")
alphabet_path = os.path.join(model_path, 'alphabets')
word_alphabet, char_alphabet, pos_alphabet, type_alphabet = conllx_data.create_alphabets(
alphabet_path,
train_path,
data_paths=[dev_path, test_path],
embedd_dict=embedd_dict,
max_vocabulary_size=50000)
logger.info("Word Alphabet Size: %d" % word_alphabet.size())
logger.info("Character Alphabet Size: %d" % char_alphabet.size())
logger.info("POS Alphabet Size: %d" % pos_alphabet.size())
logger.info("Reading Data")
data_train = conllx_data.read_bucketed_data(train_path, word_alphabet,
char_alphabet, pos_alphabet,
type_alphabet)
num_data = sum(data_train[1])
num_labels = pos_alphabet.size()
data_dev = conllx_data.read_data(dev_path, word_alphabet, char_alphabet,
pos_alphabet, type_alphabet)
data_test = conllx_data.read_data(test_path, word_alphabet, char_alphabet,
pos_alphabet, type_alphabet)
def construct_word_embedding_table():
scale = np.sqrt(3.0 / embedd_dim)
table = np.empty([word_alphabet.size(), embedd_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(
-scale, scale, [1, embedd_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in embedd_dict:
embedding = embedd_dict[word]
elif word.lower() in embedd_dict:
embedding = embedd_dict[word.lower()]
else:
embedding = np.random.uniform(
-scale, scale, [1, embedd_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('oov: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
logger.info("constructing network...")
hyps = json.load(open(args.config, 'r'))
json.dump(hyps,
open(os.path.join(model_path, 'config.json'), 'w'),
indent=2)
dropout = hyps['dropout']
crf = hyps['crf']
bigram = hyps['bigram']
assert embedd_dim == hyps['embedd_dim']
char_dim = hyps['char_dim']
mode = hyps['rnn_mode']
hidden_size = hyps['hidden_size']
out_features = hyps['out_features']
num_layers = hyps['num_layers']
p_in = hyps['p_in']
p_out = hyps['p_out']
p_rnn = hyps['p_rnn']
activation = hyps['activation']
if dropout == 'std':
if crf:
network = BiRecurrentConvCRF(embedd_dim,
word_alphabet.size(),
char_dim,
char_alphabet.size(),
mode,
hidden_size,
out_features,
num_layers,
num_labels,
embedd_word=word_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
bigram=bigram,
activation=activation)
else:
network = BiRecurrentConv(embedd_dim,
word_alphabet.size(),
char_dim,
char_alphabet.size(),
mode,
hidden_size,
out_features,
num_layers,
num_labels,
embedd_word=word_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
activation=activation)
elif dropout == 'variational':
if crf:
network = BiVarRecurrentConvCRF(embedd_dim,
word_alphabet.size(),
char_dim,
char_alphabet.size(),
mode,
hidden_size,
out_features,
num_layers,
num_labels,
embedd_word=word_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
bigram=bigram,
activation=activation)
else:
network = BiVarRecurrentConv(embedd_dim,
word_alphabet.size(),
char_dim,
char_alphabet.size(),
mode,
hidden_size,
out_features,
num_layers,
num_labels,
embedd_word=word_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
activation=activation)
else:
raise ValueError('Unkown dropout type: {}'.format(dropout))
network = network.to(device)
optimizer, scheduler = get_optimizer(network.parameters(), optim,
learning_rate, lr_decay, amsgrad,
weight_decay, warmup_steps)
model = "{}-CNN{}".format(mode, "-CRF" if crf else "")
logger.info("Network: %s, num_layer=%d, hidden=%d, act=%s" %
(model, num_layers, hidden_size, activation))
logger.info(
"training: l2: %f, (#training data: %d, batch: %d, unk replace: %.2f)"
% (weight_decay, num_data, batch_size, unk_replace))
logger.info("dropout(in, out, rnn): %s(%.2f, %.2f, %s)" %
(dropout, p_in, p_out, p_rnn))
print('# of Parameters: %d' %
(sum([param.numel() for param in network.parameters()])))
best_corr = 0.0
best_total = 0.0
test_corr = 0.0
test_total = 0.0
best_epoch = 0
patient = 0
num_batches = num_data // batch_size + 1
result_path = os.path.join(model_path, 'tmp')
if not os.path.exists(result_path):
os.makedirs(result_path)
for epoch in range(1, num_epochs + 1):
start_time = time.time()
train_loss = 0.
num_insts = 0
num_words = 0
num_back = 0
network.train()
lr = scheduler.get_lr()[0]
print('Epoch %d (%s, lr=%.6f, lr decay=%.6f, amsgrad=%s, l2=%.1e): ' %
(epoch, optim, lr, lr_decay, amsgrad, weight_decay))
if args.cuda:
torch.cuda.empty_cache()
gc.collect()
for step, data in enumerate(
iterate_data(data_train,
batch_size,
bucketed=True,
unk_replace=unk_replace,
shuffle=True)):
optimizer.zero_grad()
words = data['WORD'].to(device)
chars = data['CHAR'].to(device)
labels = data['POS'].to(device)
masks = data['MASK'].to(device)
nbatch = words.size(0)
nwords = masks.sum().item()
loss_total = network.loss(words, chars, labels, mask=masks).sum()
if loss_ty_token:
loss = loss_total.div(nwords)
else:
loss = loss_total.div(nbatch)
loss.backward()
if grad_clip > 0:
clip_grad_norm_(network.parameters(), grad_clip)
optimizer.step()
scheduler.step()
with torch.no_grad():
num_insts += nbatch
num_words += nwords
train_loss += loss_total.item()
# update log
if step % 100 == 0:
torch.cuda.empty_cache()
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
curr_lr = scheduler.get_lr()[0]
log_info = '[%d/%d (%.0f%%) lr=%.6f] loss: %.4f (%.4f)' % (
step, num_batches, 100. * step / num_batches, curr_lr,
train_loss / num_insts, train_loss / num_words)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print('total: %d (%d), loss: %.4f (%.4f), time: %.2fs' %
(num_insts, num_words, train_loss / num_insts,
train_loss / num_words, time.time() - start_time))
print('-' * 100)
# evaluate performance on dev data
with torch.no_grad():
dev_corr, dev_total = eval(data_dev, network, device)
print('Dev corr: %d, total: %d, acc: %.2f%%' %
(dev_corr, dev_total, dev_corr * 100 / dev_total))
if best_corr < dev_corr:
torch.save(network.state_dict(), model_name)
best_corr = dev_corr
best_total = dev_total
best_epoch = epoch
# evaluate on test data when better performance detected
test_corr, test_total = eval(data_test, network, device)
print('test corr: %d, total: %d, acc: %.2f%%' %
(test_corr, test_total, test_corr * 100 / test_total))
patient = 0
else:
patient += 1
print('-' * 100)
print(
"Best dev corr: %d, total: %d, acc: %.2f%% (epoch: %d (%d))" %
(best_corr, best_total, best_corr * 100 / best_total,
best_epoch, patient))
print(
"Best test corr: %d, total: %d, acc: %.2f%% (epoch: %d (%d))" %
(test_corr, test_total, test_corr * 100 / test_total,
best_epoch, patient))
print('=' * 100)
if patient > 4:
logger.info('reset optimizer momentums')
scheduler.reset_state()
patient = 0
def biaffine(model_path, model_name, pre_model_path, pre_model_name, use_gpu, logger, args):
alphabet_path = os.path.join(pre_model_path, 'alphabets/')
logger.info("Alphabet Path: %s" % alphabet_path)
pre_model_name = os.path.join(pre_model_path, pre_model_name)
model_name = os.path.join(model_path, model_name)
# Load pre-created alphabets
word_alphabet, char_alphabet, pos_alphabet, type_alphabet, max_sent_length = conllx_data.create_alphabets(
alphabet_path, None, data_paths=[None, None], max_vocabulary_size=50000, embedd_dict=None)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
logger.info('use gpu: %s' % (use_gpu))
if args.test_lang:
extra_embed = args.embed_dir + ("wiki.multi.%s.vec" % args.test_lang)
extra_word_dict, _ = load_embedding_dict('word2vec', extra_embed)
test_path = args.data_dir + args.test_lang + '_test.conllu'
extra_embeds_arr = augment_with_extra_embedding(word_alphabet, extra_word_dict, test_path, logger)
else:
extra_embeds_arr = []
for language in args.langs:
extra_embed = args.embed_dir + ("wiki.multi.%s.vec" % language)
extra_word_dict, _ = load_embedding_dict('word2vec', extra_embed)
test_path = args.data_dir + language + '_train.conllu'
embeds_arr1 = augment_with_extra_embedding(word_alphabet, extra_word_dict, test_path, logger)
test_path = args.data_dir + language + '_dev.conllu'
embeds_arr2 = augment_with_extra_embedding(word_alphabet, extra_word_dict, test_path, logger)
test_path = args.data_dir + language + '_test.conllu'
embeds_arr3 = augment_with_extra_embedding(word_alphabet, extra_word_dict, test_path, logger)
extra_embeds_arr.extend(embeds_arr1 + embeds_arr2 + embeds_arr3)
# ------------------------------------------------------------------------- #
# --------------------- Loading model ------------------------------------- #
def load_model_arguments_from_json():
arguments = json.load(open(arg_path, 'r'))
return arguments['args'], arguments['kwargs']
arg_path = pre_model_name + '.arg.json'
margs, kwargs = load_model_arguments_from_json()
network = BiRecurrentConvBiAffine(use_gpu=use_gpu, *margs, **kwargs)
network.load_state_dict(torch.load(pre_model_name))
args.use_bert = kwargs.get('use_bert', False)
#
augment_network_embed(word_alphabet.size(), network, extra_embeds_arr)
network.eval()
logger.info('model: %s' % pre_model_name)
# Freeze the network
for p in network.parameters():
p.requires_grad = False
nclass = args.nclass
classifier = nn.Sequential(
nn.Linear(network.encoder.output_dim, 512),
nn.Linear(512, nclass)
)
if use_gpu:
network.cuda()
classifier.cuda()
else:
network.cpu()
classifier.cpu()
batch_size = args.batch_size
# ===== the reading
def _read_one(path, is_train=False, max_size=None):
lang_id = guess_language_id(path)
logger.info("Reading: guess that the language of file %s is %s." % (path, lang_id))
one_data = conllx_data.read_data_to_variable(path, word_alphabet, char_alphabet, pos_alphabet,
type_alphabet, use_gpu=use_gpu, volatile=(not is_train),
use_bert=args.use_bert, symbolic_root=True, lang_id=lang_id,
max_size=max_size)
return one_data
def compute_accuracy(data, lang_idx):
total_corr, total = 0, 0
classifier.eval()
with torch.no_grad():
for batch in conllx_data.iterate_batch_variable(data, batch_size):
word, char, pos, _, _, masks, lengths, bert_inputs = batch
if use_gpu:
word = word.cuda()
char = char.cuda()
pos = pos.cuda()
masks = masks.cuda()
lengths = lengths.cuda()
if bert_inputs[0] is not None:
bert_inputs[0] = bert_inputs[0].cuda()
bert_inputs[1] = bert_inputs[1].cuda()
bert_inputs[2] = bert_inputs[2].cuda()
output = network.forward(word, char, pos, input_bert=bert_inputs,
mask=masks, length=lengths, hx=None)
output = output['output'].detach()
if args.train_level == 'word':
output = classifier(output)
output = output.contiguous().view(-1, output.size(2))
else:
output = torch.mean(output, dim=1)
output = classifier(output)
preds = output.max(1)[1].cpu()
labels = torch.LongTensor([lang_idx])
labels = labels.expand(*preds.size())
n_correct = preds.eq(labels).sum().item()
total_corr += n_correct
total += output.size(0)
return {'total_corr': total_corr, 'total': total}
if args.test_lang:
classifier.load_state_dict(torch.load(model_name))
path = args.data_dir + args.test_lang + '_train.conllu'
test_data = _read_one(path)
# TODO: fixed indexing is not GOOD
lang_idx = 0 if args.test_lang == args.src_lang else 1
result = compute_accuracy(test_data, lang_idx)
accuracy = (result['total_corr'] * 100.0) / result['total']
logger.info('[Classifier performance] Language: %s || accuracy: %.2f%%' % (args.test_lang, accuracy))
else:
# if output directory doesn't exist, create it
if not os.path.exists(args.model_path):
os.makedirs(args.model_path)
# --------------------- Loading data -------------------------------------- #
train_data = dict()
dev_data = dict()
test_data = dict()
num_data = dict()
lang_ids = dict()
reverse_lang_ids = dict()
# loading language data
for language in args.langs:
lang_ids[language] = len(lang_ids)
reverse_lang_ids[lang_ids[language]] = language
train_path = args.data_dir + language + '_train.conllu'
# Utilize at most 10000 examples
tmp_data = _read_one(train_path, max_size=10000)
num_data[language] = sum(tmp_data[1])
train_data[language] = tmp_data
dev_path = args.data_dir + language + '_dev.conllu'
tmp_data = _read_one(dev_path)
dev_data[language] = tmp_data
test_path = args.data_dir + language + '_test.conllu'
tmp_data = _read_one(test_path)
test_data[language] = tmp_data
# ------------------------------------------------------------------------- #
optim = torch.optim.Adam(classifier.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
def compute_loss(lang_name, land_idx):
word, char, pos, _, _, masks, lengths, bert_inputs = conllx_data.get_batch_variable(train_data[lang_name],
batch_size,
unk_replace=0.5)
if use_gpu:
word = word.cuda()
char = char.cuda()
pos = pos.cuda()
masks = masks.cuda()
lengths = lengths.cuda()
if bert_inputs[0] is not None:
bert_inputs[0] = bert_inputs[0].cuda()
bert_inputs[1] = bert_inputs[1].cuda()
bert_inputs[2] = bert_inputs[2].cuda()
output = network.forward(word, char, pos, input_bert=bert_inputs,
mask=masks, length=lengths, hx=None)
output = output['output'].detach()
if args.train_level == 'word':
output = classifier(output)
output = output.contiguous().view(-1, output.size(2))
else:
output = torch.mean(output, dim=1)
output = classifier(output)
labels = torch.empty(output.size(0)).fill_(land_idx).type_as(output).long()
loss = criterion(output, labels)
return loss
# ---------------------- Form the mini-batches -------------------------- #
num_batches = 0
batch_lang_labels = []
for lang in args.langs:
nbatches = num_data[lang] // batch_size + 1
batch_lang_labels.extend([lang] * nbatches)
num_batches += nbatches
assert len(batch_lang_labels) == num_batches
# ------------------------------------------------------------------------- #
best_dev_accuracy = 0
patience = 0
for epoch in range(1, args.num_epochs + 1):
# shuffling the data
lang_in_batch = copy.copy(batch_lang_labels)
random.shuffle(lang_in_batch)
classifier.train()
for batch in range(1, num_batches + 1):
lang_name = lang_in_batch[batch - 1]
lang_id = lang_ids.get(lang_name)
loss = compute_loss(lang_name, lang_id)
loss.backward()
optim.step()
# Validation
avg_acc = dict()
for dev_lang in dev_data.keys():
lang_idx = lang_ids.get(dev_lang)
result = compute_accuracy(dev_data[dev_lang], lang_idx)
accuracy = (result['total_corr'] * 100.0) / result['total']
avg_acc[dev_lang] = accuracy
acc = ', '.join('%s: %.2f' % (key, val) for (key, val) in avg_acc.items())
logger.info('Epoch: %d, Performance[%s]' % (epoch, acc))
avg_acc = sum(avg_acc.values()) / len(avg_acc)
if best_dev_accuracy < avg_acc:
best_dev_accuracy = avg_acc
patience = 0
state_dict = classifier.state_dict()
torch.save(state_dict, model_name)
else:
patience += 1
if patience >= 5:
break
# Testing
logger.info('Testing model %s' % pre_model_name)
total_corr, total = 0, 0
for test_lang in UD_languages:
if test_lang in test_data:
lang_idx = lang_ids.get(test_lang)
result = compute_accuracy(test_data[test_lang], lang_idx)
accuracy = (result['total_corr'] * 100.0) / result['total']
print('[LANG]: %s, [ACC]: %.2f' % (test_lang.upper(), accuracy))
total_corr += result['total_corr']
total += result['total']
print('[Avg. Performance]: %.2f' % ((total_corr * 100.0) / total))
def main():
args_parser = argparse.ArgumentParser(
description='Tuning with graph-based parsing')
args_parser.add_argument('--seed',
type=int,
default=1234,
help='random seed for reproducibility')
args_parser.add_argument('--mode',
choices=['RNN', 'LSTM', 'GRU', 'FastLSTM'],
help='architecture of rnn',
required=True)
args_parser.add_argument('--num_epochs',
type=int,
default=1000,
help='Number of training epochs')
args_parser.add_argument('--batch_size',
type=int,
default=64,
help='Number of sentences in each batch')
args_parser.add_argument('--hidden_size',
type=int,
default=256,
help='Number of hidden units in RNN')
args_parser.add_argument('--arc_space',
type=int,
default=128,
help='Dimension of tag space')
args_parser.add_argument('--type_space',
type=int,
default=128,
help='Dimension of tag space')
args_parser.add_argument('--num_layers',
type=int,
default=1,
help='Number of layers of encoder.')
args_parser.add_argument('--num_filters',
type=int,
default=50,
help='Number of filters in CNN')
args_parser.add_argument('--pos',
action='store_true',
help='use part-of-speech embedding.')
args_parser.add_argument('--char',
action='store_true',
help='use character embedding and CNN.')
args_parser.add_argument('--pos_dim',
type=int,
default=50,
help='Dimension of POS embeddings')
args_parser.add_argument('--char_dim',
type=int,
default=50,
help='Dimension of Character embeddings')
args_parser.add_argument('--opt',
choices=['adam', 'sgd', 'adamax'],
help='optimization algorithm')
args_parser.add_argument('--objective',
choices=['cross_entropy', 'crf'],
default='cross_entropy',
help='objective function of training procedure.')
args_parser.add_argument('--decode',
choices=['mst', 'greedy'],
default='mst',
help='decoding algorithm')
args_parser.add_argument('--learning_rate',
type=float,
default=0.01,
help='Learning rate')
# args_parser.add_argument('--decay_rate', type=float, default=0.05, help='Decay rate of learning rate')
args_parser.add_argument('--clip',
type=float,
default=5.0,
help='gradient clipping')
args_parser.add_argument('--gamma',
type=float,
default=0.0,
help='weight for regularization')
args_parser.add_argument('--epsilon',
type=float,
default=1e-8,
help='epsilon for adam or adamax')
args_parser.add_argument('--p_rnn',
nargs='+',
type=float,
required=True,
help='dropout rate for RNN')
args_parser.add_argument('--p_in',
type=float,
default=0.33,
help='dropout rate for input embeddings')
args_parser.add_argument('--p_out',
type=float,
default=0.33,
help='dropout rate for output layer')
# args_parser.add_argument('--schedule', type=int, help='schedule for learning rate decay')
args_parser.add_argument(
'--unk_replace',
type=float,
default=0.,
help='The rate to replace a singleton word with UNK')
args_parser.add_argument('--punctuation',
nargs='+',
type=str,
help='List of punctuations')
args_parser.add_argument(
'--word_embedding',
choices=['word2vec', 'glove', 'senna', 'sskip', 'polyglot'],
help='Embedding for words',
required=True)
args_parser.add_argument('--word_path',
help='path for word embedding dict')
args_parser.add_argument(
'--freeze',
action='store_true',
help='frozen the word embedding (disable fine-tuning).')
args_parser.add_argument('--char_embedding',
choices=['random', 'polyglot'],
help='Embedding for characters',
required=True)
args_parser.add_argument('--char_path',
help='path for character embedding dict')
args_parser.add_argument(
'--train') # "data/POS-penn/wsj/split1/wsj1.train.original"
args_parser.add_argument(
'--dev') # "data/POS-penn/wsj/split1/wsj1.dev.original"
args_parser.add_argument(
'--test') # "data/POS-penn/wsj/split1/wsj1.test.original"
args_parser.add_argument('--vocab_path',
help='path for prebuilt alphabets.',
default=None)
args_parser.add_argument('--model_path',
help='path for saving model file.',
required=True)
args_parser.add_argument('--model_name',
help='name for saving model file.',
required=True)
#
args_parser.add_argument('--no_word',
action='store_true',
help='do not use word embedding.')
#
# lrate schedule with warmup in the first iter.
args_parser.add_argument('--use_warmup_schedule',
action='store_true',
help="Use warmup lrate schedule.")
args_parser.add_argument('--decay_rate',
type=float,
default=0.75,
help='Decay rate of learning rate')
args_parser.add_argument('--max_decay',
type=int,
default=9,
help='Number of decays before stop')
args_parser.add_argument('--schedule',
type=int,
help='schedule for learning rate decay')
args_parser.add_argument('--double_schedule_decay',
type=int,
default=5,
help='Number of decays to double schedule')
args_parser.add_argument(
'--check_dev',
type=int,
default=5,
help='Check development performance in every n\'th iteration')
# Tansformer encoder
args_parser.add_argument('--no_CoRNN',
action='store_true',
help='do not use context RNN.')
args_parser.add_argument(
'--trans_hid_size',
type=int,
default=1024,
help='#hidden units in point-wise feed-forward in transformer')
args_parser.add_argument(
'--d_k',
type=int,
default=64,
help='d_k for multi-head-attention in transformer encoder')
args_parser.add_argument(
'--d_v',
type=int,
default=64,
help='d_v for multi-head-attention in transformer encoder')
args_parser.add_argument('--multi_head_attn',
action='store_true',
help='use multi-head-attention.')
args_parser.add_argument('--num_head',
type=int,
default=8,
help='Value of h in multi-head attention')
# - positional
args_parser.add_argument(
'--enc_use_neg_dist',
action='store_true',
help="Use negative distance for enc's relational-distance embedding.")
args_parser.add_argument(
'--enc_clip_dist',
type=int,
default=0,
help="The clipping distance for relative position features.")
args_parser.add_argument('--position_dim',
type=int,
default=50,
help='Dimension of Position embeddings.')
args_parser.add_argument(
'--position_embed_num',
type=int,
default=200,
help=
'Minimum value of position embedding num, which usually is max-sent-length.'
)
args_parser.add_argument('--train_position',
action='store_true',
help='train positional encoding for transformer.')
#
args_parser.add_argument(
'--train_len_thresh',
type=int,
default=100,
help='In training, discard sentences longer than this.')
#
args = args_parser.parse_args()
# fix data-prepare seed
random.seed(1234)
np.random.seed(1234)
# model's seed
torch.manual_seed(args.seed)
logger = get_logger("GraphParser")
mode = args.mode
obj = args.objective
decoding = args.decode
train_path = args.train
dev_path = args.dev
test_path = args.test
model_path = args.model_path
model_name = args.model_name
num_epochs = args.num_epochs
batch_size = args.batch_size
hidden_size = args.hidden_size
arc_space = args.arc_space
type_space = args.type_space
num_layers = args.num_layers
num_filters = args.num_filters
learning_rate = args.learning_rate
opt = args.opt
momentum = 0.9
betas = (0.9, 0.9)
eps = args.epsilon
decay_rate = args.decay_rate
clip = args.clip
gamma = args.gamma
schedule = args.schedule
p_rnn = tuple(args.p_rnn)
p_in = args.p_in
p_out = args.p_out
unk_replace = args.unk_replace
punctuation = args.punctuation
freeze = args.freeze
word_embedding = args.word_embedding
word_path = args.word_path
use_char = args.char
char_embedding = args.char_embedding
char_path = args.char_path
use_pos = args.pos
pos_dim = args.pos_dim
word_dict, word_dim = utils.load_embedding_dict(word_embedding, word_path)
char_dict = None
char_dim = args.char_dim
if char_embedding != 'random':
char_dict, char_dim = utils.load_embedding_dict(
char_embedding, char_path)
#
vocab_path = args.vocab_path if args.vocab_path is not None else args.model_path
logger.info("Creating Alphabets")
alphabet_path = os.path.join(vocab_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
# todo(warn): exactly same for loading vocabs
word_alphabet, char_alphabet, pos_alphabet, type_alphabet, max_sent_length = conllx_data.create_alphabets(
alphabet_path,
train_path,
data_paths=[dev_path, test_path],
max_vocabulary_size=50000,
embedd_dict=word_dict)
max_sent_length = max(max_sent_length, args.position_embed_num)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
logger.info("Reading Data")
use_gpu = torch.cuda.is_available()
# ===== the reading
def _read_one(path, is_train):
lang_id = guess_language_id(path)
logger.info("Reading: guess that the language of file %s is %s." %
(path, lang_id))
one_data = conllx_data.read_data_to_variable(
path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
use_gpu=use_gpu,
volatile=(not is_train),
symbolic_root=True,
lang_id=lang_id,
len_thresh=(args.train_len_thresh if is_train else 100000))
return one_data
data_train = _read_one(train_path, True)
num_data = sum(data_train[1])
data_dev = _read_one(dev_path, False)
data_test = _read_one(test_path, False)
# =====
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" %
(len(punct_set), ' '.join(punct_set)))
def construct_word_embedding_table():
scale = np.sqrt(3.0 / word_dim)
table = np.empty([word_alphabet.size(), word_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.zeros([1, word_dim]).astype(
np.float32) if freeze else np.random.uniform(
-scale, scale, [1, word_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in word_dict:
embedding = word_dict[word]
elif word.lower() in word_dict:
embedding = word_dict[word.lower()]
else:
embedding = np.zeros([1, word_dim]).astype(
np.float32) if freeze else np.random.uniform(
-scale, scale, [1, word_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('word OOV: %d' % oov)
return torch.from_numpy(table)
def construct_char_embedding_table():
if char_dict is None:
return None
scale = np.sqrt(3.0 / char_dim)
table = np.empty([num_chars, char_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(
-scale, scale, [1, char_dim]).astype(np.float32)
oov = 0
for char, index, in char_alphabet.items():
if char in char_dict:
embedding = char_dict[char]
else:
embedding = np.random.uniform(-scale, scale,
[1, char_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('character OOV: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
char_table = construct_char_embedding_table()
window = 3
if obj == 'cross_entropy':
network = BiRecurrentConvBiAffine(
word_dim,
num_words,
char_dim,
num_chars,
pos_dim,
num_pos,
num_filters,
window,
mode,
hidden_size,
num_layers,
num_types,
arc_space,
type_space,
embedd_word=word_table,
embedd_char=char_table,
p_in=p_in,
p_out=p_out,
p_rnn=p_rnn,
biaffine=True,
pos=use_pos,
char=use_char,
train_position=args.train_position,
use_con_rnn=(not args.no_CoRNN),
trans_hid_size=args.trans_hid_size,
d_k=args.d_k,
d_v=args.d_v,
multi_head_attn=args.multi_head_attn,
num_head=args.num_head,
enc_use_neg_dist=args.enc_use_neg_dist,
enc_clip_dist=args.enc_clip_dist,
position_dim=args.position_dim,
max_sent_length=max_sent_length,
use_gpu=use_gpu,
no_word=args.no_word)
elif obj == 'crf':
raise NotImplementedError
else:
raise RuntimeError('Unknown objective: %s' % obj)
def save_args():
arg_path = model_name + '.arg.json'
arguments = [
word_dim, num_words, char_dim, num_chars, pos_dim, num_pos,
num_filters, window, mode, hidden_size, num_layers, num_types,
arc_space, type_space
]
kwargs = {
'p_in': p_in,
'p_out': p_out,
'p_rnn': p_rnn,
'biaffine': True,
'pos': use_pos,
'char': use_char,
'train_position': args.train_position,
'use_con_rnn': (not args.no_CoRNN),
'trans_hid_size': args.trans_hid_size,
'd_k': args.d_k,
'd_v': args.d_v,
'multi_head_attn': args.multi_head_attn,
'num_head': args.num_head,
'enc_use_neg_dist': args.enc_use_neg_dist,
'enc_clip_dist': args.enc_clip_dist,
'position_dim': args.position_dim,
'max_sent_length': max_sent_length,
'no_word': args.no_word
}
json.dump({
'args': arguments,
'kwargs': kwargs
},
open(arg_path, 'w'),
indent=4)
if freeze:
network.word_embedd.freeze()
if use_gpu:
network.cuda()
save_args()
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
def generate_optimizer(opt, lr, params):
params = filter(lambda param: param.requires_grad, params)
if opt == 'adam':
return Adam(params,
lr=lr,
betas=betas,
weight_decay=gamma,
eps=eps)
elif opt == 'sgd':
return SGD(params,
lr=lr,
momentum=momentum,
weight_decay=gamma,
nesterov=True)
elif opt == 'adamax':
return Adamax(params,
lr=lr,
betas=betas,
weight_decay=gamma,
eps=eps)
else:
raise ValueError('Unknown optimization algorithm: %s' % opt)
lr = learning_rate
optim = generate_optimizer(opt, lr, network.parameters())
opt_info = 'opt: %s, ' % opt
if opt == 'adam':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
elif opt == 'sgd':
opt_info += 'momentum=%.2f' % momentum
elif opt == 'adamax':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
word_status = 'frozen' if freeze else 'fine tune'
char_status = 'enabled' if use_char else 'disabled'
pos_status = 'enabled' if use_pos else 'disabled'
logger.info(
"Embedding dim: word=%d (%s), char=%d (%s), pos=%d (%s)" %
(word_dim, word_status, char_dim, char_status, pos_dim, pos_status))
logger.info("CNN: filter=%d, kernel=%d" % (num_filters, window))
logger.info(
"RNN: %s, num_layer=%d, hidden=%d, arc_space=%d, type_space=%d" %
(mode, num_layers, hidden_size, arc_space, type_space))
logger.info(
"train: obj: %s, l2: %f, (#data: %d, batch: %d, clip: %.2f, unk replace: %.2f)"
% (obj, gamma, num_data, batch_size, clip, unk_replace))
logger.info("dropout(in, out, rnn): (%.2f, %.2f, %s)" %
(p_in, p_out, p_rnn))
logger.info("decoding algorithm: %s" % decoding)
logger.info(opt_info)
num_batches = num_data / batch_size + 1
dev_ucorrect = 0.0
dev_lcorrect = 0.0
dev_ucomlpete_match = 0.0
dev_lcomplete_match = 0.0
dev_ucorrect_nopunc = 0.0
dev_lcorrect_nopunc = 0.0
dev_ucomlpete_match_nopunc = 0.0
dev_lcomplete_match_nopunc = 0.0
dev_root_correct = 0.0
best_epoch = 0
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_root_correct = 0.0
test_total = 0
test_total_nopunc = 0
test_total_inst = 0
test_total_root = 0
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
patient = 0
decay = 0
max_decay = args.max_decay
double_schedule_decay = args.double_schedule_decay
# lrate schedule
step_num = 0
use_warmup_schedule = args.use_warmup_schedule
warmup_factor = (lr + 0.) / num_batches
if use_warmup_schedule:
logger.info("Use warmup lrate for the first epoch, from 0 up to %s." %
(lr, ))
#
for epoch in range(1, num_epochs + 1):
print(
'Epoch %d (%s, optim: %s, learning rate=%.6f, eps=%.1e, decay rate=%.2f (schedule=%d, patient=%d, decay=%d)): '
%
(epoch, mode, opt, lr, eps, decay_rate, schedule, patient, decay))
train_err = 0.
train_err_arc = 0.
train_err_type = 0.
train_total = 0.
start_time = time.time()
num_back = 0
network.train()
for batch in range(1, num_batches + 1):
# lrate schedule (before each step)
step_num += 1
if use_warmup_schedule and epoch <= 1:
cur_lrate = warmup_factor * step_num
# set lr
for param_group in optim.param_groups:
param_group['lr'] = cur_lrate
#
word, char, pos, heads, types, masks, lengths = conllx_data.get_batch_variable(
data_train, batch_size, unk_replace=unk_replace)
optim.zero_grad()
loss_arc, loss_type = network.loss(word,
char,
pos,
heads,
types,
mask=masks,
length=lengths)
loss = loss_arc + loss_type
loss.backward()
clip_grad_norm(network.parameters(), clip)
optim.step()
num_inst = word.size(
0) if obj == 'crf' else masks.data.sum() - word.size(0)
train_err += loss.data[0] * num_inst
train_err_arc += loss_arc.data[0] * num_inst
train_err_type += loss_type.data[0] * num_inst
train_total += num_inst
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
# update log
if batch % 10 == 0:
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
log_info = 'train: %d/%d loss: %.4f, arc: %.4f, type: %.4f, time left: %.2fs' % (
batch, num_batches, train_err / train_total, train_err_arc
/ train_total, train_err_type / train_total, time_left)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print(
'train: %d loss: %.4f, arc: %.4f, type: %.4f, time: %.2fs' %
(num_batches, train_err / train_total, train_err_arc / train_total,
train_err_type / train_total, time.time() - start_time))
################################################################################################
if epoch % args.check_dev != 0:
continue
# evaluate performance on dev data
network.eval()
pred_filename = 'tmp/%spred_dev%d' % (str(uid), epoch)
pred_writer.start(pred_filename)
gold_filename = 'tmp/%sgold_dev%d' % (str(uid), epoch)
gold_writer.start(gold_filename)
dev_ucorr = 0.0
dev_lcorr = 0.0
dev_total = 0
dev_ucomlpete = 0.0
dev_lcomplete = 0.0
dev_ucorr_nopunc = 0.0
dev_lcorr_nopunc = 0.0
dev_total_nopunc = 0
dev_ucomlpete_nopunc = 0.0
dev_lcomplete_nopunc = 0.0
dev_root_corr = 0.0
dev_total_root = 0.0
dev_total_inst = 0.0
for batch in conllx_data.iterate_batch_variable(data_dev, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(
word,
char,
pos,
mask=masks,
length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
pred_writer.write(word,
pos,
heads_pred,
types_pred,
lengths,
symbolic_root=True)
gold_writer.write(word,
pos,
heads,
types,
lengths,
symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(
word,
pos,
heads_pred,
types_pred,
heads,
types,
word_alphabet,
pos_alphabet,
lengths,
punct_set=punct_set,
symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
dev_ucorr += ucorr
dev_lcorr += lcorr
dev_total += total
dev_ucomlpete += ucm
dev_lcomplete += lcm
dev_ucorr_nopunc += ucorr_nopunc
dev_lcorr_nopunc += lcorr_nopunc
dev_total_nopunc += total_nopunc
dev_ucomlpete_nopunc += ucm_nopunc
dev_lcomplete_nopunc += lcm_nopunc
dev_root_corr += corr_root
dev_total_root += total_root
dev_total_inst += num_inst
pred_writer.close()
gold_writer.close()
print(
'W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%'
% (dev_ucorr, dev_lcorr, dev_total, dev_ucorr * 100 / dev_total,
dev_lcorr * 100 / dev_total, dev_ucomlpete * 100 /
dev_total_inst, dev_lcomplete * 100 / dev_total_inst))
print(
'Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%'
% (dev_ucorr_nopunc, dev_lcorr_nopunc, dev_total_nopunc,
dev_ucorr_nopunc * 100 / dev_total_nopunc, dev_lcorr_nopunc *
100 / dev_total_nopunc, dev_ucomlpete_nopunc * 100 /
dev_total_inst, dev_lcomplete_nopunc * 100 / dev_total_inst))
print('Root: corr: %d, total: %d, acc: %.2f%%' %
(dev_root_corr, dev_total_root,
dev_root_corr * 100 / dev_total_root))
if dev_lcorrect_nopunc < dev_lcorr_nopunc or (
dev_lcorrect_nopunc == dev_lcorr_nopunc
and dev_ucorrect_nopunc < dev_ucorr_nopunc):
dev_ucorrect_nopunc = dev_ucorr_nopunc
dev_lcorrect_nopunc = dev_lcorr_nopunc
dev_ucomlpete_match_nopunc = dev_ucomlpete_nopunc
dev_lcomplete_match_nopunc = dev_lcomplete_nopunc
dev_ucorrect = dev_ucorr
dev_lcorrect = dev_lcorr
dev_ucomlpete_match = dev_ucomlpete
dev_lcomplete_match = dev_lcomplete
dev_root_correct = dev_root_corr
best_epoch = epoch
patient = 0
# torch.save(network, model_name)
torch.save(network.state_dict(), model_name)
pred_filename = 'tmp/%spred_test%d' % (str(uid), epoch)
pred_writer.start(pred_filename)
gold_filename = 'tmp/%sgold_test%d' % (str(uid), epoch)
gold_writer.start(gold_filename)
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_total = 0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_total_nopunc = 0
test_total_inst = 0
test_root_correct = 0.0
test_total_root = 0
for batch in conllx_data.iterate_batch_variable(
data_test, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(
word,
char,
pos,
mask=masks,
length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
pred_writer.write(word,
pos,
heads_pred,
types_pred,
lengths,
symbolic_root=True)
gold_writer.write(word,
pos,
heads,
types,
lengths,
symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(
word,
pos,
heads_pred,
types_pred,
heads,
types,
word_alphabet,
pos_alphabet,
lengths,
punct_set=punct_set,
symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
test_ucorrect += ucorr
test_lcorrect += lcorr
test_total += total
test_ucomlpete_match += ucm
test_lcomplete_match += lcm
test_ucorrect_nopunc += ucorr_nopunc
test_lcorrect_nopunc += lcorr_nopunc
test_total_nopunc += total_nopunc
test_ucomlpete_match_nopunc += ucm_nopunc
test_lcomplete_match_nopunc += lcm_nopunc
test_root_correct += corr_root
test_total_root += total_root
test_total_inst += num_inst
pred_writer.close()
gold_writer.close()
else:
if dev_ucorr_nopunc * 100 / dev_total_nopunc < dev_ucorrect_nopunc * 100 / dev_total_nopunc - 5 or patient >= schedule:
# network = torch.load(model_name)
network.load_state_dict(torch.load(model_name))
lr = lr * decay_rate
optim = generate_optimizer(opt, lr, network.parameters())
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' %
decoding)
patient = 0
decay += 1
if decay % double_schedule_decay == 0:
schedule *= 2
else:
patient += 1
print(
'----------------------------------------------------------------------------------------------------------------------------'
)
print(
'best dev W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (dev_ucorrect, dev_lcorrect, dev_total,
dev_ucorrect * 100 / dev_total, dev_lcorrect * 100 / dev_total,
dev_ucomlpete_match * 100 / dev_total_inst,
dev_lcomplete_match * 100 / dev_total_inst, best_epoch))
print(
'best dev Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (dev_ucorrect_nopunc, dev_lcorrect_nopunc, dev_total_nopunc,
dev_ucorrect_nopunc * 100 / dev_total_nopunc,
dev_lcorrect_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_match_nopunc * 100 / dev_total_inst,
dev_lcomplete_match_nopunc * 100 / dev_total_inst, best_epoch))
print('best dev Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' %
(dev_root_correct, dev_total_root,
dev_root_correct * 100 / dev_total_root, best_epoch))
print(
'----------------------------------------------------------------------------------------------------------------------------'
)
print(
'best test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
% (test_ucorrect, test_lcorrect, test_total, test_ucorrect * 100 /
test_total, test_lcorrect * 100 / test_total,
test_ucomlpete_match * 100 / test_total_inst,
test_lcomplete_match * 100 / test_total_inst, best_epoch))
print(
'best test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)'
%
(test_ucorrect_nopunc, test_lcorrect_nopunc, test_total_nopunc,
test_ucorrect_nopunc * 100 / test_total_nopunc,
test_lcorrect_nopunc * 100 / test_total_nopunc,
test_ucomlpete_match_nopunc * 100 / test_total_inst,
test_lcomplete_match_nopunc * 100 / test_total_inst, best_epoch))
print('best test Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' %
(test_root_correct, test_total_root,
test_root_correct * 100 / test_total_root, best_epoch))
print(
'============================================================================================================================'
)
if decay == max_decay:
break
def biaffine(model_path, model_name, test_path, punct_set, use_gpu, logger,
args):
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
word_alphabet, char_alphabet, pos_alphabet, \
type_alphabet = conllx_data.create_alphabets(alphabet_path, None, data_paths=[None, None], max_vocabulary_size=50000, embedd_dict=None)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
decoding = args.decode
logger.info('use gpu: %s, decoding: %s' % (use_gpu, decoding))
data_test = conllx_data.read_data_to_tensor(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
use_gpu=use_gpu,
volatile=True,
symbolic_root=True)
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
logger.info('model: %s' % model_name)
def load_model_arguments_from_json():
arguments = json.load(open(arg_path, 'r'))
return arguments['args'], arguments['kwargs']
arg_path = model_name + '.arg.json'
args, kwargs = load_model_arguments_from_json()
network = BiRecurrentConvBiAffine(*args, **kwargs)
network.load_state_dict(torch.load(model_name))
if use_gpu:
network.cuda()
else:
network.cpu()
network.eval()
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_total = 0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_total_nopunc = 0
test_total_inst = 0
test_root_correct = 0.0
test_total_root = 0
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
pred_writer.start('tmp/analyze_pred_%s' % str(uid))
gold_writer.start('tmp/analyze_gold_%s' % str(uid))
sent = 0
start_time = time.time()
for batch in conllx_data.iterate_batch_tensor(data_test, 1):
sys.stdout.write('%d, ' % sent)
sys.stdout.flush()
sent += 1
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(
word,
char,
pos,
mask=masks,
length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
pred_writer.write(word,
pos,
heads_pred,
types_pred,
lengths,
symbolic_root=True)
gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(
word,
pos,
heads_pred,
types_pred,
heads,
types,
word_alphabet,
pos_alphabet,
lengths,
punct_set=punct_set,
symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
test_ucorrect += ucorr
test_lcorrect += lcorr
test_total += total
test_ucomlpete_match += ucm
test_lcomplete_match += lcm
test_ucorrect_nopunc += ucorr_nopunc
test_lcorrect_nopunc += lcorr_nopunc
test_total_nopunc += total_nopunc
test_ucomlpete_match_nopunc += ucm_nopunc
test_lcomplete_match_nopunc += lcm_nopunc
test_root_correct += corr_root
test_total_root += total_root
test_total_inst += num_inst
pred_writer.close()
gold_writer.close()
print('\ntime: %.2fs' % (time.time() - start_time))
print(
'test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%'
%
(test_ucorrect, test_lcorrect, test_total, test_ucorrect * 100 /
test_total, test_lcorrect * 100 / test_total, test_ucomlpete_match *
100 / test_total_inst, test_lcomplete_match * 100 / test_total_inst))
print(
'test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%'
%
(test_ucorrect_nopunc, test_lcorrect_nopunc, test_total_nopunc,
test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc *
100 / test_total_nopunc, test_ucomlpete_match_nopunc * 100 /
test_total_inst, test_lcomplete_match_nopunc * 100 / test_total_inst))
print('test Root: corr: %d, total: %d, acc: %.2f%%' %
(test_root_correct, test_total_root,
test_root_correct * 100 / test_total_root))
def run_biaffine(model_path, model_name, test_path, punct_set, use_gpu, logger,
args):
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
word_alphabet, char_alphabet, pos_alphabet, \
type_alphabet = conllx_data.create_alphabets(
alphabet_path,
None,
data_paths=[None, None],
max_vocabulary_size=50000,
embedd_dict=None
)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
decoding = args.decode
logger.info('use gpu: %s, decoding: %s' % (use_gpu, decoding))
device = torch.device('cuda') if use_gpu else torch.device('cpu')
data_test = aida_data.read_data_to_tensor(test_path,
word_alphabet,
char_alphabet,
pos_alphabet,
type_alphabet,
symbolic_root=True,
device=device)
pred_writer = AIDAWriter(word_alphabet, char_alphabet, pos_alphabet,
type_alphabet)
logger.info('model: %s' % model_name)
def load_model_arguments_from_json():
arguments = json.load(open(arg_path, 'r'))
return arguments['args'], arguments['kwargs']
arg_path = model_name + '.arg.json'
model_args, model_kwargs = load_model_arguments_from_json()
network = BiRecurrentConvBiAffine(*model_args, **model_kwargs)
if torch.cuda.is_available():
map_location = lambda storage, loc: storage.cuda()
else:
map_location = 'cpu'
network.load_state_dict(torch.load(model_name, map_location=map_location))
if use_gpu:
network.cuda()
else:
network.cpu()
network.eval()
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
pred_writer.start(args.output_path)
sent = 0
start_time = time.time()
with torch.no_grad():
for batch in aida_data.iterate_batch_tensor(data_test, 1):
sys.stdout.write('Processing sentence: %d\n' % sent)
sys.stdout.flush()
sent += 1
word, char, pos, _, _, masks, lengths, segment_ids_words = batch
heads_pred, types_pred = decode(
word,
char,
pos,
mask=masks,
length=lengths,
leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
segment_ids, segment_words = zip(*segment_ids_words)
pred_writer.write(segment_ids,
segment_words,
word,
pos,
heads_pred,
types_pred,
lengths,
symbolic_root=True)
pred_writer.close()
print('\ntime: %.2fs' % (time.time() - start_time))
def main():
args_parser = argparse.ArgumentParser(description='Tuning with graph-based parsing')
args_parser.add_argument('--mode', choices=['RNN', 'LSTM', 'GRU', 'FastLSTM'],
help='architecture of rnn', required=True)
args_parser.add_argument('--num_epochs', type=int, default=200, help='Number of training epochs')
args_parser.add_argument('--batch_size', type=int, default=64, help='Number of sentences in each batch')
args_parser.add_argument('--hidden_size', type=int, default=256, help='Number of hidden units in RNN')
args_parser.add_argument('--arc_space', type=int, default=128, help='Dimension of tag space')
args_parser.add_argument('--type_space', type=int, default=128, help='Dimension of tag space')
args_parser.add_argument('--num_layers', type=int, default=1, help='Number of layers of RNN')
args_parser.add_argument('--num_filters', type=int, default=50, help='Number of filters in CNN')
args_parser.add_argument('--pos', action='store_true', help='use part-of-speech embedding.')
args_parser.add_argument('--pos_dim', type=int, default=50, help='Dimension of POS embeddings')
args_parser.add_argument('--char_dim', type=int, default=50, help='Dimension of Character embeddings')
args_parser.add_argument('--objective', choices=['cross_entropy', 'crf'], default='cross_entropy',
help='objective function of training procedure.')
args_parser.add_argument('--decode', choices=['mst', 'greedy'], help='decoding algorithm', required=True)
args_parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate')
args_parser.add_argument('--decay_rate', type=float, default=0.05, help='Decay rate of learning rate')
args_parser.add_argument('--gamma', type=float, default=0.0, help='weight for regularization')
args_parser.add_argument('--p_rnn', nargs=2, type=float, required=True, help='dropout rate for RNN')
args_parser.add_argument('--p_in', type=float, default=0.33, help='dropout rate for input embeddings')
args_parser.add_argument('--p_out', type=float, default=0.33, help='dropout rate for output layer')
args_parser.add_argument('--schedule', type=int, help='schedule for learning rate decay')
args_parser.add_argument('--unk_replace', type=float, default=0.,
help='The rate to replace a singleton word with UNK')
args_parser.add_argument('--punctuation', nargs='+', type=str, help='List of punctuations')
args_parser.add_argument('--word_embedding', choices=['glove', 'senna', 'sskip', 'polyglot'],
help='Embedding for words', required=True)
args_parser.add_argument('--word_path', help='path for word embedding dict')
args_parser.add_argument('--char_embedding', choices=['random', 'polyglot'], help='Embedding for characters',
required=True)
args_parser.add_argument('--char_path', help='path for character embedding dict')
args_parser.add_argument('--train') # "data/POS-penn/wsj/split1/wsj1.train.original"
args_parser.add_argument('--dev') # "data/POS-penn/wsj/split1/wsj1.dev.original"
args_parser.add_argument('--test') # "data/POS-penn/wsj/split1/wsj1.test.original"
args_parser.add_argument('--model_path', help='path for saving model file.', required=True)
args = args_parser.parse_args()
print("*** Model UID: %s ***" % uid)
logger = get_logger("GraphParser")
mode = args.mode
obj = args.objective
decoding = args.decode
train_path = args.train
dev_path = args.dev
test_path = args.test
model_path = args.model_path
num_epochs = args.num_epochs
batch_size = args.batch_size
hidden_size = args.hidden_size
arc_space = args.arc_space
type_space = args.type_space
num_layers = args.num_layers
num_filters = args.num_filters
learning_rate = args.learning_rate
momentum = 0.9
betas = (0.9, 0.9)
decay_rate = args.decay_rate
gamma = args.gamma
schedule = args.schedule
p_rnn = tuple(args.p_rnn)
p_in = args.p_in
p_out = args.p_out
unk_replace = args.unk_replace
punctuation = args.punctuation
word_embedding = args.word_embedding
word_path = args.word_path
char_embedding = args.char_embedding
char_path = args.char_path
use_pos = args.pos
pos_dim = args.pos_dim
word_dict, word_dim = utils.load_embedding_dict(word_embedding, word_path)
char_dict = None
char_dim = args.char_dim
if char_embedding != 'random':
char_dict, char_dim = utils.load_embedding_dict(char_embedding, char_path)
logger.info("Creating Alphabets")
alphabet_path = os.path.join(model_path, 'alphabets/')
word_alphabet, char_alphabet, pos_alphabet, type_alphabet = conllx_data.create_alphabets(alphabet_path, train_path, data_paths=[dev_path, test_path],
max_vocabulary_size=50000, embedd_dict=word_dict)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
logger.info("Reading Data")
use_gpu = torch.cuda.is_available()
data_train = conllx_data.read_data_to_variable(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, symbolic_root=True)
# data_train = conllx_data.read_data(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
# num_data = sum([len(bucket) for bucket in data_train])
num_data = sum(data_train[1])
data_dev = conllx_data.read_data_to_variable(dev_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, volatile=True, symbolic_root=True)
data_test = conllx_data.read_data_to_variable(test_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, volatile=True, symbolic_root=True)
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" % (len(punct_set), ' '.join(punct_set)))
def construct_word_embedding_table():
scale = np.sqrt(3.0 / word_dim)
table = np.empty([word_alphabet.size(), word_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(-scale, scale, [1, word_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in word_dict:
embedding = word_dict[word]
elif word.lower() in word_dict:
embedding = word_dict[word.lower()]
else:
embedding = np.random.uniform(-scale, scale, [1, word_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('word OOV: %d' % oov)
return torch.from_numpy(table)
def construct_char_embedding_table():
if char_dict is None:
return None
scale = np.sqrt(3.0 / char_dim)
table = np.empty([num_chars, char_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.random.uniform(-scale, scale, [1, char_dim]).astype(np.float32)
oov = 0
for char, index, in char_alphabet.items():
if char in char_dict:
embedding = char_dict[char]
else:
embedding = np.random.uniform(-scale, scale, [1, char_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('character OOV: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
char_table = construct_char_embedding_table()
window = 3
if obj == 'cross_entropy':
network = BiRecurrentConvBiAffine(word_dim, num_words,
char_dim, num_chars,
pos_dim, num_pos,
num_filters, window,
mode, hidden_size, num_layers,
num_types, arc_space, type_space,
embedd_word=word_table, embedd_char=char_table,
p_in=p_in, p_out=p_out, p_rnn=p_rnn, biaffine=True, pos=use_pos)
elif obj == 'crf':
raise NotImplementedError
else:
raise RuntimeError('Unknown objective: %s' % obj)
if use_gpu:
network.cuda()
pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
adam_epochs = 50
adam_rate = 0.001
if adam_epochs > 0:
lr = adam_rate
opt = 'adam'
optim = Adam(network.parameters(), lr=adam_rate, betas=betas, weight_decay=gamma)
else:
opt = 'sgd'
lr = learning_rate
optim = SGD(network.parameters(), lr=lr, momentum=momentum, weight_decay=gamma, nesterov=True)
logger.info("Embedding dim: word=%d, char=%d, pos=%d (%s)" % (word_dim, char_dim, pos_dim, use_pos))
logger.info("Network: %s, num_layer=%d, hidden=%d, filter=%d, arc_space=%d, type_space=%d" % (
mode, num_layers, hidden_size, num_filters, arc_space, type_space))
logger.info("train: obj: %s, l2: %f, (#data: %d, batch: %d, dropout(in, out, rnn): (%.2f, %.2f, %s), unk replace: %.2f)" % (
obj, gamma, num_data, batch_size, p_in, p_out, p_rnn, unk_replace))
logger.info("decoding algorithm: %s" % decoding)
num_batches = num_data / batch_size + 1
dev_ucorrect = 0.0
dev_lcorrect = 0.0
dev_ucomlpete_match = 0.0
dev_lcomplete_match = 0.0
dev_ucorrect_nopunc = 0.0
dev_lcorrect_nopunc = 0.0
dev_ucomlpete_match_nopunc = 0.0
dev_lcomplete_match_nopunc = 0.0
dev_root_correct = 0.0
best_epoch = 0
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_root_correct = 0.0
test_total = 0
test_total_nopunc = 0
test_total_inst = 0
test_total_root = 0
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
for epoch in range(1, num_epochs + 1):
print('Epoch %d (%s, optim: %s, learning rate=%.4f, decay rate=%.4f (schedule=%d)): ' % (
epoch, mode, opt, lr, decay_rate, schedule))
train_err = 0.
train_err_arc = 0.
train_err_type = 0.
train_total = 0.
start_time = time.time()
num_back = 0
network.train()
for batch in range(1, num_batches + 1):
word, char, pos, heads, types, masks, lengths = conllx_data.get_batch_variable(data_train, batch_size,
unk_replace=unk_replace)
optim.zero_grad()
loss_arc, loss_type = network.loss(word, char, pos, heads, types, mask=masks, length=lengths)
loss = loss_arc + loss_type
loss.backward()
optim.step()
num_inst = word.size(0) if obj == 'crf' else masks.data.sum() - word.size(0)
train_err += loss.data[0] * num_inst
train_err_arc += loss_arc.data[0] * num_inst
train_err_type += loss_type.data[0] * num_inst
train_total += num_inst
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
# update log
if batch % 10 == 0:
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
log_info = 'train: %d/%d loss: %.4f, arc: %.4f, type: %.4f, time left (estimated): %.2fs' % (
batch, num_batches, train_err / train_total,
train_err_arc / train_total, train_err_type / train_total, time_left)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print('train: %d loss: %.4f, arc: %.4f, type: %.4f, time: %.2fs' % (
num_batches, train_err / train_total, train_err_arc / train_total, train_err_type / train_total,
time.time() - start_time))
# evaluate performance on dev data
network.eval()
pred_filename = 'tmp/%spred_dev%d' % (str(uid), epoch)
pred_writer.start(pred_filename)
gold_filename = 'tmp/%sgold_dev%d' % (str(uid), epoch)
gold_writer.start(gold_filename)
print('[%s] Epoch %d complete' % (time.strftime("%Y-%m-%d %H:%M:%S"), epoch))
dev_ucorr = 0.0
dev_lcorr = 0.0
dev_total = 0
dev_ucomlpete = 0.0
dev_lcomplete = 0.0
dev_ucorr_nopunc = 0.0
dev_lcorr_nopunc = 0.0
dev_total_nopunc = 0
dev_ucomlpete_nopunc = 0.0
dev_lcomplete_nopunc = 0.0
dev_root_corr = 0.0
dev_total_root = 0.0
dev_total_inst = 0.0
for batch in conllx_data.iterate_batch_variable(data_dev, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
pred_writer.write(word, pos, heads_pred, types_pred, lengths, symbolic_root=True)
gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types, word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
dev_ucorr += ucorr
dev_lcorr += lcorr
dev_total += total
dev_ucomlpete += ucm
dev_lcomplete += lcm
dev_ucorr_nopunc += ucorr_nopunc
dev_lcorr_nopunc += lcorr_nopunc
dev_total_nopunc += total_nopunc
dev_ucomlpete_nopunc += ucm_nopunc
dev_lcomplete_nopunc += lcm_nopunc
dev_root_corr += corr_root
dev_total_root += total_root
dev_total_inst += num_inst
pred_writer.close()
gold_writer.close()
print('W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
dev_ucorr, dev_lcorr, dev_total, dev_ucorr * 100 / dev_total, dev_lcorr * 100 / dev_total,
dev_ucomlpete * 100 / dev_total_inst, dev_lcomplete * 100 / dev_total_inst))
print('Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
dev_ucorr_nopunc, dev_lcorr_nopunc, dev_total_nopunc, dev_ucorr_nopunc * 100 / dev_total_nopunc,
dev_lcorr_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_nopunc * 100 / dev_total_inst, dev_lcomplete_nopunc * 100 / dev_total_inst))
print('Root: corr: %d, total: %d, acc: %.2f%%' %(
dev_root_corr, dev_total_root, dev_root_corr * 100 / dev_total_root))
if dev_ucorrect_nopunc <= dev_ucorr_nopunc:
dev_ucorrect_nopunc = dev_ucorr_nopunc
dev_lcorrect_nopunc = dev_lcorr_nopunc
dev_ucomlpete_match_nopunc = dev_ucomlpete_nopunc
dev_lcomplete_match_nopunc = dev_lcomplete_nopunc
dev_ucorrect = dev_ucorr
dev_lcorrect = dev_lcorr
dev_ucomlpete_match = dev_ucomlpete
dev_lcomplete_match = dev_lcomplete
dev_root_correct = dev_root_corr
best_epoch = epoch
pred_filename = 'tmp/%spred_test%d' % (str(uid), epoch)
pred_writer.start(pred_filename)
gold_filename = 'tmp/%sgold_test%d' % (str(uid), epoch)
gold_writer.start(gold_filename)
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_total = 0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_total_nopunc = 0
test_total_inst = 0
test_root_correct = 0.0
test_total_root = 0
for batch in conllx_data.iterate_batch_variable(data_test, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
pred_writer.write(word, pos, heads_pred, types_pred, lengths, symbolic_root=True)
gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types, word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
test_ucorrect += ucorr
test_lcorrect += lcorr
test_total += total
test_ucomlpete_match += ucm
test_lcomplete_match += lcm
test_ucorrect_nopunc += ucorr_nopunc
test_lcorrect_nopunc += lcorr_nopunc
test_total_nopunc += total_nopunc
test_ucomlpete_match_nopunc += ucm_nopunc
test_lcomplete_match_nopunc += lcm_nopunc
test_root_correct += corr_root
test_total_root += total_root
test_total_inst += num_inst
pred_writer.close()
gold_writer.close()
print('----------------------------------------------------------------------------------------------------------------------------')
print('best dev W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
dev_ucorrect, dev_lcorrect, dev_total, dev_ucorrect * 100 / dev_total, dev_lcorrect * 100 / dev_total,
dev_ucomlpete_match * 100 / dev_total_inst, dev_lcomplete_match * 100 / dev_total_inst,
best_epoch))
print('best dev Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
dev_ucorrect_nopunc, dev_lcorrect_nopunc, dev_total_nopunc,
dev_ucorrect_nopunc * 100 / dev_total_nopunc, dev_lcorrect_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_match_nopunc * 100 / dev_total_inst, dev_lcomplete_match_nopunc * 100 / dev_total_inst,
best_epoch))
print('best dev Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' % (
dev_root_correct, dev_total_root, dev_root_correct * 100 / dev_total_root, best_epoch))
print('----------------------------------------------------------------------------------------------------------------------------')
print('best test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
test_ucorrect, test_lcorrect, test_total, test_ucorrect * 100 / test_total, test_lcorrect * 100 / test_total,
test_ucomlpete_match * 100 / test_total_inst, test_lcomplete_match * 100 / test_total_inst,
best_epoch))
print('best test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
test_ucorrect_nopunc, test_lcorrect_nopunc, test_total_nopunc,
test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc * 100 / test_total_nopunc,
test_ucomlpete_match_nopunc * 100 / test_total_inst, test_lcomplete_match_nopunc * 100 / test_total_inst,
best_epoch))
print('best test Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' % (
test_root_correct, test_total_root, test_root_correct * 100 / test_total_root, best_epoch))
print('============================================================================================================================')
if epoch % schedule == 0:
# lr = lr * decay_rate
if epoch < adam_epochs:
opt = 'adam'
lr = adam_rate / (1.0 + epoch * decay_rate)
optim = Adam(network.parameters(), lr=lr, betas=betas, weight_decay=gamma)
else:
opt = 'sgd'
lr = learning_rate / (1.0 + (epoch - adam_epochs) * decay_rate)
optim = SGD(network.parameters(), lr=lr, momentum=momentum, weight_decay=gamma, nesterov=True)
def main():
args_parser = argparse.ArgumentParser(description='Tuning with graph-based parsing')
args_parser.add_argument('--schedule', type=int, help='schedule for learning rate decay')
args_parser.add_argument('--unk_replace', type=float, default=0., help='The rate to replace a singleton word with UNK')
args_parser.add_argument('--freeze', action='store_true', help='frozen the word embedding (disable fine-tuning).')
args = args_parser.parse_args()
logger = get_logger("GraphParser")
mode = "FastLSTM" #fast lstm here
obj = "cross_entropy"
decoding = "mst" #mst decode here
train_path = "data/train.stanford.conll"
dev_path = "data/dev.stanford.conll"
test_path = "data/test.stanford.conll"
model_path = "models/parsing/biaffine/"
model_name = 'network.pt'
num_epochs = 80
batch_size = 32
hidden_size = 512
arc_space = 512
type_space = 128
num_layers = 10
num_filters = 1
learning_rate = 0.001
opt = "adam" #default adam
momentum = 0.9
betas = (0.9, 0.9)
eps = 1e-4
decay_rate = 0.75
clip = 5 #what is clip
gamma = 0
schedule = 10 #?What is this?
p_rnn = (0.05,0.05)
p_in = 0.33
p_out = 0.33
unk_replace = args.unk_replace# ?what is this?
punctuation = ['.','``', "''", ':', ',']
freeze = args.freeze
word_embedding = 'glove'
word_path = "data/glove.6B.100d.txt"
use_char = False
char_embedding = None
#char_path = args.char_path
use_pos = True
pos_dim = 100
word_dict, word_dim = utils.load_embedding_dict(word_embedding, word_path)
char_dict = None
char_dim = 0
logger.info("Creating Alphabets")
alphabet_path = os.path.join(model_path, 'alphabets/')
model_name = os.path.join(model_path, model_name)
word_alphabet, char_alphabet, pos_alphabet, type_alphabet = conllx_data.create_alphabets(alphabet_path, train_path, data_paths=[dev_path, test_path],
max_vocabulary_size=50000, embedd_dict=word_dict)
num_words = word_alphabet.size()
num_chars = char_alphabet.size()
num_pos = pos_alphabet.size()
num_types = type_alphabet.size()
#print(word_alphabet.instance2index)
logger.info("Word Alphabet Size: %d" % num_words)
logger.info("Character Alphabet Size: %d" % num_chars)
logger.info("POS Alphabet Size: %d" % num_pos)
logger.info("Type Alphabet Size: %d" % num_types)
logger.info("Reading Data")
use_gpu = torch.cuda.is_available()
print(use_gpu)
data_train = conllx_data.read_data_to_variable(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, symbolic_root=True)
# data_train = conllx_data.read_data(train_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
# num_data = sum([len(bucket) for bucket in data_train])
num_data = sum(data_train[1])
"""
print("bucket_size")
print(data_train[1])
print("___________________________________data_train")
print(data_train[0])
"""
data_dev = conllx_data.read_data_to_variable(dev_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, volatile=True, symbolic_root=True)
data_test = conllx_data.read_data_to_variable(test_path, word_alphabet, char_alphabet, pos_alphabet, type_alphabet, use_gpu=use_gpu, volatile=True, symbolic_root=True)
punct_set = None
if punctuation is not None:
punct_set = set(punctuation)
logger.info("punctuations(%d): %s" % (len(punct_set), ' '.join(punct_set)))
def construct_word_embedding_table():
scale = np.sqrt(3.0 / word_dim)
table = np.empty([word_alphabet.size(), word_dim], dtype=np.float32)
table[conllx_data.UNK_ID, :] = np.zeros([1, word_dim]).astype(np.float32) if freeze else np.random.uniform(-scale, scale, [1, word_dim]).astype(np.float32)
oov = 0
for word, index in word_alphabet.items():
if word in word_dict:
embedding = word_dict[word]
elif word.lower() in word_dict:
embedding = word_dict[word.lower()]
else:
embedding = np.zeros([1, word_dim]).astype(np.float32) if freeze else np.random.uniform(-scale, scale, [1, word_dim]).astype(np.float32)
oov += 1
table[index, :] = embedding
print('word OOV: %d' % oov)
return torch.from_numpy(table)
word_table = construct_word_embedding_table()
window = 3
if obj == 'cross_entropy':
network = BiRecurrentConvBiAffine(word_dim, num_words, char_dim, num_chars, pos_dim, num_pos, num_filters, window,
mode, hidden_size, num_layers, num_types, arc_space, type_space,
embedd_word=word_table, embedd_char=None,
p_in=p_in, p_out=p_out, p_rnn=p_rnn, biaffine=True, pos=use_pos, char=use_char)
def save_args():
arg_path = model_name + '.arg.json'
arguments = [word_dim, num_words, char_dim, num_chars, pos_dim, num_pos, num_filters, window,
mode, hidden_size, num_layers, num_types, arc_space, type_space]
kwargs = {'p_in': p_in, 'p_out': p_out, 'p_rnn': p_rnn, 'biaffine': True, 'pos': use_pos, 'char': use_char}
json.dump({'args': arguments, 'kwargs': kwargs}, open(arg_path, 'w'), indent=4)
if freeze:
network.word_embedd.freeze()
if use_gpu:
network.cuda()
save_args()
#pred_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
#gold_writer = CoNLLXWriter(word_alphabet, char_alphabet, pos_alphabet, type_alphabet)
##print parameters:
print("number of parameters")
num_param = sum([param.nelement() for param in network.parameters()])
print(num_param)
def generate_optimizer(opt, lr, params):
params = filter(lambda param: param.requires_grad, params)
if opt == 'adam':
return Adam(params, lr=lr, betas=betas, weight_decay=gamma, eps=eps)
lr = learning_rate
optim = generate_optimizer(opt, lr, network.parameters())
opt_info = 'opt: %s, ' % opt
if opt == 'adam':
opt_info += 'betas=%s, eps=%.1e' % (betas, eps)
word_status = 'frozen' if freeze else 'fine tune'
char_status = 'enabled' if use_char else 'disabled'
pos_status = 'enabled' if use_pos else 'disabled'
logger.info("Embedding dim: word=%d (%s), char=%d (%s), pos=%d (%s)" % (word_dim, word_status, char_dim, char_status, pos_dim, pos_status))
logger.info("CNN: filter=%d, kernel=%d" % (num_filters, window))
logger.info("RNN: %s, num_layer=%d, hidden=%d, arc_space=%d, type_space=%d" % (mode, num_layers, hidden_size, arc_space, type_space))
logger.info("train: obj: %s, l2: %f, (#data: %d, batch: %d, clip: %.2f, unk replace: %.2f)" % (obj, gamma, num_data, batch_size, clip, unk_replace))
logger.info("dropout(in, out, rnn): (%.2f, %.2f, %s)" % (p_in, p_out, p_rnn))
logger.info("decoding algorithm: %s" % decoding)
logger.info(opt_info)
#logger.info("Attention")
num_batches = num_data / batch_size + 1
dev_ucorrect = 0.0
dev_lcorrect = 0.0
dev_ucomlpete_match = 0.0
dev_lcomplete_match = 0.0
dev_ucorrect_nopunc = 0.0
dev_lcorrect_nopunc = 0.0
dev_ucomlpete_match_nopunc = 0.0
dev_lcomplete_match_nopunc = 0.0
dev_root_correct = 0.0
best_epoch = 0
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_root_correct = 0.0
test_total = 0
test_total_nopunc = 0
test_total_inst = 0
test_total_root = 0
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
patient = 0
decay = 0
max_decay = 9
double_schedule_decay = 5
f = open("testout.csv", "wt")
writer = csv.writer(f)
writer.writerow(('train', 'dev'))
for epoch in range(1, num_epochs + 1):
print(epoch, mode, opt, lr, eps, decay_rate, schedule, patient, decay)
print('Epoch %d (%s, optim: %s, learning rate=%.6f, eps=%.1e, decay rate=%.2f (schedule=%d, patient=%d, decay=%d)): ' % (epoch, mode, opt, lr, eps, decay_rate, schedule, patient, decay))
train_err = 0.
train_err_arc = 0.
train_err_type = 0.
train_total = 0.
start_time = time.time()
num_back = 0
network.train()
for batch in range(1, num_batches + 1):
word, char, pos, heads, types, masks, lengths = conllx_data.get_batch_variable(data_train, batch_size, unk_replace=unk_replace)
optim.zero_grad()
loss_arc, loss_type = network.loss(word, char, pos, heads, types, mask=masks, length=lengths)
loss = loss_arc + loss_type
loss.backward()
clip_grad_norm(network.parameters(), clip)
optim.step()
num_inst = word.size(0) if obj == 'crf' else masks.data.sum() - word.size(0)
train_err += loss.data[0] * num_inst
train_err_arc += loss_arc.data[0] * num_inst
train_err_type += loss_type.data[0] * num_inst
train_total += num_inst
#bp()
time_ave = (time.time() - start_time) / batch
time_left = (num_batches - batch) * time_ave
# update log
if batch % 10 == 0:
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
log_info = 'train: %d/%d loss: %.4f, arc: %.4f, type: %.4f, time left: %.2fs' % (batch, num_batches, train_err / train_total,
train_err_arc / train_total, train_err_type / train_total, time_left)
sys.stdout.write(log_info)
sys.stdout.flush()
num_back = len(log_info)
sys.stdout.write("\b" * num_back)
sys.stdout.write(" " * num_back)
sys.stdout.write("\b" * num_back)
print('train: %d loss: %.4f, arc: %.4f, type: %.4f, time: %.2fs' % (num_batches, train_err / train_total, train_err_arc / train_total, train_err_type / train_total, time.time() - start_time))
# evaluate performance on dev data
network.eval()
dev_ucorr = 0.0
dev_lcorr = 0.0
dev_total = 0
dev_ucomlpete = 0.0
dev_lcomplete = 0.0
dev_ucorr_nopunc = 0.0
dev_lcorr_nopunc = 0.0
dev_total_nopunc = 0
dev_ucomlpete_nopunc = 0.0
dev_lcomplete_nopunc = 0.0
dev_root_corr = 0.0
dev_total_root = 0.0
dev_total_inst = 0.0
t_ucorr = 0.0
t_lcorr = 0.0
t_total = 0
t_ucomlpete = 0.0
t_lcomplete = 0.0
t_ucorr_nopunc = 0.0
t_lcorr_nopunc = 0.0
t_total_nopunc = 0
t_ucomlpete_nopunc = 0.0
t_lcomplete_nopunc = 0.0
t_root_corr = 0.0
t_total_root = 0.0
t_total_inst = 0.0
list_iter = iter(conllx_data.iterate_batch_variable(data_train, batch_size))
for batch in list_iter:
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types, word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
#print(t_ucorr)
t_ucorr += ucorr
t_lcorr += lcorr
t_total += total
t_ucomlpete += ucm
t_lcomplete += lcm
t_ucorr_nopunc += ucorr_nopunc
t_lcorr_nopunc += lcorr_nopunc
t_total_nopunc += total_nopunc
t_ucomlpete_nopunc += ucm_nopunc
t_lcomplete_nopunc += lcm_nopunc
t_root_corr += corr_root
t_total_root += total_root
t_total_inst += num_inst
for _ in range(10):
next(list_iter, None)
for batch in conllx_data.iterate_batch_variable(data_dev, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types, word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
dev_ucorr += ucorr
dev_lcorr += lcorr
dev_total += total
dev_ucomlpete += ucm
dev_lcomplete += lcm
dev_ucorr_nopunc += ucorr_nopunc
dev_lcorr_nopunc += lcorr_nopunc
dev_total_nopunc += total_nopunc
dev_ucomlpete_nopunc += ucm_nopunc
dev_lcomplete_nopunc += lcm_nopunc
dev_root_corr += corr_root
dev_total_root += total_root
dev_total_inst += num_inst
writer.writerow((t_ucorr_nopunc*100/t_total_nopunc,dev_ucorr_nopunc*100/dev_total_nopunc))
f.flush()
#pred_writer.close()
#gold_writer.close()
print('Train Wo Punct:%.2f%%'% (t_ucorr_nopunc*100/t_total_nopunc))
print('W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
dev_ucorr, dev_lcorr, dev_total, dev_ucorr * 100 / dev_total, dev_lcorr * 100 / dev_total, dev_ucomlpete * 100 / dev_total_inst, dev_lcomplete * 100 / dev_total_inst))
print('Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%%' % (
dev_ucorr_nopunc, dev_lcorr_nopunc, dev_total_nopunc, dev_ucorr_nopunc * 100 / dev_total_nopunc,
dev_lcorr_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_nopunc * 100 / dev_total_inst, dev_lcomplete_nopunc * 100 / dev_total_inst))
print('Root: corr: %d, total: %d, acc: %.2f%%' %(dev_root_corr, dev_total_root, dev_root_corr * 100 / dev_total_root))
if dev_lcorrect_nopunc< dev_lcorr_nopunc or (dev_lcorrect_nopunc == dev_lcorr_nopunc and dev_ucorrect_nopunc < dev_ucorr_nopunc):
dev_ucorrect_nopunc = dev_ucorr_nopunc
dev_lcorrect_nopunc = dev_lcorr_nopunc
dev_ucomlpete_match_nopunc = dev_ucomlpete_nopunc
dev_lcomplete_match_nopunc = dev_lcomplete_nopunc
dev_ucorrect = dev_ucorr
dev_lcorrect = dev_lcorr
dev_ucomlpete_match = dev_ucomlpete
dev_lcomplete_match = dev_lcomplete
dev_root_correct = dev_root_corr
best_epoch = epoch
patient = 0
# torch.save(network, model_name)
torch.save(network.state_dict(), model_name)
#pred_filename = 'tmp/%spred_test%d' % (str(uid), epoch)
#pred_writer.start(pred_filename)
#gold_filename = 'tmp/%sgold_test%d' % (str(uid), epoch)
#gold_writer.start(gold_filename)
test_ucorrect = 0.0
test_lcorrect = 0.0
test_ucomlpete_match = 0.0
test_lcomplete_match = 0.0
test_total = 0
test_ucorrect_nopunc = 0.0
test_lcorrect_nopunc = 0.0
test_ucomlpete_match_nopunc = 0.0
test_lcomplete_match_nopunc = 0.0
test_total_nopunc = 0
test_total_inst = 0
test_root_correct = 0.0
test_total_root = 0
for batch in conllx_data.iterate_batch_variable(data_test, batch_size):
word, char, pos, heads, types, masks, lengths = batch
heads_pred, types_pred = decode(word, char, pos, mask=masks, length=lengths, leading_symbolic=conllx_data.NUM_SYMBOLIC_TAGS)
word = word.data.cpu().numpy()
pos = pos.data.cpu().numpy()
lengths = lengths.cpu().numpy()
heads = heads.data.cpu().numpy()
types = types.data.cpu().numpy()
#pred_writer.write(word, pos, heads_pred, types_pred, lengths, symbolic_root=True)
#gold_writer.write(word, pos, heads, types, lengths, symbolic_root=True)
stats, stats_nopunc, stats_root, num_inst = parser.eval(word, pos, heads_pred, types_pred, heads, types, word_alphabet, pos_alphabet, lengths, punct_set=punct_set, symbolic_root=True)
ucorr, lcorr, total, ucm, lcm = stats
ucorr_nopunc, lcorr_nopunc, total_nopunc, ucm_nopunc, lcm_nopunc = stats_nopunc
corr_root, total_root = stats_root
test_ucorrect += ucorr
test_lcorrect += lcorr
test_total += total
test_ucomlpete_match += ucm
test_lcomplete_match += lcm
test_ucorrect_nopunc += ucorr_nopunc
test_lcorrect_nopunc += lcorr_nopunc
test_total_nopunc += total_nopunc
test_ucomlpete_match_nopunc += ucm_nopunc
test_lcomplete_match_nopunc += lcm_nopunc
test_root_correct += corr_root
test_total_root += total_root
test_total_inst += num_inst
#pred_writer.close()
#gold_writer.close()
else:
if dev_ucorr_nopunc * 100 / dev_total_nopunc < dev_ucorrect_nopunc * 100 / dev_total_nopunc - 5 or patient >= schedule:
# network = torch.load(model_name)
network.load_state_dict(torch.load(model_name))
lr = lr * decay_rate
optim = generate_optimizer(opt, lr, network.parameters())
if decoding == 'greedy':
decode = network.decode
elif decoding == 'mst':
decode = network.decode_mst
else:
raise ValueError('Unknown decoding algorithm: %s' % decoding)
patient = 0
decay += 1
if decay % double_schedule_decay == 0:
schedule *= 2
else:
patient += 1
print('----------------------------------------------------------------------------------------------------------------------------')
print('best dev W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
dev_ucorrect, dev_lcorrect, dev_total, dev_ucorrect * 100 / dev_total, dev_lcorrect * 100 / dev_total,
dev_ucomlpete_match * 100 / dev_total_inst, dev_lcomplete_match * 100 / dev_total_inst,
best_epoch))
print('best dev Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
dev_ucorrect_nopunc, dev_lcorrect_nopunc, dev_total_nopunc,
dev_ucorrect_nopunc * 100 / dev_total_nopunc, dev_lcorrect_nopunc * 100 / dev_total_nopunc,
dev_ucomlpete_match_nopunc * 100 / dev_total_inst, dev_lcomplete_match_nopunc * 100 / dev_total_inst,
best_epoch))
print('best dev Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' % (
dev_root_correct, dev_total_root, dev_root_correct * 100 / dev_total_root, best_epoch))
print('----------------------------------------------------------------------------------------------------------------------------')
print('best test W. Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
test_ucorrect, test_lcorrect, test_total, test_ucorrect * 100 / test_total, test_lcorrect * 100 / test_total,
test_ucomlpete_match * 100 / test_total_inst, test_lcomplete_match * 100 / test_total_inst,
best_epoch))
print('best test Wo Punct: ucorr: %d, lcorr: %d, total: %d, uas: %.2f%%, las: %.2f%%, ucm: %.2f%%, lcm: %.2f%% (epoch: %d)' % (
test_ucorrect_nopunc, test_lcorrect_nopunc, test_total_nopunc,
test_ucorrect_nopunc * 100 / test_total_nopunc, test_lcorrect_nopunc * 100 / test_total_nopunc,
test_ucomlpete_match_nopunc * 100 / test_total_inst, test_lcomplete_match_nopunc * 100 / test_total_inst,
best_epoch))
print('best test Root: corr: %d, total: %d, acc: %.2f%% (epoch: %d)' % (
test_root_correct, test_total_root, test_root_correct * 100 / test_total_root, best_epoch))
print('============================================================================================================================')
if decay == max_decay:
break
