import tensorflow as tf
from tensorflow import keras
import tensorflow_datasets as tfds
import numpy as np
import matplotlib.pyplot as plt
# Print the version of tf, and tfds
print("TensorFlow's version used in notebook:{}".format(tf.__version__))
print("TensorFlow datasets's version used in notebook:{}".format(tfds.__version__))
# (train_data, train_label), (test_data, test_label) = keras.datasets.cifar10.load_data()
(train_data, val_data, test_data), info = tfds.load('cifar10',
split=['train', 'test[:50%]','test[50%:]'],
as_supervised=True,
shuffle_files=False,
with_info=True
)
print("The number images in training set: {}".format(len(train_data)))
print("The number images in validation set: {}".format(len(val_data)))
print("The number images in test set: {}".format(len(test_data)))
# Getting the number of examples
info.splits['train'].num_examples
# Getting the number of examples
info.splits['test'].num_examples
# getting class names
info.features['label'].names
# Number of classes
info.features['label'].num_classes
fig = tfds.show_examples(train_data, info)
def preprocess(image, label):
"""
Take image and label,
convert images to float32, and return converted image &label
"""
normalized_img = tf.cast(image, tf.float32)/255.0
return normalized_img, label
def train_data_prep(data, shuffle_size, batch_size):
data = data.map(preprocess)
data = data.cache()
data = data.shuffle(shuffle_size).repeat()
data = data.batch(batch_size)
data = data.prefetch(1)
return data
def test_data_prep(data, batch_size):
data = data.map(preprocess)
data = data.batch(batch_size)
data = data.cache()
data = data.prefetch(1)
return data
train_data_prepared = train_data_prep(train_data, 1000, 32)
test_data_prepared = test_data_prep(test_data, 32)
val_data_prepared = test_data_prep(val_data, 32)
input_shape = [32,32,3]
cifar_cnn = tf.keras.models.Sequential([
# First Convolutional layer: 64 filters, kernel/filter size of 3
tf.keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu', input_shape=input_shape),
# First Pooling layer
tf.keras.layers.MaxPooling2D(pool_size=2),
# Second Convolutional layer & Pooling
tf.keras.layers.Conv2D(filters=128, kernel_size=(3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
# Third Convolutional & Pooling layer
tf.keras.layers.Conv2D(filters=256, kernel_size=(3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
# Flattening layer: For converting previous output into 1D column vector
tf.keras.layers.Flatten(),
# Fully Connected layers
tf.keras.layers.Dense(units=128, activation='relu'),
tf.keras.layers.Dense(units=64, activation='relu'),
# Last layer: 10 neurons for 10 classes, activated by softmax
tf.keras.layers.Dense(units=10, activation='softmax')
])
# Model summary
cifar_cnn.summary()
tf.keras.utils.plot_model(cifar_cnn, rankdir='LR',show_dtype=True)
cifar_cnn.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
batch_size = 32
train_size = info.splits["train"].num_examples
val_size = len(val_data_prepared)
train_steps = int(train_size/batch_size)
val_steps = int(val_size/batch_size)
model_history = cifar_cnn.fit(train_data_prepared,
validation_data=val_data_prepared,
epochs=9,
steps_per_epoch=train_steps,
validation_steps=val_steps)
import pandas as pd
# Getting the model training history
model_history = model_history.history
# Model history into a pandas dataframe
loss_acc_df = pd.DataFrame(model_history)
# Plotting the loss and accuracy
loss_acc_df.plot(figsize=(10,5))
acc = model_history['accuracy']
val_acc = model_history['val_accuracy']
loss = model_history['loss']
val_loss = model_history['val_loss']
epochs = cifar_cnn.history.epoch
# function to plot accuracy
def plot_acc(acc, val_acc, epochs):
plt.figure(figsize=(10,5))
plt.plot(epochs, acc, 'r', label='Training Accuracy')
plt.plot(epochs, val_acc, 'g', label='Validation Accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
def plot_loss(loss, val_loss, epochs):
plt.figure(figsize=(10,5))
plt.plot(epochs, loss, 'b', label='Training Loss')
plt.plot(epochs, val_loss, 'y', label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend(loc=0)
plt.figure()
#Plotting acc
plot_acc(acc, val_acc, epochs)
plot_loss(loss, val_loss, epochs)
# reloading the data
# Training set = 80% of orginal training set (50,000 images)
# Validation set = 20% of training set = 10,000 images
# Test set = full orginal test set = 10,000 images
(train_data, val_data, test_data), info = tfds.load('cifar10',
split=['train[:80%]', 'train[80%:]','test'],
as_supervised=True,
shuffle_files=True,
with_info=True
)
train_final = train_data_prep(train_data, 1000, 32)
val_final = test_data_prep(val_data, 32)
test_final = test_data_prep(test_data, 32)
input_shape = [32,32,3]
cifar_cnn_2 = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(filters=64, kernel_size=(3,3), padding='same',activation='relu', input_shape=input_shape),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(units=128, activation='relu'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(units=10, activation='softmax')
])
# Nadam optimizer is a version of adam
cifar_cnn_2.compile(loss='sparse_categorical_crossentropy',
optimizer='nadam',
metrics='accuracy')
# Training the model for 10 epochs
batch_size = 32
train_size = 40000
val_size = 10000
train_steps = int(train_size/batch_size)
val_steps = int(val_size/batch_size)
model_history_2 = cifar_cnn_2.fit(train_final,
validation_data=val_final,
epochs=10,
steps_per_epoch=train_steps,
validation_steps=val_steps)
model_history = model_history_2.history
acc = model_history['accuracy']
val_acc = model_history['val_accuracy']
loss = model_history['loss']
val_loss = model_history['val_loss']
epochs = model_history_2.epoch
# Plot accuracy
plot_acc(acc, val_acc, epochs)
# Plot loss
plot_loss(loss, val_loss, epochs)
# Evaluating a model on test set
loss, acc = cifar_cnn_2.evaluate(test_final)
# Print loss and acc with 3 only decimal points
print('Test Loss: {:.3f}'.format(loss))
print('Test Accuracy: {:.3f}'.format(acc))
# Saving a model
cifar_cnn_2.save('Cifar Best.h5')
# Loading a saved model
from keras.models import load_model
load_cifar = load_model('Cifar Best.h5')
load_cifar.summary()