如何使用python實現識別手寫MNIST數字集的程序

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

我們需要做的第?件事情是獲取 MNIST 數據。如果你是?個 git ??，那么你能夠通過克隆這本書的代碼倉庫獲得數據，實現我們的?絡來分類數字

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 包含各層神經元的數量。例如，如果我們想創建?個在第?層有2 個神經元，第?層有 3 個神經元，最后層有 1 個神經元的 Network 對象，我們應這樣寫代碼：

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

Network 對象中的偏置和權重都是被隨機初始化的，使? Numpy 的 np.random.randn 函數來?成均值為 0，標準差為 1 的?斯分布。這樣的隨機初始化給了我們的隨機梯度下降算法?個起點。在后?的章節中我們將會發現更好的初始化權重和偏置的?法，但是?前隨機地將其初始化。注意 Network 初始化代碼假設第?層神經元是?個輸?層，并對這些神經元不設置任何偏置，因為偏置僅在后?的層中?于計算輸出。有了這些，很容易寫出從?個 Network 實例計算輸出的代碼。我們從定義 S 型函數開始：

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

注意，當輸? z 是?個向量或者 Numpy 數組時，Numpy ?動地按元素應? sigmoid 函數，即以向量形式。

我們然后對 Network 類添加?個 feedforward ?法，對于?絡給定?個輸? a，返回對應的輸出 6 。這個?法所做的是對每?層應??程 (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

當然，我們想要 Network 對象做的主要事情是學習。為此我們給它們?個實現隨即梯度下降算法的 SGD ?法。代碼如下。其中?些地?看似有?點神秘，我會在代碼后?逐個分析

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

在每個迭代期，它?先隨機地將訓練數據打亂，然后將它分成多個適當??的?批量數據。這是?個簡單的從訓練數據的隨機采樣?法。然后對于每?個 mini_batch我們應??次梯度下降。這是通過代碼 self.update_mini_batch(mini_batch, eta) 完成的，它僅僅使? mini_batch 中的訓練數據，根據單次梯度下降的迭代更新?絡的權重和偏置。這是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)

這?調?了?個稱為反向傳播的算法，?種快速計算代價函數的梯度的?法。因此update_mini_batch 的?作僅僅是對 mini_batch 中的每?個訓練樣本計算梯度，然后適當地更新 self.weights 和 self.biases 。我現在不會列出 self.backprop 的代碼。我們將在下章中學習反向傳播是怎樣?作的，包括self.backprop 的代碼。現在，就假設它按照我們要求的?作，返回與訓練樣本 x 相關代價的適當梯度

完整的程序

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

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