# Tensorflow and tf.keras
import tensorflow as tf 
from tensorflow import keras

# Helper Libraries
import numpy as np
import matplotlib.pyplot as plt
# 添加下行代码可在notebook中展示matplotlib生成的图片
%matplotlib inline

print(tf.__version__)

# Import the Fashion MNIST dataset
fashion_mnist=keras.datasets.fashion_mnist
# Loading the dataset returns 4 Numpy arrays
(train_images,train_labels),(test_images,test_labels)=fashion_mnist.load_data()
# The images are 28x28 numpy arrays,with pixel values ranging from 0 to 255.
print("train_iamges.shape:",train_images.shape)
# The labels are an array of integers, ranging from 0 to 9.These correspond to the class of clothing the image represents:
# 0:T-shirt/top
# 1:Trouser
# 2:Pullover
# 3:Dress
# 4:Coat
# 5:Sandal
# 6:Shirt
# 7:Sneaker
# 8:Bag
# 9:Ankle boot
print("train_labels.shape:",train_labels.shape)

# storage the 10 classes into a list
class_names=['T-shirt/top','Trouser','Pullover','Dress','Coat','Sandal','Shirt','Sneaker','Bag','Ankle boot']

# Use this function you can see the pixel values fall in the range of 0 to 255
def show_img_colorbar(image):
    plt.figure()
    plt.imshow(image)
    plt.colorbar()
    plt.grid(False)
    plt.show()
show_img_colorbar(train_images[0])
show_img_colorbar(test_images[0])

# scale these pixel values to a range of 0 to 1
# test set shuold do the same as train set
train_images = train_images/255.0
test_images = test_images/255.0

# after scaled, the img didn't change although the range has changed
show_img_colorbar(train_images[0])
show_img_colorbar(test_images[0])

def display_images(images,image_num,labels):
    plt.figure(figsize=(10,10))
    for i in range(image_num):
        plt.subplot(5,5,i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(images[i],cmap=plt.cm.binary)
        plt.xlabel(class_names[labels[i]])
    plt.show()
    
display_images(train_images,25,train_labels)

# Build the model
model=keras.Sequential([
    # keras.layers.Flatten transforms the format of the images from a two-dimensional array(of 28x28 pixels) to a one-dimensional array(of 28*28=784 pixels)
    keras.layers.Flatten(input_shape=(28,28)),
    # keras.layers.Dense:fully connected neural layer
    keras.layers.Dense(128,activation='relu'),
    keras.layers.Dense(10)
])

# Before the model is ready for training, it needs a few more settings. These are added during the model's compile step:
# 1.Loss function —This measures how accurate the model is during training. You want to minimize this function to "steer" the model in the right direction.
# 2.Optimizer —This is how the model is updated based on the data it sees and its loss function.
# 3.Metrics —Used to monitor the training and testing steps. The following example uses accuracy, the fraction of the images that are correctly classified.

model.compile(optimizer='adam',loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),metrics=['accuracy'])
# print the structure of our model
model.summary()

# Train the model

# To start training, call the model.fit method—so called because it "fits" the model to the training data:
model.fit(train_images,train_labels,epochs=20)

# This gap between training accuracy and test accuracy represents overfitting.
test_loss,test_acc=model.evaluate(test_images,test_labels,verbose=2)
print('\nTest accuracy:',test_acc)

# Make predictions

# Softmax layer convert the logits to probabilities
probability_model=keras.Sequential([model,keras.layers.Softmax()])

predictions=probability_model.predict(test_images)
predictions[0]

print("prediction_label:",np.argmax(predictions[0]))
print("true_label:",test_labels[0])

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()

# Use the trained model: use the trained model to make a prediction about a single image.

img = test_images[24]
print(img.shape)

img=np.expand_dims(img,0)
print(img.shape)

prediction_single=probability_model.predict(img)
print(prediction_single)

plot_value_array(24, prediction_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

print("prediction_label:",np.argmax(prediction_single[0]))
print("true_label:",test_labels[24])