From 165459c69eaaf619b29eb76b89629c3fcd57efee Mon Sep 17 00:00:00 2001 From: Prateek Sawhney Date: Fri, 21 Dec 2018 19:10:42 +0530 Subject: [PATCH] Add files via upload --- Traffic_Sign_Classifier.html | 14267 ++++++++++++++++++++++++++++++++ Traffic_Sign_Classifier.ipynb | 1017 +++ 2 files changed, 15284 insertions(+) create mode 100644 Traffic_Sign_Classifier.html create mode 100644 Traffic_Sign_Classifier.ipynb diff --git a/Traffic_Sign_Classifier.html b/Traffic_Sign_Classifier.html new file mode 100644 index 0000000..7b3a335 --- /dev/null +++ b/Traffic_Sign_Classifier.html @@ -0,0 +1,14267 @@ + + + + +Traffic_Sign_Classifier + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
+

Self-Driving Car Engineer Nanodegree

Deep Learning

Project: Build a Traffic Sign Recognition Classifier

In this notebook, a template is provided for you to implement your functionality in stages, which is required to successfully complete this project. If additional code is required that cannot be included in the notebook, be sure that the Python code is successfully imported and included in your submission if necessary.

+

Note: Once you have completed all of the code implementations, you need to finalize your work by exporting the iPython Notebook as an HTML document. Before exporting the notebook to html, all of the code cells need to have been run so that reviewers can see the final implementation and output. You can then export the notebook by using the menu above and navigating to \n", + "File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.

+
+

In addition to implementing code, there is a writeup to complete. The writeup should be completed in a separate file, which can be either a markdown file or a pdf document. There is a write up template that can be used to guide the writing process. Completing the code template and writeup template will cover all of the rubric points for this project.

+

The rubric contains "Stand Out Suggestions" for enhancing the project beyond the minimum requirements. The stand out suggestions are optional. If you decide to pursue the "stand out suggestions", you can include the code in this Ipython notebook and also discuss the results in the writeup file.

+

Note: Code and Markdown cells can be executed using the Shift + Enter keyboard shortcut. In addition, Markdown cells can be edited by typically double-clicking the cell to enter edit mode.

+
+ +
+
+
+
+
+
+
+

Step 0: Load The Data

+
+
+
+
+
+
In [1]:
+
+
+
# Load pickled data
+import pickle
+import random
+import numpy as np
+from sklearn.model_selection import train_test_split
+# TODO: Fill this in based on where you saved the training and testing data
+
+training_file = 'traffic-signs-data/train.p'
+validation_file= 'traffic-signs-data/valid.p'
+testing_file = 'traffic-signs-data/test.p'
+
+with open(training_file, mode='rb') as f:
+    train = pickle.load(f)
+with open(validation_file, mode='rb') as f:
+    valid = pickle.load(f)
+with open(testing_file, mode='rb') as f:
+    test = pickle.load(f)
+    
+X_train, y_train = train['features'], train['labels']
+X_valid, y_valid = valid['features'], valid['labels']
+X_test, y_test = test['features'], test['labels']
+
+ +
+
+
+ +
+
+
+
+
+

Step 1: Dataset Summary & Exploration

The pickled data is a dictionary with 4 key/value pairs:

+
    +
  • 'features' is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).
    • +
  • 'labels' is a 1D array containing the label/class id of the traffic sign. The file signnames.csv contains id -> name mappings for each id.
    • +
  • 'sizes' is a list containing tuples, (width, height) representing the original width and height the image.
    • +
  • 'coords' is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGES
    • +
+

Complete the basic data summary below. Use python, numpy and/or pandas methods to calculate the data summary rather than hard coding the results. For example, the pandas shape method might be useful for calculating some of the summary results.

+ +
+
+
+
+
+
+

Provide a Basic Summary of the Data Set Using Python, Numpy and/or Pandas

+
+
+
+
+
+
In [2]:
+
+
+
# TODO: Number of training examples
+n_train = len(y_train)
+
+# TODO: Number of validation examples
+n_validation = len(y_valid)
+
+# TODO: Number of testing examples.
+n_test = len(y_test)
+
+# TODO: What's the shape of an traffic sign image?
+image_shape = X_train[0].shape
+
+# TODO: How many unique classes/labels there are in the dataset.
+n_classes = len(np.unique(y_train))
+
+print("Number of training examples =", n_train)
+print("Number of testing examples =", n_test)
+print("Image data shape =", image_shape)
+print("Number of classes =", n_classes)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Number of training examples = 34799
+Number of testing examples = 12630
+Image data shape = (32, 32, 3)
+Number of classes = 43
+
+
+
+ +
+
+ +
+
+
+
In [3]:
+
+
+
from sklearn.model_selection import train_test_split
+X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.2, random_state=0)
+print("Updated Image Shape: {}".format(X_train[0].shape))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Updated Image Shape: (32, 32, 3)
+
+
+
+ +
+
+ +
+
+
+
+

Include an exploratory visualization of the dataset

+
+
+
+
+
+
+

Visualize the German Traffic Signs Dataset using the pickled file(s). This is open ended, suggestions include: plotting traffic sign images, plotting the count of each sign, etc.

+

The Matplotlib examples and gallery pages are a great resource for doing visualizations in Python.

+

NOTE: It's recommended you start with something simple first. If you wish to do more, come back to it after you've completed the rest of the sections. It can be interesting to look at the distribution of classes in the training, validation and test set. Is the distribution the same? Are there more examples of some classes than others?

+ +
+
+
+
+
+
+

Implementing simple visualization.

+
+
+
+
+
+
In [4]:
+
+
+
import random
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+index = random.randint(0, len(X_train))
+image = X_train[index].squeeze()
+
+plt.figure(figsize=(1,1))
+plt.imshow(image)
+print(y_train[index])
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
10
+
+
+
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+

Implementing complex visualization

+
+
+
+
+
+
In [5]:
+
+
+
fig=plt.figure(figsize=(20, 20))
+columns = 7
+rows = 5
+for i in range(1, columns*rows +1):
+    X_few = X_train[y_train == i]
+    fig.add_subplot(rows, columns, i)
+    plt.imshow(X_few[0, :, :, :]) #drawing the first image of each class, 43 classes in total.
+plt.show()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+
+

Step 2: Design and Test a Model Architecture

Design and implement a deep learning model that learns to recognize traffic signs. Train and test your model on the German Traffic Sign Dataset.

+

The LeNet-5 implementation shown in the classroom at the end of the CNN lesson is a solid starting point. You'll have to change the number of classes and possibly the preprocessing, but aside from that it's plug and play!

+

With the LeNet-5 solution from the lecture, you should expect a validation set accuracy of about 0.89. To meet specifications, the validation set accuracy will need to be at least 0.93. It is possible to get an even higher accuracy, but 0.93 is the minimum for a successful project submission.

