tf.flags.DEFINE_boolean("allow_soft_placement", True, "Allow device soft device placement") tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices") tf.flags.DEFINE_boolean("new_data_format", False, "Use load_data_and_labels2") FLAGS = tf.flags.FLAGS FLAGS._parse_flags() print("\nParameters:") for attr, value in sorted(FLAGS.__flags.items()): print("{}={}".format(attr.upper(), value)) print("") # Load data. if FLAGS.new_data_format: x_raw, y_test = data_helpers.load_data_and_labels2(FLAGS.path_to_json_file) y_test = np.argmax(y_test, axis=1) else: x_raw, y_test = data_helpers.load_data_and_labels(FLAGS.path_to_json_file) y_test = np.argmax(y_test, axis=1) # Map data into vocabulary vocab_path = os.path.join(FLAGS.checkpoint_dir, "vocab/", "vocab") vocab_processor = learn.preprocessing.VocabularyProcessor.restore(vocab_path) x_test = np.array(list(vocab_processor.transform(x_raw))) print("Total score for {} is {}".format(x_raw)) print("What is x_raw {}" % (x_raw)) print("\nEvaluating...\n")
def eval(): with tf.device('/gpu:0'): # x_text, y = data_helpers.load_data_and_labels(FLAGS.rank0_dir, FLAGS.rank1_dir, FLAGS.rank2_dir, FLAGS.rank3_dir) x_text, y = data_helpers.load_data_and_labels2(FLAGS.rank1_dir, FLAGS.rank2_dir, FLAGS.rank3_dir) # Map data into vocabulary text_path = os.path.join(FLAGS.checkpoint_dir_rnn, "..", "text_vocab") text_vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor.restore( text_path) x_eval = np.array(list(text_vocab_processor.transform(x_text))) y_eval = np.argmax(y, axis=1) # first model # RNN checkpoint_dir_rnn = tf.train.latest_checkpoint(FLAGS.checkpoint_dir_rnn) rnn_logits_list = [] graph = tf.Graph() with graph.as_default(): session_conf = tf.ConfigProto( allow_soft_placement=FLAGS.allow_soft_placement, log_device_placement=FLAGS.log_device_placement) sess = tf.Session(config=session_conf) with sess.as_default(): # Load the saved meta graph and restore variables saver = tf.train.import_meta_graph( "{}.meta".format(checkpoint_dir_rnn)) saver.restore(sess, checkpoint_dir_rnn) # Get the placeholders from the graph by name input_text = graph.get_operation_by_name("input_text").outputs[0] # input_y = graph.get_operation_by_name("input_y").outputs[0] dropout_keep_prob = graph.get_operation_by_name( "dropout_keep_prob").outputs[0] # Tensors we want to evaluate predictions = graph.get_operation_by_name( "output/predictions").outputs[0] logits = graph.get_operation_by_name("output/logits").outputs[0] # Generate batches for one epoch batches = data_helpers.batch_iter(list(x_eval), FLAGS.batch_size, 1, shuffle=False) # Collect the predictions here rnn_predictions = [] for x_batch in batches: batch_predictions = sess.run(predictions, {input_text: x_batch}) batch_logits = sess.run(logits, {input_text: x_batch}) rnn_predictions = np.concatenate( [rnn_predictions, batch_predictions]) for i in range(len(batch_logits)): rnn_logits_list.append(batch_logits[i]) correct_predictions = float(sum(rnn_predictions == y_eval)) print("Total number of test examples: {}".format(len(y_eval))) print("Accuracy: {:g}".format(correct_predictions / float(len(y_eval)))) # second model # CNN # Map data into vocabulary text_path = os.path.join(FLAGS.checkpoint_dir_cnn, "..", "vocab") text_vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor.restore( text_path) x_eval = np.array(list(text_vocab_processor.transform(x_text))) y_eval = np.argmax(y, axis=1) checkpoint_dir_cnn = tf.train.latest_checkpoint(FLAGS.checkpoint_dir_cnn) cnn_logits_list = [] graph2 = tf.Graph() with graph2.as_default(): session_conf = tf.ConfigProto( allow_soft_placement=FLAGS.allow_soft_placement, log_device_placement=FLAGS.log_device_placement) sess2 = tf.Session(config=session_conf) with sess2.as_default(): # Load the saved meta graph and restore variables saver = tf.train.import_meta_graph( "{}.meta".format(checkpoint_dir_cnn)) saver.restore(sess2, checkpoint_dir_cnn) # Get the placeholders from the graph by name input_text = graph2.get_operation_by_name("input_x").outputs[0] # input_y = graph.get_operation_by_name("input_y").outputs[0] dropout_keep_prob = graph2.get_operation_by_name( "dropout_keep_prob").outputs[0] # Tensors we want to evaluate predictions = graph2.get_operation_by_name( "output/predictions").outputs[0] logits = graph2.get_operation_by_name("output/scores").outputs[0] # Generate batches for one epoch batches = data_helpers.batch_iter(list(x_eval), FLAGS.batch_size, 1, shuffle=False) # Collect the predictions here cnn_predictions = [] for x_batch in batches: batch_predictions = sess2.run(predictions, { input_text: x_batch, dropout_keep_prob: 1.0 }) batch_logits = sess2.run(logits, { input_text: x_batch, dropout_keep_prob: 1.0 }) cnn_predictions = np.concatenate( [cnn_predictions, batch_predictions]) for i in range(len(batch_logits)): cnn_logits_list.append(batch_logits[i]) correct_predictions = float(sum(cnn_predictions == y_eval)) print("Total number of test examples: {}".format(len(y_eval))) print("Accuracy: {:g}".format(correct_predictions / float(len(y_eval)))) return y_eval, rnn_logits_list, cnn_logits_list
print("") # Data Preparation # ================================================== # Load data print("Loading data...") x_text, y = data_helpers.load_data_and_labels2([ "./data/hotshare_train/artist.txt", "./data/hotshare_train/emotion.txt", "./data/hotshare_train/extend.txt", "./data/hotshare_train/foods.txt", "./data/hotshare_train/goplaces.txt", "./data/hotshare_train/hotnews.txt", "./data/hotshare_train/human.txt", "./data/hotshare_train/nature.txt", "./data/hotshare_train/news.txt", "./data/hotshare_train/poets.txt", "./data/hotshare_train/programmer.txt", "./data/hotshare_train/scene.txt", "./data/hotshare_train/talk.txt", "./data/hotshare_train/travel.txt" ]) # Build vocabulary max_document_length = max([len(x) for x in x_text]) vocab_processor = learn.preprocessing.VocabularyProcessor(max_document_length) x = np.array(list(vocab_processor.fit_transform(x_text))) # Randomly shuffle data np.random.seed(10)
tf.flags.DEFINE_boolean("allow_soft_placement", True, "Allow device soft device placement") tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices") FLAGS = tf.flags.FLAGS FLAGS._parse_flags() print("\nParameters:") for attr, value in sorted(FLAGS.__flags.items()): print("{}={}".format(attr.upper(), value)) print("") # CHANGE THIS: Load data. Load your own data here if FLAGS.eval_train: #x_raw, y_test = data_helpers.load_data_and_labels(FLAGS.positive_data_file, FLAGS.negative_data_file) x_raw, y_test = data_helpers.load_data_and_labels2(FLAGS.data_file) y_test = np.argmax(y_test, axis=1) else: x_raw = ["a masterpiece four years in the making", "everything is off."] y_test = [1, 0] # Map data into vocabulary vocab_path = os.path.join(FLAGS.checkpoint_dir, "..", "vocab") vocab_processor = learn.preprocessing.VocabularyProcessor.restore(vocab_path) x_test = np.array(list(vocab_processor.transform(x_raw))) print("\nEvaluating...\n") # Evaluation # ================================================== checkpoint_file = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
#! /usr/bin/env python import tensorflow as tf import data_helpers #tf.flags.DEFINE_string("positive_data_file", "./data/rt-polaritydata/rt-polarity.pos", "Data source for the positive data.") #tf.flags.DEFINE_string("positive_data_file", "./data/rt-polaritydata/test.pos", "Data source for the positive data.") tf.flags.DEFINE_string("data_file", "../nsmc/small.txt", "Data source for test.") tf.flags.DEFINE_string("negative_data_file", "./data/rt-polaritydata/rt-polarity.neg", "Data source for the negative data.") FLAGS = tf.flags.FLAGS FLAGS._parse_flags() print("\nParameters:") for attr, value in sorted(FLAGS.__flags.items()): print("{}={}".format(attr.upper(), value)) print("") #x_text, y = data_helpers.load_data_and_labels(FLAGS.positive_data_file, FLAGS.negative_data_file) x_text, y = data_helpers.load_data_and_labels2(FLAGS.data_file) #x_text, y = data_helpers.load_data_and_labels2(FLAGS.positive_data_file) print(x_text)
FLAGS = tf.flags.FLAGS FLAGS._parse_flags() print("\nParameters:") for attr, value in sorted(FLAGS.__flags.items()): print("{}={}".format(attr.upper(), value)) print("") # CHANGE THIS: Load data. Load your own data here if FLAGS.eval_train: x_raw, y_test = data_helpers.load_data_and_labels2([ "./data/hotshare_eval/artist.txt", "./data/hotshare_eval/emotion.txt", "./data/hotshare_eval/extend.txt", "./data/hotshare_eval/foods.txt", "./data/hotshare_eval/goplaces.txt", "./data/hotshare_eval/hotnews.txt", "./data/hotshare_eval/human.txt", "./data/hotshare_eval/nature.txt", "./data/hotshare_eval/news.txt", "./data/hotshare_eval/poets.txt", "./data/hotshare_eval/programmer.txt", "./data/hotshare_eval/scene.txt", "./data/hotshare_eval/talk.txt", "./data/hotshare_eval/travel.txt" ]) y_test = np.argmax(y_test, axis=1) else: x_raw = ["a masterpiece four years in the making", "everything is off."] y_test = [1, 0] # Map data into vocabulary vocab_path = os.path.join(FLAGS.checkpoint_dir, "..", "vocab") vocab_processor = learn.preprocessing.VocabularyProcessor.restore(vocab_path) x_test = np.array(list(vocab_processor.transform(x_raw)))
tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices") FLAGS = tf.flags.FLAGS FLAGS._parse_flags() print("\nParameters:") for attr, value in sorted(FLAGS.__flags.items()): print("{}={}".format(attr.upper(), value)) print("") # Data Preparation # ================================================== # Load data print("Loading data...") x_text, y = data_helpers.load_data_and_labels2(FLAGS.data_file, FLAGS.num_classes) # Build vocabulary max_document_length = max([len(x) for x in x_text]) vocab_processor = learn.preprocessing.VocabularyProcessor(max_document_length) print(x_text) x = np.array(list(vocab_processor.fit_transform(x_text))) # Randomly shuffle data np.random.seed(10) shuffle_indices = np.random.permutation(np.arange(len(y))) x_shuffled = x[shuffle_indices] y_shuffled = y[shuffle_indices] # Split train/test set # TODO: This is very crude, should use cross-validation
def train(): with tf.device('/gpu:0'): # x_text, y = data_helpers.load_data_and_labels(FLAGS.rank0_dir, FLAGS.rank1_dir, FLAGS.rank2_dir, FLAGS.rank3_dir) x_text, y = data_helpers.load_data_and_labels2(FLAGS.rank1_dir, FLAGS.rank2_dir, FLAGS.rank3_dir) max_document_length = max([len(x.split(" ")) for x in x_text]) text_vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor( max_document_length) x = np.array(list(text_vocab_processor.fit_transform(x_text))) print("Text Vocabulary Size: {:d}".format( len(text_vocab_processor.vocabulary_))) print("x = {0}".format(x.shape)) print("y = {0}".format(y.shape)) print("") # Randomly shuffle data np.random.seed(10) shuffle_indices = np.random.permutation(np.arange(len(y))) x_shuffled = x[shuffle_indices] y_shuffled = y[shuffle_indices] x_train, y_train, x_dev, y_dev = make_dataset(x_shuffled, y_shuffled, 10) # print("Train/Dev split: {:d}/{:d}\n".format(len(y_train), len(y_dev))) with tf.Graph().as_default(): session_conf = tf.ConfigProto( allow_soft_placement=FLAGS.allow_soft_placement, log_device_placement=FLAGS.log_device_placement) sess = tf.Session(config=session_conf) with sess.as_default(): rnn = RNN(sequence_length=x_train.shape[1], num_classes=y_train.shape[1], vocab_size=len(text_vocab_processor.vocabulary_), embedding_size=FLAGS.embedding_dim, cell_type=FLAGS.cell_type, hidden_size=FLAGS.hidden_size, l2_reg_lambda=FLAGS.l2_reg_lambda) # Define Training procedure global_step = tf.Variable(0, name="global_step", trainable=False) train_op = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize( rnn.loss, global_step=global_step) # Output directory for models and summaries timestamp = str(int(time.time())) out_dir = os.path.abspath( os.path.join(os.path.curdir, "runs", timestamp)) print("Writing to {}\n".format(out_dir)) # Summaries for loss and accuracy loss_summary = tf.summary.scalar("loss", rnn.loss) acc_summary = tf.summary.scalar("accuracy", rnn.accuracy) # Train Summaries train_summary_op = tf.summary.merge([loss_summary, acc_summary]) train_summary_dir = os.path.join(out_dir, "summaries", "train") train_summary_writer = tf.summary.FileWriter( train_summary_dir, sess.graph) # Dev summaries dev_summary_op = tf.summary.merge([loss_summary, acc_summary]) dev_summary_dir = os.path.join(out_dir, "summaries", "dev") dev_summary_writer = tf.summary.FileWriter(dev_summary_dir, sess.graph) # Checkpoint directory. Tensorflow assumes this directory already exists so we need to create it checkpoint_dir = os.path.abspath( os.path.join(out_dir, "checkpoints")) checkpoint_prefix = os.path.join(checkpoint_dir, "model") if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) saver = tf.train.Saver(tf.global_variables(), max_to_keep=FLAGS.num_checkpoints) # Write vocabulary text_vocab_processor.save(os.path.join(out_dir, "text_vocab")) # Initialize all variables sess.run(tf.global_variables_initializer()) # Pre-trained word2vec if FLAGS.word2vec: # initial matrix with random uniform initW = np.random.uniform(-0.25, 0.25, (len( text_vocab_processor.vocabulary_), FLAGS.embedding_dim)) # load any vectors from the word2vec print("Load word2vec file {0}".format(FLAGS.word2vec)) with open(FLAGS.word2vec, "rb") as f: header = f.readline() vocab_size, layer1_size = map(int, header.split()) binary_len = np.dtype('float32').itemsize * layer1_size for line in range(vocab_size): word = [] while True: ch = f.read(1).decode('latin-1') if ch == ' ': word = ''.join(word) break if ch != '\n': word.append(ch) idx = text_vocab_processor.vocabulary_.get(word) if idx != 0: initW[idx] = np.fromstring(f.read(binary_len), dtype='float32') else: f.read(binary_len) sess.run(rnn.W_text.assign(initW)) print("Success to load pre-trained word2vec model!\n") for train_index, test_index in KFold(10).split(x): x_train, x_dev = x[train_index], x[test_index] y_train, y_dev = y[train_index], y[test_index] # Generate batches batches = data_helpers.batch_iter(list(zip(x_train, y_train)), FLAGS.batch_size, FLAGS.num_epochs) # Training loop. For each batch... for batch in batches: x_batch, y_batch = zip(*batch) # Train feed_dict = { rnn.input_text: x_batch, rnn.input_y: y_batch, rnn.dropout_keep_prob: FLAGS.dropout_keep_prob } _, step, summaries, loss, accuracy, = sess.run([ train_op, global_step, train_summary_op, rnn.loss, rnn.accuracy ], feed_dict) train_summary_writer.add_summary(summaries, step) # Training log display if step % FLAGS.display_every == 0: time_str = datetime.datetime.now().isoformat() print("{}: step {}, loss {:g}, acc {:g}".format( time_str, step, loss, accuracy)) # Evaluation if step % FLAGS.evaluate_every == 0: print("\nEvaluation:") feed_dict_dev = { rnn.input_text: x_dev, rnn.input_y: y_dev, rnn.dropout_keep_prob: FLAGS.dropout_keep_prob } summaries_dev, loss, accuracy = sess.run( [dev_summary_op, rnn.loss, rnn.accuracy], feed_dict_dev) dev_summary_writer.add_summary(summaries_dev, step) time_str = datetime.datetime.now().isoformat() print("{}: step {}, loss {:g}, acc {:g}\n".format( time_str, step, loss, accuracy)) # Model checkpoint if step % FLAGS.checkpoint_every == 0: path = saver.save(sess, checkpoint_prefix, global_step=step) print("Saved model checkpoint to {}\n".format(path)) # Export model export_path = 'models/1' builder = tf.saved_model.builder.SavedModelBuilder(export_path) g = tf.get_default_graph() inp = g.get_tensor_by_name(rnn.input_text.name) out_pred = g.get_tensor_by_name(rnn.predictions.name) out_logit = g.get_tensor_by_name(rnn.logits.name) # Build the signature_def_map. classification_inputs = tf.saved_model.utils.build_tensor_info(inp) classification_outputs_classes = tf.saved_model.utils.build_tensor_info( out_pred) classification_outputs_logits = tf.saved_model.utils.build_tensor_info( out_logit) classification_signature = ( tf.saved_model.signature_def_utils.build_signature_def( inputs={ tf.saved_model.signature_constants.CLASSIFY_INPUTS: classification_inputs }, outputs={ tf.saved_model.signature_constants.CLASSIFY_OUTPUT_CLASSES: classification_outputs_classes, tf.saved_model.signature_constants.CLASSIFY_OUTPUT_SCORES: classification_outputs_logits }, method_name=tf.saved_model.signature_constants. CLASSIFY_METHOD_NAME)) builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING], signature_def_map={ tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: classification_signature, }, main_op=tf.tables_initializer(), strip_default_attrs=True) builder.save()