This article mainly demonstrates how to use the Inception V3 model for transfer learning to create a new image classifier.
01 – a simple linear model | 02 – convolution neural network | 03 – PrettyTensor | 04 – save and restore 05 – integrated learning 06 – CIFAR 10 | | 07 – Inception model
By Magnus Erik Hvass Pedersen/GitHub/Videos on YouTube 英 文翻译
If reproduced, please attach a link to this article.
Introduction to the
In the previous tutorial #07, we learned how to classify images using a pre-trained Indeption model. Unfortunately, the Inception model doesn’t seem to be able to classify human images. The reason lies in the training set used by the model, which has some confusing category labels.
The Inception model can actually extract useful information from an image. Therefore, we can train the Inception model with other data sets. But training such models on new data sets can take weeks on a powerful and expensive computer.
Instead, we can reuse the pre-trained Inception model and only replace the last layer of classification. This method is called transfer learning.
This article builds on the previous tutorial. You will need to be familiar with the Inception model in tutorial #07, as well as the previous tutorial on how to create and train neural networks in TensorFlow. Part of the code for this tutorial is in the file inception. Py.
The flow chart
The following figure shows the flow of data for transfer learning using the Inception model. First, we enter and process an image in the Inception model. Before the final classification layer of the model, the so-called transfer-values are saved to a cache file.
The reason for using cached files is that the Inception model takes a long time to process a diagram. My laptop with a Quad-core 2 GHz CPU can process 3 images per second from the Inception model. Saving transfer-Values can save a lot of time if each image needs to be processed multiple times.
Transfer-values are sometimes called bottleneck-values, but this term can be confusing and is not used here.
After all images in the new data set have been processed with Inception and the resulting transfer-values have been saved to a cache file, we can use these transfer-values as input to other neural networks. A second neural network is then trained to classify new data sets, so the network learns how to classify images based on transfer-values of the Inception model.
Thus, the Inception model extracts useful information from the image, and then uses additional neural networks to do the actual classification.
from IPython.display import Image, display
Image('images/08_transfer_learning_flowchart.png')Copy the code
The import
%matplotlib inline
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
import time
from datetime import timedelta
import os
# Functions and classes for loading and using the Inception model.import inception
# We use Pretty Tensor to define the new classifier.import prettytensor as ptCopy the code
Developed using Python3.5.2 (Anaconda), the TensorFlow version is:
tf.__version__Copy the code
‘0.12.0 – rc0’
PrettyTensor version:
pt.__version__Copy the code
‘0.7.1’
Load CIFAR-10 data
import cifar10Copy the code
Data dimensions are already defined in the cirfa10 module, so we can just import them if we need them.
from cifar10 import num_classesCopy the code
Set the path to save the data set on your computer.
# cifar10.data_path = "data/CIFAR-10/"Copy the code
The CIFAR-10 dataset is about 163MB and will be downloaded automatically if no files are found in a given path.
cifar10.maybe_download_and_extract()Copy the code
Data has apparently already been downloaded and unpacked.
Load the class name.
class_names = cifar10.load_class_names()
class_namesCopy the code
The CIFAR-10 dataset has now been loaded with 60,000 images and associated labels (classification of images). The data set is divided into two independent subsets, namely the training set and the test set.
print("Size of:")
print("- Training-set:\t\t{}".format(len(images_train)))
print("- Test-set:\t\t{}".format(len(images_test)))Copy the code
Size of:
Training-set: 50000
Test-set: 10000
Help function for drawing pictures
This function is used to draw nine images in a 3×3 grid and write the real category and the predicted category under each image.
defplot_images(images, cls_true, cls_pred=None, smooth=True):assert len(images) == len(cls_true)
# Create figure with sub-plots.
fig, axes = plt.subplots(3.3)
# Adjust vertical spacing.if cls_pred isNone:
hspace = 0.3else:
hspace = 0.6
fig.subplots_adjust(hspace=hspace, wspace=0.3)
# Interpolation type.if smooth:
interpolation = 'spline16'else:
interpolation = 'nearest'for i, ax in enumerate(axes.flat):
# There may be less than 9 images, ensure it doesn't crash.if i < len(images):
# Plot image.
ax.imshow(images[i],
interpolation=interpolation)
# Name of the true class.
cls_true_name = class_names[cls_true[i]]
# Show true and predicted classes.if cls_pred isNone:
xlabel = "True: {0}".format(cls_true_name)
else:
# Name of the predicted class.
cls_pred_name = class_names[cls_pred[i]]
xlabel = "True: {0}\nPred: {1}".format(cls_true_name, cls_pred_name)
# Show the classes as the label on the x-axis.
ax.set_xlabel(xlabel)
# Remove ticks from the plot.
ax.set_xticks([])
ax.set_yticks([])
# Ensure the plot is shown correctly with multiple plots# in a single Notebook cell.
plt.show()Copy the code
Draw a few images to see if the data is correct
# Get the first images from the test-set.
images = images_test[0:9]
# Get the true classes for those images.
cls_true = cls_test[0:9]
# Plot the images and labels using our helper-function above.
plot_images(images=images, cls_true=cls_true, smooth=False)Copy the code
Download Inception model
Download the Inception model from the Web. This is the default folder where you save your data files. The folder is created automatically if it does not exist.
# inception.data_dir = 'inception/'Copy the code
If the Inception model does not exist in the folder, it is downloaded automatically. It is 85 MB.
See tutorial #07 for more details.
inception.maybe_download()Copy the code
Downloading Inception v3 Model … Data has apparently already been downloaded and unpacked.
Loading Inception model
Load the model to prepare for image classification.
Pay attention to this warning. The program may fail to run in the future.
model = inception.Inception()Copy the code
Calculate Transfer – Values
Import the help function used to get transfer-values from the Inception model.
from inception import transfer_values_cacheCopy the code
Sets the directory for training and test set cache files.
file_path_cache_train = os.path.join(cifar10.data_path, 'inception_cifar10_train.pkl')
file_path_cache_test = os.path.join(cifar10.data_path, 'inception_cifar10_test.pkl')Copy the code
print("Processing Inception transfer-values for training-images ...")
# Scale images because Inception needs pixels to be between 0 and 255,# while the CIFAR-10 functions return pixels between 0.0 and 1.0
images_scaled = images_train * 255.0# If transfer-values have already been calculated then reload them,# otherwise calculate them and save them to a cache-file.
transfer_values_train = transfer_values_cache(cache_path=file_path_cache_train,
images=images_scaled,
model=model)Copy the code
Processing Inception transfer-values for training-images ...
- Data loaded from cache-file: data/CIFAR-10/inception_cifar10_train.pklCopy the code
print("Processing Inception transfer-values for test-images ...")
# Scale images because Inception needs pixels to be between 0 and 255,# while the CIFAR-10 functions return pixels between 0.0 and 1.0
images_scaled = images_test * 255.0# If transfer-values have already been calculated then reload them,# otherwise calculate them and save them to a cache-file.
transfer_values_test = transfer_values_cache(cache_path=file_path_cache_test,
images=images_scaled,
model=model)Copy the code
Processing Inception transfer-values for test-images …
Data loaded from cache-file: data/CIFAR-10/inception_cifar10_test.pkl
Check the array size of transfer-Values. There are 50,000 images in the training set, with 2048 transfer-values per image.
transfer_values_train.shapeCopy the code
(50000, 2048)
Similarly, there were 10,000 images in the test set, with 2048 transfer-values per image.
transfer_values_test.shapeCopy the code
(10000, 2048)
Draw the help function for Transfer-Values
defplot_transfer_values(i):
print("Input image:")
# Plot the i'th image from the test-set.
plt.imshow(images_test[i], interpolation='nearest')
plt.show()
print("Transfer-values for the image using Inception model:")
# Transform the transfer-values into an image.
img = transfer_values_test[i]
img = img.reshape((32.64))
# Plot the image for the transfer-values.
plt.imshow(img, interpolation='nearest', cmap='Reds')
plt.show()Copy the code
plot_transfer_values(i=16)Copy the code
Input image:
Transfer-values for the image using Inception model:
plot_transfer_values(i=17)Copy the code
Input image:
Transfer-values for the image using Inception model:
PCA analysis results of Transfer-Values
Principal component analysis (PCA) in SciKit-Learn was used to reduce the dimensions of transfer-Values from 2048 dimensions to 2 dimensions for easy drawing.
from sklearn.decomposition import PCACopy the code
Create a new PCA-Object with the target array dimension set to 2.
pca = PCA(n_components=2)Copy the code
The calculation of PCA takes time, so the sample size is limited to 3000. You can use the entire training set if you like.
transfer_values = transfer_values_train[0:3000]Copy the code
Gets the category number of the sample you selected.
cls = cls_train[0:3000]Copy the code
The guarantee array has 3000 samples, each with 2048 transfer-values.
transfer_values.shapeCopy the code
(3000, 2048)Copy the code
PCA was used to reduce transfer-value from 2048 dimensions to 2 dimensions.
transfer_values_reduced = pca.fit_transform(transfer_values)Copy the code
The array now has 3000 samples with two values per sample.
transfer_values_reduced.shapeCopy the code
(3000, 2)
The help function is used to draw transfer-values after dimensionality reduction.
defplot_scatter(values, cls):# Create a color-map with a different color for each class.import matplotlib.cm as cm
cmap = cm.rainbow(np.linspace(0.0.1.0, num_classes))
# Get the color for each sample.
colors = cmap[cls]
# Extract the x- and y-values.
x = values[:, 0]
y = values[:, 1]
# Plot it.
plt.scatter(x, y, color=colors)
plt.show()Copy the code
Draw transfer-values after dimensionality reduction with PCA. Ten different colors are used to represent different categories in the CIFAR-10 dataset. The colors are individually combined, but there’s a lot of overlap. This may be because PCA cannot properly separate transfer-values.
plot_scatter(transfer_values_reduced, cls)Copy the code
T-sne analysis results of Transfer-Values
from sklearn.manifold import TSNECopy the code
Another method of dimensionality reduction is t-SNE. Unfortunately, T-SNE is slow, so we first reduced the dimensions from 2048 to 50 using PCA.
pca = PCA(n_components=50)
transfer_values_50d = pca.fit_transform(transfer_values)Copy the code
Create a new T-SNE object to do the final dimension reduction, setting the target dimension to 2.
tsne = TSNE(n_components=2)Copy the code
The final dimension reduction was performed using t-SNE. The t-SNE currently implemented in SciKit-Learn may not be able to handle many samples of data, so the program may crash if you use the entire training set.
transfer_values_reduced = tsne.fit_transform(transfer_values_50d)Copy the code
Ensure that the array has 3000 samples with two transfer-values per sample.
transfer_values_reduced.shapeCopy the code
(3000, 2)
Draw the transfer-values reduced to 2d by T-SNE, which has better separation than the above PCA results.
This means that transfer-values obtained from the Inception model seem to contain enough information to classify ciFAR-10 images, but there is still some overlap, indicating that the separation is not perfect.
plot_scatter(transfer_values_reduced, cls)Copy the code
New classifier in TensorFlow
We will create a new neural network in TensorFlow. The network takes transfer-values in the Inception model as input and outputs the predicted categories of CIFAR-10 images.
It is assumed that you are already familiar with how to build neural networks in TensorFlow, otherwise please read tutorial #03.
Placeholder variables
You first need to find the array length of Transfer-Values, which is a variable stored in the Inception model object.
transfer_len = model.transfer_lenCopy the code
Now create a placeholder variable for the input transfer-values into our new network. The variable’s shape is [None, transfer_len]. None means that its input array contains any number of samples, each with 2048 elements, namely transfer_len.
x = tf.placeholder(tf.float32, shape=[None, transfer_len], name='x')Copy the code
Define another placeholder variable for the input image’s real type tag. This is a one-Hot encoded array of 10 elements, each representing One of the possible categories in the dataset.
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')Copy the code
Computes the integer representing the real category. This could also be a placeholder variable.
y_true_cls = tf.argmax(y_true, dimension=1)Copy the code
The neural network
Create a neural network for classification on the CIFAR-10 dataset. It takes transfer-values derived from the Inception model as input and stores them in placeholder variable X. Network output prediction category y_pred.
Tutorial #03 has more details on constructing neural networks using Pretty Tensor.
# Wrap the transfer-values as a Pretty Tensor object.
x_pretty = pt.wrap(x)
with pt.defaults_scope(activation_fn=tf.nn.relu):
y_pred, loss = x_pretty.\
fully_connected(size=1024, name='layer_fc1').\
softmax_classifier(num_classes=num_classes, labels=y_true)Copy the code
An optimization method
Create a variable to record the number of current optimization iterations.
global_step = tf.Variable(initial_value=0,
name='global_step', trainable=False)Copy the code
Methods for optimizing new neural networks.
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(loss, global_step)Copy the code
Classification accuracy
The network output y_pred is an array of 10 elements. The category number is the index of the largest element in the array.
y_pred_cls = tf.argmax(y_pred, dimension=1)Copy the code
Create a Boolean vector that indicates whether the true category of each image is the same as the predicted category.
correct_prediction = tf.equal(y_pred_cls, y_true_cls)Copy the code
The accuracy of the classification is calculated by converting the Boolean vector type to a floating-point vector, where False becomes 0 and True becomes 1, and averaging the values.
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))Copy the code
Run TensorFlow
Creating TensorFlow sessions (Session)
Once the TensorFlow diagram is created, we need to create a TensorFlow session to run the diagram.
session = tf.Session()Copy the code
Initialize a variable
We need to initialize the weights and biases variables before we can start optimizing them.
session.run(tf.global_variables_initializer())Copy the code
Get the help function for random training Batch
There are 50,000 images in the training set (and an array to hold transfer-Values). It takes a lot of time to calculate the gradient of the model with these transfer-vlues. Therefore, we use only a small number of transfer-vlues in each iteration of the optimizer.
If running out of memory causes your computer to crash or become slow, you should try to reduce those numbers, but more optimized iterations may be needed in the meantime.
train_batch_size = 64Copy the code
The transfer-Vlues function is used to select a random batch of transfer-Vlues from the training set.
defrandom_batch(a):# Number of images (transfer-values) in the training-set.
num_images = len(transfer_values_train)
# Create a random index.
idx = np.random.choice(num_images,
size=train_batch_size,
replace=False)
# Use the random index to select random x and y-values.# We use the transfer-values instead of images as x-values.
x_batch = transfer_values_train[idx]
y_batch = labels_train[idx]
return x_batch, y_batchCopy the code
Perform the help function for the optimization iteration
Function is used to perform a number of optimization iterations to gradually improve the network layer variables. In each iteration, a new batch of data is selected from the training set, and TensorFlow performs optimization on these training samples. Progress is printed every 100 iterations.
defoptimize(num_iterations):# Start-time used for printing time-usage below.
start_time = time.time()
for i in range(num_iterations):
# Get a batch of training examples.# x_batch now holds a batch of images (transfer-values) and# y_true_batch are the true labels for those images.
x_batch, y_true_batch = random_batch()
# Put the batch into a dict with the proper names# for placeholder variables in the TensorFlow graph.
feed_dict_train = {x: x_batch,
y_true: y_true_batch}
# Run the optimizer using this batch of training data.# TensorFlow assigns the variables in feed_dict_train# to the placeholder variables and then runs the optimizer.# We also want to retrieve the global_step counter.
i_global, _ = session.run([global_step, optimizer],
feed_dict=feed_dict_train)
# Print status to screen every 100 iterations (and last).if (i_global % 100= =0) or (i == num_iterations - 1) :# Calculate the accuracy on the training-batch.
batch_acc = session.run(accuracy,
feed_dict=feed_dict_train)
# Print status.
msg = "Global Step: {0:>6}, Training Batch Accuracy: {1:>6.1%}"
print(msg.format(i_global, batch_acc))
# Ending time.
end_time = time.time()
# Difference between start and end-times.
time_dif = end_time - start_time
# Print the time-usage.
print("Time usage: " + str(timedelta(seconds=int(round(time_dif)))))Copy the code
Help function to show results
Help function for drawing error samples
The draw () function is used to draw misclassified samples in the test set.
defplot_example_errors(cls_pred, correct):# This function is called from print_test_accuracy() below.# cls_pred is an array of the predicted class-number for# all images in the test-set.# correct is a boolean array whether the predicted class# is equal to the true class for each image in the test-set.# Negate the boolean array.
incorrect = (correct == False)
# Get the images from the test-set that have been# incorrectly classified.
images = images_test[incorrect]
# Get the predicted classes for those images.
cls_pred = cls_pred[incorrect]
# Get the true classes for those images.
cls_true = cls_test[incorrect]
n = min(9, len(images))
# Plot the first n images.
plot_images(images=images[0:n],
cls_true=cls_true[0:n],
cls_pred=cls_pred[0:n])Copy the code
Help function to draw the confusion matrix
# Import a function from sklearn to calculate the confusion-matrix.from sklearn.metrics import confusion_matrix
defplot_confusion_matrix(cls_pred):# This is called from print_test_accuracy() below.# cls_pred is an array of the predicted class-number for# all images in the test-set.# Get the confusion matrix using sklearn.
cm = confusion_matrix(y_true=cls_test, # True class for test-set.
y_pred=cls_pred) # Predicted class.# Print the confusion matrix as text.for i in range(num_classes):
# Append the class-name to each line.
class_name = "({}) {}".format(i, class_names[i])
print(cm[i, :], class_name)
# Print the class-numbers for easy reference.
class_numbers = ["({0})".format(i) for i in range(num_classes)]
print("".join(class_numbers))Copy the code
Compute the help function for classification
This function computes the predicted categories of images and returns a Boolean array representing whether each image is correctly classified.
Because the calculations may consume too much memory, batch them. If your computer crashes, try lowering batch-size.
# Split the data-set in batches of this size to limit RAM usage.
batch_size = 256defpredict_cls(transfer_values, labels, cls_true):# Number of images.
num_images = len(transfer_values)
# Allocate an array for the predicted classes which# will be calculated in batches and filled into this array.
cls_pred = np.zeros(shape=num_images, dtype=np.int)
# Now calculate the predicted classes for the batches.# We will just iterate through all the batches.# There might be a more clever and Pythonic way of doing this.# The starting index for the next batch is denoted i.
i = 0while i < num_images:
# The ending index for the next batch is denoted j.
j = min(i + batch_size, num_images)
# Create a feed-dict with the images and labels# between index i and j.
feed_dict = {x: transfer_values[i:j],
y_true: labels[i:j]}
# Calculate the predicted class using TensorFlow.
cls_pred[i:j] = session.run(y_pred_cls, feed_dict=feed_dict)
# Set the start-index for the next batch to the# end-index of the current batch.
i = j
# Create a boolean array whether each image is correctly classified.
correct = (cls_true == cls_pred)
return correct, cls_predCopy the code
Calculates the prediction categories on the test set.
Help function to calculate classification accuracy
This function calculates the classification accuracy of a given Boolean array indicating whether each image is correctly classified. For example, cls_accuracy([True, True, False, False, False]) = 2/5 = 0.4.
defclassification_accuracy(correct):# When averaging a boolean array, False means 0 and True means 1.# So we are calculating: number of True / len(correct) which is# the same as the classification accuracy.# Return the classification accuracy# and the number of correct classifications.return correct.mean(), correct.sum()Copy the code
Show the help function for classification accuracy
The class accuracy () function prints the classification accuracy on the test set.
It will take a while to calculate the classification for all the images on the test set, so we call the above functions directly from this function so that we don’t have to recalculate the classification for each function.
defprint_test_accuracy(show_example_errors=False, show_confusion_matrix=False):# For all the images in the test-set,# calculate the predicted classes and whether they are correct.
correct, cls_pred = predict_cls_test()
# Classification accuracy and the number of correct classifications.
acc, num_correct = classification_accuracy(correct)
# Number of images being classified.
num_images = len(correct)
# Print the accuracy.
msg = "Accuracy on Test-Set: {0:.1%} ({1} / {2})"
print(msg.format(acc, num_correct, num_images))
# Plot some examples of mis-classifications, if desired.if show_example_errors:
print("Example errors:")
plot_example_errors(cls_pred=cls_pred, correct=correct)
# Plot the confusion matrix, if desired.if show_confusion_matrix:
print("Confusion Matrix:")
plot_confusion_matrix(cls_pred=cls_pred)Copy the code
The results of
Optimize previous performance
The accuracy on the test set is very low because the model is only initialized, not optimized, so it just randomly classifies the images.
print_test_accuracy(show_example_errors=False,
show_confusion_matrix=False)Copy the code
Accuracy on test-set: 9.4% (939/10000)
Performance after 10,000 optimized iterations
After 10,000 optimization iterations, classification accuracy on the test set was about 90%. This compares to less than 80% accuracy in the previous tutorial #06.
optimize(num_iterations=10000)Copy the code
Global Step: 100, Training Batch Accuracy: 82.8% Global Step: 200, Training Batch Accuracy: 90.6% Global Step: 300, Training Batch Accuracy: 90.6% Global Step: 400, Training Batch Accuracy: 95.3% Global Step: 500, Training Batch Accuracy: 85.9% Global Step: 600, Training Batch Accuracy: 84.4% Global Step: 700, Training Batch Accuracy: 90.6% Global Step: 800, Training Batch Accuracy: 93.8% Global Step: 900, Training Batch Accuracy: 92.2% Global Step: 1000, Training Batch Accuracy: 95.3% Global Step: 1100, Training Batch Accuracy: 93.8% Global Step: 1200, Training Batch Accuracy: 90.6% Global Step: 1300, Training Batch Accuracy: 95.3% Global Step: 1400, Training Batch Accuracy: 90.6% Global Step: 1500, Training Batch Accuracy: 90.6% Global Step: 1600, Training Batch Accuracy: 92.2% Global Step: 1700, Training Batch Accuracy: 90.6% Global Step: 1800, Training Batch Accuracy: 92.2% Global Step: 1900, Training Batch Accuracy: 84.4% Global Step: 2000, Training Batch Accuracy: 85.9% Global Step: 2100, Training Batch Accuracy: 87.5% Global Step: 2200, Training Batch Accuracy: 90.6% Global Step: 2300, Training Batch Accuracy: 92.2% Global Step: 2400, Training Batch Accuracy: 95.3% Global Step: 2500, Training Batch Accuracy: 89.1% Global Step: 2600, Training Batch Accuracy: 93.8% Global Step: 2700, Training Batch Accuracy: 87.5% Global Step: 2800, Training Batch Accuracy: 90.6% Global Step: 2900, Training Batch Accuracy: 92.2% Global Step: 3000, Training Batch Accuracy: 96.9% Global Step: 3100, Training Batch Accuracy: 96.9% Global Step: 3200, Training Batch Accuracy: 92.2% Global Step: 3300, Training Batch Accuracy: 95.3% Global Step: 3400, Training Batch Accuracy: 93.8% Global Step: 3500, Training Batch Accuracy: 89.1% Global Step: 3600, Training Batch Accuracy: 89.1% Global Step: 3700, Training Batch Accuracy: 95.3% Global Step: 3800, Training Batch Accuracy: 98.4% Global Step: 3900, Training Batch Accuracy: 89.1% Global Step: 4000, Training Batch Accuracy: 92.2% Global Step: 4100, Training Batch Accuracy: 96.9% Global Step: 4200, Training Batch Accuracy: 100.0% Global Step: 4300, Training Batch Accuracy: 100.0% Global Step: 4400, Training Batch Accuracy: 90.6% Global Step: 4500, Training Batch Accuracy: 95.3% Global Step: 4600, Training Batch Accuracy: 96.9% Global Step: 4700, Training Batch Accuracy: 96.9% Global Step: 4800, Training Batch Accuracy: 96.9% Global Step: 4900, Training Batch Accuracy: 92.2% Global Step: 5000, Training Batch Accuracy: 98.4% Global Step: 5100, Training Batch Accuracy: 93.8% Global Step: 5200, Training Batch Accuracy: 92.2% Global Step: 5300, Training Batch Accuracy: 98.4% Global Step: 5400, Training Batch Accuracy: 98.4% Global Step: 5500, Training Batch Accuracy: 100.0% Global Step: 5600, Training Batch Accuracy: 92.2% Global Step: 5700, Training Batch Accuracy: 98.4% Global Step: 5800, Training Batch Accuracy: 92.2% Global Step: 5900, Training Batch Accuracy: 92.2% Global Step: 6000, Training Batch Accuracy: 93.8% Global Step: 6100, Training Batch Accuracy: 95.3% Global Step: 6200, Training Batch Accuracy: 98.4% Global Step: 6300, Training Batch Accuracy: 98.4% Global Step: 6400, Training Batch Accuracy: 96.9% Global Step: 6500, Training Batch Accuracy: 95.3% Global Step: 6600, Training Batch Accuracy: 96.9% Global Step: 6700, Training Batch Accuracy: 96.9% Global Step: 6800, Training Batch Accuracy: 92.2% Global Step: 6900, Training Batch Accuracy: 96.9% Global Step: 7000, Training Batch Accuracy: 100.0% Global Step: 7100, Training Batch Accuracy: 95.3% Global Step: 7200, Training Batch Accuracy: 96.9% Global Step: 7300, Training Batch Accuracy: 96.9% Global Step: 7400, Training Batch Accuracy: 95.3% Global Step: 7500, Training Batch Accuracy: 95.3% Global Step: 7600, Training Batch Accuracy: 93.8% Global Step: 7700, Training Batch Accuracy: 93.8% Global Step: 7800, Training Batch Accuracy: 95.3% Global Step: 7900, Training Batch Accuracy: 95.3% Global Step: 8000, Training Batch Accuracy: 93.8% Global Step: 8100, Training Batch Accuracy: 95.3% Global Step: 8200, Training Batch Accuracy: 98.4% Global Step: 8300, Training Batch Accuracy: 93.8% Global Step: 8400, Training Batch Accuracy: 98.4% Global Step: 8500, Training Batch Accuracy: 96.9% Global Step: 8600, Training Batch Accuracy: 96.9% Global Step: 8700, Training Batch Accuracy: 98.4% Global Step: 8800, Training Batch Accuracy: 95.3% Global Step: 8900, Training Batch Accuracy: 98.4% Global Step: 9000, Training Batch Accuracy: 98.4% Global Step: 9100, Training Batch Accuracy: 98.4% Global Step: 9200, Training Batch Accuracy: 96.9% Global Step: 9300, Training Batch Accuracy: 100.0% Global Step: 9400, Training Batch Accuracy: 90.6% Global Step: 9500, Training Batch Accuracy: 92.2% Global Step: 9600, Training Batch Accuracy: 98.4% Global Step: 9700, Training Batch Accuracy: 96.9% Global Step: 9800, Training Batch Accuracy: 98.4% Global Step: 9900, Training Batch Accuracy: 98.4% Global Step: 10000, Training Batch Accuracy: 100.0% Time usage: 0:00:32
print_test_accuracy(show_example_errors=True,
show_confusion_matrix=True)Copy the code
Accuracy on test-set: 90.7% (9069/10000) Example errors:
Confusion Matrix:
[926 6 13 2 3 0 1 1 29 19] (0) airplane
[ 9 921 2 5 0 1 1 1 2 58] (1) automobile
[ 18 1 883 31 32 4 22 5 1 3] (2) bird
[ 7 2 19 855 23 57 24 9 2 2] (3) cat
[ 5 0 21 25 896 4 24 22 2 1] (4) deer
[ 2 0 12 97 18 843 10 15 1 2] (5) dog
[ 2 1 16 17 17 4 940 1 2 0] (6) frog
[ 8 0 10 19 28 14 1 914 2 4] (7) horse
[ 42 6 1 4 1 0 2 0 932 12] (8) ship
[ 6 19 2 2 1 0 1 1 9 959] (9) truck
(1) (2) (3) (4) (5) (6) (7) (8) (9)
Close the TensorFlow session
We have now completed the task with TensorFlow, closing the session and freeing resources. Note that we need to close two Tensorflow-Sessions, one for each model object.
# This has been commented out in case you want to modify and experiment# with the Notebook without having to restart it.# model.close()# session.close()Copy the code
conclusion
In the previous tutorial #06, we spent 15 hours on a laptop training a neural network to classify the CIFAR-10 data set with approximately 80% accuracy on the test set.
In this tutorial, we use the Inception model from Tutorial #07 to obtain approximately 90% classification accuracy on the CIFAR-10 dataset. We input all images from the CIFAR-10 dataset into the Inception model and then obtain transfer-values prior to the final classification layer. Another neural network is then created that takes Transfer-Values as input and generates a CIFAR-10 category as output.
The CIFAR-10 dataset contains 60,000 images. On a COMPUTER without a GPU, it took approximately 6 hours to calculate the Transfer-values of the Inception model for these images. It only takes a few minutes to train a new classifier on these transfer-values. Combined, this transfer learning is more than twice as fast as training a neural network directly for the CIFRA-10 data set, and it results in higher classification accuracy.
Therefore, using Inception model for transfer learning is very helpful for building an image classifier on your own data set.
practice
Here are some suggested exercises that might help you improve your TensorFlow skills. In order to learn how to use TensorFlow more appropriately, practical experience is important.
Before you can make changes to this Notebook, you may want to make a backup.
Try using the entire training set in PCA and T-SNE. What happens?
Try changing the neural network for the new classifier. What happens if you remove full connection layers or add more full connection layers?
What happens if you do more or fewer iterations?
If you change the optimizer’slearning_rateWhat happens?
What if you distorted the CIFAR-10 image as you did in tutorial #06? You won’t be able to use caching because each graph is different.
Try to replace the CIFAR-10 dataset with MNIST dataset.
