def train():
batch_size = 64
# maxlen = 36
data_loader = Data_Loader(batch_size)
maxlen = data_loader.maxlen
model = Model(data_loader.emb_mat, num_class=3, drop_out=0.5).to(device)
optimizer = torch.optim.Adam(
model.parameters(),
lr=0.0001) ###############learning rate is important
epochs = 100
for i in range(epochs):
data_loader.reset_pointer()
num_batch = int(data_loader.train_size / batch_size)
for b in range(num_batch + 1):
input_data, mask_data, y_data = data_loader.__next__()
loss = model(input_data.to(device), maxlen, mask_data.to(device),
y_data.to(device))
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm(model.parameters(), 1.)
optimizer.step()
sys.stdout.write("\repoch:{}, batch:{}, loss:{}".format(
i, b, loss))
def train():
batch_size = 32
neg_size = 4
data_loader = Data_Loader(batch_size)
maxlen = data_loader.maxlen
model = Model(data_loader.emb_mat,
num_tag = data_loader.num_tag,
num_class = 3,
maxlen = maxlen,
batch_size = batch_size,
drop_out = 0.5,
neg_size = neg_size)
epochs = 100
best_acc = 0
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
for i in range(epochs):
data_loader.reset_pointer()
num_batch = int(data_loader.train_size/batch_size)
for b in range(num_batch+1):
input_data, input_tag, mask_data, y_data, label_mask = data_loader.__next__()
# print(input_data.shape, mask_data.shape, y_data.shape)
input_neg = np.random.randint(1,data_loader.vocab_size, (input_data.shape[0], maxlen, neg_size))
# print(input_neg)
y_data = to_categorical(y_data, 3)
# print(y_data.shape,'uqjwen')
_,loss = sess.run([model.train_op, model.cost], feed_dict = {model.x:input_data,
model.t:input_tag,
model.mask:mask_data,
model.neg:input_neg,
model.labels:y_data})
sys.stdout.write('\repoch:{}, batch:{}, loss:{}'.format(i,b,loss))
sys.stdout.flush()
# break
acc1, acc2 = val(sess, model, data_loader)
if acc1>best_acc:
best_acc = acc1
saver.save(sess, checkpointer_dir+'model.ckpt', global_step=i)
print("\nacc1: ",acc1, "acc2: ",acc2)
def train():
batch_size = 32
# domain = sys.argv[1]
data_loader = Data_Loader(batch_size, FLAGS.domain, FLAGS.emb_size)
maxlen = data_loader.maxlen
model = Model(data_loader.gen_mat,
data_loader.emb_mat,
num_tag=data_loader.num_tag,
num_cat=data_loader.num_cat,
num_class=3,
maxlen=maxlen,
batch_size=batch_size,
drop_out=0.5)
epochs = 100
best_1 = 0
best_2 = 0
train_loss = []
val_score = []
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# saver = tf.train.Saver(tf.global_variables())
saver = tf.train.Saver(max_to_keep=1)
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print(" [*] loading parameters success!!!")
else:
print(" [!] loading parameters failed...")
lambda_1 = 1
lambda_2 = 1
if FLAGS.variant == 'term':
lambda_2 = 0.
elif FLAGS.variant == 'category':
lambda_1 = 0.
print('lambda: ', lambda_1, lambda_2)
# print('lambda_2: ',lambda_2)
val_data = data_loader.val(1)
for i in range(epochs):
data_loader.reset_pointer()
num_batch = int(data_loader.train_size / batch_size)
# print("total batch: ", num_batch)
for b in range(num_batch + 1):
input_data, input_tag, mask_data, y_data, clabels, tfidf = data_loader.__next__(
)
# print(input_data.shape, input_tag.shape, mask_data.shape, y_data.shape, label_mask.shape)
# print(input_data.shape, mask_data.shape, y_data.shape)
# print(input_neg)
y_data = to_categorical(y_data, 3)
# print(y_data.shape,'uqjwen')
feed_dict = {
model.x: input_data,
model.t: input_tag,
model.mask: mask_data,
model.labels: y_data,
model.clabels: clabels,
model.is_training: True,
model.tfidf: tfidf,
model.lambda_1: lambda_1,
model.lambda_2: lambda_2
}
_, loss = sess.run([model.train_op, model.cost],
feed_dict=feed_dict)
sys.stdout.write('\repoch:{}, batch:{}, loss:{}'.format(
i, b, loss))
sys.stdout.flush()
# if loss is np.nan:
# print('sum_score',sum_score,'\nd1',d1,'\nd2',d2)
# break
# print("validation....")
lr = sess.run(model.lr, feed_dict={model.global_step: i})
# print('\t learning_rate: ',lr)
fscore_1, fscore_2 = val(sess, model, val_data)
print('\n', fscore_1, fscore_2)
# if i>=100:
# lambda_1 = 1.
if FLAGS.oriented == 'term' and fscore_1 > best_1:
saver.save(sess, checkpoint_dir + 'model.ckpt', global_step=i)
best_1 = fscore_1
print('\n', fscore_1)
elif FLAGS.oriented == 'category' and fscore_2 > best_2:
saver.save(sess, checkpoint_dir + 'model.ckpt', global_step=i)
best_2 = fscore_2
print('\n', fscore_2)
# print("\nfscore_1: ", fscore_1, "fscore_2: ", fscore_2)
# break
train_loss.append(loss)
val_score.append([fscore_1, fscore_2])
np.savetxt(FLAGS.output + train_loss_filename, train_loss, fmt='%.5f')
np.savetxt(FLAGS.output + val_loss_filename, val_score, fmt='%.5f')
