def main(argv):
test_data = Path.cwd() / 'data_in' / 'test.txt'
with open(Path.cwd() / 'data_in' / 'vocab.pkl', mode='rb') as io:
vocab = pickle.load(io)
test = tf.data.TextLineDataset(str(test_data)).batch(batch_size=FLAGS.batch_size)
tokenized = Mecab()
processing = Corpus(vocab=vocab, tokenizer=tokenized)
# init params
classes = FLAGS.classes
max_length = FLAGS.length
epochs = FLAGS.epochs
batch_size = FLAGS.batch_size
learning_rate = FLAGS.learning_rate
# create model
sen_cnn = SenCNN(vocab=vocab, classes=classes)
# create optimizer & loss_fn
opt = tf.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.losses.SparseCategoricalCrossentropy()
test_loss_metric = tf.keras.metrics.Mean(name='val_loss')
test_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='val_accuracy')
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=sen_cnn)
manager = tf.train.CheckpointManager(ckpt, './data_out/tf_ckpts', max_to_keep=3)
ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
print("Restored from {}".format(manager.latest_checkpoint))
else:
print("Initializing from scratch.")
tf.keras.backend.set_learning_phase(0)
test_loss_metric.reset_states()
test_acc_metric.reset_states()
for step, val in enumerate(test):
data, label = processing.token2idex(val)
logits = sen_cnn(data)
val_loss = loss_fn(label, logits)
# val_loss += mb_loss.numpy()
test_loss_metric.update_state(val_loss)
test_acc_metric.update_state(label, logits)
test_loss = test_loss_metric.result()
tqdm.write(
'epoch : {}, tr_acc : {:.3f}%, tr_loss : {:.3f}, '.format(1, test_acc_metric.result() * 100, test_loss))
def main(argv):
train_data = Path.cwd() / '..' / 'data_in' / 'train.txt'
val_data = Path.cwd() / '..' / 'data_in' / 'val.txt'
test_data = Path.cwd() / '..' / 'data_in' / 'test.txt'
dev_data = Path.cwd() / '..' / 'data_in' / 'dev.txt'
# init params
classes = FLAGS.classes
max_length = FLAGS.length
epochs = FLAGS.epochs
learning_rate = FLAGS.learning_rate
dim = FLAGS.embedding_dim
global_step = 1000
batch_size = FLAGS.batch_size
with open(Path.cwd() / '..' / 'data_in' / 'vocab.pkl', mode='rb') as io:
vocab = pickle.load(io)
train = tf.data.TextLineDataset(str(train_data)).shuffle(
buffer_size=batch_size).batch(batch_size=batch_size)
eval = tf.data.TextLineDataset(str(val_data)).batch(batch_size=batch_size)
test = tf.data.TextLineDataset(str(test_data)).batch(batch_size=batch_size)
dev = tf.data.TextLineDataset(str(dev_data)).batch(batch_size=batch_size)
padder = PadSequence(max_length,
pad_val=vocab.to_indices(vocab.padding_token))
processing = Corpus(vocab=vocab, split_fn=Split(), pad_fn=padder)
# create model
char_cnn = CharCNN(vocab=vocab, classes=classes, dim=dim)
# create optimizer & loss_fn
opt = tf.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.losses.SparseCategoricalCrossentropy()
train_loss_metric = tf.keras.metrics.Mean(name='train_loss')
train_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy(
name='train_accuracy')
val_loss_metric = tf.keras.metrics.Mean(name='val_loss')
val_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy(
name='val_accuracy')
# train_summary_writer = tf.summary.create_file_writer('./data_out/summaries/train')
# eval_summary_writer = tf.summary.create_file_writer('./data_out/summaries/eval')
# ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=char_cnn)
# manager = tf.train.CheckpointManager(ckpt, './data_out/tf_ckpts', max_to_keep=3)
# ckpt.restore(manager.latest_checkpoint)
#
# if manager.latest_checkpoint:
# print("Restored from {}".format(manager.latest_checkpoint))
# else:
# print("Initializing from scratch.")
#training
for epoch in tqdm(range(epochs), desc='epochs'):
train_loss_metric.reset_states()
train_acc_metric.reset_states()
val_loss_metric.reset_states()
val_acc_metric.reset_states()
tf.keras.backend.set_learning_phase(1)
#with train_summary_writer.as_default():
for step, val in tqdm(enumerate(train), desc='steps'):
data, label = processing.token2idex(val)
with tf.GradientTape() as tape:
logits = char_cnn(data)
train_loss = loss_fn(label, logits)
#ckpt.step.assign_add(1)
grads = tape.gradient(target=train_loss,
sources=char_cnn.trainable_variables)
opt.apply_gradients(
grads_and_vars=zip(grads, char_cnn.trainable_variables))
train_loss_metric.update_state(train_loss)
train_acc_metric.update_state(label, logits)
# if tf.equal(opt.iterations % global_step, 0):
# tf.summary.scalar('loss', train_loss_metric.result(), step=opt.iterations)
tr_loss = train_loss_metric.result()
#save_path = manager.save()
#print(save_path)
tqdm.write('epoch : {}, tr_acc : {:.3f}%, tr_loss : {:.3f}'.format(
epoch + 1,
train_acc_metric.result() * 100, tr_loss))
def main(argv):
train_data = Path.cwd() / 'data_in' / 'train.txt'
val_data = Path.cwd() / 'data_in' / 'val.txt'
with open(Path.cwd() / 'data_in' / 'vocab.pkl', mode='rb') as io:
vocab = pickle.load(io)
train = tf.data.TextLineDataset(str(train_data)).shuffle(buffer_size=1000).batch(batch_size=FLAGS.batch_size,
drop_remainder=True)
eval = tf.data.TextLineDataset(str(val_data)).batch(batch_size=FLAGS.batch_size, drop_remainder=True)
tokenized = MeCab()
processing = Corpus(vocab=vocab, tokenizer=tokenized)
# init params
classes = FLAGS.classes
max_length = FLAGS.length
epochs = FLAGS.epochs
learning_rate = FLAGS.learning_rate
global_step = 1000
# create model
sen_cnn = SenCNN(vocab=vocab, classes=classes)
# create optimizer & loss_fn
opt = tf.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.losses.SparseCategoricalCrossentropy(from_logits=True)
train_loss_metric = tf.keras.metrics.Mean(name='train_loss')
train_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
val_loss_metric = tf.keras.metrics.Mean(name='val_loss')
val_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='val_accuracy')
train_summary_writer = tf.summary.create_file_writer('./data_out/summaries/train')
eval_summary_writer = tf.summary.create_file_writer('./data_out/summaries/eval')
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=sen_cnn)
manager = tf.train.CheckpointManager(ckpt, './data_out/tf_ckpts', max_to_keep=3)
ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
print("Restored from {}".format(manager.latest_checkpoint))
else:
print("Initializing from scratch.")
# training
for epoch in tqdm(range(epochs), desc='epochs'):
train_loss_metric.reset_states()
train_acc_metric.reset_states()
val_loss_metric.reset_states()
val_acc_metric.reset_states()
tf.keras.backend.set_learning_phase(1)
tr_loss = 0
with train_summary_writer.as_default():
for step, val in tqdm(enumerate(train), desc='steps'):
data, label = processing.token2idex(val)
with tf.GradientTape() as tape:
logits = sen_cnn(data)
train_loss = loss_fn(label, logits)
ckpt.step.assign_add(1)
grads = tape.gradient(target=train_loss, sources=sen_cnn.trainable_variables)
opt.apply_gradients(grads_and_vars=zip(grads, sen_cnn.trainable_variables))
# tr_loss += pred_loss.numpy()
train_loss_metric.update_state(train_loss)
train_acc_metric.update_state(label, logits)
if tf.equal(opt.iterations % global_step, 0):
tf.summary.scalar('loss', train_loss_metric.result(), step=opt.iterations)
# else:
# tr_loss /= (step + 1)
# print("t_loss {}".format(tr_loss))
tr_loss = train_loss_metric.result()
save_path = manager.save()
print(save_path)
tf.keras.backend.set_learning_phase(0)
val_loss = 0
with eval_summary_writer.as_default():
for step, val in tqdm(enumerate(eval), desc='steps'):
data, label = processing.token2idex(val)
logits = sen_cnn(data)
val_loss = loss_fn(label, logits)
# val_loss += mb_loss.numpy()
val_loss_metric.update_state(val_loss)
val_acc_metric.update_state(label, logits)
tf.summary.scalar('loss', val_loss_metric.result(), step=step)
val_loss = val_loss_metric.result()
tqdm.write(
'epoch : {}, tr_acc : {:.3f}%, tr_loss : {:.3f}, val_acc : {:.3f}%, val_loss : {:.3f}'.format(epoch + 1,
train_acc_metric.result() * 100,
tr_loss,
val_acc_metric.result() * 100,
val_loss))