+

There are various aspects to consider when thinking about this problem:

+
    +
  • Neural network architecture (is the network over or underfitting?)
    • +
  • Play around preprocessing techniques (normalization, rgb to grayscale, etc)
    • +
  • Number of examples per label (some have more than others).
    • +
  • Generate fake data.
    • +
+

Here is an example of a published baseline model on this problem. It's not required to be familiar with the approach used in the paper but, it's good practice to try to read papers like these.

+ +
+
+
+
+
+
+

Pre-process the Data Set (normalization, grayscale, etc.)

+
+
+
+
+
+
+

Minimally, the image data should be normalized so that the data has mean zero and equal variance. For image data, (pixel - 128)/ 128 is a quick way to approximately normalize the data and can be used in this project.

+

Other pre-processing steps are optional. You can try different techniques to see if it improves performance.

+

Use the code cell (or multiple code cells, if necessary) to implement the first step of your project.

+ +
+
+
+
+
+
+

Shuffling the dataset

+
+
+
+
+
+
In [6]:
+
+
+
from sklearn.utils import shuffle
+X_train, y_train = shuffle(X_train, y_train)
+
+ +
+
+
+ +
+
+
+
In [7]:
+
+
+
import tensorflow as tf
+
+EPOCHS = 20
+BATCH_SIZE = 128
+
+ +
+
+
+ +
+
+
+
+

Normalization as one of the preprocessing technique.

+
+
+
+
+
+
In [8]:
+
+
+
def normalization(x_label):
+    return x_label / 255 * 0.8 + 0.1
+
+X_train =  normalization(X_train)
+X_test =  normalization(X_test)
+X_valid = normalization(X_valid)
+
+ +
+
+
+ +
+
+
+
+

Model Architecture

+
+
+
+
+
+
In [9]:
+
+
+
from tensorflow.contrib.layers import flatten
+
+def LeNet(x):    
+    mu = 0
+    sigma = 0.1
+    
+    # Layer 1: Convolutional. Input = 32x32x3. Output = 28x28x6.
+    weights_layer_1 = tf.Variable(tf.truncated_normal(shape=(5,5,3,6), mean = mu, stddev = sigma))
+    bias_layer_1 = tf.Variable(tf.zeros(6))
+    output_layer_1 = tf.nn.conv2d(x, weights_layer_1, strides=[1, 1, 1, 1], padding='VALID')
+    output_layer_1 = tf.nn.bias_add(output_layer_1, bias_layer_1)
+    # Activation.
+    output_layer_1 = tf.nn.relu(output_layer_1)
+    # Pooling. Input = 28x28x6. Output = 14x14x6.
+    output_layer_1 = tf.nn.max_pool(output_layer_1, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'VALID')
+    
+    # Layer 2: Convolutional. Output = 10x10x16.
+    weights_layer_2 = tf.Variable(tf.truncated_normal(shape=(5,5,6,16), mean = mu, stddev = sigma))
+    bias_layer_2 = tf.Variable(tf.zeros(16))
+    output_layer_2 = tf.nn.conv2d(output_layer_1, weights_layer_2, strides=[1, 1, 1, 1], padding='VALID')
+    output_layer_2 = tf.nn.bias_add(output_layer_2, bias_layer_2)
+    # Activation.
+    output_layer_2 = tf.nn.relu(output_layer_2)
+    # Pooling. Input = 10x10x16. Output = 5x5x16.
+    output_layer_2 = tf.nn.max_pool(output_layer_2, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'VALID')
+    # Flatten. Input = 5x5x16. Output =400.
+    output_layer_2 = flatten(output_layer_2)
+    
+    # Layer 3: Fully Connected. Input = 400. Output = 120.
+    weights_fully_3 = tf.Variable(tf.truncated_normal(shape=(400, 120), mean = mu, stddev = sigma))
+    bias_fully_3 = tf.Variable(tf.zeros(120))
+    output_layer_3 =  tf.add(tf.matmul(output_layer_2, weights_fully_3), bias_fully_3)
+    # Activation.
+    output_layer_3 = tf.nn.relu(output_layer_3)
+    
+    # Layer 4: Fully Connected. Input = 120. Output = 84.
+    weights_fully_4 = tf.Variable(tf.truncated_normal(shape=(120, 84), mean = mu, stddev = sigma))
+    bias_fully_4 = tf.Variable(tf.zeros(84))
+    output_layer_4 =  tf.add(tf.matmul(output_layer_3, weights_fully_4), bias_fully_4)
+    # Activation.
+    output_layer_4 = tf.nn.relu(output_layer_4)
+    
+    # Layer 5: Fully Connected. Input = 84. Output = 43.
+    weights_fully_5 = tf.Variable(tf.truncated_normal(shape=(84, 43), mean = mu, stddev = sigma))
+    bias_fully_5 = tf.Variable(tf.zeros(43))
+    logits =  tf.add(tf.matmul(output_layer_4, weights_fully_5), bias_fully_5)
+    
+    return logits
+
+ +
+
+
+ +
+
+
+
In [10]:
+
+
+
x = tf.placeholder(tf.float32, (None, 32, 32, 3))
+y = tf.placeholder(tf.int32, (None))
+one_hot_y = tf.one_hot(y, 43)
+
+ +
+
+
+ +
+
+
+
In [11]:
+
+
+
rate = 0.001
+
+logits = LeNet(x)
+cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=one_hot_y, logits=logits)
+loss_operation = tf.reduce_mean(cross_entropy)
+optimizer = tf.train.AdamOptimizer(learning_rate = rate)
+training_operation = optimizer.minimize(loss_operation)
+
+ +
+
+
+ +
+
+
+
In [12]:
+
+
+
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))
+accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+saver = tf.train.Saver()
+
+def evaluate(X_data, y_data):
+    num_examples = len(X_data)
+    total_accuracy = 0
+    sess = tf.get_default_session()
+    for offset in range(0, num_examples, BATCH_SIZE):
+        batch_x, batch_y = X_data[offset:offset+BATCH_SIZE], y_data[offset:offset+BATCH_SIZE]
+        accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y})
+        total_accuracy += (accuracy * len(batch_x))
+    return total_accuracy / num_examples
+
+ +
+
+
+ +
+
+
+
+

Train, Validate and Test the Model

+
+
+
+
+
+
+

A validation set can be used to assess how well the model is performing. A low accuracy on the training and validation +sets imply underfitting. A high accuracy on the training set but low accuracy on the validation set implies overfitting.

