Detailed explanation of python to recognize handwritten MNIST number set procedures

What we need to do is # #12032; One thing is to get the MNIST data. If you are ⼀ A git & # 12132; The & # 12094; , then you can get the data by cloning the code warehouse of this book, and implement our To classify numbers

git clone https://github.com/mnielsen/neural-networks-and-deep-learning.git

class Network(object):
def __init__(self, sizes):
self.num_layers = len(sizes)
self.sizes = sizes
self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
self.weights = [np.random.randn(y, x)
for x, y in zip(sizes[:-1], sizes[1:])]

In this code, listing sizes contains the number of neurons in each layer. For example, if we want to create ⼀ In the first & # 12032; There are 2 neurons in the layer, # ⼆ There are 3 neurons in the layer, and the Network object with 1 neuron in the last layer, we should write the code as follows:

net = Network([2, 3, 1])

The bias and weights in the Network object are randomly initialized to ⽤ Numpy np. random. randn function to #12131; With mean 0 and standard deviation 1 ⾼ Distribution. This random initialization gives us the stochastic gradient descent algorithm #12032; Starting point. In the & # 12207; We will find better initialization weights and bias ⽅ Law, but ⽬ Initializes it randomly. Note that the Network initialization code assumes # ⼀ The layer neuron is ⼀ A lost & # 12042; Layer, and do not set any bias on these neurons, because the bias is only after. The layer of & # 12132; Calculate the output. With these, it is easy to write from ⼀ The code for the output of two Network instances. We start by defining S type functions:

def sigmoid(z):
return 1.0/(1.0+np.exp(-z))

Note that when input ⼊ z is the & # 12032; Numpy ⾃ for a vector or an Numpy array; Dynamically press element # #12132; The sigmoid function, that is, in vector form.

We then add ⼀ to the Network class; A feedforward & # 12101; Method, for ⽹ Winding given & # 12032; A lost & # 12042; a, returns the corresponding output 6. The & # 12101; What the method does is for each ⼀ Layer should be & # 12132; The & # 12101; (22) :

def feedforward(self, a):
"""Return the output of the network if "a" is input."""
for b, w in zip(self.biases, self.weights):
a = sigmoid(np.dot(w, a)+b)
return a

Of course, the main thing we want Network objects to do is learn. For this we give them #12032; SGD ⽅ to implement random gradient descent algorithm; Method. The code is as follows. The & # 12032; Some of the & # 12101; Seems the & # 12032; Point mysterious, I will be in the code after ⾯ One by one analysis

def SGD(self, training_data, epochs, mini_batch_size, eta,
test_data=None):
"""Train the neural network using mini-batch stochastic
gradient descent. The "training_data" is a list of tuples
"(x, y)" representing the training inputs and the desired
outputs. The other non-optional parameters are
self-explanatory. If "test_data" is provided then the
network will be evaluated against the test data after each
epoch, and partial progress printed out. This is useful for
tracking progress, but slows things down substantially."""
if test_data: n_test = len(test_data)
n = len(training_data)
for j in xrange(epochs):
random.shuffle(training_data)
mini_batches = [
training_data[k:k+mini_batch_size]
for k in xrange(0, n, mini_batch_size)]
for mini_batch in mini_batches:
self.update_mini_batch(mini_batch, eta)
if test_data:
print "Epoch {0}: {1} / {2}".format(
j, self.evaluate(test_data), n_test)
else:
print "Epoch {0} complete".format(j)

training_data is the & # 12032; List of (x, y) tuples, table ⽰ Training to lose the & # 12042; And its corresponding expected output. The variables epochs and mini_batch_size are as you would expect -- number of iterations, and #12073 at sampling time; Batch data ⼤ The & # 12073; . eta is the learning rate, the pie. If the optional parameter test_data is given, the program evaluates after each trainer ⽹ Collateral and print out part of the progress. This is great for tracking progress. , but rather slow grasping ⾏ Speed.

During each iteration, it ⾸ Randomly scramble the training data and then break it up into several appropriate groups. The & # 12073; The & # 12073; Batch data. This is the & # 12032; A simple random sampling from training data ⽅ Method. And then for every ⼀ mini_batch we should ⽤ The & # 12032; Subgradient descent. This is done with the code self.es62EN_ES63en_ES64en (mini_batch, eta), which just makes ⽤ Training data in mini_batch, updated according to iteration of single gradient descent ⽹ Weights and offsets of collaterals. This is update_mini_batch & # 12101; Code of law:

def update_mini_batch(self, mini_batch, eta):
"""Update the network's weights and biases by applying
gradient descent using backpropagation to a single mini batch.
The "mini_batch" is a list of tuples "(x, y)", and "eta"
is the learning rate."""
nabla_b = [np.zeros(b.shape) for b in self.biases]
nabla_w = [np.zeros(w.shape) for w in self.weights]
for x, y in mini_batch:
delta_nabla_b, delta_nabla_w = self.backprop(x, y)
nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
self.weights = [w-(eta/len(mini_batch))*nw
for w, nw in zip(self.weights, nabla_w)]
self.biases = [b-(eta/len(mini_batch))*nb
for b, nb in zip(self.biases, nabla_b)]

