text: #! /usr/bin/env python
  
  import tensorflow as tf
  import numpy as np
  import os
  import time
  import datetime
  import data_helpers
  from text_cnn import TextCNN
  from tensorflow.contrib import learn
  import csv
  
  class TwitterAnalysis:
      def __init__(self, data, hashtag):
          self.data = data
          self.numberOfTweets = len(data)
          self.hashtag = hashtag
  
      def printAnalysis(self, predictions):
          average = np.mean(predictions)
          print('\n\nAverage Sentiment Score: {}'.format(average))
          if average > .5:
              print('Turns out people like "{}". Who Knew'.format(self.hashtag))
          else:
              print('Turns out people dont like "{}". Who Knew'.format(self.hashtag))
  
      def runAnalysis(self, x_raw=None, y_test=None):
          tf.flags.DEFINE_integer("batch_size", 64, "Batch Size (default: 64)")
          tf.flags.DEFINE_string("checkpoint_dir", ".\\runs\\1508178059\\checkpoints", "Checkpoint directory from training run")
          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()
  
          if not x_raw:
              x_raw = self.data
          if not y_test:
              print('No test prediction exists')
  
          # 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)))
  
  
          # Evaluation
          checkpoint_file = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
          graph = tf.Graph()
          all_predictions = []
  
          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_file))
                  saver.restore(sess, checkpoint_file)
  
                  # Get the placeholders from the graph by name
                  input_x = graph.get_operation_by_name("input_x").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]
  
                  # Generate batches for one epoch
                  batches = data_helpers.batch_iter(list(x_test), FLAGS.batch_size, 1, shuffle=False)
  
                  for x_test_batch in batches:
                      batch_predictions = sess.run(predictions, {input_x: x_test_batch, dropout_keep_prob: 1.0})
                      all_predictions = np.concatenate([all_predictions, batch_predictions])
  
          if y_test is not None:
              correct_predictions = float(sum(all_predictions == y_test))
              print("Total number of test examples: {}".format(len(y_test)))
              print("Accuracy: {:g}".format(correct_predictions / float(len(y_test))))
  
          self.printAnalysis(all_predictions)
  
          # # Save the evaluation to a csv
          # predictions_human_readable = np.column_stack((np.array(x_raw), all_predictions))
          # out_path = os.path.join(FLAGS.checkpoint_dir, "..", "prediction.csv")
          # #print("Saving evaluation to {0}".format(out_path))
          # with open(out_path, 'w') as f:
          #     csv.writer(f).writerows(predictions_human_readable)
  