def evaluate(test_data, tagger, vocab, config):
total_acc, total_loss = 0, 0
nb_total = 0
tagger.eval()
for batch_data in get_batch(test_data, config.batch_size):
xb, yb, seq_lens = batch_variable_mask_easy(batch_data, vocab)
if config.use_cuda:
xb = xb.cuda()
yb = yb.cuda()
seq_lens = seq_lens.cuda()
pred = tagger(xb, seq_lens)
loss = calc_loss(pred, yb)
total_loss += loss.data.cpu().item()
total_acc += calc_acc(pred, yb)
nb_total += seq_lens.cpu().sum().item()
total_acc = float(total_acc) / nb_total
print('test: |loss: %f acc: %f|' % (total_loss, total_acc))
def evaluate(test_data, tagger, vocab, char_vocab, config):
total_acc, total_loss = 0, 0
nb_total = 0
tagger.eval()
for batch_data in get_batch(test_data, config.batch_size):
xb, xch, yb, mask, seq_lens = batch_variable_mask_easy(
batch_data, vocab, char_vocab)
if config.use_cuda:
xb = xb.cuda()
xch = xch.cuda()
yb = yb.cuda()
mask = mask.cuda()
seq_lens = seq_lens.cuda()
loss = torch.neg(tagger.neg_log_likelihood(xb, xch, mask, yb))
pred = tagger(xb, xch, mask)
total_loss += loss.data.cpu().item()
total_acc += calc_acc(pred, yb, mask)
nb_total += seq_lens.cpu().sum().item()
total_acc = float(total_acc) / nb_total
print('test: |loss: %f acc: %f|' % (total_loss, total_acc))
def train(train_data, test_data, dev_data, vocab, config, embed_weights):
tagger = POSTagger(vocab, config, embed_weights)
optimizer = optim.Adam(tagger.parameters(),
lr=config.learning_rate,
weight_decay=config.weight_decay)
# optimizer = optim.Adam(filter(lambda p: p.requires_grad, tagger.parameters()), lr=config.learning_rate, weight_decay=config.weight_decay)
if config.use_cuda:
tagger = tagger.cuda()
# print('model:', next(tagger.parameters()).is_cuda)
tagger.train()
total_acc, total_loss = [], []
for i in range(config.epochs):
print(' -- Epoch %d' % (i + 1))
epoch_acc, epoch_loss = 0, 0
nb_total = 0
t1 = time.time()
for batch_data in get_batch(train_data, config.batch_size):
# 1、准备数据
xb, yb, seq_lens = batch_variable_mask_easy(batch_data,
vocab) # 处理batch_data
if config.use_cuda:
xb = xb.cuda()
yb = yb.cuda()
seq_lens = seq_lens.cuda()
# 2、重置模型梯度为0
tagger.zero_grad()
# 3、将数据喂给模型
pred = tagger(xb, seq_lens)
# 4、计算损失值
loss = calc_loss(pred, yb)
epoch_acc += calc_acc(pred, yb)
epoch_loss += loss.data.cpu().item()
nb_total += seq_lens.cpu().sum().item()
# 5、误差反向传播
loss.backward()
# 6、更新模型参数
optimizer.step()
t2 = time.time()
print('time: %.3f min' % ((t2 - t1) / 60))
epoch_acc = float(epoch_acc) / nb_total
print('train: |loss: %f acc: %f|' % (epoch_loss, epoch_acc))
total_loss.append(epoch_loss)
total_acc.append(epoch_acc)
with torch.no_grad():
dev_total_acc, dev_total_loss = 0, 0
nb_total = 0
tagger.eval()
for batch_data in get_batch(dev_data, config.batch_size):
xb, yb, seq_lens = batch_variable_mask_easy(batch_data, vocab)
if config.use_cuda:
xb = xb.cuda()
yb = yb.cuda()
seq_lens = seq_lens.cuda()
pred = tagger(xb, seq_lens)
loss = calc_loss(pred, yb)
dev_total_loss += loss.data.cpu().item()
dev_total_acc += calc_acc(pred, yb)
nb_total += seq_lens.cpu().sum().item()
dev_total_acc = float(dev_total_acc) / nb_total
print('dev: |loss: %f acc: %f|' % (dev_total_loss, dev_total_acc))
# draw(total_acc, total_loss)
save_model(tagger, config.save_model_path)
evaluate(test_data, tagger, vocab, config)
def train(train_data, test_data, dev_data, vocab, config, wd_embed_weights,
char_embed_weights):
tagger = POSTagger(vocab, config, wd_embed_weights, char_embed_weights)
# optimizer = optim.Adam(tagger.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay)
optimizer = optim.Adam(filter(lambda p: p.requires_grad,
tagger.parameters()),
lr=config.learning_rate,
weight_decay=config.weight_decay)
if config.use_cuda:
tagger = tagger.cuda()
# print('model:', next(tagger.parameters()).is_cuda)
total_acc, total_loss = [], []
val_total_acc, val_total_loss = [], []
for ep in range(config.epochs):
tagger.train() # 不要放到循环外面！
print(' -- Epoch %d' % (ep + 1))
epoch_acc, epoch_loss = 0, 0
nb_total = 0
t1 = time.time()
for batch_data in get_batch(train_data, config.batch_size):
# 1、准备数据
xb, xch, yb, mask, seq_lens = batch_variable_mask_easy(
batch_data, vocab, char_vocab) # 处理batch_data
if config.use_cuda:
xb = xb.cuda()
xch = xch.cuda()
yb = yb.cuda()
mask = mask.cuda()
seq_lens = seq_lens.cuda()
# wd_lens = wd_lens.cuda()
# 2、重置模型梯度为0
tagger.zero_grad()
# 3、计算误差
loss = torch.neg(tagger.neg_log_likelihood(xb, xch, mask, yb))
# 4、将数据喂给模型
pred = tagger(xb, xch, mask)
epoch_acc += calc_acc(pred, yb, mask)
epoch_loss += loss.data.cpu().item()
nb_total += seq_lens.cpu().sum().item()
# 5、误差反向传播
loss.backward()
# 6、更新模型参数
optimizer.step()
t2 = time.time()
print('time: %.3f min' % ((t2 - t1) / 60))
epoch_acc = float(epoch_acc) / nb_total
print('train: |loss: %f acc: %f|' % (epoch_loss, epoch_acc))
total_loss.append(epoch_loss)
total_acc.append(epoch_acc)
with torch.no_grad(): # 适用于推断阶段，不需要反向传播
dev_total_acc, dev_total_loss = 0, 0
nb_total = 0
tagger.eval()
for batch_data in get_batch(dev_data, config.batch_size):
xb, xch, yb, mask, seq_lens = batch_variable_mask_easy(
batch_data, vocab, char_vocab)
if config.use_cuda:
xb = xb.cuda()
xch = xch.cuda()
yb = yb.cuda()
mask = mask.cuda()
seq_lens = seq_lens.cuda()
loss = torch.neg(tagger.neg_log_likelihood(xb, xch, mask, yb))
pred = tagger(xb, xch, mask)
dev_total_loss += loss.data.cpu().item()
dev_total_acc += calc_acc(pred, yb, mask)
nb_total += seq_lens.cpu().sum().item()
dev_total_acc = float(dev_total_acc) / nb_total
print('dev: |loss: %f acc: %f|' % (dev_total_loss, dev_total_acc))
val_total_acc.append(dev_total_acc)
val_total_loss.append(dev_total_loss)
# EarlyStopping
# if (ep+1) % 2 == 0 and dev_total_loss > min(val_total_loss):
# print('误差开始，执行早停！！！')
# save_model(tagger, config.save_model_path)
# break
# ModelCheckPoint: save_best_only
# if (ep+1) % 2 == 0 and dev_total_acc < max(val_total_acc):
# save_model(tagger, 'model-%02d-%.3f.pkl' % (ep, dev_total_acc))
print('acc:', total_acc, 'loss:', total_loss)
print('val_acc:', val_total_acc, 'val_loss:', val_total_loss)
# draw(total_acc, total_loss)
save_model(tagger, config.save_model_path)