+

Your first neural network¶

In this project, you'll build your first neural network and use it to predict daily bike rental ridership. We've provided some of the code, but left the implementation of the neural network up to you (for the most part). After you've submitted this project, feel free to explore the data and the model more.

+ +

%matplotlib inline
+%config InlineBackend.figure_format = 'retina'
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+

+

Load and prepare the data¶

A critical step in working with neural networks is preparing the data correctly. Variables on different scales make it difficult for the network to efficiently learn the correct weights. Below, we've written the code to load and prepare the data. You'll learn more about this soon!

+ +

data_path = 'Bike-Sharing-Dataset/hour.csv'
+
+rides = pd.read_csv(data_path)
+

rides.head()
+

+

Checking out the data¶

This dataset has the number of riders for each hour of each day from January 1 2011 to December 31 2012. The number of riders is split between casual and registered, summed up in the cnt column. You can see the first few rows of the data above.

+

Below is a plot showing the number of bike riders over the first 10 days in the data set. You can see the hourly rentals here. This data is pretty complicated! The weekends have lower over all ridership and there are spikes when people are biking to and from work during the week. Looking at the data above, we also have information about temperature, humidity, and windspeed, all of these likely affecting the number of riders. You'll be trying to capture all this with your model.

+ +

rides[:24*10].plot(x='dteday', y='cnt')
+

<matplotlib.axes._subplots.AxesSubplot at 0x7fa490564c18>

+

Dummy variables¶

Here we have some categorical variables like season, weather, month. To include these in our model, we'll need to make binary dummy variables. This is simple to do with Pandas thanks to get_dummies().

+ +

dummy_fields = ['season', 'weathersit', 'mnth', 'hr', 'weekday']
+for each in dummy_fields:
+    dummies = pd.get_dummies(rides[each], prefix=each, drop_first=False)
+    rides = pd.concat([rides, dummies], axis=1)
+
+fields_to_drop = ['instant', 'dteday', 'season', 'weathersit', 
+                  'weekday', 'atemp', 'mnth', 'workingday', 'hr']
+data = rides.drop(fields_to_drop, axis=1)
+data.head()
+

+

Scaling target variables¶

To make training the network easier, we'll standardize each of the continuous variables. That is, we'll shift and scale the variables such that they have zero mean and a standard deviation of 1.

+

The scaling factors are saved so we can go backwards when we use the network for predictions.

+ +

quant_features = ['casual', 'registered', 'cnt', 'temp', 'hum', 'windspeed']
+# Store scalings in a dictionary so we can convert back later
+scaled_features = {}
+for each in quant_features:
+    mean, std = data[each].mean(), data[each].std()
+    scaled_features[each] = [mean, std]
+    data.loc[:, each] = (data[each] - mean)/std
+

+

Splitting the data into training, testing, and validation sets¶

We'll save the last 21 days of the data to use as a test set after we've trained the network. We'll use this set to make predictions and compare them with the actual number of riders.

+ +

# Save the last 21 days 
+test_data = data[-21*24:]
+data = data[:-21*24]
+
+# Separate the data into features and targets
+target_fields = ['cnt', 'casual', 'registered']
+features, targets = data.drop(target_fields, axis=1), data[target_fields]
+test_features, test_targets = test_data.drop(target_fields, axis=1), test_data[target_fields]
+

+

We'll split the data into two sets, one for training and one for validating as the network is being trained. Since this is time series data, we'll train on historical data, then try to predict on future data (the validation set).

+ +

# Hold out the last 60 days of the remaining data as a validation set
+train_features, train_targets = features[:-60*24], targets[:-60*24]
+val_features, val_targets = features[-60*24:], targets[-60*24:]
+

+

Time to build the network¶

Below you'll build your network. We've built out the structure and the backwards pass. You'll implement the forward pass through the network. You'll also set the hyperparameters: the learning rate, the number of hidden units, and the number of training passes.

+

The network has two layers, a hidden layer and an output layer. The hidden layer will use the sigmoid function for activations. The output layer has only one node and is used for the regression, the output of the node is the same as the input of the node. That is, the activation function is $f(x)=x$. A function that takes the input signal and generates an output signal, but takes into account the threshold, is called an activation function. We work through each layer of our network calculating the outputs for each neuron. All of the outputs from one layer become inputs to the neurons on the next layer. This process is called forward propagation.

+

We use the weights to propagate signals forward from the input to the output layers in a neural network. We use the weights to also propagate error backwards from the output back into the network to update our weights. This is called backpropagation.

+

Hint: You'll need the derivative of the output activation function ($f(x) = x$) for the backpropagation implementation. If you aren't familiar with calculus, this function is equivalent to the equation $y = x$. What is the slope of that equation? That is the derivative of $f(x)$.
+

+

Below, you have these tasks:

+

Implement the sigmoid function to use as the activation function. Set self.activation_function in __init__ to your sigmoid function.
Implement the forward pass in the train method.
Implement the backpropagation algorithm in the train method, including calculating the output error.
Implement the forward pass in the run method.

+ +

+

Shape of weight matrices¶

+

Node j1 -> | w1|w2|w3|....wn
+---------------|--|-------
+Node j2 -> | w1|w2|w3|....wn
+---------------|--|-------
+Node j3 -> | w1|w2|w3|....wn
+.            ...
+.            ...
+Node jm      ...

+ +