The & # 12068; Part of the & # 12079; Made by the & # 12175; Code completion:

delta_nabla_b, delta_nabla_w = self.backprop(x, y)

The & # 12175; The & # 12132; The & # 12032; An algorithm called back propagation, ⼀ A kind of quick calculation of the gradient of cost function ⽅ Method. So update_mini_batch ⼯ Do only for each ⼀ in mini_batch; The gradient was calculated for the training samples, and then the self.weights and ES87en.biases were updated appropriately. I won't list the code for ES89en.backprop now. We'll learn how back propagation works in the next chapter. Do, including self.backprop code. Now, suppose it does what we want. To return the appropriate gradient of the cost associated with the training sample x

Complete program

"""
network.py
~~~~~~~~~~
 
A module to implement the stochastic gradient descent learning
algorithm for a feedforward neural network. Gradients are calculated
using backpropagation. Note that I have focused on making the code
simple, easily readable, and easily modifiable. It is not optimized,
and omits many desirable features.
"""
 
#### Libraries
# Standard library
import random
 
# Third-party libraries
import numpy as np
 
class Network(object):
 
 def __init__(self, sizes):
  """The list ``sizes`` contains the number of neurons in the
  respective layers of the network. For example, if the list
  was [2, 3, 1] then it would be a three-layer network, with the
  first layer containing 2 neurons, the second layer 3 neurons,
  and the third layer 1 neuron. The biases and weights for the
  network are initialized randomly, using a Gaussian
  distribution with mean 0, and variance 1. Note that the first
  layer is assumed to be an input layer, and by convention we
  won't set any biases for those neurons, since biases are only
  ever used in computing the outputs from later layers."""
  self.num_layers = len(sizes)
  self.sizes = sizes
  self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
  self.weights = [np.random.randn(y, x)
      for x, y in zip(sizes[:-1], sizes[1:])]
 
 def feedforward(self, a):
  """Return the output of the network if ``a`` is input."""
  for b, w in zip(self.biases, self.weights):
   a = sigmoid(np.dot(w, a)+b)
  return a
 
 def SGD(self, training_data, epochs, mini_batch_size, eta,
   test_data=None):
  """Train the neural network using mini-batch stochastic
  gradient descent. The ``training_data`` is a list of tuples
  ``(x, y)`` representing the training inputs and the desired
  outputs. The other non-optional parameters are
  self-explanatory. If ``test_data`` is provided then the
  network will be evaluated against the test data after each
  epoch, and partial progress printed out. This is useful for
  tracking progress, but slows things down substantially."""
  if test_data: n_test = len(test_data)
  n = len(training_data)
  for j in xrange(epochs):
   random.shuffle(training_data)
   mini_batches = [
    training_data[k:k+mini_batch_size]
    for k in xrange(0, n, mini_batch_size)]
   for mini_batch in mini_batches:
    self.update_mini_batch(mini_batch, eta)
   if test_data:
    print "Epoch {0}: {1} / {2}".format(
     j, self.evaluate(test_data), n_test)
   else:
    print "Epoch {0} complete".format(j)
 
 def update_mini_batch(self, mini_batch, eta):
  """Update the network's weights and biases by applying
  gradient descent using backpropagation to a single mini batch.
  The ``mini_batch`` is a list of tuples ``(x, y)``, and ``eta``
  is the learning rate."""
  nabla_b = [np.zeros(b.shape) for b in self.biases]
  nabla_w = [np.zeros(w.shape) for w in self.weights]
  for x, y in mini_batch:
   delta_nabla_b, delta_nabla_w = self.backprop(x, y)
   nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
   nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
  self.weights = [w-(eta/len(mini_batch))*nw
      for w, nw in zip(self.weights, nabla_w)]
  self.biases = [b-(eta/len(mini_batch))*nb
      for b, nb in zip(self.biases, nabla_b)]
 
 def backprop(self, x, y):
  """Return a tuple ``(nabla_b, nabla_w)`` representing the
  gradient for the cost function C_x. ``nabla_b`` and
  ``nabla_w`` are layer-by-layer lists of numpy arrays, similar
  to ``self.biases`` and ``self.weights``."""
  nabla_b = [np.zeros(b.shape) for b in self.biases]
  nabla_w = [np.zeros(w.shape) for w in self.weights]
  # feedforward
  activation = x
  activations = [x] # list to store all the activations, layer by layer
  zs = [] # list to store all the z vectors, layer by layer
  for b, w in zip(self.biases, self.weights):
   z = np.dot(w, activation)+b
   zs.append(z)
   activation = sigmoid(z)
   activations.append(activation)
  # backward pass
  delta = self.cost_derivative(activations[-1], y) * \
   sigmoid_prime(zs[-1])
  nabla_b[-1] = delta
  nabla_w[-1] = np.dot(delta, activations[-2].transpose())
  # Note that the variable l in the loop below is used a little
  # differently to the notation in Chapter 2 of the book. Here,
  # l = 1 means the last layer of neurons, l = 2 is the
  # second-last layer, and so on. It's a renumbering of the
  # scheme in the book, used here to take advantage of the fact
  # that Python can use negative indices in lists.
  for l in xrange(2, self.num_layers):
   z = zs[-l]
   sp = sigmoid_prime(z)
   delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
   nabla_b[-l] = delta
   nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
  return (nabla_b, nabla_w)
 
 def evaluate(self, test_data):
  """Return the number of test inputs for which the neural
  network outputs the correct result. Note that the neural
  network's output is assumed to be the index of whichever
  neuron in the final layer has the highest activation."""
  test_results = [(np.argmax(self.feedforward(x)), y)
      for (x, y) in test_data]
  return sum(int(x == y) for (x, y) in test_results)
 
 def cost_derivative(self, output_activations, y):
  """Return the vector of partial derivatives \partial C_x /
  \partial a for the output activations."""
  return (output_activations-y)
 
