Вы находитесь на странице: 1из 4

# 12/8/2017 Implementing a five-layer neural network - Deep Learning with TensorFlow

##  Deep Learning with TensorFlow

PREV NEXT
⏮ ⏭
So max loader source code Visualization
   🔎

Implementing a
five-layer neural
network
The following implementation increases the network complexity by
adding four layers before the softmax layer. To determine the appropriate
size of the network, that is, the number of hidden layers and the number
of neurons per layer, generally we rely on general empirical criteria, the
personal experience, or appropriate tests.

## The following table summarizes the implemented network architecture, it

shows the number of neurons per layer and the respective activation
functions:

Number of Activation
Layer
neurons function

## First L = 200 sigmoid

Second M = 100 sigmoid

Third N = 60 sigmoid

12/8/2017 Implementing a five-layer neural network - Deep Learning with TensorFlow

Fourth O = 30 sigmoid

Fifth 10 softmax

The transfer function for the first four layers is the sigmoid function; the
last layer of the transfer function is always the softmax since the output
of the network must express a probability for the input digit. In general,
the number and the size of the intermediate layers greatly affect the
network performance:

In a positive way, because on these layers is based the ability of the net to
generalize and to detect peculiar characteristics of the input

## In a negative way because if the network is redundant it unnecessarily

weighs down the learning phase

## We will now start to implement the network, importing the following

libraries:

import mnist_data
import tensorflow as tf
import math

## Then we will set the following configuration parameters:

logs_path = 'log_simple_stats_5_layers_relu_softmax'
batch_size = 100
learning_rate = 0.5
training_epochs = 10

We will then download images and labels and prepare the dataset:

Starting with the input layer, we'll now see how to build the network's
architecture.

The input layer is now a tensor of the shape [1×784], which represents the
image to classify:

## X = tf.placeholder(tf.float32, [None, 28, 28, 1])

XX = tf.reshape(X, [-1, 784])

The first layer receives the pixels of the input image to be classified
combined with the W1 weight connections and added to the respective
values of the B1 biases tensor:

## W1 = tf.Variable(tf.truncated_normal([784, L], stddev=0.1))

B1 = tf.Variable(tf.zeros([L]))

The first layer sends its output to the second layer, through the sigmoid
activation function:

## Y1 = tf.nn.sigmoid(tf.matmul(XX, W1) + B1)

12/8/2017 Implementing a five-layer neural network - Deep Learning with TensorFlow

The second layer receives the Y1 output from the first layer and combines
it with the W2 weight connections and adds it to the respective values of
the B2 biases tensor:

## W2 = tf.Variable(tf.truncated_normal([L, M], stddev=0.1))

B2 = tf.Variable(tf.zeros([M]))

The second layer sends its output to the third layer, through the sigmoid
activation function:

## Y2 = tf.nn.sigmoid(tf.matmul(Y1, W2) + B2)

The third layer receives the Y2 output from the second layer and
combines it with the W3 weight connections and adds it to the respective
values of the B3 biases tensor:

## W3 = tf.Variable(tf.truncated_normal([M, N], stddev=0.1))

B3 = tf.Variable(tf.zeros([N]))

The third layer sends its output to the fourth layer, through the sigmoid
activation function:

## Y3 = tf.nn.sigmoid(tf.matmul(Y2, W3) + B3)

The fourth layer receives the Y3 output from the third layer and combines
it with the W4 weight connections and adds it to the respective values of
the B4 biases tensor:

## W4 = tf.Variable(tf.truncated_normal([N, O], stddev=0.1))

B4 = tf.Variable(tf.zeros([O]))

It sends its output to the fifth layer, through the sigmoid activation
function:

## Y4 = tf.nn.sigmoid(tf.matmul(Y3, W4) + B4)

The fifth layer will receive in input the O = 30 stimuli coming from the
fourth layer that will be converted in the respective classes of probability
for each number, through the softmax activation function:

## W5 = tf.Variable(tf.truncated_normal([O, 10], stddev=0.1))

B5 = tf.Variable(tf.zeros())
Ylogits = tf.matmul(Y4, W5) + B5
Y = tf.nn.softmax(Ylogits)

Here, our loss function is the cross-entropy between the target and
the softmax activation function applied to the model's prediction:

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=Ylogits,

The tf.train.AdamOptimizer uses the Kingma and Ba's Adam
algorithm (https://arxiv.org/pdf/1412.6980v8.pdf) to
control the learning rate. AdamOptimizer offers several advantages
over the simple tf.train.GradientDescentOptimizer; in

12/8/2017 Implementing a five-layer neural network - Deep Learning with TensorFlow

fact, it uses a larger effective step size, and the algorithm will converge to
this step size without fine tuning:

learning_rate = 0.003

accuracy:

## correct_prediction = tf.equal(tf.argmax(Y, 1), tf.argmax(Y_, 1))

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

The source code for the definition of the summaries and the running of
the session is almost identical to the previous. We can pass directly to
evaluate the implemented model. Running the model, we have the
following output. The final test set accuracy after running this code should
be approximately 97%:

>>>
Epoch: 0
Epoch: 1
Epoch: 2
Epoch: 3
Epoch: 4
Epoch: 5
Epoch: 6
Epoch: 7
Epoch: 8
Epoch: 9
Accuracy: 0.9744
done
>>>

Recommended / Queue / History / Topics / Tutorials / Settings / Get the App / Sign Out