code: # -*- coding: utf-8 -*-
  
  """ Auto Encoder Example.
  Using an auto encoder on MNIST handwritten digits.
  References:
      Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. "Gradient-based
      learning applied to document recognition." Proceedings of the IEEE,
      86(11):2278-2324, November 1998.
  Links:
      [MNIST Dataset] http://yann.lecun.com/exdb/mnist/
  """
  from __future__ import division, print_function, absolute_import
  
  import tensorflow as tf
  import numpy as np
  
  # Set seeds for consistent results
  np.random.seed(1)
  try:
      tf.random.set_seed(1)
  except:
      tf.set_random_seed(1)
  
  # Import MNIST data
  from tensorflow.examples.tutorials.mnist import input_data
  
  mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
  
  # Parameters
  learning_rate = 0.01
  training_epochs = 1
  batch_size = 256
  display_step = 1
  examples_to_show = 2
  
  
  # Network Parameters
  n_hidden_1 = 256  # 1st layer num features
  n_hidden_2 = 128  # 2nd layer num features
  n_input = 784  # MNIST data input (img shape: 28*28)
  
  # tf Graph input (only pictures)
  X = tf.placeholder("float", [None, n_input])
  
  weights = {
      "encoder_h1": tf.Variable(tf.random_normal([n_input, n_hidden_1])),
      "encoder_h2": tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
      "decoder_h1": tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
      "decoder_h2": tf.Variable(tf.random_normal([n_hidden_1, n_input])),
  }
  biases = {
      "encoder_b1": tf.Variable(tf.random_normal([n_hidden_1])),
      "encoder_b2": tf.Variable(tf.random_normal([n_hidden_2])),
      "decoder_b1": tf.Variable(tf.random_normal([n_hidden_1])),
      "decoder_b2": tf.Variable(tf.random_normal([n_input])),
  }
  
  
  # Building the encoder
  def encoder(x):
      # Encoder Hidden layer with sigmoid activation #1
      layer_1 = tf.nn.sigmoid(
          tf.add(tf.matmul(x, weights["encoder_h1"]), biases["encoder_b1"])
      )
      # Decoder Hidden layer with sigmoid activation #2
      layer_2 = tf.nn.sigmoid(
          tf.add(tf.matmul(layer_1, weights["encoder_h2"]), biases["encoder_b2"])
      )
      return layer_2
  
  
  # Building the decoder
  def decoder(x):
      # Encoder Hidden layer with sigmoid activation #1
      layer_1 = tf.nn.sigmoid(
          tf.add(tf.matmul(x, weights["decoder_h1"]), biases["decoder_b1"])
      )
      # Decoder Hidden layer with sigmoid activation #2
      layer_2 = tf.nn.sigmoid(
          tf.add(tf.matmul(layer_1, weights["decoder_h2"]), biases["decoder_b2"])
      )
      return layer_2
  
  
  # Construct model
  encoder_op = encoder(X)
  decoder_op = decoder(encoder_op)
  
  # Prediction
  y_pred = decoder_op
  # Targets (Labels) are the input data.
  y_true = X
  
  # Define loss and optimizer, minimize the squared error
  cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
  optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(cost)
  
  # Initializing the variables
  init = tf.initialize_all_variables()
  
  # Launch the graph
  with tf.Session() as sess:
      sess.run(init)
      total_batch = int(mnist.train.num_examples / batch_size)
      # Training cycle
      for epoch in range(training_epochs):
          # Loop over all batches
          for i in range(total_batch):
              batch_xs, batch_ys = mnist.train.next_batch(batch_size)
              # Run optimization op (backprop) and cost op (to get loss value)
              _, c = sess.run([optimizer, cost], feed_dict={X: batch_xs})
          # Display logs per epoch step
          if epoch % display_step == 0:
              print("Epoch:", "%04d" % (epoch + 1), "cost=", "{:.9f}".format(c))
  
      print("Optimization Finished!")
  
      # Applying encode and decode over test set
      encode_decode = sess.run(
          y_pred, feed_dict={X: mnist.test.images[:examples_to_show]}
      )
  
      # just compare one example
      print(list(encode_decode[1]))
  
