text: import tensorflow as tf
  import numpy as np
  import matplotlib.pyplot as plt
  
  fashion_mnist = tf.keras.datasets.fashion_mnist  # Import the dataset.
  (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
  
  # Store the labels here as they're excluded.
  class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
                 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
  
  # Verify the data.
  print(train_images.shape)
  print(len(train_labels))
  print(train_labels)
  print(test_images.shape)
  print(len(test_labels))
  
  train_images = train_images / 255  # Divide by 255 for correct scaling.
  test_images = test_images / 255
  
  # Verify the scaling.
  plt.figure(figsize=(10, 10))
  for i in range(25):
      plt.subplot(5, 5, i + 1)
      plt.xticks([])
      plt.yticks([])
      plt.grid(False)
      plt.imshow(train_images[i], cmap=plt.cm.binary)
      plt.xlabel(class_names[train_labels[i]])
  plt.show()
  
  # Set up the layers.
  model = tf.keras.Sequential([
      tf.keras.layers.Flatten(input_shape=(28, 28)),  # Reformat the 2D-array of 28x28p to a 1D-array of 28*28=784p.
      tf.keras.layers.Dense(128, activation="relu"),  # Last two layers are densely connected. 128 nodes scores image.
      tf.keras.layers.Dense(10)
  ])
  
  # Now compile the model.
  model.compile(optimizer="adam",  # How the data is optimized based on data.
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),  # Loss = accuracy.
                metrics=["accuracy"])  # Monitors by accuracy while training and testing.
  
  # Then train the model.
  model.fit(train_images, train_labels, epochs=10)  # Epochs = amount of simulations.
  test_loss, test_accuracy = model.evaluate(test_images, test_labels, verbose=2)
  print("\nTest accuracy: ", test_accuracy)
  
  # Make predictions.
  probability_model = tf.keras.Sequential([
      model, tf.keras.layers.Softmax()  # Softmax converts logits (lin-OP) to probability.
  ])
  predictions = probability_model.predict(test_images)
  print(predictions[0])
  print(np.argmax(predictions[0]))  # Find the maximum value in our prediction (highest probability).
  print(test_labels[0])  # Should return the same as our prediction (if accurate).
  
  
  #  Graph the entire test set.
  def plot_image(i, predictions_array, true_label, img):
      true_label, img = true_label[i], img[i]
      plt.grid(False)
      plt.xticks([])
      plt.yticks([])
  
      plt.imshow(img, cmap=plt.cm.binary)
  
      predicted_label = np.argmax(predictions_array)
      if predicted_label == true_label:
          color = "green"
      else:
          color = "red"
  
      plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                           100 * np.max(predictions_array),
                                           class_names[true_label]),
                 color=color)
  
  
  def plot_value_array(i, predictions_array, true_label):
      true_label = true_label[i]
      plt.grid(False)
      plt.xticks(range(10))
      plt.yticks([])
      thisplot = plt.bar(range(10), predictions_array, color="#777777")
      plt.ylim([0, 1])
      predicted_label = np.argmax(predictions_array)
  
      thisplot[predicted_label].set_color("red")
      thisplot[true_label].set_color("green")
  
  
  # Time to predict
  rows = 3
  cols = 3
  images = rows * cols
  plt.figure(figsize=(2 * 2 * cols, 2 * rows))
  for i in range(images):
      plt.subplot(rows, 2 * cols, 2 * i + 1)
      plot_image(i, predictions[i], test_labels, test_images)
      plt.subplot(rows, 2 * cols, 2 * i + 2)
      plot_value_array(i, predictions[i], test_labels)
  plt.tight_layout()
  plt.show()
  
  # Use model on single image
  img = test_images[10]
  print(img.shape)
  img = (np.expand_dims(img, 0))
  prediction = probability_model.predict(img)
  print(prediction)
  print(np.argmax(prediction[0]))  # Did it work?
  print(test_labels[10])
  