class NeuralNetwork(object):
+    def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
+        # Set number of nodes in input, hidden and output layers.
+        self.input_nodes = input_nodes
+        self.hidden_nodes = hidden_nodes
+        self.output_nodes = output_nodes
+        
+        #print("DEBUG: hidden units ",self.hidden_nodes)
+        
+
+        # Initialize weights
+        self.weights_input_to_hidden = np.random.normal(0.0, self.hidden_nodes**-0.5, 
+                                       (self.hidden_nodes, self.input_nodes)) # shape hidden_n x n_features
+
+        self.weights_hidden_to_output = np.random.normal(0.0, self.output_nodes**-0.5, 
+                                       (self.output_nodes, self.hidden_nodes)) # shape 1 x hidden_n
+        self.lr = learning_rate
+        
+        #### Set this to your implemented sigmoid function ####
+        # Activation function is the sigmoid function
+        self.activation_function = self._sigmoid
+        self.hidden_gradient_function = self._gradient_sigmoid
+        self.output_activation = lambda x: x
+    
+    def _sigmoid(self, x):
+        return 1 / (1 + np.exp(-x))
+    
+    def _gradient_sigmoid(self, output):
+        return output * (1-output)
+    
+    
+    def train(self, inputs_list, targets_list):
+        # Convert inputs list to 2d array
+        inputs = np.array(inputs_list, ndmin=2).T
+        targets = np.array(targets_list, ndmin=2).T
+        
+        #### Implement the forward pass here ####
+        ### Forward pass ###
+        # TODO: Hidden layer
+        
+        # signal into hidden layer
+        hidden_inputs = np.dot(self.weights_input_to_hidden, inputs) # shape: hidden_n x n . nx1 -> hidden_n x 1
+        # signals from hidden layer
+        hidden_outputs = self.activation_function(hidden_inputs) # shape: hidden_n x 1
+        
+        # TODO: Output layer
+        
+        # signals into final output layer
+        final_inputs = np.dot(self.weights_hidden_to_output, hidden_outputs) # 1 x hidden_n . hidden_n x 1 -> 1x1
+        # signals from final output layer - same, h(f(x)) = f(x)
+        final_outputs = self.output_activation(final_inputs)  # shape 1x1
+        
+        #### Implement the backward pass here ####
+        ### Backward pass ###
+        
+        # TODO: Output error
+        
+        # Output layer error is the difference between desired target and actual output.
+        output_errors = targets - final_outputs
+        
+        # since the gradient of f(x) = x is 1, the error and output error are the same 
+        
+        # TODO: Backpropagated error
+        
+        # errors propagated to the hidden layer
+        # shape: 1xhidden_n . 1x1
+        hidden_errors = np.multiply(self.weights_hidden_to_output, output_errors) # shape 1 x hidden_n
+        
+        # hidden layer gradients
+        # Calculate using sigmoid gradient of the hidden output
+        #shape hidden_nx1  
+        hidden_grad = self.hidden_gradient_function(hidden_outputs)
+        
+        # TODO: Update the weights
+        
+        # update hidden-to-output weights with gradient descent step 
+        self.weights_hidden_to_output += np.dot(self.lr, output_errors).dot(hidden_outputs.T) #shape hidden_nx1
+
+        
+        # update input-to-hidden weights with gradient descent step
+        # shape hidden_n x input_n += (hidden_nx1 * hidden_nx1) . (1x1 . inputs_nx1.T) 
+        self.weights_input_to_hidden += np.multiply(hidden_grad, hidden_errors.T).dot(self.lr).dot(inputs.T) 
+        
+    def run(self, inputs_list):
+        # Run a forward pass through the network
+        inputs = np.array(inputs_list, ndmin=2).T
+        
+        #### Implement the forward pass here ####
+        # TODO: Hidden layer
+        hidden_inputs = np.dot(self.weights_input_to_hidden, inputs)# signals into hidden layer
+        hidden_outputs = self.activation_function(hidden_inputs)# signals from hidden layer
+        
+        # TODO: Output layer
+        final_inputs = np.dot(self.weights_hidden_to_output, hidden_outputs)# signals into final output layer
+        final_outputs = self.output_activation(final_inputs)# signals from final output layer
+        return final_outputs
+

def MSE(y, Y):
+    return np.mean((y-Y)**2)
+

+

Training the network¶

Here you'll set the hyperparameters for the network. The strategy here is to find hyperparameters such that the error on the training set is low, but you're not overfitting to the data. If you train the network too long or have too many hidden nodes, it can become overly specific to the training set and will fail to generalize to the validation set. That is, the loss on the validation set will start increasing as the training set loss drops.

+

You'll also be using a method know as Stochastic Gradient Descent (SGD) to train the network. The idea is that for each training pass, you grab a random sample of the data instead of using the whole data set. You use many more training passes than with normal gradient descent, but each pass is much faster. This ends up training the network more efficiently. You'll learn more about SGD later.

+

Choose the number of epochs¶

This is the number of times the dataset will pass through the network, each time updating the weights. As the number of epochs increases, the network becomes better and better at predicting the targets in the training set. You'll need to choose enough epochs to train the network well but not too many or you'll be overfitting.

+

Choose the learning rate¶

This scales the size of weight updates. If this is too big, the weights tend to explode and the network fails to fit the data. A good choice to start at is 0.1. If the network has problems fitting the data, try reducing the learning rate. Note that the lower the learning rate, the smaller the steps are in the weight updates and the longer it takes for the neural network to converge.

+

Choose the number of hidden nodes¶

The more hidden nodes you have, the more accurate predictions the model will make. Try a few different numbers and see how it affects the performance. You can look at the losses dictionary for a metric of the network performance. If the number of hidden units is too low, then the model won't have enough space to learn and if it is too high there are too many options for the direction that the learning can take. The trick here is to find the right balance in number of hidden units you choose.

+ +

import sys
+
+### Set the hyperparameters here ###
+epochs = 1000
+#learning_rate = 0.03
+learning_rate = 0.07
+N_i = train_features.shape[1]
+hidden_nodes = int(N_i / 1.2)
+output_nodes = 1
+
+
+network = NeuralNetwork(N_i, hidden_nodes, output_nodes, learning_rate)
+
+losses = {'train':[], 'validation':[]}
+for e in range(epochs):
+    # Go through a random batch of 128 records from the training data set
+    batch = np.random.choice(train_features.index, size=128)
+    for record, target in zip(train_features.ix[batch].values, 
+                              train_targets.ix[batch]['cnt']):
+        network.train(record, target)
+    
+    # Printing out the training progress
+    train_loss = MSE(network.run(train_features), train_targets['cnt'].values)
+    val_loss = MSE(network.run(val_features), val_targets['cnt'].values)
+    sys.stdout.write("\rProgress: " + str(100 * e/float(epochs))[:4] \
+                     + "% ... Training loss: " + str(train_loss)[:5] \
+                     + " ... Validation loss: " + str(val_loss)[:5])
+    
+    losses['train'].append(train_loss)
+    losses['validation'].append(val_loss)
+

Progress: 99.9% ... Training loss: 0.067 ... Validation loss: 0.162

plt.plot(losses['train'], label='Training loss')
+plt.plot(losses['validation'], label='Validation loss')
+plt.legend()
+plt.ylim(ymax=0.8)
+

(0.0, 0.8)

+

Check out your predictions¶

Here, use the test data to view how well your network is modeling the data. If something is completely wrong here, make sure each step in your network is implemented correctly.