+ +
+
+
+
+
+
In [13]:
+
+
+
with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+    num_examples = len(X_train)
+    
+    print("Training...")
+    print()
+    for i in range(EPOCHS):
+        X_train, y_train = shuffle(X_train, y_train)
+        for offset in range(0, num_examples, BATCH_SIZE):
+            end = offset + BATCH_SIZE
+            batch_x, batch_y = X_train[offset:end], y_train[offset:end]
+            sess.run(training_operation, feed_dict={x: batch_x, y: batch_y})
+            
+        validation_accuracy = evaluate(X_valid, y_valid)
+        print("EPOCH {} ...".format(i+1))
+        print("Validation Accuracy = {:.3f}".format(validation_accuracy))
+        print()
+        
+    saver.save(sess, './lenet')
+    print("Model saved")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Training...
+
+EPOCH 1 ...
+Validation Accuracy = 0.659
+
+EPOCH 2 ...
+Validation Accuracy = 0.828
+
+EPOCH 3 ...
+Validation Accuracy = 0.899
+
+EPOCH 4 ...
+Validation Accuracy = 0.916
+
+EPOCH 5 ...
+Validation Accuracy = 0.922
+
+EPOCH 6 ...
+Validation Accuracy = 0.948
+
+EPOCH 7 ...
+Validation Accuracy = 0.953
+
+EPOCH 8 ...
+Validation Accuracy = 0.936
+
+EPOCH 9 ...
+Validation Accuracy = 0.961
+
+EPOCH 10 ...
+Validation Accuracy = 0.961
+
+EPOCH 11 ...
+Validation Accuracy = 0.969
+
+EPOCH 12 ...
+Validation Accuracy = 0.972
+
+EPOCH 13 ...
+Validation Accuracy = 0.972
+
+EPOCH 14 ...
+Validation Accuracy = 0.978
+
+EPOCH 15 ...
+Validation Accuracy = 0.971
+
+EPOCH 16 ...
+Validation Accuracy = 0.977
+
+EPOCH 17 ...
+Validation Accuracy = 0.976
+
+EPOCH 18 ...
+Validation Accuracy = 0.974
+
+EPOCH 19 ...
+Validation Accuracy = 0.971
+
+EPOCH 20 ...
+Validation Accuracy = 0.975
+
+Model saved
+
+
+
+ +
+
+ +
+
+
+
+
+

Step 3: Test a Model on New Images

To give yourself more insight into how your model is working, download at least five pictures of German traffic signs from the web and use your model to predict the traffic sign type.

+

You may find signnames.csv useful as it contains mappings from the class id (integer) to the actual sign name.

+ +
+
+
+
+
+
+

Load and Output the Images

+
+
+
+
+
+
In [14]:
+
+
+
import glob
+import cv2
+import os
+import matplotlib.image as mpimg 
+%matplotlib inline
+
+resize_images = []
+load_images_name = []
+
+test_images = glob.glob('test-data-german-traffic-signs/test*.jpeg')
+
+for fname in test_images:
+    image = mpimg.imread(fname)
+    resize_image = cv2.resize(image, (32, 32))
+    #gray_image = cv2.cvtColor(resize_image,cv2.COLOR_BGR2GRAY)
+    resize_images.append(resize_image)
+    load_images_name += [fname]
+    plt.figure()
+    plt.imshow(resize_image)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+

Predict the Sign Type for Each Image

+
+
+
+
+
+
In [15]:
+
+
+
with tf.Session() as sess:
+    #sess.run(tf.global_variables_initializer())
+    saver.restore(sess, tf.train.latest_checkpoint('.'))
+    logits_predicted = sess.run(logits, feed_dict={x: resize_images})
+    labels_predicted = np.argmax(logits_predicted, axis=1)
+    for i in range(len(load_images_name)):
+        print("{0} - Prediction: {1}".format(load_images_name[i],labels_predicted[i]))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
INFO:tensorflow:Restoring parameters from ./lenet
+test-data-german-traffic-signs/test_7.jpeg - Prediction: 13
+test-data-german-traffic-signs/test_1.jpeg - Prediction: 14
+test-data-german-traffic-signs/test_4.jpeg - Prediction: 14
+test-data-german-traffic-signs/test_6.jpeg - Prediction: 2
+test-data-german-traffic-signs/test_8.jpeg - Prediction: 25
+test-data-german-traffic-signs/test_5.jpeg - Prediction: 13
+test-data-german-traffic-signs/test_2.jpeg - Prediction: 29
+test-data-german-traffic-signs/test_3.jpeg - Prediction: 17
+
+
+
+ +
+
+ +
+
+
+
+

Analyze Performance

+
+
+
+
+
+
In [16]:
+
+
+
with tf.Session() as sess:
+    saver.restore(sess, tf.train.latest_checkpoint('.'))
+    
+    #Based on above cell output.
+    #y_test = [correct_label_for_test_7, correct_label_for_test_1, and so on .....]
+    y_test = [13,14,14,27,25,38,4,17]
+    load_new_images_accuracy = evaluate(resize_images, y_test)
+    print("Test Accuracy on new loaded images = {:.3f}".format(load_new_images_accuracy))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
INFO:tensorflow:Restoring parameters from ./lenet
+Test Accuracy on new loaded images = 0.625
+
+
+
+ +
+
+ +
+
+
+
+

Output Top 5 Softmax Probabilities For Each Image Found on the Web

+
+
+
+
+
+
+

For each of the new images, print out the model's softmax probabilities to show the certainty of the model's predictions (limit the output to the top 5 probabilities for each image). tf.nn.top_k could prove helpful here.

+

The example below demonstrates how tf.nn.top_k can be used to find the top k predictions for each image.

+

tf.nn.top_k will return the values and indices (class ids) of the top k predictions. So if k=3, for each sign, it'll return the 3 largest probabilities (out of a possible 43) and the correspoding class ids.

+

Take this numpy array as an example. The values in the array represent predictions. The array contains softmax probabilities for five candidate images with six possible classes. tf.nn.top_k is used to choose the three classes with the highest probability:

+ +
# (5, 6) array
+a = np.array([[ 0.24879643,  0.07032244,  0.12641572,  0.34763842,  0.07893497,
+         0.12789202],
+       [ 0.28086119,  0.27569815,  0.08594638,  0.0178669 ,  0.18063401,
+         0.15899337],
+       [ 0.26076848,  0.23664738,  0.08020603,  0.07001922,  0.1134371 ,
+         0.23892179],
+       [ 0.11943333,  0.29198961,  0.02605103,  0.26234032,  0.1351348 ,
+         0.16505091],
+       [ 0.09561176,  0.34396535,  0.0643941 ,  0.16240774,  0.24206137,
+         0.09155967]])
+

Running it through sess.run(tf.nn.top_k(tf.constant(a), k=3)) produces:

