# Cell 18

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y_true)

# Cell 19

cost = tf.reduce_mean(cross_entropy)

# Cell 20

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(cost)

# Cell 21

correct_prediction = tf.equal(y_pred_cls, y_true_cls)

# Cell 22

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# Cell 23

session = tf.Session()

# Cell 24

session.run(tf.global_variables_initializer())

# Cell 25

batch_size = 100

# Cell 26

def optimize(num_iterations):

    for i in range(num_iterations):

        # Get a batch of training examples.

        # x_batch now holds a batch of images and

        # y_true_batch are the true labels for those images. 

        x_batch, y_true_batch = data.train.next_batch(batch_size)

        # Put the batch into a dict with the proper names

        # for placeholder variables in the TensorFlow graph. # Note that the placeholder for y_true_cls is not set # because it is not used during training. 

        feed_dict_train = {x: x_batch,

                                            y_true: y_true_batch}

        # Run the optimizer using this batch of training data.

        # TensorFlow assigns the variables in feed_dict_train

        # to the placeholder variables and then runs the optimizer. 

        session.run(optimizer, feed_dict=feed_dict_train)

# Cell 27

feed_dict_test = {x: data.test.images, y_true: data.test.labels,

                            y_true_cls: data.test.cls}

# Cell 28

def print_accuracy():

    # Use TensorFlow to compute the accuracy.

    acc = session.run(accuracy, feed_dict=feed_dict_test)

    # Print the accuracy.

    print("Accuracy on test-set: {0:.1%}".format(acc))

# Cell 29

def plot_weights():

    # Get the values for the weights from the TensorFlow variable. w = session.run(weights)

    # Get the lowest and highest values for the weights. # This is used to correct the colour intensity across # the images so they can be compared with each other. w_min = np.min(w)

    w_max = np.max(w)

    # Create figure with 3x4 sub-plots,

    # where the last 2 sub-plots are unused. fig, axes = plt.subplots(3, 4) fig.subplots_adjust(hspace=0.3, wspace=0.3)

    for i, ax in enumerate(axes.flat):

        # Only use the weights for the first 10 sub-plots. 

        if i<10:

            # Get the weights for the i'th digit and reshape it. # Note that w.shape == (img_size_flat, 10)

            image = w[:, i].reshape(img_shape)

                                # Set the label for the sub-plot.

            ax.set_xlabel("Weights: {0}".format(i)) 

            # Plot the image.

            ax.imshow(image, vmin=w_min, vmax=w_max, cmap='seismic')

        # Remove ticks from each sub-plot.

        ax.set_xticks([])

        ax.set_yticks([])

# Cell 30

print_accuracy()

Accuracy on test-set: 9.8%

# Cell 31

optimize(num_iterations=1)

# Cell 32

print_accuracy()

Accuracy on test-set: 40.7%

# Cell 33

plot_weights()

# Cell 34

# We have already performed 1 iteration already. 

optimize(num_iterations=999)

# Cell 35

print_accuracy()

Accuracy on test-set: 91.7%

# Cell 36

plot_weights()

# Cell 37

session.close()