+ +

fig, ax = plt.subplots(figsize=(8,4))
+
+mean, std = scaled_features['cnt']
+predictions = network.run(test_features)*std + mean
+ax.plot(predictions[0], label='Prediction')
+ax.plot((test_targets['cnt']*std + mean).values, label='Data')
+ax.set_xlim(right=len(predictions))
+ax.legend()
+
+dates = pd.to_datetime(rides.ix[test_data.index]['dteday'])
+dates = dates.apply(lambda d: d.strftime('%b %d'))
+ax.set_xticks(np.arange(len(dates))[12::24])
+_ = ax.set_xticklabels(dates[12::24], rotation=45)
+

+

Thinking about your results¶

Answer these questions about your results. How well does the model predict the data? Where does it fail? Why does it fail where it does?

+

Note: You can edit the text in this cell by double clicking on it. When you want to render the text, press control + enter
+

+

Your answer below¶

The model predicts the data good enough.
+
The model fails for the period of christmas holidays.
+
Reason: We can expect users to change behavior around christmas time (family visit, holidays ..). We also have much less data for christmas holidays which occures only once a year then the rest of the year. So the model is over fitted for normal days vs christmas holidays. We would need data over several years to fit the model for these seasonal changes.
+

+ +

+

Unit tests¶

Run these unit tests to check the correctness of your network implementation. These tests must all be successful to pass the project.

+ +

import unittest
+
+inputs = [0.5, -0.2, 0.1]
+targets = [0.4]
+test_w_i_h = np.array([[0.1, 0.4, -0.3], 
+                       [-0.2, 0.5, 0.2]])
+test_w_h_o = np.array([[0.3, -0.1]])
+
+class TestMethods(unittest.TestCase):
+    
+    ##########
+    # Unit tests for data loading
+    ##########
+    
+    def test_data_path(self):
+        # Test that file path to dataset has been unaltered
+        self.assertTrue(data_path.lower() == 'bike-sharing-dataset/hour.csv')
+        
+    def test_data_loaded(self):
+        # Test that data frame loaded
+        self.assertTrue(isinstance(rides, pd.DataFrame))
+    
+    ##########
+    # Unit tests for network functionality
+    ##########
+
+    def test_activation(self):
+        network = NeuralNetwork(3, 2, 1, 0.5)
+        # Test that the activation function is a sigmoid
+        self.assertTrue(np.all(network.activation_function(0.5) == 1/(1+np.exp(-0.5))))
+
+    def test_train(self):
+        # Test that weights are updated correctly on training
+        network = NeuralNetwork(3, 2, 1, 0.5)
+        network.weights_input_to_hidden = test_w_i_h.copy()
+        network.weights_hidden_to_output = test_w_h_o.copy()
+        
+        network.train(inputs, targets)
+        self.assertTrue(np.allclose(network.weights_hidden_to_output, 
+                                    np.array([[ 0.37275328, -0.03172939]])))
+        self.assertTrue(np.allclose(network.weights_input_to_hidden,
+                                    np.array([[ 0.10562014,  0.39775194, -0.29887597],
+                                              [-0.20185996,  0.50074398,  0.19962801]])))
+
+    def test_run(self):
+        # Test correctness of run method
+        network = NeuralNetwork(3, 2, 1, 0.5)
+        network.weights_input_to_hidden = test_w_i_h.copy()
+        network.weights_hidden_to_output = test_w_h_o.copy()
+
+        self.assertTrue(np.allclose(network.run(inputs), 0.09998924))
+
+suite = unittest.TestLoader().loadTestsFromModule(TestMethods())
+unittest.TextTestRunner().run(suite)
+

.....
+----------------------------------------------------------------------
+Ran 5 tests in 0.004s
+
+OK
+

<unittest.runner.TextTestResult run=5 errors=0 failures=0>

+

Image Classification¶

In this project, you'll classify images from the CIFAR-10 dataset. The dataset consists of airplanes, dogs, cats, and other objects. You'll preprocess the images, then train a convolutional neural network on all the samples. The images need to be normalized and the labels need to be one-hot encoded. You'll get to apply what you learned and build a convolutional, max pooling, dropout, and fully connected layers. At the end, you'll get to see your neural network's predictions on the sample images.

+

Get the Data¶

Run the following cell to download the CIFAR-10 dataset for python.

+ +

"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+from urllib.request import urlretrieve
+from os.path import isfile, isdir
+from tqdm import tqdm
+import problem_unittests as tests
+import tarfile
+
+cifar10_dataset_folder_path = 'cifar-10-batches-py'
+
+class DLProgress(tqdm):
+    last_block = 0
+
+    def hook(self, block_num=1, block_size=1, total_size=None):
+        self.total = total_size
+        self.update((block_num - self.last_block) * block_size)
+        self.last_block = block_num
+
+if not isfile('cifar-10-python.tar.gz'):
+    with DLProgress(unit='B', unit_scale=True, miniters=1, desc='CIFAR-10 Dataset') as pbar:
+        urlretrieve(
+            'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz',
+            'cifar-10-python.tar.gz',
+            pbar.hook)
+
+if not isdir(cifar10_dataset_folder_path):
+    with tarfile.open('cifar-10-python.tar.gz') as tar:
+        tar.extractall()
+        tar.close()
+
+
+tests.test_folder_path(cifar10_dataset_folder_path)
+

All files found!
+

+

Explore the Data¶

The dataset is broken into batches to prevent your machine from running out of memory. The CIFAR-10 dataset consists of 5 batches, named data_batch_1, data_batch_2, etc.. Each batch contains the labels and images that are one of the following:

+

airplane
automobile
bird
cat
deer
dog
frog
horse
ship
truck

+

Understanding a dataset is part of making predictions on the data. Play around with the code cell below by changing the batch_id and sample_id. The batch_id is the id for a batch (1-5). The sample_id is the id for a image and label pair in the batch.

+

Ask yourself "What are all possible labels?", "What is the range of values for the image data?", "Are the labels in order or random?". Answers to questions like these will help you preprocess the data and end up with better predictions.

+ +

%matplotlib inline
+%config InlineBackend.figure_format = 'retina'
+
+import helper
+import numpy as np
+
+# Explore the dataset
+batch_id = 1
+sample_id = 32
+helper.display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
+

