input: from typing import Tuple
  
  def evaluate_model(training_epochs: int, batch_size: int) -> Tuple[float, float]:
      """Evaluate the performance of the neural network model trained for classifying hand-written digits from the MNIST dataset.
      
      The function initializes the model with the given number of training epochs and batch size,
      trains the model, and then evaluates the accuracy on the test set.
      
      >>> evaluate_model(15, 100)
      (0.001, 0.95)
      """
      import tensorflow as tf
  
      # 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.001
      display_step = 1
  
      # Network Parameters
      n_hidden_1 = 256 # 1st layer number of neurons
      n_hidden_2 = 256 # 2nd layer number of neurons
      n_input = 784 # MNIST data input (img shape: 28*28)
      n_classes = 10 # MNIST total classes (0-9 digits)
  
      # 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
      model = tf.Session()
      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:
              pass  # Suppress output for this example
  
      # Test model
      pred = tf.nn.softmax(logits)  # Apply softmax to logits
      correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(Y, 1))
      accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
      test_accuracy = accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}, model)
  
      return learning_rate, test_accuracy
  
output:     model.close()