apis: tensorflow.matmul numpy.random.seed tensorflow.pow tensorflow.train.RMSPropOptimizer tensorflow.placeholder tensorflow.initialize_all_variables tensorflow.Session tensorflow.set_random_seed tensorflow.examples.tutorials.mnist.input_data.read_data_sets tensorflow.random.set_seed tensorflow.random_normal
api_extract: [(18, 'numpy.random.seed', 'np.random.seed', (['(1)'], {}), True, 'import numpy as np\n'), (27, 'tensorflow.examples.tutorials.mnist.input_data.read_data_sets', 'input_data.read_data_sets', (['"""/tmp/data/"""'], {'one_hot': '(True)'}), False, 'from tensorflow.examples.tutorials.mnist import input_data\n'), (43, 'tensorflow.placeholder', 'tf.placeholder', (['"""float"""', '[None, n_input]'], {}), True, 'import tensorflow as tf\n'), (99, 'tensorflow.initialize_all_variables', 'tf.initialize_all_variables', ([], {}), True, 'import tensorflow as tf\n'), (20, 'tensorflow.random.set_seed', 'tf.random.set_seed', (['(1)'], {}), True, 'import tensorflow as tf\n'), (95, 'tensorflow.pow', 'tf.pow', (['(y_true - y_pred)', '(2)'], {}), True, 'import tensorflow as tf\n'), (102, 'tensorflow.Session', 'tf.Session', ([], {}), True, 'import tensorflow as tf\n'), (22, 'tensorflow.set_random_seed', 'tf.set_random_seed', (['(1)'], {}), True, 'import tensorflow as tf\n'), (46, 'tensorflow.random_normal', 'tf.random_normal', (['[n_input, n_hidden_1]'], {}), True, 'import tensorflow as tf\n'), (47, 'tensorflow.random_normal', 'tf.random_normal', (['[n_hidden_1, n_hidden_2]'], {}), True, 'import tensorflow as tf\n'), (48, 'tensorflow.random_normal', 'tf.random_normal', (['[n_hidden_2, n_hidden_1]'], {}), True, 'import tensorflow as tf\n'), (49, 'tensorflow.random_normal', 'tf.random_normal', (['[n_hidden_1, n_input]'], {}), True, 'import tensorflow as tf\n'), (52, 'tensorflow.random_normal', 'tf.random_normal', (['[n_hidden_1]'], {}), True, 'import tensorflow as tf\n'), (53, 'tensorflow.random_normal', 'tf.random_normal', (['[n_hidden_2]'], {}), True, 'import tensorflow as tf\n'), (54, 'tensorflow.random_normal', 'tf.random_normal', (['[n_hidden_1]'], {}), True, 'import tensorflow as tf\n'), (55, 'tensorflow.random_normal', 'tf.random_normal', (['[n_input]'], {}), True, 'import tensorflow as tf\n'), (96, 'tensorflow.train.RMSPropOptimizer', 'tf.train.RMSPropOptimizer', (['learning_rate'], {}), True, 'import tensorflow as tf\n'), (63, 'tensorflow.matmul', 'tf.matmul', (['x', "weights['encoder_h1']"], {}), True, 'import tensorflow as tf\n'), (67, 'tensorflow.matmul', 'tf.matmul', (['layer_1', "weights['encoder_h2']"], {}), True, 'import tensorflow as tf\n'), (76, 'tensorflow.matmul', 'tf.matmul', (['x', "weights['decoder_h1']"], {}), True, 'import tensorflow as tf\n'), (80, 'tensorflow.matmul', 'tf.matmul', (['layer_1', "weights['decoder_h2']"], {}), True, 'import tensorflow as tf\n')]