def main(cfgpath):
# parsing config.json
proj_dir = Path.cwd()
params = json.load((proj_dir / cfgpath).open())
# create dataset
batch_size = params['training'].get('batch_size')
tr_filepath = params['filepath'].get('tr')
val_filepath = params['filepath'].get('val')
tr_ds = create_dataset(tr_filepath, batch_size, True)
val_ds = create_dataset(val_filepath, batch_size, False)
# create pre_processor
vocab = pickle.load(
(proj_dir / params['filepath'].get('vocab')).open(mode='rb'))
pre_processor = PreProcessor(vocab=vocab, tokenizer=Okt)
# create model
model = SenCNN(num_classes=2, vocab=vocab)
# create optimizer & loss_fn
epochs = params['training'].get('epochs')
learning_rate = params['training'].get('learning_rate')
opt = tf.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.losses.SparseCategoricalCrossentropy()
# training
for epoch in tqdm(range(epochs), desc='epochs'):
tr_loss = 0
tf.keras.backend.set_learning_phase(1)
for step, mb in tqdm(enumerate(tr_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
with tf.GradientTape() as tape:
mb_loss = loss_fn(y_mb, model(x_mb))
grads = tape.gradient(target=mb_loss,
sources=model.trainable_variables)
opt.apply_gradients(
grads_and_vars=zip(grads, model.trainable_variables))
tr_loss += mb_loss.numpy()
else:
tr_loss /= (step + 1)
tf.keras.backend.set_learning_phase(0)
val_loss = 0
for step, mb in tqdm(enumerate(val_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
mb_loss = loss_fn(y_mb, model(x_mb))
val_loss += mb_loss.numpy()
else:
val_loss /= (step + 1)
tqdm.write('epoch : {}, tr_loss : {:.3f}, val_loss : {:.3f}'.format(
epoch + 1, tr_loss, val_loss))
def main(self):
batch_size = self._batch_size
tr_filepath = 'data/train.txt'
val_filepath = 'data/val.txt'
tr_ds = SmCnn.create_dataset(self,
tr_filepath,
batch_size,
shuffle=True)
val_ds = SmCnn.create_dataset(self,
val_filepath,
batch_size,
shuffle=False)
vocab = pd.read_pickle('data/vocab.pkl')
pre_processor = PreProcessor(vocab=vocab, tokenizer=Mecab())
# create model
model = SmCnn()
# create optimizer & loss_fn
epochs = self._epochs
learning_rate = self._learning_rate
opt = tf.keras.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()
# training
for epoch in tqdm(range(epochs), desc='steps'):
tr_loss = 0
tf.keras.backend.set_learning_phase(1)
for step, mb in tqdm(enumerate(tr_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
with tf.GradientTape() as tape:
mb_loss = loss_fn(y_mb, model(x_mb))
grads = tape.gradient(target=mb_loss,
sources=model.trainable_variables)
opt.apply_gradients(
grads_and_vars=zip(grads, model.trainable_variables))
tr_loss += mb_loss.numpy()
else:
tr_loss /= (step + 1)
tf.keras.backend.set_learning_phase(0)
val_loss = 0
for step, mb in tqdm(enumerate(val_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
mb_loss = loss_fn(y_mb, model(x_mb))
val_loss += mb_loss.numpy()
else:
val_loss /= (step + 1)
tqdm.write(
'epoch : {}, tr_loss : {:.3f}, val_loss : {:.3f}'.format(
epoch + 1, tr_loss, val_loss))
def main(cfgpath, global_step):
# parsing config.json
proj_dir = Path.cwd()
params = json.load((proj_dir / cfgpath).open())
# create dataset
batch_size = params['training'].get('batch_size')
tr_filepath = params['filepath'].get('tr')
val_filepath = params['filepath'].get('val')
tr_ds = create_dataset(tr_filepath, batch_size, True)
val_ds = create_dataset(val_filepath, batch_size, False)
# create pre_processor
vocab = pickle.load((proj_dir / params['filepath'].get('vocab')).open(mode='rb'))
pre_processor = PreProcessor(vocab=vocab, tokenizer=MeCab().morphs, pad_idx=1)
# create model
model = SenCNN(num_classes=2, vocab=vocab)
# create optimizer & loss_fn
epochs = params['training'].get('epochs')
learning_rate = params['training'].get('learning_rate')
opt = tf.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.losses.SparseCategoricalCrossentropy(from_logits=True)
writer = tf.summary.create_file_writer(logdir='./runs/exp')
# training
for epoch in tqdm(range(epochs), desc='epochs'):
tr_loss = 0
tf.keras.backend.set_learning_phase(1)
for step, mb in tqdm(enumerate(tr_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
with tf.GradientTape() as tape:
mb_loss = loss_fn(y_mb, model(x_mb))
grads = tape.gradient(target=mb_loss, sources=model.trainable_variables)
opt.apply_gradients(grads_and_vars=zip(grads, model.trainable_variables))
tr_loss += mb_loss.numpy()
if tf.equal(opt.iterations % global_step, 0):
with writer.as_default():
val_loss = evaluate(model, val_ds, loss_fn, pre_processor.convert2idx)
tf.summary.scalar('tr_loss', tr_loss / (step + 1), step=opt.iterations)
tf.summary.scalar('val_loss', val_loss, step=opt.iterations)
tf.keras.backend.set_learning_phase(1)
else:
tr_loss /= (step + 1)
val_loss = evaluate(model, val_ds, loss_fn, pre_processor.convert2idx)
tqdm.write('epoch : {}, tr_loss : {:.3f}, val_loss : {:.3f}'.format(epoch + 1, tr_loss, val_loss))
ckpt_path = proj_dir / params['filepath'].get('ckpt')
ckpt = tf.train.Checkpoint(model=model)
ckpt.save(ckpt_path)
def main():
tr_filepath = Path.cwd() / 'data' / 'train.txt'
val_filepath = Path.cwd() / 'data' / 'val.txt'
with open(Path.cwd() / 'data/vocab.pkl', mode='rb') as f:
vocab = pickle.load(f)
tr_ds = create_dataset(str(tr_filepath), 128, shuffle=True)
val_ds = create_dataset(str(val_filepath), 128,
shuffle=False) # 평가 데이터는 셔플 ㄴㄴ
tokenized = Okt()
pre_processor = PreProcessor(vocab=vocab, tokenizer=tokenized)
# create model
model = SenCNN(num_classes=2, vocab=vocab)
# create optimizer & loss_fn
epochs = 10
learning_rate = 1e-3
opt = tf.optimizers.Adam(learning_rate=learning_rate)
loss_fn = tf.losses.SparseCategoricalCrossentropy(from_logits=True)
# metrics
tr_loss_metric = tf.keras.metrics.Mean(name='train_loss')
tr_accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(
name='train_accuracy')
val_loss_metric = tf.keras.metrics.Mean(name='validation_loss')
val_accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(
name='validation_accuracy')
# training
for epoch in tqdm(range(epochs), desc='epochs'):
# trining data
tf.keras.backend.set_learning_phase(1) # train mode
for _, mb in tqdm(enumerate(tr_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
x_mb = pre_processor.pad_sequences(x_mb, 70)
x_mb, y_mb = pre_processor.convert_to_tensor(x_mb, y_mb)
with tf.GradientTape() as tape:
mb_loss = loss_fn(y_mb, model(x_mb))
grads = tape.gradient(target=mb_loss,
sources=model.trainable_variables)
opt.apply_gradients(
grads_and_vars=zip(grads, model.trainable_variables))
tr_loss_metric.update_state(mb_loss)
tr_accuracy_metric(y_mb, model(x_mb))
tr_mean_loss = tr_loss_metric.result()
tr_mean_accuracy = tr_accuracy_metric.result()
# test data
tf.keras.backend.set_learning_phase(0) # test mode
for _, mb in tqdm(enumerate(val_ds), desc='steps'):
x_mb, y_mb = pre_processor.convert2idx(mb)
x_mb = pre_processor.pad_sequences(x_mb, 70)
x_mb, y_mb = pre_processor.convert_to_tensor(x_mb, y_mb)
mb_loss = loss_fn(y_mb, model(x_mb))
val_loss_metric.update_state(mb_loss)
val_accuracy_metric.update_state(y_mb, model(x_mb))
val_mean_loss = val_loss_metric.result()
val_mean_accuracy = val_accuracy_metric.result()
tqdm.write(
'epoch : {}, tr_accuracy : {:.3f}, tr_loss : {:.3f}, val_accuracy : {:.3f}, val_loss : {:.3f}'
.format(epoch + 1, tr_mean_accuracy, tr_mean_loss,
val_mean_accuracy, val_mean_loss))
ckpt_path = Path.cwd() / 'checkpoint/ckpt'
ckpt = tf.train.Checkpoint(model=model)
ckpt.save(ckpt_path)