+Stats of batch 1:
+Samples: 10000
+Label Counts: {0: 1005, 1: 974, 2: 1032, 3: 1016, 4: 999, 5: 937, 6: 1030, 7: 1001, 8: 1025, 9: 981}
+First 20 Labels: [6, 9, 9, 4, 1, 1, 2, 7, 8, 3, 4, 7, 7, 2, 9, 9, 9, 3, 2, 6]
+
+Example of Image 32:
+Image - Min Value: 0 Max Value: 255
+Image - Shape: (32, 32, 3)
+Label - Label Id: 1 Name: automobile
+

+

Implement Preprocess Functions¶

Normalize¶

In the cell below, implement the normalize function to take in image data, x, and return it as a normalized Numpy array. The values should be in the range of 0 to 1, inclusive. The return object should be the same shape as x.

+ +

def normalize(x):
+    """
+    Normalize a list of sample image data in the range of 0 to 1
+    : x: List of image data.  The image shape is (32, 32, 3)
+    : return: Numpy array of normalize data
+    """
+    return (x - x.min()) / (x.max() - x.min())
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_normalize(normalize)
+

Tests Passed
+

+

One-hot encode¶

Just like the previous code cell, you'll be implementing a function for preprocessing. This time, you'll implement the one_hot_encode function. The input, x, are a list of labels. Implement the function to return the list of labels as One-Hot encoded Numpy array. The possible values for labels are 0 to 9. The one-hot encoding function should return the same encoding for each value between each call to one_hot_encode. Make sure to save the map of encodings outside the function.

+

Hint: Don't reinvent the wheel.

+ +

encodings = {}
+for i in range(10):
+    v = np.zeros(10)
+    v[i] = 1
+    encodings[i] = v
+
+def one_hot_encode(x):
+    """
+    One hot encode a list of sample labels. Return a one-hot encoded vector for each label.
+    : x: List of sample Labels
+    : return: Numpy array of one-hot encoded labels
+    """
+    assert np.max(x) < 10 and np.min(x) >= 0, 'label must be between 0 and 9'
+    encoded = np.array(list(map(lambda v: encodings[v],x)))
+    return encoded
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_one_hot_encode(one_hot_encode)
+

Tests Passed
+

+

Randomize Data¶

As you saw from exploring the data above, the order of the samples are randomized. It doesn't hurt to randomize it again, but you don't need to for this dataset.

+ +

+

Preprocess all the data and save it¶

Running the code cell below will preprocess all the CIFAR-10 data and save it to file. The code below also uses 10% of the training data for validation.

+ +

"""
+DON'T MODIFY ANYTHING IN THIS CELL
+"""
+# Preprocess Training, Validation, and Testing Data
+helper.preprocess_and_save_data(cifar10_dataset_folder_path, normalize, one_hot_encode)
+

+

Check Point¶

This is your first checkpoint. If you ever decide to come back to this notebook or have to restart the notebook, you can start from here. The preprocessed data has been saved to disk.

+ +

"""
+DON'T MODIFY ANYTHING IN THIS CELL
+"""
+import pickle
+import problem_unittests as tests
+import helper
+
+# Load the Preprocessed Validation data
+valid_features, valid_labels = pickle.load(open('preprocess_validation.p', mode='rb'))
+

+

Build the network¶

For the neural network, you'll build each layer into a function. Most of the code you've seen has been outside of functions. To test your code more thoroughly, we require that you put each layer in a function. This allows us to give you better feedback and test for simple mistakes using our unittests before you submit your project.

+

If you're finding it hard to dedicate enough time for this course a week, we've provided a small shortcut to this part of the project. In the next couple of problems, you'll have the option to use TensorFlow Layers or TensorFlow Layers (contrib) to build each layer, except "Convolutional & Max Pooling" layer. TF Layers is similar to Keras's and TFLearn's abstraction to layers, so it's easy to pickup.

+

If you would like to get the most of this course, try to solve all the problems without TF Layers. Let's begin!

+

Input¶

The neural network needs to read the image data, one-hot encoded labels, and dropout keep probability. Implement the following functions

+

Implement neural_net_image_input
- Return a TF Placeholder
- Set the shape using image_shape with batch size set to None.
- Name the TensorFlow placeholder "x" using the TensorFlow name parameter in the TF Placeholder.
+
Implement neural_net_label_input
- Return a TF Placeholder
- Set the shape using n_classes with batch size set to None.
- Name the TensorFlow placeholder "y" using the TensorFlow name parameter in the TF Placeholder.
+
Implement neural_net_keep_prob_input
- Return a TF Placeholder for dropout keep probability.
- Name the TensorFlow placeholder "keep_prob" using the TensorFlow name parameter in the TF Placeholder.
+

+

These names will be used at the end of the project to load your saved model.

+

Note: None for shapes in TensorFlow allow for a dynamic size.

+ +

import tensorflow as tf
+
+def neural_net_image_input(image_shape):
+    """
+    Return a Tensor for a bach of image input
+    : image_shape: Shape of the images
+    : return: Tensor for image input.
+    """
+    # shape [None, 32, 32, 3]
+    return tf.placeholder(tf.float32, [None] + list(image_shape), name='x')
+
+
+
+def neural_net_label_input(n_classes):
+    """
+    Return a Tensor for a batch of label input
+    : n_classes: Number of classes
+    : return: Tensor for label input.
+    """
+    return tf.placeholder(tf.float32, [None, n_classes], name='y')
+
+
+def neural_net_keep_prob_input():
+    """
+    Return a Tensor for keep probability
+    : return: Tensor for keep probability.
+    """
+    # TODO: Implement Function
+    return tf.placeholder(tf.float32, name='keep_prob')
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tf.reset_default_graph()
+tests.test_nn_image_inputs(neural_net_image_input)
+tests.test_nn_label_inputs(neural_net_label_input)
+tests.test_nn_keep_prob_inputs(neural_net_keep_prob_input)
+

Image Input Tests Passed.
+Label Input Tests Passed.
+Keep Prob Tests Passed.
+

+

Convolution and Max Pooling Layer¶

Convolution layers have a lot of success with images. For this code cell, you should implement the function conv2d_maxpool to apply convolution then max pooling:

+

Create the weight and bias using conv_ksize, conv_num_outputs and the shape of x_tensor.
Apply a convolution to x_tensor using weight and conv_strides.
- We recommend you use same padding, but you're welcome to use any padding.
+
Add bias
Add a nonlinear activation to the convolution.
Apply Max Pooling using pool_ksize and pool_strides.
- We recommend you use same padding, but you're welcome to use any padding.
+

