def transfer_test():
params = {
'checkpoint_path':
'data/exp1a/trial_0/',
'old_scope':
'/',
'hidden_size':
12,
'num_layers':
2,
'max_len':
20,
'num_classes':
2,
'dropout':
1.0,
'quantifiers':
[quantifiers.at_least_n(4),
quantifiers.at_least_n_or_at_most_m(6, 2)]
}
# print(params['quantifiers'][0]._name)
model = tf.estimator.Estimator(model_fn=transfer_lstm_model_fn,
params=params)
generator = data_gen.DataGenerator(params['max_len'],
params['quantifiers'],
num_data_points=1000)
some_data = generator.get_training_data()
# must train before predict, so we'll give it one example
model.train(input_fn=tf.estimator.inputs.numpy_input_fn(
x={quant_verify.INPUT_FEATURE: np.array([some_data[0][0]])},
y=np.array([some_data[0][1]]),
shuffle=False))
some_inputs = np.array([datum[0] for datum in some_data])
predict_input_fn = tf.estimator.inputs.numpy_input_fn(
x={quant_verify.INPUT_FEATURE: some_inputs}, shuffle=False)
predictions = list(model.predict(input_fn=predict_input_fn))
for idx in range(5):
print('input: {}\nprobs: {}\n'.format(some_inputs[idx],
predictions[idx]['probs']))
def run_trial(eparams,
hparams,
trial_num,
write_path='/tmp/tensorflow/quantexp'):
tf.reset_default_graph()
write_dir = '{}/trial_{}'.format(write_path, trial_num)
csv_file = '{}/trial_{}.csv'.format(write_path, trial_num)
# BUILD MODEL
run_config = tf.estimator.RunConfig(
save_checkpoints_steps=eparams['eval_steps'],
save_checkpoints_secs=None,
save_summary_steps=eparams['eval_steps'])
model = tf.estimator.Estimator(model_fn=lstm_model_fn,
params=hparams,
model_dir=write_dir,
config=run_config)
# GENERATE DATA
generator = data_gen.DataGenerator(hparams['max_len'],
hparams['quantifiers'],
mode=eparams['generator_mode'],
num_data_points=eparams['num_data'])
training_data = generator.get_training_data()
test_data = generator.get_test_data()
def get_np_data(data):
x_data = np.array([datum[0] for datum in data])
y_data = np.array([datum[1] for datum in data])
return x_data, y_data
# input fn for training
train_x, train_y = get_np_data(training_data)
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={INPUT_FEATURE: train_x},
y=train_y,
batch_size=eparams['batch_size'],
num_epochs=eparams['num_epochs'],
shuffle=True)
# input fn for evaluation
test_x, test_y = get_np_data(test_data)
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
x={INPUT_FEATURE: test_x},
y=test_y,
batch_size=len(test_x),
shuffle=False)
print '\n------ TRIAL {} -----'.format(trial_num)
# train and evaluate model together, using the Hook
model.train(input_fn=train_input_fn,
hooks=[
EvalEarlyStopHook(model, eval_input_fn, csv_file,
eparams['eval_steps'],
eparams['stop_loss'])
])
def main():
# Read datasets
data = Dataset(args.DATA_DIR)
sents, tags = data.get_all_data()
# Construct the model
MyModel = BiLSTMModel(args.MAX_SEQ_LEN, args.EMBEDDING,
args.LSTM_HIDDEN_UNITS, args.LSTM_DENSE_DIM,
data.get_nwords(), data.get_ntags())
model = MyModel.define_model()
num_train_sents = len(data.train_sents)
num_val_sents = len(data.val_sents)
num_test_sents = len(data.test_sents)
print(
"# train sents = {0} \n # of val sents = {1} \n # of test sents = {2}".
format(num_train_sents, num_val_sents, num_test_sents),
flush=True)
# indexes to train, val and test data
partition = {
"train": list(range(num_train_sents)),
"val": list(range(num_val_sents)),
"test": list(range(num_test_sents))
}
# Parameters
params = {
'dim': args.MAX_SEQ_LEN,
'batch_size': args.BATCH_SIZE,
'n_classes': data.get_ntags(),
'shuffle': True,
'word2idx': data.get_word2idx(),
'tag2idx': data.get_tag2idx()
}
# Generators
training_generator = DG.DataGenerator(partition['train'], data.train_sents,
data.train_tags, **params)
validation_generator = DG.DataGenerator(partition['val'], data.val_sents,
data.val_tags, **params)
# Train model on dataset
history = model.fit_generator(generator=training_generator,
validation_data=validation_generator,
use_multiprocessing=True,
epochs=args.NUM_EPOCHS,
verbose=1)
# Parameters
params_test = {
'dim': args.MAX_SEQ_LEN,
'batch_size': 1,
'n_classes': data.get_ntags(),
'shuffle': False,
'word2idx': data.get_word2idx(),
'tag2idx': data.get_tag2idx()
}
# Make predictions
testing_generator = DG.DataGenerator(partition['test'], data.test_sents,
data.train_tags, **params_test)
pred_test = model.predict_generator(generator=testing_generator,
steps=num_test_sents)
pred_test = np.argmax(pred_test, axis=-1)
# print(pred_test.shape)
def pad(x):
x1 = [
tgs + ([data.get_tag2idx()["PAD"]] * (args.MAX_SEQ_LEN - len(tgs)))
for tgs in x
]
x2 = [tgs[:args.MAX_SEQ_LEN] for tgs in x1]
return np.array(x2)
test_tags_padded = pad(data.test_tags)
# print(test_tags_padded.shape)
def get_measures(yTrue, yPred):
y1 = yTrue.reshape(1, -1).squeeze()
y2 = yPred.reshape(1, -1).squeeze()
P = precision_score(y1, y2, average=None)
R = recall_score(y1, y2, average=None)
F1 = f1_score(y1, y2, average=None)
print("Precision=", flush=True)
print(P, flush=True)
print("Recall=", flush=True)
print(R, flush=True)
print("F1 score=", flush=True)
print(F1, flush=True)
print("Test...", flush=True)
get_measures(test_tags_padded, pred_test)
