input: def train_mnist_model(learning_rate: float, training_epochs: int, batch_size: int, display_step: int) -> None:
      """ Trains a neural network model using TensorFlow to classify hand-written digits from the MNIST dataset.
      The model consists of two hidden layers with 256 neurons each.
      
      >>> train_mnist_model(0.001, 15, 100, 1)
      Epoch: 0001 cost= 1.180752949
      Epoch: 0002 cost= 0.437506198
      Epoch: 0003 cost= 0.342709501
      Epoch: 0004 cost= 0.295514577
      Epoch: 0005 cost= 0.264156952
      Epoch: 0006 cost= 0.235640569
      Epoch: 0007 cost= 0.221258164
      Epoch: 0008 cost= 0.201352198
      Epoch: 0009 cost= 0.188985592
      Epoch: 0010 cost= 0.175805501
      Epoch: 0011 cost= 0.163563500
      Epoch: 0012 cost= 0.158185000
      Epoch: 0013 cost= 0.144468789
      Epoch: 0014 cost= 0.139108929
      Epoch: 0015 cost= 0.130174000
      Optimization Finished!
      Accuracy: 0.8539
      """
output:     import tensorflow as tf
      import numpy as np
      from tensorflow.examples.tutorials.mnist import input_data
  
      mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
  
      x = tf.placeholder(tf.float32, [None, 784])
      y = tf.placeholder(tf.float32, [None, 10])
  
      W1 = tf.Variable(tf.random_normal([784, 256]))
      b1 = tf.Variable(tf.random_normal([256]))
      layer1 = tf.nn.relu(tf.matmul(x, W1) + b1)
  
      W2 = tf.Variable(tf.random_normal([256, 256]))
      b2 = tf.Variable(tf.random_normal([256]))
      layer2 = tf.nn.relu(tf.matmul(layer1, W2) + b2)
  
      W3 = tf.Variable(tf.random_normal([256, 10]))
      b3 = tf.Variable(tf.random_normal([10]))
      logits = tf.matmul(layer2, W3) + b3
  
      cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))
      optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
  
      init = tf.global_variables_initializer()
  
      with tf.Session() as sess:
          sess.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 = sess.run([optimizer, cost], feed_dict={x: batch_x, y: batch_y})
                  avg_cost += c / total_batch
  
              if epoch % display_step == 0:
                  print(f"Epoch: {epoch+1:04d} cost= {avg_cost:.9f}")
  
          print("Optimization Finished!")
  
          correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
          accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
          print(f"Accuracy: {accuracy.eval({x: mnist.test.images, y: mnist.test.labels})}")