#### Miscellaneous functions
def sigmoid(z):
 """The sigmoid function."""
 return 1.0/(1.0+np.exp(-z))
 
def sigmoid_prime(z):
 """Derivative of the sigmoid function."""
 return sigmoid(z)*(1-sigmoid(z))

"""
mnist_loader
~~~~~~~~~~~~
 
A library to load the MNIST image data. For details of the data
structures that are returned, see the doc strings for ``load_data``
and ``load_data_wrapper``. In practice, ``load_data_wrapper`` is the
function usually called by our neural network code.
"""
 
#### Libraries
# Standard library
import cPickle
import gzip
 
# Third-party libraries
import numpy as np
 
def load_data():
 """Return the MNIST data as a tuple containing the training data,
 the validation data, and the test data.
 
 The ``training_data`` is returned as a tuple with two entries.
 The first entry contains the actual training images. This is a
 numpy ndarray with 50,000 entries. Each entry is, in turn, a
 numpy ndarray with 784 values, representing the 28 * 28 = 784
 pixels in a single MNIST image.
 
 The second entry in the ``training_data`` tuple is a numpy ndarray
 containing 50,000 entries. Those entries are just the digit
 values (0...9) for the corresponding images contained in the first
 entry of the tuple.
 
 The ``validation_data`` and ``test_data`` are similar, except
 each contains only 10,000 images.
 
 This is a nice data format, but for use in neural networks it's
 helpful to modify the format of the ``training_data`` a little.
 That's done in the wrapper function ``load_data_wrapper()``, see
 below.
 """
 f = gzip.open('../data/mnist.pkl.gz', 'rb')
 training_data, validation_data, test_data = cPickle.load(f)
 f.close()
 return (training_data, validation_data, test_data)
 
def load_data_wrapper():
 """Return a tuple containing ``(training_data, validation_data,
 test_data)``. Based on ``load_data``, but the format is more
 convenient for use in our implementation of neural networks.
 
 In particular, ``training_data`` is a list containing 50,000
 2-tuples ``(x, y)``. ``x`` is a 784-dimensional numpy.ndarray
 containing the input image. ``y`` is a 10-dimensional
 numpy.ndarray representing the unit vector corresponding to the
 correct digit for ``x``.
 
 ``validation_data`` and ``test_data`` are lists containing 10,000
 2-tuples ``(x, y)``. In each case, ``x`` is a 784-dimensional
 numpy.ndarry containing the input image, and ``y`` is the
 corresponding classification, i.e., the digit values (integers)
 corresponding to ``x``.
 
 Obviously, this means we're using slightly different formats for
 the training data and the validation / test data. These formats
 turn out to be the most convenient for use in our neural network
 code."""
 tr_d, va_d, te_d = load_data()
 training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]
 training_results = [vectorized_result(y) for y in tr_d[1]]
 training_data = zip(training_inputs, training_results)
 validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
 validation_data = zip(validation_inputs, va_d[1])
 test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]
 test_data = zip(test_inputs, te_d[1])
 return (training_data, validation_data, test_data)
 
def vectorized_result(j):
 """Return a 10-dimensional unit vector with a 1.0 in the jth
 position and zeroes elsewhere. This is used to convert a digit
 (0...9) into a corresponding desired output from the neural
 network."""
 e = np.zeros((10, 1))
 e[j] = 1.0
 return e

class Network(object):
def __init__(self, sizes):
self.num_layers = len(sizes)
self.sizes = sizes
self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
self.weights = [np.random.randn(y, x)
for x, y in zip(sizes[:-1], sizes[1:])]

0

The original English view: http: / / neuralnetworksanddeeplearning com/chap1 html