input: Write a function that constructs and trains a neural network model using TensorFlow to classify hand-written digits from the MNIST dataset. The function should initialize the model, define the parameters and layers, train the model using the training data, and finally evaluate the accuracy of the model on the test data.
  
  def build_and_train_mnist_model():
      import tensorflow as tf
      from tensorflow.examples.tutorials.mnist import input_data
  
      mnist = input_data.read_data_sets("/tmp/data", one_hot=True)
  
      # Parameters
      learning_rate = 0.001
      training_epochs = 15
      batch_size = 100
      display_step = 1
  
      # Network Parameters
      n_hidden_1 = 256
      n_hidden_2 = 256
      n_input = 784
      n_classes = 10
  
      # tf Graph input
      X = tf.placeholder("float", [None, n_input])
      Y = tf.placeholder("float", [None, n_classes])
  
      # Store layers weight & bias
      weights = {
          'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
          'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
          'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
      }
      biases = {
          'b1': tf.Variable(tf.random_normal([n_hidden_1])),
          'b2': tf.Variable(tf.random_normal([n_hidden_2])),
          'out': tf.Variable(tf.random_normal([n_classes]))
      }
  
      # Create model
      def multilayer_perceptron(x):
          layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
          layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
          out_layer = tf.matmul(layer_2, weights['out']) + biases['out']
          return out_layer
  
      # Construct model
      logits = multilayer_perceptron(X)
  
      # Define loss and optimizer
      loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y))
      optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
      train_op = optimizer.minimize(loss_op)
  
      # Initializing the variables
      init = tf.global_variables_initializer()
  
      # Train model
      with tf.Session() as model:
          model.run(init)
  
          # Training cycle
          for epoch in range(training_epochs):
              avg_cost = 0.
              total_batch = int(mnist.train.num_examples/batch_size)
              for i in range(total_batch):
                  batch_x, batch_y = mnist.train.next_batch(batch_size)
                  _, c = model.run([train_op, loss_op], feed_dict={X: batch_x, Y: batch_y})
                  avg_cost += c / total_batch
              if epoch % display_step == 0:
                  print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
          print("Optimization Finished!")
  
          # Test model
          pred = tf.nn.softmax(logits)
          correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(Y, 1))
          accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
          return accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}, model)
  
  assert build_and_train_mnist_model() > 0.90
  assert isinstance(build_and_train_mnist_model(), float)
  assert build_and_train_mnist_model() < 1.0
output: import tensorflow as tf
  from tensorflow.examples.tutorials.mnist import input_data
  
  def build_and_train_mnist_model():
      mnist = input_data.read_data_sets("/tmp/data", one_hot=True)
  
      learning_rate = 0.001
      training_epochs = 15
      batch_size = 100
      display_step = 1
  
      n_hidden_1 = 256
      n_hidden_2 = 256
      n_input = 784
      n_classes = 10
  
      X = tf.placeholder("float", [None, n_input])
      Y = tf.placeholder("float", [None, n_classes])
  
      weights = {
          'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
          'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
          'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]))
      }
      biases = {
          'b1': tf.Variable(tf.random_normal([n_hidden_1])),
          'b2': tf.Variable(tf.random_normal([n_hidden_2])),
          'out': tf.Variable(tf.random_normal([n_classes]))
      }
  
      def multilayer_perceptron(x):
          layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
          layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
          out_layer = tf.matmul(layer_2, weights['out']) + biases['out']
          return out_layer
  
      logits = multilayer_perceptron(X)
  
      loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y))
      optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
      train_op = optimizer.minimize(loss_op)
  
      init = tf.global_variables_initializer()
  
      with tf.Session() as model:
          model.run(init)
  
          for epoch in range(training_epochs):
              avg_cost = 0.
              total_batch = int(mnist.train.num_examples/batch_size)
              for i in range(total_batch):
                  batch_x, batch_y = mnist.train.next_batch(batch_size)
                  _, c = model.run([train_op, loss_op], feed_dict={X: batch_x, Y: batch_y})
                  avg_cost += c / total_batch
              if epoch % display_step == 0:
                  print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
          print("Optimization Finished!")
  
          pred = tf.nn.softmax(logits)
          correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(Y, 1))
          accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
          return accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}, model)