def main():
debug = False
parser = argparse.ArgumentParser()
parser.add_argument('--nn_weights', type=str)
parser.add_argument('--output_file', type=str)
parser.add_argument('--bimpmp', action='store_true')
args = parser.parse_args()
weightFn = args.nn_weights
output_fn = args.output_file
assert weightFn
isBimpmp = args.bimpmp
if isBimpmp:
print "using bimpmp"
config = BimpmpConfig()
else:
print "using bidirattn"
config = BiDirAttnBidirCondConfig()
# Create result directories
linear_related_preds = classify_related_unrelated()
glove_matrix, related_h_glove_index_matrix, related_a_glove_index_matrix, related_h_seq_lengths, related_a_seq_lengths, max_input_lengths, related_labels, unrelated_labels = create_sub_class_test_data(
linear_related_preds, config)
test_set = [
related_h_glove_index_matrix, related_a_glove_index_matrix,
related_h_seq_lengths, related_a_seq_lengths, related_labels
]
sub1_labels = vectorize_stances(unrelated_labels)
with tf.Graph().as_default():
print 80 * "="
print "INITIALIZING"
print 80 * "="
print "Building model...",
scoring_fn = lambda actual, preds: report_pipeline_score(
actual, preds, sub1_labels)
if isBimpmp:
model = Bimpmp(config, scoring_fn, max_input_lengths, glove_matrix,
debug)
else:
model = Bidirectional_Attention_Conditonal_Encoding_LSTM_Model(
config, scoring_fn, max_input_lengths, glove_matrix, debug)
model.print_params()
# Initialize variables
init = tf.global_variables_initializer()
with tf.Session() as session:
session.run(init)
saver = create_tensorflow_saver(model.exclude_names)
saver.restore(session, weightFn)
# Finalize graph
session.graph.finalize()
print "TESTING"
test_score, preds, test_confusion_matrix_str = model.predict(
session, test_set, save_preds=True, UseShuffle=False)
print preds
print test_confusion_matrix_str
with open(output_file, 'w') as file:
file.write(test_confusion_matrix_str)
file.write(preds)
def run_model(config, max_input_lengths, glove_matrix, args, train_examples,
dev_set, test_set):
""" Run the model.
"""
with tf.Graph().as_default():
print 80 * "="
print "INITIALIZING"
print 80 * "="
# Create and configure model
print "Building model...",
start = time.time()
model = Bidirectional_Attention_Conditonal_Encoding_LSTM_Model(
config, report_score, max_input_lengths, glove_matrix)
model.print_params()
print "took {:.2f} seconds\n".format(time.time() - start)
# Initialize variables
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as session:
# Load weights if necessary
session.run(init)
saver = create_tensorflow_saver(model.exclude_names)
if args.restore:
saver.restore(session, model.curr_weights_fn)
# Finalize graph
session.graph.finalize()
# Train Model
print 80 * "="
print "TRAINING"
print 80 * "="
model.fit(session, saver, train_examples, dev_set)
print 80 * "="
print "TESTING"
print 80 * "="
print "Restoring the best model weights found on the dev set"
saver.restore(session, model.best_weights_fn)
print "Final evaluation on test set",
test_score, _, test_confusion_matrix_str = model.predict(
session, test_set, save_preds=True)
with open(model.test_confusion_matrix_fn, 'w') as file:
file.write(test_confusion_matrix_str)
print "- test Score: {:.2f}".format(test_score)
return test_score, test_confusion_matrix_str
def main(debug=True):
# Parse Arguments
parser = argparse.ArgumentParser()
parser.add_argument('--epoch', type=int, default=5)
parser.add_argument('--restore', action='store_true')
args = parser.parse_args()
# Create Config
config = Config()
if args.epoch:
config.n_epochs = args.epoch
X, y, glove_matrix, max_input_lengths, word_to_glove_index = create_embeddings(
training_size=config.training_size,
random_split=config.random_split,
truncate_headlines=config.truncate_headlines,
truncate_articles=config.truncate_articles,
classification_problem=config.classification_problem,
max_headline_length=config.max_headline_length,
max_article_length=config.max_article_length,
glove_set=None,
debug=debug)
if config.uniform_data_split:
X, y = produce_uniform_data_split(X, y)
# Each set is of the form:
# [headline_glove_index_matrix, article_glove_index_matrix, h_seq_lengths, a_seq_lengths, labels]
train_examples, dev_set, test_set = create_data_sets_for_model(X, y)
print "Distribution of Train {}".format(np.sum(train_examples[4], axis=0))
print "Distribtion of Dev {}".format(np.sum(dev_set[4], axis=0))
print "Distribution of Test{}".format(np.sum(test_set[4], axis=0))
with tf.Graph().as_default():
print 80 * "="
print "INITIALIZING"
print 80 * "="
# Create and configure model
print "Building model...",
start = time.time()
model = Attention_Conditonal_Encoding_LSTM_Model(
config, report_score, max_input_lengths, glove_matrix, debug)
model.print_params()
print "took {:.2f} seconds\n".format(time.time() - start)
# Initialize variables
init = tf.global_variables_initializer()
saver = None if debug else tf.train.Saver()
with tf.Session() as session:
# Load weights if necessary
session.run(init)
saver = create_tensorflow_saver(model.exclude_names)
if args.restore:
saver.restore(session, model.curr_weights_fn)
# Finalize graph
session.graph.finalize()
# Train Model
print 80 * "="
print "TRAINING"
print 80 * "="
model.fit(session, saver, train_examples, dev_set)
if not debug:
print 80 * "="
print "TESTING"
print 80 * "="
print "Restoring the best model weights found on the dev set"
saver.restore(session, model.best_weights_fn)
print "Final evaluation on test set",
test_score, _, test_confusion_matrix_str = model.predict(
session, test_set, save_preds=True)
with open(model.test_confusion_matrix_fn, 'w') as file:
file.write(test_confusion_matrix_str)
def main(debug=True):
# Parse Arguments
arg_epoch, arg_restore, arg_test = parse_args()
# Create Config
config = Config()
if arg_epoch:
config.n_epochs = arg_epoch
X, y, glove_matrix, max_input_lengths, word_to_glove_index = create_embeddings(
training_size=config.training_size,
random_split=config.random_split,
truncate_headlines=config.truncate_headlines,
truncate_articles=config.truncate_articles,
classification_problem=config.classification_problem,
max_headline_length=config.max_headline_length,
max_article_length=config.max_article_length,
glove_set=None,
debug=debug)
if config.uniform_data_split:
X, y = produce_uniform_data_split(X, y)
# Each set is of the form:
# [headline_glove_index_matrix, article_glove_index_matrix, h_seq_lengths, a_seq_lengths, labels]
train_examples, dev_set, test_set = create_data_sets_for_model(X, y)
print "Distribution of Train {}".format(np.sum(train_examples[4], axis=0))
print "Distribtion of Dev {}".format(np.sum(dev_set[4], axis=0))
print "Distribution of Test{}".format(np.sum(test_set[4], axis=0))
with tf.Graph().as_default():
print 80 * "="
print "INITIALIZING"
print 80 * "="
# Create and configure model
print "Building model...",
start = time.time()
model = Bimpmp(config, report_score, max_input_lengths, glove_matrix,
debug)
model.print_params()
print "took {:.2f} seconds\n".format(time.time() - start)
# Initialize variables
init = tf.global_variables_initializer()
saver = None if debug else tf.train.Saver()
with tf.Session(config=tf.ConfigProto(
log_device_placement=True)) as session:
# Load weights if necessary
session.run(init)
saver = create_tensorflow_saver(model.exclude_names)
if arg_restore != None:
weights_path = './data/{}/{}/weights'.format(
model.get_model_name(), arg_restore)
restore_path = '{}/{}'.format(weights_path,
model.get_fn_names()[1])
saver.restore(session, model.curr_weights_fn)
# Finalize graph
session.graph.finalize()
# train_vars = [var for var in tf.global_variables()]
# for var in train_vars:
# print (var.name, var.get_shape())
# Train Model
print 80 * "="
print "TRAINING"
print 80 * "="
model.fit(session, saver, train_examples, dev_set)
if not debug:
print 80 * "="
print "TESTING"
print 80 * "="
print "Restoring the best model weights found on the dev set"
saver.restore(session, model.best_weights_fn)
print "Final evaluation on test set",
test_score, _, test_confusion_matrix_str = model.predict(
session, test_set, save_preds=True)
with open(model.test_confusion_matrix_fn, 'w') as file:
file.write(test_confusion_matrix_str)
def main(debug=True):
parser = argparse.ArgumentParser()
parser.add_argument('--epoch', type=int, default=5)
parser.add_argument('--restore', action='store_true')
args = parser.parse_args()
if not os.path.exists('./data/weights/'):
os.makedirs('./data/weights/')
if not os.path.exists('./data/predictions/'):
os.makedirs('./data/predictions/')
if not os.path.exists('./data/plots/'):
os.makedirs('./data/plots/')
with tf.Graph().as_default():
print 80 * "="
print "INITIALIZING"
print 80 * "="
config = Config()
if args.epoch:
config.n_epochs = args.epoch
# Load Data
# Note: X_train_input, X_dev_input, X_test_input are lists where each item is an example.
# Each example is a sparse representation of a headline + article, where the text
# is encoded as a series of indices into the glove-vectors.
# y_train_input, y_dev_input, y_test_input are matrices (num_examples, num_classes)
X_train_input, X_dev_input, X_test_input, y_train_input, y_dev_input, y_test_input, glove_matrix, max_lengths = create_inputs_by_glove(
)
config.max_length = max_lengths[0] + max_lengths[1]
print "Max Length is {}".format(config.max_length)
# Create Basic LSTM Model
config.pretrained_embeddings = glove_matrix
model = BasicLSTM(config)
# Create Data Lists
train_examples = [X_train_input, y_train_input]
dev_set = [X_dev_input, y_dev_input]
test_set = [X_test_input, y_test_input]
print "Building model...",
start = time.time()
print "took {:.2f} seconds\n".format(time.time() - start)
init = tf.global_variables_initializer()
with tf.Session() as session:
session.run(init)
exclude_names = set([
"embedding_matrix:0", "embedding_matrix/Adam:0",
"embedding_matrix/Adam_1:0"
])
saver = create_tensorflow_saver(exclude_names)
if args.restore:
saver.restore(session,
'./data/weights/basic_lstm_curr_stance.weights')
print "Restored weights from ./data/weights/basic_lstm_curr_stance.weights"
print "-------------------------------------------"
session.graph.finalize()
print 80 * "="
print "TRAINING"
print 80 * "="
model.fit(session, saver, train_examples, dev_set)
if saver:
print 80 * "="
print "TESTING"
print 80 * "="
print "Restoring the best model weights found on the dev set"
saver.restore(session,
'./data/weights/basic_lstm_best_stance.weights')
print "Final evaluation on test set",
prog = Progbar(target=1 + len(test_set[0]) / config.batch_size)
actual = vectorize_stances(test_set[1])
preds = []
for i, (inputs_batch, labels_batch) in enumerate(
minibatches(test_set, config.batch_size)):
predictions_batch = list(
model.predict_on_batch(session, inputs_batch))
preds.extend(predictions_batch)
prog.update(i + 1)
test_score, test_lines = report_score(actual, preds)
print "- test Score: {:.2f}".format(test_score)
print "Writing predictions"
with open('./data/predictions/basic_lstm_predicted.pkl',
'w') as f:
cPickle.dump(preds, f, -1)
print "Done!"
def main(debug=True):
# Parse Arguments
parser = argparse.ArgumentParser()
parser.add_argument('--epoch', type=int, default=5)
parser.add_argument('--restore', action='store_true')
args = parser.parse_args()
# Create Config
config = Config()
if args.epoch:
config.n_epochs = args.epoch
# Load Data
X, y, glove_matrix, max_input_lengths, word_to_glove_index = create_embeddings(
training_size=0.8,
random_split=False,
truncate_headlines=False,
truncate_articles=True,
classification_problem=3,
max_headline_length=500,
max_article_length=200,
glove_set=None,
debug=debug)
# TODO: Remove This
# X, y = produce_uniform_data_split(X, y)
with tf.Graph().as_default():
print 80 * "="
print "INITIALIZING"
print 80 * "="
# Create and configure model
print "Building model...",
model = Two_LSTM_Encoders_Model(config, report_score, max_lengths,
glove_matrix)
start = time.time()
print "took {:.2f} seconds\n".format(time.time() - start)
# Initialize variables
init = tf.global_variables_initializer()
saver = None if debug else tf.train.Saver()
with tf.Session() as session:
# Load weights if necessary
session.run(init)
saver = create_tensorflow_saver(model.exclude_names)
if args.restore:
saver.restore(session, model.curr_weights_fn)
# Finalize graph
session.graph.finalize()
# Train Model
print 80 * "="
print "TRAINING"
print 80 * "="
model.fit(session, saver, train_examples, dev_set)
if not debug:
print 80 * "="
print "TESTING"
print 80 * "="
print "Restoring the best model weights found on the dev set"
saver.restore(session, model.best_weights_fn)
print "Final evaluation on test set",
test_score, _, _ = model.predict(session,
test_set,
save_preds=True)
print "- test Score: {:.2f}".format(test_score)
