text: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from sklearn.preprocessing import Normalizer
  from SharedFunctions import get_current_time, fmt, find_accuracy
  from datetime import datetime
  from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
  from ReadPreprocessData import read_preprocess
  from Tokenize import tokenize
  import numpy as np
  import tensorflow as tf
  import scipy.sparse as ss
  
  tf.logging.set_verbosity(tf.logging.INFO)
  
  vectorizer = TfidfVectorizer(tokenizer=tokenize, stop_words='english')
  
  def convert_sparse_matrix_to_sparse_tensor(X):
      coo = X.tocoo()
      indices = np.mat([coo.row, coo.col]).transpose()
      return tf.SparseTensor(indices, coo.data, coo.shape)
  
  
  def cnn_model_fn(features, labels, mode):
  
  
  
    # Dense Layer
  
    dense = tf.layers.dense(inputs=features, units=0, activation=tf.nn.relu)
  
    dense1 = tf.layers.dense(inputs=dense, units=1000, activation=tf.nn.relu)
  
    dense2 = tf.layers.dense(inputs=dense1, units=200, activation=tf.nn.relu)
  
  
  
    # Add dropout operation; 0.6 probability that element will be kept
    dropout = tf.layers.dropout(
        inputs=dense2, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
  
    # Logits layer
    # Input Tensor Shape: [batch_size, 1024]
    # Output Tensor Shape: [batch_size, 10]
    logits = tf.layers.dense(inputs=dense2, units=2)
  
    predictions = {
        # Generate predictions (for PREDICT and EVAL mode)
        "classes": tf.argmax(input=logits, axis=1),
        # Add `softmax_tensor` to the graph. It is used for PREDICT and by the
        # `logging_hook`.
        "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
    }
    if mode == tf.estimator.ModeKeys.PREDICT:
      return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
  
    # Calculate Loss (for both TRAIN and EVAL modes)
    loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
  
    # Configure the Training Op (for TRAIN mode)
    if mode == tf.estimator.ModeKeys.TRAIN:
      optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
      train_op = optimizer.minimize(
          loss=loss,
          global_step=tf.train.get_global_step())
      return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
  
    # Add evaluation metrics (for EVAL mode)
    eval_metric_ops = {
        "accuracy": tf.metrics.accuracy(
            labels=labels, predictions=predictions["classes"])}
    return tf.estimator.EstimatorSpec(
        mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
  
  
  def main(unused_argv):
  
  
  
  
    # Load training and eval data
  
    # reading and preprocessing data
    t = get_current_time()
    train_emails, train_labels, test_emails, test_labels = read_preprocess()
    print("Time taken to Read and Preprocess Data:",
          datetime.strptime(get_current_time(), fmt) - datetime.strptime(t, fmt))
  
    # vectorizing data
    t = get_current_time()
    train_features = vectorizer.fit_transform(train_emails)
    test_features = vectorizer.transform(test_emails)
    print("Time taken to Vectorize:", datetime.strptime(get_current_time(), fmt) - datetime.strptime(t, fmt))
    print(len(vectorizer.get_feature_names()))
  
  
    train_data = train_features.toarray()
    eval_data = test_features.toarray()
  
  
  
  
  
  
  
    # Create the Estimator
    mnist_classifier = tf.estimator.Estimator(
        model_fn=cnn_model_fn, model_dir="/tmp/mnist_convnet_model")
  
  
  
    # Train the model
    train_input_fn = tf.estimator.inputs.numpy_input_fn(
        x=train_data[0:23687],
        y=np.array(train_labels),
        batch_size=1,
        num_epochs=None,
        shuffle=True)
    mnist_classifier.train(
        input_fn=train_input_fn,
        steps=500)
  
    # Evaluate the model and print results
    eval_input_fn = tf.estimator.inputs.numpy_input_fn(
        x=eval_data[0:23687],
        y=np.array(test_labels),
        num_epochs=1,
        shuffle=False)
    eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
    print(eval_results)
  
  
    results=mnist_classifier.predict(eval_input_fn)
  
  
    predictions = list(p["classes"] for p in results)
  
    a=np.asarray(predictions)
  
    np.savetxt("result.csv", np.dstack((np.arange(1, a.size + 1), a))[0], "%d,%d", header="ID,Label",comments="")
  
  
  if __name__ == "__main__":
    tf.app.run()