+ +
TopKV2(values=array([[ 0.34763842,  0.24879643,  0.12789202],
+       [ 0.28086119,  0.27569815,  0.18063401],
+       [ 0.26076848,  0.23892179,  0.23664738],
+       [ 0.29198961,  0.26234032,  0.16505091],
+       [ 0.34396535,  0.24206137,  0.16240774]]), indices=array([[3, 0, 5],
+       [0, 1, 4],
+       [0, 5, 1],
+       [1, 3, 5],
+       [1, 4, 3]], dtype=int32))
+

Looking just at the first row we get [ 0.34763842, 0.24879643, 0.12789202], you can confirm these are the 3 largest probabilities in a. You'll also notice [3, 0, 5] are the corresponding indices.

+ +
+
+
+
+
+
In [17]:
+
+
+
softmax_result = tf.nn.softmax(logits_predicted)
+
+with tf.Session() as sess:
+    top_five_softmax = sess.run(tf.nn.top_k(softmax_result, k=5))
+    print("Top 5 Softmax Probabilities For Each Image :")
+    print()
+    for x in range(len(load_images_name)):
+        print("{0}:".format(load_images_name[x]))
+        print()
+        for y in range(5):
+            print("{:d}: {:.2f}%".format(top_five_softmax[1][x][y], top_five_softmax[0][x][y]*100))
+        print()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Top 5 Softmax Probabilities For Each Image :
+
+test-data-german-traffic-signs/test_7.jpeg:
+
+13: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+test-data-german-traffic-signs/test_1.jpeg:
+
+14: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+test-data-german-traffic-signs/test_4.jpeg:
+
+14: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+test-data-german-traffic-signs/test_6.jpeg:
+
+2: 100.00%
+0: 0.00%
+1: 0.00%
+3: 0.00%
+4: 0.00%
+
+test-data-german-traffic-signs/test_8.jpeg:
+
+25: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+test-data-german-traffic-signs/test_5.jpeg:
+
+13: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+test-data-german-traffic-signs/test_2.jpeg:
+
+29: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+test-data-german-traffic-signs/test_3.jpeg:
+
+17: 100.00%
+0: 0.00%
+1: 0.00%
+2: 0.00%
+3: 0.00%
+
+
+
+
+ +
+
+ +
+
+
+
+

Project Writeup

Once you have completed the code implementation, document your results in a project writeup using this template as a guide. The writeup can be in a markdown or pdf file.

+ +
+
+
+
+
+
+

Note: Once you have completed all of the code implementations and successfully answered each question above, you may finalize your work by exporting the iPython Notebook as an HTML document. You can do this by using the menu above and navigating to \n", + "File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.

+
+ +
+
+
+
+
+
+
+

Step 4 (Optional): Visualize the Neural Network's State with Test Images

This Section is not required to complete but acts as an additional excersise for understaning the output of a neural network's weights. While neural networks can be a great learning device they are often referred to as a black box. We can understand what the weights of a neural network look like better by plotting their feature maps. After successfully training your neural network you can see what it's feature maps look like by plotting the output of the network's weight layers in response to a test stimuli image. From these plotted feature maps, it's possible to see what characteristics of an image the network finds interesting. For a sign, maybe the inner network feature maps react with high activation to the sign's boundary outline or to the contrast in the sign's painted symbol.

+

Provided for you below is the function code that allows you to get the visualization output of any tensorflow weight layer you want. The inputs to the function should be a stimuli image, one used during training or a new one you provided, and then the tensorflow variable name that represents the layer's state during the training process, for instance if you wanted to see what the LeNet lab's feature maps looked like for it's second convolutional layer you could enter conv2 as the tf_activation variable.

+

For an example of what feature map outputs look like, check out NVIDIA's results in their paper End-to-End Deep Learning for Self-Driving Cars in the section Visualization of internal CNN State. NVIDIA was able to show that their network's inner weights had high activations to road boundary lines by comparing feature maps from an image with a clear path to one without. Try experimenting with a similar test to show that your trained network's weights are looking for interesting features, whether it's looking at differences in feature maps from images with or without a sign, or even what feature maps look like in a trained network vs a completely untrained one on the same sign image.

+

+ Combined Image +
+

+

Your output should look something like this (above)

+
+
+

