如何使用python實(shí)現(xiàn)識(shí)別手寫MNIST數(shù)字集的程序

小編給大家分享一下如何使用python實(shí)現(xiàn)識(shí)別手寫MNIST數(shù)字集的程序，希望大家閱讀完這篇文章之后都有所收獲，下面讓我們一起去探討吧！

我們需要做的第?件事情是獲取 MNIST 數(shù)據(jù)。如果你是?個(gè) git ??，那么你能夠通過克隆這本書的代碼倉庫獲得數(shù)據(jù)，實(shí)現(xiàn)我們的?絡(luò)來分類數(shù)字

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:])]

在這段代碼中，列表 sizes 包含各層神經(jīng)元的數(shù)量。例如，如果我們想創(chuàng)建?個(gè)在第?層有2 個(gè)神經(jīng)元，第?層有 3 個(gè)神經(jīng)元，最后層有 1 個(gè)神經(jīng)元的 Network 對(duì)象，我們應(yīng)這樣寫代碼：

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

Network 對(duì)象中的偏置和權(quán)重都是被隨機(jī)初始化的，使? Numpy 的 np.random.randn 函數(shù)來?成均值為 0，標(biāo)準(zhǔn)差為 1 的?斯分布。這樣的隨機(jī)初始化給了我們的隨機(jī)梯度下降算法?個(gè)起點(diǎn)。在后?的章節(jié)中我們將會(huì)發(fā)現(xiàn)更好的初始化權(quán)重和偏置的?法，但是?前隨機(jī)地將其初始化。注意 Network 初始化代碼假設(shè)第?層神經(jīng)元是?個(gè)輸?層，并對(duì)這些神經(jīng)元不設(shè)置任何偏置，因?yàn)槠脙H在后?的層中?于計(jì)算輸出。有了這些，很容易寫出從?個(gè) Network 實(shí)例計(jì)算輸出的代碼。我們從定義 S 型函數(shù)開始：

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

注意，當(dāng)輸? z 是?個(gè)向量或者 Numpy 數(shù)組時(shí)，Numpy ?動(dòng)地按元素應(yīng)? sigmoid 函數(shù)，即以向量形式。

我們?nèi)缓髮?duì) Network 類添加?個(gè) feedforward ?法，對(duì)于?絡(luò)給定?個(gè)輸? a，返回對(duì)應(yīng)的輸出 6 。這個(gè)?法所做的是對(duì)每?層應(yīng)??程 (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

當(dāng)然，我們想要 Network 對(duì)象做的主要事情是學(xué)習(xí)。為此我們給它們?個(gè)實(shí)現(xiàn)隨即梯度下降算法的 SGD ?法。代碼如下。其中?些地?看似有?點(diǎn)神秘，我會(huì)在代碼后?逐個(gè)分析

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 是?個(gè) (x, y) 元組的列表，表?訓(xùn)練輸?和其對(duì)應(yīng)的期望輸出。變量 epochs 和mini_batch_size 正如你預(yù)料的——迭代期數(shù)量，和采樣時(shí)的?批量數(shù)據(jù)的??。 eta 是學(xué)習(xí)速率，η。如果給出了可選參數(shù) test_data ，那么程序會(huì)在每個(gè)訓(xùn)練器后評(píng)估?絡(luò)，并打印出部分進(jìn)展。這對(duì)于追蹤進(jìn)度很有?，但相當(dāng)拖慢執(zhí)?速度。

在每個(gè)迭代期，它?先隨機(jī)地將訓(xùn)練數(shù)據(jù)打亂，然后將它分成多個(gè)適當(dāng)??的?批量數(shù)據(jù)。這是?個(gè)簡單的從訓(xùn)練數(shù)據(jù)的隨機(jī)采樣?法。然后對(duì)于每?個(gè) mini_batch我們應(yīng)??次梯度下降。這是通過代碼 self.update_mini_batch(mini_batch, eta) 完成的，它僅僅使? mini_batch 中的訓(xùn)練數(shù)據(jù)，根據(jù)單次梯度下降的迭代更新?絡(luò)的權(quán)重和偏置。這是update_mini_batch ?法的代碼：

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)]

?部分?作由這?代碼完成：

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

這?調(diào)?了?個(gè)稱為反向傳播的算法，?種快速計(jì)算代價(jià)函數(shù)的梯度的?法。因此update_mini_batch 的?作僅僅是對(duì) mini_batch 中的每?個(gè)訓(xùn)練樣本計(jì)算梯度，然后適當(dāng)?shù)馗?self.weights 和 self.biases 。我現(xiàn)在不會(huì)列出 self.backprop 的代碼。我們將在下章中學(xué)習(xí)反向傳播是怎樣?作的，包括self.backprop 的代碼?，F(xiàn)在，就假設(shè)它按照我們要求的?作，返回與訓(xùn)練樣本 x 相關(guān)代價(jià)的適當(dāng)梯度

完整的程序

"""
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

# test network.py "cost function square func"
import mnist_loader
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
import network
net = network.Network([784, 10])
net.SGD(training_data, 5, 10, 5.0, test_data=test_data)

看完了這篇文章，相信你對(duì)“如何使用python實(shí)現(xiàn)識(shí)別手寫MNIST數(shù)字集的程序”有了一定的了解，如果想了解更多相關(guān)知識(shí)，歡迎關(guān)注億速云行業(yè)資訊頻道，感謝各位的閱讀！