+

Note: You can't use TensorFlow Layers or TensorFlow Layers (contrib) for this layer. You're free to use any TensorFlow package for all the other layers.

+ +

def conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides):
+    """
+    Apply convolution then max pooling to x_tensor
+    :param x_tensor: TensorFlow Tensor
+    :param conv_num_outputs: Number of outputs for the convolutional layer
+    :param conv_strides: Stride 2-D Tuple for convolution
+    :param pool_ksize: kernal size 2-D Tuple for pool
+    :param pool_strides: Stride 2-D Tuple for pool
+    : return: A tensor that represents convolution and max pooling of x_tensor
+    """
+    w_conv = tf.Variable(tf.truncated_normal((conv_ksize[0], # Kernel height
+                                                 conv_ksize[1], # Kernel width
+                                                 x_tensor.get_shape()[3].value, # Input channels
+                                                 conv_num_outputs), stddev=0.05)) # output depth
+    bias_conv = tf.Variable(tf.random_normal([conv_num_outputs], stddev=0.05))
+    
+    padding = 'VALID'
+    
+    
+    # DEBUG
+    #print('conv ksize: ', conv_ksize)
+    #print('conv strides: ',conv_strides)
+    #print('pool ksize: ', pool_ksize)
+    #print('pool strides: ',pool_strides)
+    #print('conv_depth: ', conv_num_outputs)
+    #print('x_tensor :',x_tensor)
+    #print('conv weights :', w_conv) 
+    # DEBUG
+    
+    
+    # Apply conv to x_tensor
+    cv1 = tf.nn.conv2d(x_tensor,
+                       w_conv,
+                       [1, conv_strides[0], conv_strides[1], 1],
+                       padding=padding
+                      )
+    # add bias
+    cv1 = tf.nn.bias_add(cv1, bias_conv)
+    
+    # Apply relu
+    cv1 = tf.nn.relu(cv1)
+    
+    # Apply Maxpooling
+    cv1 = tf.nn.max_pool(cv1,
+                         ksize=[1,pool_ksize[0], pool_ksize[1], 1],
+                         strides=[1, pool_strides[0], pool_strides[1], 1],
+                         padding=padding
+                        )
+    
+     
+    
+    #print('conv layer :', cv1.get_shape())
+    return cv1 
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_con_pool(conv2d_maxpool)
+

Tests Passed
+

+

Flatten Layer¶

Implement the flatten function to change the dimension of x_tensor from a 4-D tensor to a 2-D tensor. The output should be the shape (Batch Size, Flattened Image Size). You can use TensorFlow Layers or TensorFlow Layers (contrib) for this layer.

+ +

def flatten(x_tensor):
+    """
+    Flatten x_tensor to (Batch Size, Flattened Image Size)
+    : x_tensor: A tensor of size (Batch Size, ...), where ... are the image dimensions.
+    : return: A tensor of size (Batch Size, Flattened Image Size).
+    """
+    flat_size = np.multiply.reduce(x_tensor.get_shape()[1:].as_list())
+    return tf.reshape(x_tensor, [-1, flat_size])
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_flatten(flatten)
+

Tests Passed
+

+

Fully-Connected Layer¶

Implement the fully_conn function to apply a fully connected layer to x_tensor with the shape (Batch Size, num_outputs). You can use TensorFlow Layers or TensorFlow Layers (contrib) for this layer.

+ +

def fully_conn(x_tensor, num_outputs):
+    """
+    Apply a fully connected layer to x_tensor using weight and bias
+    : x_tensor: A 2-D tensor where the first dimension is batch size.
+    : num_outputs: The number of output that the new tensor should be.
+    : return: A 2-D tensor where the second dimension is num_outputs.
+    """
+    full_w = tf.Variable(tf.truncated_normal((x_tensor.get_shape()[1].value, num_outputs), stddev=0.05))
+    full_b = tf.Variable(tf.random_normal([num_outputs], stddev=0.05))
+    
+    full = tf.add(tf.matmul(x_tensor, full_w), full_b)
+    full = tf.nn.relu(full)
+    return full
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_fully_conn(fully_conn)
+

Tests Passed
+

+

Output Layer¶

Implement the output function to apply a fully connected layer to x_tensor with the shape (Batch Size, num_outputs). You can use TensorFlow Layers or TensorFlow Layers (contrib) for this layer.

+

Note: Activation, softmax, or cross entropy shouldn't be applied to this.

+ +

def output(x_tensor, num_outputs):
+    """
+    Apply a output layer to x_tensor using weight and bias
+    : x_tensor: A 2-D tensor where the first dimension is batch size.
+    : num_outputs: The number of output that the new tensor should be.
+    : return: A 2-D tensor where the second dimension is num_outputs.
+    """
+    out_w = tf.Variable(tf.truncated_normal((x_tensor.get_shape()[1].value, num_outputs)))
+    out_b = tf.Variable(tf.zeros(num_outputs))
+    
+    out = tf.add(tf.matmul(x_tensor, out_w), out_b)
+    return out
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_output(output)
+

Tests Passed
+

+

Create Convolutional Model¶

Implement the function conv_net to create a convolutional neural network model. The function takes in a batch of images, x, and outputs logits. Use the layers you created above to create this model:

+

Apply 1, 2, or 3 Convolution and Max Pool layers
Apply a Flatten Layer
Apply 1, 2, or 3 Fully Connected Layers
Apply an Output Layer
Return the output
Apply TensorFlow's Dropout to one or more layers in the model using keep_prob.

+ +

