text: from __future__ import absolute_import, division, print_function, unicode_literals
  
  # TensorFlow and tf.keras
  import tensorflow as tf
  import keras
  from keras.preprocessing.image import ImageDataGenerator
  from keras.models import Sequential
  from keras.layers import Dense, Dropout, Activation, Flatten
  from keras.layers import Conv2D, MaxPooling2D
  import os
  
  # Helper libraries
  import numpy as np
  import matplotlib.pyplot as plt
  
  print(tf.__version__)
  
  batch_size = 32
  num_classes = 10
  epochs = 100
  
  cifar10 = keras.datasets.cifar10
  
  (train_images, train_labels), (test_images, test_labels) = cifar10.load_data()
  
  # Convert class vectors to binary class matrices.
  train_labels = keras.utils.to_categorical(train_labels, num_classes)
  test_labels = keras.utils.to_categorical(test_labels, num_classes)
  
  class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 
                 'dog', 'frog', 'horse', 'ship', 'truck']
  
  print(train_images.shape)
  
  print(len(train_labels))
  
  print(train_labels)
  
  print(test_images.shape)
  
  print(len(test_labels))
  
  plt.figure()
  plt.imshow(train_images[0])
  plt.colorbar()
  plt.grid(False)
  plt.show()
  
  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[np.argmax(train_labels[i])])
  plt.show()
  
  
  model = Sequential()
  model.add(Conv2D(32, (3, 3), padding='same',
                   input_shape=train_images.shape[1:]))
  model.add(Activation('relu'))
  model.add(Conv2D(32, (3, 3)))
  model.add(Activation('relu'))
  model.add(MaxPooling2D(pool_size=(2, 2)))
  model.add(Dropout(0.25))
  
  model.add(Conv2D(64, (3, 3), padding='same'))
  model.add(Activation('relu'))
  model.add(Conv2D(64, (3, 3)))
  model.add(Activation('relu'))
  model.add(MaxPooling2D(pool_size=(2, 2)))
  model.add(Dropout(0.25))
  
  model.add(Flatten())
  model.add(Dense(512))
  model.add(Activation('relu'))
  model.add(Dropout(0.5))
  model.add(Dense(num_classes))
  model.add(Activation('softmax'))
  
  
  opt = keras.optimizers.RMSprop(learning_rate=0.0001, decay=1e-6)
  
  model.compile(optimizer=opt,
                loss='categorical_crossentropy',
                metrics=['accuracy'])
  
  model.fit(train_images, train_labels, batch_size=batch_size, epochs=epochs, validation_data=(test_images, test_labels), shuffle=True)
  train_images = train_images.astype('float32')
  test_images = test_images.astype('float32')
  train_images /= 255
  test_images /= 255
  
  test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
  
  print('\nTest accuracy:', test_acc)
  
  predictions = model.predict(test_images)
  
  print(predictions[0])
  
  print(np.argmax(predictions[0]))
  
  print(test_labels[0])
  
  test_labels = [np.argmax(label) for label in test_labels]
  def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array, 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 = 'blue'
    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):
    predictions_array, true_label = predictions_array, 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('blue')
  
  
  i = 0
  plt.figure(figsize=(6,3))
  plt.subplot(1,2,1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(1,2,2)
  plot_value_array(i, predictions[i],  test_labels)
  plt.show()
  
  i = 12
  plt.figure(figsize=(6,3))
  plt.subplot(1,2,1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(1,2,2)
  plot_value_array(i, predictions[i],  test_labels)
  plt.show()
  
  # Plot the first X test images, their predicted labels, and the true labels.
  # Color correct predictions in blue and incorrect predictions in red.
  num_rows = 5
  num_cols = 3
  num_images = num_rows*num_cols
  plt.figure(figsize=(2*2*num_cols, 2*num_rows))
  for i in range(num_images):
    plt.subplot(num_rows, 2*num_cols, 2*i+1)
    plot_image(i, predictions[i], test_labels, test_images)
    plt.subplot(num_rows, 2*num_cols, 2*i+2)
    plot_value_array(i, predictions[i], test_labels)
  plt.tight_layout()
  plt.show()
  
  # Grab an image from the test dataset.
  img = test_images[1]
  
  print(img.shape)
  
  # Add the image to a batch where it's the only member.
  img = (np.expand_dims(img,0))
  
  print(img.shape)
  
  predictions_single = model.predict(img)
  
  print(predictions_single)
  
  plot_value_array(1, predictions_single[0], test_labels)
  _ = plt.xticks(range(10), class_names, rotation=45)
  
  print(np.argmax(predictions_single[0]))