详解python实现识别手写MNIST数字集的程序

　　我们需要做的第⼀件事情是获取 MNIST 数据。如果你是⼀个 git ⽤⼾，那么你能够通过克隆这本书的代码仓库获得数据，实现我们的⽹络来分类数字

　　 git clone 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 networks 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 相关代价的适当梯度

　　完整的程序

　　 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 its helpful to modify the format of the ``training_data`` a little. Thats 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 were 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

　　原英文查看：

　　以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。