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)