+ +
+
+
+
+
+
In [ ]:
+
+
+
### Visualize your network's feature maps here.
+### Feel free to use as many code cells as needed.
+
+# image_input: the test image being fed into the network to produce the feature maps
+# tf_activation: should be a tf variable name used during your training procedure that represents the calculated state of a specific weight layer
+# activation_min/max: can be used to view the activation contrast in more detail, by default matplot sets min and max to the actual min and max values of the output
+# plt_num: used to plot out multiple different weight feature map sets on the same block, just extend the plt number for each new feature map entry
+
+def outputFeatureMap(image_input, tf_activation, activation_min=-1, activation_max=-1 ,plt_num=1):
+    # Here make sure to preprocess your image_input in a way your network expects
+    # with size, normalization, ect if needed
+    # image_input =
+    # Note: x should be the same name as your network's tensorflow data placeholder variable
+    # If you get an error tf_activation is not defined it may be having trouble accessing the variable from inside a function
+    activation = tf_activation.eval(session=sess,feed_dict={x : image_input})
+    featuremaps = activation.shape[3]
+    plt.figure(plt_num, figsize=(15,15))
+    for featuremap in range(featuremaps):
+        plt.subplot(6,8, featuremap+1) # sets the number of feature maps to show on each row and column
+        plt.title('FeatureMap ' + str(featuremap)) # displays the feature map number
+        if activation_min != -1 & activation_max != -1:
+            plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", vmin =activation_min, vmax=activation_max, cmap="gray")
+        elif activation_max != -1:
+            plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", vmax=activation_max, cmap="gray")
+        elif activation_min !=-1:
+            plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", vmin=activation_min, cmap="gray")
+        else:
+            plt.imshow(activation[0,:,:, featuremap], interpolation="nearest", cmap="gray")
+
+ +
+
+
+ +
+
+
+ + + + + + diff --git a/Traffic_Sign_Classifier.ipynb b/Traffic_Sign_Classifier.ipynb new file mode 100644 index 0000000..ac6d4e8 --- /dev/null +++ b/Traffic_Sign_Classifier.ipynb @@ -0,0 +1,1017 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Self-Driving Car Engineer Nanodegree\n", + "\n", + "## Deep Learning\n", + "\n", + "## Project: Build a Traffic Sign Recognition Classifier\n", + "\n", + "In this notebook, a template is provided for you to implement your functionality in stages, which is required to successfully complete this project. If additional code is required that cannot be included in the notebook, be sure that the Python code is successfully imported and included in your submission if necessary. \n", + "\n", + "> **Note**: Once you have completed all of the code implementations, you need to finalize your work by exporting the iPython Notebook as an HTML document. Before exporting the notebook to html, all of the code cells need to have been run so that reviewers can see the final implementation and output. You can then export the notebook by using the menu above and navigating to \\n\",\n", + " \"**File -> Download as -> HTML (.html)**. Include the finished document along with this notebook as your submission. \n", + "\n", + "In addition to implementing code, there is a writeup to complete. The writeup should be completed in a separate file, which can be either a markdown file or a pdf document. There is a [write up template](https://github.com/udacity/CarND-Traffic-Sign-Classifier-Project/blob/master/writeup_template.md) that can be used to guide the writing process. Completing the code template and writeup template will cover all of the [rubric points](https://review.udacity.com/#!/rubrics/481/view) for this project.\n", + "\n", + "The [rubric](https://review.udacity.com/#!/rubrics/481/view) contains \"Stand Out Suggestions\" for enhancing the project beyond the minimum requirements. The stand out suggestions are optional. If you decide to pursue the \"stand out suggestions\", you can include the code in this Ipython notebook and also discuss the results in the writeup file.\n", + "\n", + "\n", + ">**Note:** Code and Markdown cells can be executed using the **Shift + Enter** keyboard shortcut. In addition, Markdown cells can be edited by typically double-clicking the cell to enter edit mode." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Step 0: Load The Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Load pickled data\n", + "import pickle\n", + "import random\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "# TODO: Fill this in based on where you saved the training and testing data\n", + "\n", + "training_file = 'traffic-signs-data/train.p'\n", + "validation_file= 'traffic-signs-data/valid.p'\n", + "testing_file = 'traffic-signs-data/test.p'\n", + "\n", + "with open(training_file, mode='rb') as f:\n", + " train = pickle.load(f)\n", + "with open(validation_file, mode='rb') as f:\n", + " valid = pickle.load(f)\n", + "with open(testing_file, mode='rb') as f:\n", + " test = pickle.load(f)\n", + " \n", + "X_train, y_train = train['features'], train['labels']\n", + "X_valid, y_valid = valid['features'], valid['labels']\n", + "X_test, y_test = test['features'], test['labels']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Step 1: Dataset Summary & Exploration\n", + "\n", + "The pickled data is a dictionary with 4 key/value pairs:\n", + "\n", + "- `'features'` is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).\n", + "- `'labels'` is a 1D array containing the label/class id of the traffic sign. The file `signnames.csv` contains id -> name mappings for each id.\n", + "- `'sizes'` is a list containing tuples, (width, height) representing the original width and height the image.\n", + "- `'coords'` is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. **THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGES**\n", + "\n", + "Complete the basic data summary below. Use python, numpy and/or pandas methods to calculate the data summary rather than hard coding the results. For example, the [pandas shape method](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.shape.html) might be useful for calculating some of the summary results. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Provide a Basic Summary of the Data Set Using Python, Numpy and/or Pandas" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of training examples = 34799\n", + "Number of testing examples = 12630\n", + "Image data shape = (32, 32, 3)\n", + "Number of classes = 43\n" + ] + } + ], + "source": [ + "# TODO: Number of training examples\n", + "n_train = len(y_train)\n", + "\n", + "# TODO: Number of validation examples\n", + "n_validation = len(y_valid)\n", + "\n", + "# TODO: Number of testing examples.\n", + "n_test = len(y_test)\n", + "\n", + "# TODO: What's the shape of an traffic sign image?\n", + "image_shape = X_train[0].shape\n", + "\n", + "# TODO: How many unique classes/labels there are in the dataset.\n", + "n_classes = len(np.unique(y_train))\n", + "\n", + "print(\"Number of training examples =\", n_train)\n", + "print(\"Number of testing examples =\", n_test)\n", + "print(\"Image data shape =\", image_shape)\n", + "print(\"Number of classes =\", n_classes)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Updated Image Shape: (32, 32, 3)\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.2, random_state=0)\n", + "print(\"Updated Image Shape: {}\".format(X_train[0].shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Include an exploratory visualization of the dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the German Traffic Signs Dataset using the pickled file(s). This is open ended, suggestions include: plotting traffic sign images, plotting the count of each sign, etc. \n", + "\n", + "The [Matplotlib](http://matplotlib.org/) [examples](http://matplotlib.org/examples/index.html) and [gallery](http://matplotlib.org/gallery.html) pages are a great resource for doing visualizations in Python.\n", + "\n", + "**NOTE:** It's recommended you start with something simple first. If you wish to do more, come back to it after you've completed the rest of the sections. It can be interesting to look at the distribution of classes in the training, validation and test set. Is the distribution the same? Are there more examples of some classes than others?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementing simple visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "index = random.randint(0, len(X_train))\n", + "image = X_train[index].squeeze()\n", + "\n", + "plt.figure(figsize=(1,1))\n", + "plt.imshow(image)\n", + "print(y_train[index])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementing complex visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig=plt.figure(figsize=(20, 20))\n", + "columns = 7\n", + "rows = 5\n", + "for i in range(1, columns*rows +1):\n", + " X_few = X_train[y_train == i]\n", + " fig.add_subplot(rows, columns, i)\n", + " plt.imshow(X_few[0, :, :, :]) #drawing the first image of each class, 43 classes in total.\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "----\n", + "\n", + "## Step 2: Design and Test a Model Architecture\n", + "\n", + "Design and implement a deep learning model that learns to recognize traffic signs. Train and test your model on the [German Traffic Sign Dataset](http://benchmark.ini.rub.de/?section=gtsrb&subsection=dataset).\n", + "\n", + "The LeNet-5 implementation shown in the [classroom](https://classroom.udacity.com/nanodegrees/nd013/parts/fbf77062-5703-404e-b60c-95b78b2f3f9e/modules/6df7ae49-c61c-4bb2-a23e-6527e69209ec/lessons/601ae704-1035-4287-8b11-e2c2716217ad/concepts/d4aca031-508f-4e0b-b493-e7b706120f81) at the end of the CNN lesson is a solid starting point. You'll have to change the number of classes and possibly the preprocessing, but aside from that it's plug and play! \n", + "\n", + "With the LeNet-5 solution from the lecture, you should expect a validation set accuracy of about 0.89. To meet specifications, the validation set accuracy will need to be at least 0.93. It is possible to get an even higher accuracy, but 0.93 is the minimum for a successful project submission. \n", + "\n", + "There are various aspects to consider when thinking about this problem:\n", + "\n", + "- Neural network architecture (is the network over or underfitting?)\n", + "- Play around preprocessing techniques (normalization, rgb to grayscale, etc)\n", + "- Number of examples per label (some have more than others).\n", + "- Generate fake data.\n", + "\n", + "Here is an example of a [published baseline model on this problem](http://yann.lecun.com/exdb/publis/pdf/sermanet-ijcnn-11.pdf). It's not required to be familiar with the approach used in the paper but, it's good practice to try to read papers like these." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pre-process the Data Set (normalization, grayscale, etc.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Minimally, the image data should be normalized so that the data has mean zero and equal variance. For image data, `(pixel - 128)/ 128` is a quick way to approximately normalize the data and can be used in this project. \n", + "\n", + "Other pre-processing steps are optional. You can try different techniques to see if it improves performance. \n", + "\n", + "Use the code cell (or multiple code cells, if necessary) to implement the first step of your project." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Shuffling the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.utils import shuffle\n", + "X_train, y_train = shuffle(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "\n", + "EPOCHS = 20\n", + "BATCH_SIZE = 128" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Normalization as one of the preprocessing technique." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def normalization(x_label):\n", + " return x_label / 255 * 0.8 + 0.1\n", + "\n", + "X_train = normalization(X_train)\n", + "X_test = normalization(X_test)\n", + "X_valid = normalization(X_valid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model Architecture" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.contrib.layers import flatten\n", + "\n", + "def LeNet(x): \n", + " mu = 0\n", + " sigma = 0.1\n", + " \n", + " # Layer 1: Convolutional. Input = 32x32x3. Output = 28x28x6.\n", + " weights_layer_1 = tf.Variable(tf.truncated_normal(shape=(5,5,3,6), mean = mu, stddev = sigma))\n", + " bias_layer_1 = tf.Variable(tf.zeros(6))\n", + " output_layer_1 = tf.nn.conv2d(x, weights_layer_1, strides=[1, 1, 1, 1], padding='VALID')\n", + " output_layer_1 = tf.nn.bias_add(output_layer_1, bias_layer_1)\n", + " # Activation.\n", + " output_layer_1 = tf.nn.relu(output_layer_1)\n", + " # Pooling. Input = 28x28x6. Output = 14x14x6.\n", + " output_layer_1 = tf.nn.max_pool(output_layer_1, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'VALID')\n", + " \n", + " # Layer 2: Convolutional. Output = 10x10x16.\n", + " weights_layer_2 = tf.Variable(tf.truncated_normal(shape=(5,5,6,16), mean = mu, stddev = sigma))\n", + " bias_layer_2 = tf.Variable(tf.zeros(16))\n", + " output_layer_2 = tf.nn.conv2d(output_layer_1, weights_layer_2, strides=[1, 1, 1, 1], padding='VALID')\n", + " output_layer_2 = tf.nn.bias_add(output_layer_2, bias_layer_2)\n", + " # Activation.\n", + " output_layer_2 = tf.nn.relu(output_layer_2)\n", + " # Pooling. Input = 10x10x16. Output = 5x5x16.\n", + " output_layer_2 = tf.nn.max_pool(output_layer_2, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'VALID')\n", + " # Flatten. Input = 5x5x16. Output =400.\n", + " output_layer_2 = flatten(output_layer_2)\n", + " \n", + " # Layer 3: Fully Connected. Input = 400. Output = 120.\n", + " weights_fully_3 = tf.Variable(tf.truncated_normal(shape=(400, 120), mean = mu, stddev = sigma))\n", + " bias_fully_3 = tf.Variable(tf.zeros(120))\n", + " output_layer_3 = tf.add(tf.matmul(output_layer_2, weights_fully_3), bias_fully_3)\n", + " # Activation.\n", + " output_layer_3 = tf.nn.relu(output_layer_3)\n", + " \n", + " # Layer 4: Fully Connected. Input = 120. Output = 84.\n", + " weights_fully_4 = tf.Variable(tf.truncated_normal(shape=(120, 84), mean = mu, stddev = sigma))\n", + " bias_fully_4 = tf.Variable(tf.zeros(84))\n", + " output_layer_4 = tf.add(tf.matmul(output_layer_3, weights_fully_4), bias_fully_4)\n", + " # Activation.\n", + " output_layer_4 = tf.nn.relu(output_layer_4)\n", + " \n", + " # Layer 5: Fully Connected. Input = 84. Output = 43.\n", + " weights_fully_5 = tf.Variable(tf.truncated_normal(shape=(84, 43), mean = mu, stddev = sigma))\n", + " bias_fully_5 = tf.Variable(tf.zeros(43))\n", + " logits = tf.add(tf.matmul(output_layer_4, weights_fully_5), bias_fully_5)\n", + " \n", + " return logits" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "x = tf.placeholder(tf.float32, (None, 32, 32, 3))\n", + "y = tf.placeholder(tf.int32, (None))\n", + "one_hot_y = tf.one_hot(y, 43)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "rate = 0.001\n", + "\n", + "logits = LeNet(x)\n", + "cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=one_hot_y, logits=logits)\n", + "loss_operation = tf.reduce_mean(cross_entropy)\n", + "optimizer = tf.train.AdamOptimizer(learning_rate = rate)\n", + "training_operation = optimizer.minimize(loss_operation)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))\n", + "accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n", + "saver = tf.train.Saver()\n", + "\n", + "def evaluate(X_data, y_data):\n", + " num_examples = len(X_data)\n", + " total_accuracy = 0\n", + " sess = tf.get_default_session()\n", + " for offset in range(0, num_examples, BATCH_SIZE):\n", + " batch_x, batch_y = X_data[offset:offset+BATCH_SIZE], y_data[offset:offset+BATCH_SIZE]\n", + " accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y})\n", + " total_accuracy += (accuracy * len(batch_x))\n", + " return total_accuracy / num_examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train, Validate and Test the Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A validation set can be used to assess how well the model is performing. A low accuracy on the training and validation\n", + "sets imply underfitting. A high accuracy on the training set but low accuracy on the validation set implies overfitting." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training...\n", + "\n", + "EPOCH 1 ...\n", + "Validation Accuracy = 0.659\n", + "\n", + "EPOCH 2 ...\n", + "Validation Accuracy = 0.828\n", + "\n", + "EPOCH 3 ...\n", + "Validation Accuracy = 0.899\n", + "\n", + "EPOCH 4 ...\n", + "Validation Accuracy = 0.916\n", + "\n", + "EPOCH 5 ...\n", + "Validation Accuracy = 0.922\n", + "\n", + "EPOCH 6 ...\n", + "Validation Accuracy = 0.948\n", + "\n", + "EPOCH 7 ...\n", + "Validation Accuracy = 0.953\n", + "\n", + "EPOCH 8 ...\n", + "Validation Accuracy = 0.936\n", + "\n", + "EPOCH 9 ...\n", + "Validation Accuracy = 0.961\n", + "\n", + "EPOCH 10 ...\n", + "Validation Accuracy = 0.961\n", + "\n", + "EPOCH 11 ...\n", + "Validation Accuracy = 0.969\n", + "\n", + "EPOCH 12 ...\n", + "Validation Accuracy = 0.972\n", + "\n", + "EPOCH 13 ...\n", + "Validation Accuracy = 0.972\n", + "\n", + "EPOCH 14 ...\n", + "Validation Accuracy = 0.978\n", + "\n", + "EPOCH 15 ...\n", + "Validation Accuracy = 0.971\n", + "\n", + "EPOCH 16 ...\n", + "Validation Accuracy = 0.977\n", + "\n", + "EPOCH 17 ...\n", + "Validation Accuracy = 0.976\n", + "\n", + "EPOCH 18 ...\n", + "Validation Accuracy = 0.974\n", + "\n", + "EPOCH 19 ...\n", + "Validation Accuracy = 0.971\n", + "\n", + "EPOCH 20 ...\n", + "Validation Accuracy = 0.975\n", + "\n", + "Model saved\n" + ] + } + ], + "source": [ + "with tf.Session() as sess:\n", + " sess.run(tf.global_variables_initializer())\n", + " num_examples = len(X_train)\n", + " \n", + " print(\"Training...\")\n", + " print()\n", + " for i in range(EPOCHS):\n", + " X_train, y_train = shuffle(X_train, y_train)\n", + " for offset in range(0, num_examples, BATCH_SIZE):\n", + " end = offset + BATCH_SIZE\n", + " batch_x, batch_y = X_train[offset:end], y_train[offset:end]\n", + " sess.run(training_operation, feed_dict={x: batch_x, y: batch_y})\n", + " \n", + " validation_accuracy = evaluate(X_valid, y_valid)\n", + " print(\"EPOCH {} ...\".format(i+1))\n", + " print(\"Validation Accuracy = {:.3f}\".format(validation_accuracy))\n", + " print()\n", + " \n", + " saver.save(sess, './lenet')\n", + " print(\"Model saved\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Step 3: Test a Model on New Images\n", + "\n", + "To give yourself more insight into how your model is working, download at least five pictures of German traffic signs from the web and use your model to predict the traffic sign type.\n", + "\n", + "You may find `signnames.csv` useful as it contains mappings from the class id (integer) to the actual sign name." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load and Output the Images" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import glob\n", + "import cv2\n", + "import os\n", + "import matplotlib.image as mpimg \n", + "%matplotlib inline\n", + "\n", + "resize_images = []\n", + "load_images_name = []\n", + "\n", + "test_images = glob.glob('test-data-german-traffic-signs/test*.jpeg')\n", + "\n", + "for fname in test_images:\n", + " image = mpimg.imread(fname)\n", + " resize_image = cv2.resize(image, (32, 32))\n", + " #gray_image = cv2.cvtColor(resize_image,cv2.COLOR_BGR2GRAY)\n", + " resize_images.append(resize_image)\n", + " load_images_name += [fname]\n", + " plt.figure()\n", + " plt.imshow(resize_image)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Predict the Sign Type for Each Image" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from ./lenet\n", + "test-data-german-traffic-signs/test_7.jpeg - Prediction: 13\n", + "test-data-german-traffic-signs/test_1.jpeg - Prediction: 14\n", + "test-data-german-traffic-signs/test_4.jpeg - Prediction: 14\n", + "test-data-german-traffic-signs/test_6.jpeg - Prediction: 2\n", + "test-data-german-traffic-signs/test_8.jpeg - Prediction: 25\n", + "test-data-german-traffic-signs/test_5.jpeg - Prediction: 13\n", + "test-data-german-traffic-signs/test_2.jpeg - Prediction: 29\n", + "test-data-german-traffic-signs/test_3.jpeg - Prediction: 17\n" + ] + } + ], + "source": [ + "with tf.Session() as sess:\n", + " #sess.run(tf.global_variables_initializer())\n", + " saver.restore(sess, tf.train.latest_checkpoint('.'))\n", + " logits_predicted = sess.run(logits, feed_dict={x: resize_images})\n", + " labels_predicted = np.argmax(logits_predicted, axis=1)\n", + " for i in range(len(load_images_name)):\n", + " print(\"{0} - Prediction: {1}\".format(load_images_name[i],labels_predicted[i]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Analyze Performance" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Restoring parameters from ./lenet\n", + "Test Accuracy on new loaded images = 0.625\n" + ] + } + ], + "source": [ + "with tf.Session() as sess:\n", + " saver.restore(sess, tf.train.latest_checkpoint('.'))\n", + " \n", + " #Based on above cell output.\n", + " #y_test = [correct_label_for_test_7, correct_label_for_test_1, and so on .....]\n", + " y_test = [13,14,14,27,25,38,4,17]\n", + " load_new_images_accuracy = evaluate(resize_images, y_test)\n", + " print(\"Test Accuracy on new loaded images = {:.3f}\".format(load_new_images_accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Output Top 5 Softmax Probabilities For Each Image Found on the Web" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For each of the new images, print out the model's softmax probabilities to show the **certainty** of the model's predictions (limit the output to the top 5 probabilities for each image). [`tf.nn.top_k`](https://www.tensorflow.org/versions/r0.12/api_docs/python/nn.html#top_k) could prove helpful here. \n", + "\n", + "The example below demonstrates how tf.nn.top_k can be used to find the top k predictions for each image.\n", + "\n", + "`tf.nn.top_k` will return the values and indices (class ids) of the top k predictions. So if k=3, for each sign, it'll return the 3 largest probabilities (out of a possible 43) and the correspoding class ids.\n", + "\n", + "Take this numpy array as an example. The values in the array represent predictions. The array contains softmax probabilities for five candidate images with six possible classes. `tf.nn.top_k` is used to choose the three classes with the highest probability:\n", + "\n", + "```\n", + "# (5, 6) array\n", + "a = np.array([[ 0.24879643, 0.07032244, 0.12641572, 0.34763842, 0.07893497,\n", + " 0.12789202],\n", + " [ 0.28086119, 0.27569815, 0.08594638, 0.0178669 , 0.18063401,\n", + " 0.15899337],\n", + " [ 0.26076848, 0.23664738, 0.08020603, 0.07001922, 0.1134371 ,\n", + " 0.23892179],\n", + " [ 0.11943333, 0.29198961, 0.02605103, 0.26234032, 0.1351348 ,\n", + " 0.16505091],\n", + " [ 0.09561176, 0.34396535, 0.0643941 , 0.16240774, 0.24206137,\n", + " 0.09155967]])\n", + "```\n", + "\n", + "Running it through `sess.run(tf.nn.top_k(tf.constant(a), k=3))` produces:\n", + "\n", + "```\n", + "TopKV2(values=array([[ 0.34763842, 0.24879643, 0.12789202],\n", + " [ 0.28086119, 0.27569815, 0.18063401],\n", + " [ 0.26076848, 0.23892179, 0.23664738],\n", + " [ 0.29198961, 0.26234032, 0.16505091],\n", + " [ 0.34396535, 0.24206137, 0.16240774]]), indices=array([[3, 0, 5],\n", + " [0, 1, 4],\n", + " [0, 5, 1],\n", + " [1, 3, 5],\n", + " [1, 4, 3]], dtype=int32))\n", + "```\n", + "\n", + "Looking just at the first row we get `[ 0.34763842, 0.24879643, 0.12789202]`, you can confirm these are the 3 largest probabilities in `a`. You'll also notice `[3, 0, 5]` are the corresponding indices." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top 5 Softmax Probabilities For Each Image :\n", + "\n", + "test-data-german-traffic-signs/test_7.jpeg:\n", + "\n", + "13: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_1.jpeg:\n", + "\n", + "14: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_4.jpeg:\n", + "\n", + "14: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_6.jpeg:\n", + "\n", + "2: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "3: 0.00%\n", + "4: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_8.jpeg:\n", + "\n", + "25: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_5.jpeg:\n", + "\n", + "13: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_2.jpeg:\n", + "\n", + "29: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n", + "test-data-german-traffic-signs/test_3.jpeg:\n", + "\n", + "17: 100.00%\n", + "0: 0.00%\n", + "1: 0.00%\n", + "2: 0.00%\n", + "3: 0.00%\n", + "\n" + ] + } + ], + "source": [ + "softmax_result = tf.nn.softmax(logits_predicted)\n", + "\n", + "with tf.Session() as sess:\n", + " top_five_softmax = sess.run(tf.nn.top_k(softmax_result, k=5))\n", + " print(\"Top 5 Softmax Probabilities For Each Image :\")\n", + " print()\n", + " for x in range(len(load_images_name)):\n", + " print(\"{0}:\".format(load_images_name[x]))\n", + " print()\n", + " for y in range(5):\n", + " print(\"{:d}: {:.2f}%\".format(top_five_softmax[1][x][y], top_five_softmax[0][x][y]*100))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Project Writeup\n", + "\n", + "Once you have completed the code implementation, document your results in a project writeup using this [template](https://github.com/udacity/CarND-Traffic-Sign-Classifier-Project/blob/master/writeup_template.md) as a guide. The writeup can be in a markdown or pdf file. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Note**: Once you have completed all of the code implementations and successfully answered each question above, you may finalize your work by exporting the iPython Notebook as an HTML document. You can do this by using the menu above and navigating to \\n\",\n", + " \"**File -> Download as -> HTML (.html)**. Include the finished document along with this notebook as your submission." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Step 4 (Optional): Visualize the Neural Network's State with Test Images\n", + "\n", + " This Section is not required to complete but acts as an additional excersise for understaning the output of a neural network's weights. While neural networks can be a great learning device they are often referred to as a black box. We can understand what the weights of a neural network look like better by plotting their feature maps. After successfully training your neural network you can see what it's feature maps look like by plotting the output of the network's weight layers in response to a test stimuli image. From these plotted feature maps, it's possible to see what characteristics of an image the network finds interesting. For a sign, maybe the inner network feature maps react with high activation to the sign's boundary outline or to the contrast in the sign's painted symbol.\n", + "\n", + " Provided for you below is the function code that allows you to get the visualization output of any tensorflow weight layer you want. The inputs to the function should be a stimuli image, one used during training or a new one you provided, and then the tensorflow variable name that represents the layer's state during the training process, for instance if you wanted to see what the [LeNet lab's](https://classroom.udacity.com/nanodegrees/nd013/parts/fbf77062-5703-404e-b60c-95b78b2f3f9e/modules/6df7ae49-c61c-4bb2-a23e-6527e69209ec/lessons/601ae704-1035-4287-8b11-e2c2716217ad/concepts/d4aca031-508f-4e0b-b493-e7b706120f81) feature maps looked like for it's second convolutional layer you could enter conv2 as the tf_activation variable.\n", + "\n", + "For an example of what feature map outputs look like, check out NVIDIA's results in their paper [End-to-End Deep Learning for Self-Driving Cars](https://devblogs.nvidia.com/parallelforall/deep-learning-self-driving-cars/) in the section Visualization of internal CNN State. NVIDIA was able to show that their network's inner weights had high activations to road boundary lines by comparing feature maps from an image with a clear path to one without. Try experimenting with a similar test to show that your trained network's weights are looking for interesting features, whether it's looking at differences in feature maps from images with or without a sign, or even what feature maps look like in a trained network vs a completely untrained one on the same sign image.\n", + "\n", + "
\n", + " \"Combined\n", + "
\n", + "