def conv_net(x, keep_prob):
+    """
+    Create a convolutional neural network model
+    : x: Placeholder tensor that holds image data.
+    : keep_prob: Placeholder tensor that hold dropout keep probability.
+    : return: Tensor that represents logits
+    """
+    
+    
+    conv1_hyper_params = {
+        'conv_num_outputs': 60,
+        'conv_ksize': (3,3),
+        'conv_strides': (1,1),
+        'pool_ksize': (2,2),
+        'pool_strides': (2,2)
+    }
+    
+    conv2_hyper_params = {
+        'conv_num_outputs': 120,
+        'conv_ksize': (3,3),
+        'conv_strides': (1,1),
+        'pool_ksize': (2,2),
+        'pool_strides': (2,2)
+    }
+    
+    conv3_hyper_params = {
+        'conv_num_outputs': 400,
+        'conv_ksize': (3,3),
+        'conv_strides': (1,1),
+        'pool_ksize': (2,2),
+        'pool_strides': (2,2)
+    }
+    
+   
+    conv1 = conv2d_maxpool(x, **conv1_hyper_params)  
+    conv2 = conv2d_maxpool(conv1, **conv2_hyper_params)
+    conv3 = conv2d_maxpool(conv2, **conv3_hyper_params)
+
+    
+    
+    
+    flat = flatten(conv3)
+    
+    
+    
+    
+    full1 = fully_conn(flat, 600)
+    full1 = tf.nn.dropout(full1, keep_prob)
+    
+    
+    full2 = fully_conn(full1, 60)
+    full2 = tf.nn.dropout(full2, keep_prob)
+
+
+    
+    
+    
+    # TODO: Apply an Output Layer
+    #    Set this to the number of classes
+    # Function Definition from Above:
+    #   output(x_tensor, num_outputs)
+    out = output(full2, 10)
+    
+    
+    # DEBUG
+    print(x)
+    print(conv1)
+    print(conv2)
+    print(conv3)
+    print(flat)
+    print(full1)
+    print(full2)
+    print(out)
+    # DEBUG
+    
+    
+    return out
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+
+##############################
+## Build the Neural Network ##
+##############################
+
+# Remove previous weights, bias, inputs, etc..
+tf.reset_default_graph()
+
+# Inputs
+x = neural_net_image_input((32, 32, 3))
+y = neural_net_label_input(10)
+keep_prob = neural_net_keep_prob_input()
+
+# Model
+logits = conv_net(x, keep_prob)
+
+# Name logits Tensor, so that is can be loaded from disk after training
+logits = tf.identity(logits, name='logits')
+
+# Loss and Optimizer
+cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))
+optimizer = tf.train.AdamOptimizer().minimize(cost)
+
+# Accuracy
+correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
+accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name='accuracy')
+
+tests.test_conv_net(conv_net)
+

--------------
+Tensor("x:0", shape=(?, 32, 32, 3), dtype=float32)
+Tensor("MaxPool:0", shape=(?, 15, 15, 60), dtype=float32)
+Tensor("MaxPool_1:0", shape=(?, 6, 6, 120), dtype=float32)
+Tensor("MaxPool_2:0", shape=(?, 2, 2, 400), dtype=float32)
+Tensor("Reshape:0", shape=(?, 1600), dtype=float32)
+Tensor("dropout/mul:0", shape=(?, 600), dtype=float32)
+Tensor("dropout_1/mul:0", shape=(?, 60), dtype=float32)
+Tensor("Add_2:0", shape=(?, 10), dtype=float32)
+--------------
+Tensor("Placeholder:0", shape=(?, 32, 32, 3), dtype=float32)
+Tensor("MaxPool_3:0", shape=(?, 15, 15, 60), dtype=float32)
+Tensor("MaxPool_4:0", shape=(?, 6, 6, 120), dtype=float32)
+Tensor("MaxPool_5:0", shape=(?, 2, 2, 400), dtype=float32)
+Tensor("Reshape_4:0", shape=(?, 1600), dtype=float32)
+Tensor("dropout_2/mul:0", shape=(?, 600), dtype=float32)
+Tensor("dropout_3/mul:0", shape=(?, 60), dtype=float32)
+Tensor("Add_5:0", shape=(?, 10), dtype=float32)
+Neural Network Built!
+

+

Train the Neural Network¶

Single Optimization¶

Implement the function train_neural_network to do a single optimization. The optimization should use optimizer to optimize in session with a feed_dict of the following:

+

x for image input
y for labels
keep_prob for keep probability for dropout

+

This function will be called for each batch, so tf.global_variables_initializer() has already been called.

+

Note: Nothing needs to be returned. This function is only optimizing the neural network.

+ +

def train_neural_network(session, optimizer, keep_probability, feature_batch, label_batch):
+    """
+    Optimize the session on a batch of images and labels
+    : session: Current TensorFlow session
+    : optimizer: TensorFlow optimizer function
+    : keep_probability: keep probability
+    : feature_batch: Batch of Numpy image data
+    : label_batch: Batch of Numpy label data
+    """
+    session.run([optimizer], feed_dict={x: feature_batch,
+                                        y: label_batch,
+                                        keep_prob: keep_probability
+                                       })
+
+
+"""
+DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
+"""
+tests.test_train_nn(train_neural_network)
+

Tests Passed
+

+

Show Stats¶

Implement the function print_stats to print loss and validation accuracy. Use the global variables valid_features and valid_labels to calculate validation accuracy. Use a keep probability of 1.0 to calculate the loss and validation accuracy.

+ +

def print_stats(session, feature_batch, label_batch, cost, accuracy):
+    """
+    Print information about loss and validation accuracy
+    : session: Current TensorFlow session
+    : feature_batch: Batch of Numpy image data
+    : label_batch: Batch of Numpy label data
+    : cost: TensorFlow cost function
+    : accuracy: TensorFlow accuracy function
+    """
+    loss_feed = {
+        x: feature_batch,
+        y: label_batch,
+        keep_prob: 1.
+    }
+    
+    valid_feed = {
+        x: valid_features,
+        y: valid_labels,
+        keep_prob: 1.
+    }
+    
+    loss = session.run(cost, loss_feed)
+    accuracy = session.run(accuracy, valid_feed)
+    
+    print('Loss: {:>10.4f} - Valid Accuracy: {:.2f}%'.format(loss,accuracy*100))
+    
+    
+

+

Hyperparameters¶

Tune the following parameters:

+

Set epochs to the number of iterations until the network stops learning or start overfitting
Set batch_size to the highest number that your machine has memory for. Most people set them to common sizes of memory:
- 64
- 128
- 256
- ...
+
Set keep_probability to the probability of keeping a node using dropout

+ +

# TODO: Tune Parameters
+epochs = 9
+batch_size = 512
+keep_probability = 0.75
+

+

Train on a Single CIFAR-10 Batch¶

Instead of training the neural network on all the CIFAR-10 batches of data, let's use a single batch. This should save time while you iterate on the model to get a better accuracy. Once the final validation accuracy is 50% or greater, run the model on all the data in the next section.

+ +

"""
+DON'T MODIFY ANYTHING IN THIS CELL
+"""
+print('Checking the Training on a Single Batch...')
+with tf.Session() as sess:
+    # Initializing the variables
+    sess.run(tf.global_variables_initializer())
+    
+    # Training cycle
+    for epoch in range(epochs):
+        batch_i = 1
+        for batch_features, batch_labels in helper.load_preprocess_training_batch(batch_i, batch_size):
+            train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels)
+        print('Epoch {:>2}, CIFAR-10 Batch {}:  '.format(epoch + 1, batch_i), end='')
+        print_stats(sess, batch_features, batch_labels, cost, accuracy)
+

Checking the Training on a Single Batch...
+Epoch  1, CIFAR-10 Batch 1:  Loss:     2.2416 - Valid Accuracy: 16.52%
+Epoch  2, CIFAR-10 Batch 1:  Loss:     2.0681 - Valid Accuracy: 26.34%
+Epoch  3, CIFAR-10 Batch 1:  Loss:     1.9934 - Valid Accuracy: 30.72%
+Epoch  4, CIFAR-10 Batch 1:  Loss:     1.8648 - Valid Accuracy: 36.14%
+Epoch  5, CIFAR-10 Batch 1:  Loss:     1.7653 - Valid Accuracy: 38.90%
+Epoch  6, CIFAR-10 Batch 1:  Loss:     1.6582 - Valid Accuracy: 41.92%
+Epoch  7, CIFAR-10 Batch 1:  Loss:     1.4946 - Valid Accuracy: 44.92%
+Epoch  8, CIFAR-10 Batch 1:  Loss:     1.3776 - Valid Accuracy: 48.44%
+Epoch  9, CIFAR-10 Batch 1:  Loss:     1.2710 - Valid Accuracy: 49.32%
+

+

Fully Train the Model¶

Now that you got a good accuracy with a single CIFAR-10 batch, try it with all five batches.

+ +

"""
+DON'T MODIFY ANYTHING IN THIS CELL
+"""
+save_model_path = './image_classification'
+
+print('Training...')
+with tf.Session() as sess:
+    # Initializing the variables
+    sess.run(tf.global_variables_initializer())
+    
+    # Training cycle
+    for epoch in range(epochs):
+        # Loop over all batches
+        n_batches = 5
+        for batch_i in range(1, n_batches + 1):
+            for batch_features, batch_labels in helper.load_preprocess_training_batch(batch_i, batch_size):
+                train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels)
+            print('Epoch {:>2}, CIFAR-10 Batch {}:  '.format(epoch + 1, batch_i), end='')
+            print_stats(sess, batch_features, batch_labels, cost, accuracy)
+            
+    # Save Model
+    saver = tf.train.Saver()
+    save_path = saver.save(sess, save_model_path)
+

Training...
+Epoch  1, CIFAR-10 Batch 1:  Loss:     2.2161 - Valid Accuracy: 18.40%
+Epoch  1, CIFAR-10 Batch 2:  Loss:     2.0625 - Valid Accuracy: 25.98%
+Epoch  1, CIFAR-10 Batch 3:  Loss:     1.7185 - Valid Accuracy: 34.68%
+Epoch  1, CIFAR-10 Batch 4:  Loss:     1.6533 - Valid Accuracy: 39.72%
+Epoch  1, CIFAR-10 Batch 5:  Loss:     1.5159 - Valid Accuracy: 43.98%
+Epoch  2, CIFAR-10 Batch 1:  Loss:     1.6357 - Valid Accuracy: 47.40%
+Epoch  2, CIFAR-10 Batch 2:  Loss:     1.4579 - Valid Accuracy: 48.64%
+Epoch  2, CIFAR-10 Batch 3:  Loss:     1.2390 - Valid Accuracy: 51.38%
+Epoch  2, CIFAR-10 Batch 4:  Loss:     1.2468 - Valid Accuracy: 53.06%
+Epoch  2, CIFAR-10 Batch 5:  Loss:     1.2385 - Valid Accuracy: 53.86%
+Epoch  3, CIFAR-10 Batch 1:  Loss:     1.3218 - Valid Accuracy: 55.72%
+Epoch  3, CIFAR-10 Batch 2:  Loss:     1.1992 - Valid Accuracy: 54.00%
+Epoch  3, CIFAR-10 Batch 3:  Loss:     1.0670 - Valid Accuracy: 57.56%
+Epoch  3, CIFAR-10 Batch 4:  Loss:     1.0798 - Valid Accuracy: 57.62%
+Epoch  3, CIFAR-10 Batch 5:  Loss:     1.0199 - Valid Accuracy: 59.20%
+Epoch  4, CIFAR-10 Batch 1:  Loss:     1.0873 - Valid Accuracy: 61.30%
+Epoch  4, CIFAR-10 Batch 2:  Loss:     1.0366 - Valid Accuracy: 61.46%
+Epoch  4, CIFAR-10 Batch 3:  Loss:     0.9007 - Valid Accuracy: 61.18%
+Epoch  4, CIFAR-10 Batch 4:  Loss:     0.8702 - Valid Accuracy: 63.08%
+Epoch  4, CIFAR-10 Batch 5:  Loss:     0.8193 - Valid Accuracy: 65.02%
+Epoch  5, CIFAR-10 Batch 1:  Loss:     0.9168 - Valid Accuracy: 63.96%
+Epoch  5, CIFAR-10 Batch 2:  Loss:     0.8561 - Valid Accuracy: 65.00%
+Epoch  5, CIFAR-10 Batch 3:  Loss:     0.7567 - Valid Accuracy: 65.08%
+Epoch  5, CIFAR-10 Batch 4:  Loss:     0.7559 - Valid Accuracy: 65.62%
+Epoch  5, CIFAR-10 Batch 5:  Loss:     0.7026 - Valid Accuracy: 66.76%
+Epoch  6, CIFAR-10 Batch 1:  Loss:     0.8156 - Valid Accuracy: 67.12%
+Epoch  6, CIFAR-10 Batch 2:  Loss:     0.7452 - Valid Accuracy: 67.18%
+Epoch  6, CIFAR-10 Batch 3:  Loss:     0.6952 - Valid Accuracy: 65.44%
+Epoch  6, CIFAR-10 Batch 4:  Loss:     0.6694 - Valid Accuracy: 66.68%
+Epoch  6, CIFAR-10 Batch 5:  Loss:     0.6272 - Valid Accuracy: 67.82%
+Epoch  7, CIFAR-10 Batch 1:  Loss:     0.7157 - Valid Accuracy: 68.12%
+Epoch  7, CIFAR-10 Batch 2:  Loss:     0.6450 - Valid Accuracy: 67.92%
+Epoch  7, CIFAR-10 Batch 3:  Loss:     0.6158 - Valid Accuracy: 66.10%
+Epoch  7, CIFAR-10 Batch 4:  Loss:     0.5492 - Valid Accuracy: 68.74%
+Epoch  7, CIFAR-10 Batch 5:  Loss:     0.5193 - Valid Accuracy: 68.12%
+Epoch  8, CIFAR-10 Batch 1:  Loss:     0.6347 - Valid Accuracy: 69.08%
+Epoch  8, CIFAR-10 Batch 2:  Loss:     0.5660 - Valid Accuracy: 69.54%
+Epoch  8, CIFAR-10 Batch 3:  Loss:     0.4913 - Valid Accuracy: 67.54%
+Epoch  8, CIFAR-10 Batch 4:  Loss:     0.4737 - Valid Accuracy: 69.96%
+Epoch  8, CIFAR-10 Batch 5:  Loss:     0.4385 - Valid Accuracy: 70.38%
+Epoch  9, CIFAR-10 Batch 1:  Loss:     0.5353 - Valid Accuracy: 69.56%
+Epoch  9, CIFAR-10 Batch 2:  Loss:     0.4946 - Valid Accuracy: 69.56%
+Epoch  9, CIFAR-10 Batch 3:  Loss:     0.4304 - Valid Accuracy: 68.02%
+Epoch  9, CIFAR-10 Batch 4:  Loss:     0.4035 - Valid Accuracy: 70.64%
+Epoch  9, CIFAR-10 Batch 5:  Loss:     0.3885 - Valid Accuracy: 70.56%
+