\n", + "

Your output should look something like this (above)

\n", + "
\n", + "
\n", + "

\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Visualize your network's feature maps here.\n", + "### Feel free to use as many code cells as needed.\n", + "\n", + "# image_input: the test image being fed into the network to produce the feature maps\n", + "# tf_activation: should be a tf variable name used during your training procedure that represents the calculated state of a specific weight layer\n", + "# activation_min/max: can be used to view the activation contrast in more detail, by default matplot sets min and max to the actual min and max values of the output\n", + "# plt_num: used to plot out multiple different weight feature map sets on the same block, just extend the plt number for each new feature map entry\n", + "\n", + "def outputFeatureMap(image_input, tf_activation, activation_min=-1, activation_max=-1 ,plt_num=1):\n", + " # Here make sure to preprocess your image_input in a way your network expects\n", + " # with size, normalization, ect if needed\n", + " # image_input =\n", + " # Note: x should be the same name as your network's tensorflow data placeholder variable\n", + " # If you get an error tf_activation is not defined it may be having trouble accessing the variable from inside a function\n", + " activation = tf_activation.eval(session=sess,feed_dict={x : image_input})\n", + " featuremaps = activation.shape[3]\n", + " plt.figure(plt_num, figsize=(15,15))\n", + " for featuremap in range(featuremaps):\n", + " plt.subplot(6,8, featuremap+1) # sets the number of feature maps to show on each row and column\n", + " plt.title('FeatureMap ' + str(featuremap)) # displays the feature map number\n", + " if activation_min != -1 & activation_max != -1:\n", + " plt.imshow(activation[0,:,:, featuremap], interpolation=\"nearest\", vmin =activation_min, vmax=activation_max, cmap=\"gray\")\n", + " elif activation_max != -1:\n", + " plt.imshow(activation[0,:,:, featuremap], interpolation=\"nearest\", vmax=activation_max, cmap=\"gray\")\n", + " elif activation_min !=-1:\n", + " plt.imshow(activation[0,:,:, featuremap], interpolation=\"nearest\", vmin=activation_min, cmap=\"gray\")\n", + " else:\n", + " plt.imshow(activation[0,:,:, featuremap], interpolation=\"nearest\", cmap=\"gray\")" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}