+

Checkpoint¶

The model has been saved to disk.

+

Test Model¶

Test your model against the test dataset. This will be your final accuracy. You should have an accuracy greater than 50%. If you don't, keep tweaking the model architecture and parameters.

+ +

"""
+DON'T MODIFY ANYTHING IN THIS CELL
+"""
+%matplotlib inline
+%config InlineBackend.figure_format = 'retina'
+
+import tensorflow as tf
+import pickle
+import helper
+import random
+
+# Set batch size if not already set
+try:
+    if batch_size:
+        pass
+except NameError:
+    batch_size = 64
+
+save_model_path = './image_classification'
+n_samples = 4
+top_n_predictions = 3
+
+def test_model():
+    """
+    Test the saved model against the test dataset
+    """
+
+    test_features, test_labels = pickle.load(open('preprocess_training.p', mode='rb'))
+    loaded_graph = tf.Graph()
+
+    with tf.Session(graph=loaded_graph) as sess:
+        # Load model
+        loader = tf.train.import_meta_graph(save_model_path + '.meta')
+        loader.restore(sess, save_model_path)
+
+        # Get Tensors from loaded model
+        loaded_x = loaded_graph.get_tensor_by_name('x:0')
+        loaded_y = loaded_graph.get_tensor_by_name('y:0')
+        loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob:0')
+        loaded_logits = loaded_graph.get_tensor_by_name('logits:0')
+        loaded_acc = loaded_graph.get_tensor_by_name('accuracy:0')
+        
+        # Get accuracy in batches for memory limitations
+        test_batch_acc_total = 0
+        test_batch_count = 0
+        
+        for train_feature_batch, train_label_batch in helper.batch_features_labels(test_features, test_labels, batch_size):
+            test_batch_acc_total += sess.run(
+                loaded_acc,
+                feed_dict={loaded_x: train_feature_batch, loaded_y: train_label_batch, loaded_keep_prob: 1.0})
+            test_batch_count += 1
+
+        print('Testing Accuracy: {}\n'.format(test_batch_acc_total/test_batch_count))
+
+        # Print Random Samples
+        random_test_features, random_test_labels = tuple(zip(*random.sample(list(zip(test_features, test_labels)), n_samples)))
+        random_test_predictions = sess.run(
+            tf.nn.top_k(tf.nn.softmax(loaded_logits), top_n_predictions),
+            feed_dict={loaded_x: random_test_features, loaded_y: random_test_labels, loaded_keep_prob: 1.0})
+        helper.display_image_predictions(random_test_features, random_test_labels, random_test_predictions)
+
+
+test_model()
+

Testing Accuracy: 0.7010512441396713
+
+

+

Why 50-70% Accuracy?¶

You might be wondering why you can't get an accuracy any higher. First things first, 50% isn't bad for a simple CNN. Pure guessing would get you 10% accuracy. However, you might notice people are getting scores well above 70%. That's because we haven't taught you all there is to know about neural networks. We still need to cover a few more techniques.

+

Submitting This Project¶

When submitting this project, make sure to run all the cells before saving the notebook. Save the notebook file as "dlnd_image_classification.ipynb" and save it as a HTML file under "File" -> "Download as". Include the "helper.py" and "problem_unittests.py" files in your submission.

+ +

	instant	dteday	season	mnth	weekday	workingday	weathersit	temp	atemp	hum	windspeed	casual	registered	cnt
0	1	2011-01-01	1	1	6	0	2	0.344167	0.363625	0.805833	0.160446	331	654	985
1	2	2011-01-02	1	1	0	0	2	0.363478	0.353739	0.696087	0.248539	131	670	801
2	3	2011-01-03	1	1	1	1	1	0.196364	0.189405	0.437273	0.248309	120	1229	1349
3	4	2011-01-04	1	1	2	1	1	0.200000	0.212122	0.590435	0.160296	108	1454	1562
4	5	2011-01-05	1	1	3	1	1	0.226957	0.229270	0.436957	0.186900	82	1518	1600

	instant	dteday	season	mnth	hr	weekday	weathersit	temp	atemp	hum	casual	registered	cnt
0	1	2011-01-01	1	1	0	6	1	0.24	0.2879	0.81	3	13	16
1	2	2011-01-01	1	1	1	6	1	0.22	0.2727	0.80	8	32	40
2	3	2011-01-01	1	1	2	6	1	0.22	0.2727	0.80	5	27	32
3	4	2011-01-01	1	1	3	6	1	0.24	0.2879	0.75	3	10	13
4	5	2011-01-01	1	1	4	6	1	0.24	0.2879	0.75	0	1	1