实现我们的神经网络来识别数字
好吧，让我们一个程序，学习如何使用随机梯度下降算法和MNIST的训练数据识别手写数字。我们将使用一个小Python(2.7)程度来做，仅和有74行代码！第一件事情是我们需要获取MNIST上的数据。如果你是git上的用户，那么你可以通过克隆本书的这个代码库来得到数据，
git clone https://github.com/mnielsen/neural-networks-and-deep-learning.git
如果你不是git上的用户，那你可以从这里下载数据和代码。
顺便说一下，早些时候我描述MNIST上的数据，说得是它分为60,000个训练图片和10,000个测试图片。这是MNIST官方的描述。实际上，我们要拆分数据的方式会有一点不同。我们将保留测试数据不变，但将60,000个MNIST训练数据集分为两部分：一部分是50,000个图片，用来训练神经网络，和单独的10,000个图片做为校验数据集。我们不会在本章用到这个校验数据集，但在本书的后面，我们会发现它对找出怎样设置某些神经网络的超参数——像学习率，诸如此类不是由学习算法直接选取。尽管校验数据不是原来MNIST声明里的部分，有许多人照这个样子使用MNIST，并且在神经网络里使用校验数据是很普遍的。从现在开始当我提到“MNIST训练数据”时，我指的是50,000个图片的数据集，而不是原生的60,000个图片的数据集。【正如前面提到的，MNIST的数据集是基于NIST(美国国家标准与技术研究院)收集的两个数据集。为了构建MNIST，NIST的数据集被拆开并被Yann LeCun, Corinna Cortes和Christopher J. C. Burges改成一种更便利的格式。详情请查看这个链接。在我的库里的数据集是一种容易在Python里被加载和操作的MNIST数据集格式。我是从蒙特利尔大学的LISA机器学习实验室里获取的这种特殊的数据格式。（链接）】
除了MNIST的数据，我们还需要一个叫做Numpy的Python库，来做快速的线性代数运算。如果你还没有安装Numpy，你可以从这里获取。
在给出完整的清单前，下面我解释一下神经网络代码的核心特征。核心是一个Network类，用来表示一个神经网络。这里的代码是用来初始化一个Network对象：
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列表包含着各层神经元的数量。所以，举个例子，如果我们要创建一个第一层有两个神经元，第二层有3个神经元，最后一层有1个神经元的Network对象，我们需要用这样的代码来实现：
net = Network([2, 3, 1])
在Network对象里的偏移量和权重都是被初始化成随机值的，使用的是Numpy的np.random.randn 函数生成算术平均值是0并且标准差是1的高斯分布。这里的随机初始化给我们的随机梯度下降算法一个开始的位置。在后面的章节我们会找到更好的方式来初始化权重和偏移量，但目前还是要这样做。注意Network初始化代码假设神经网络的第一层是输入层，并省略了对这些神经元的偏移量的设置，因此偏移量只是被用在后面网络层的输出计算里。
也要注意权重和偏移量被存成Numpy的矩阵列表。所以，举例来说，net.weights[1]是一个存着连接第二和第三网络层权重的Numpy矩阵。（不是第一和第二层，因为Python列表的索引是从0开始的。）因为net.weights[1]太啰嗦了，让我们用来表示矩阵。像这样的矩阵代表连接第二层里个神经元到第三层的个神经元间的权重。这里的j和k索引的顺序可能看起来有点奇怪——交换j和k索引真的更有意义？使用这种排序的最大好处是它让第三层神经网络激活向量变成这样：
在这个方程式里有一些演进，所以让我们一点一点的拆开。是第二层神经元的激活向量。为了获取，我们用乘以权重矩阵，再加上偏移向量。然后执行函数，元素自动对应向量里的每一个项。（这叫做函数的向量化）很容易验证公式(22)像我们之前的规则公式（4）一样，计算Sigmoid神经元的输出时，会给出相同的结果。
练习
- 写出公式(22)的组件形式，并证明它和规则(4)一样在计算Sigmoid神经元的输出有相同的结果。
综上所述，很容易编写代码计算Network实例输出。我们从定义Sigmoid函数开始：
def sigmoid(z):
return 1.0/(1.0+np.exp(-z))
注意当输入z是一个向量或Numpy数组，Numpy自动按元素执行Sigmoid函数，也就是向量形式。
然后在Network类里加一个feedforward方法，给网络一个输入a，返回相应的输出【假设输入a是一个(n,1)的Numpy的ndarray，不是一个(n,)向量。这里，n是网络输入的数量。如果你尝试使用一个(n,)向量作为输入，你将得到诡异的结果。虽然使用一个(n,)向量可以呈现更多自然的选择，但使用一个(n, 1)ndarray可以特别简单的修改代码，一次前向传播多个输入，这有时很方便】。
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是一个tuples(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对应的成本梯度。
让我们看一下整个生育，包括之前忽略的注释。self.backprop程序的部分自己已说明了——所有的重担都落在self.SGD和self.update_min_bat里，这些我们讨论过。self.backprop方法使用了一些额外的函数来帮助梯度的计算，也就是，sigmoid_prime——计算函数的导数，self.cost_derivative这里我们暂不描述。你可以通过查看代码和注释来了解其思想（和细节）。我们将在下一章详细的看一下。注意虽然代码看起来挺长，但大部分代码是注释用来让代码更好被理解。实际上，非空行和注释的代码只有74行。所有的代码可以在GitHub上的这里获取。
"""
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数据开始。我将用一点辅助代码mnist_loader.py，在下面进行描述。我们在Python Shell里执行下面命令，
>>> import mnist_loader
>>> training_data, validation_data, test_data = \
... mnist_loader.load_data_wrapper()
当然，也可以用一个单独的Python程序来实现，但你按照用Python Shell的方式可能会更容易一点。
下载完MNIST数据后，我们用30个隐藏神经元来搭建一个Network。在引入上面叫做network的python程序后，就可以做了，
>>> import network
>>> net = network.Network([784, 30, 10])
最终，我们使用随机梯度下降算法从MNIST的training_data学习30代，其中小批次的大小是10，学习率。
>>> net.SGD(training_data, 30, 10, 3.0, test_data=test_data)
注意如果你在读代码时运行代码，将需要一些时间——对于一台典型的机器(到2015年为止)将差不多需要花费几分钟。建议你让代码跑着，继续读，并不时的检查代码的输出。如你心急的话，可以代数，减少隐藏神经元的数量，或只用部分训练数据，来加快运行速度。注意生产代码会非常非常快：这些Python脚本是帮助你理解神经网络是如何工作的，并不是高性能的代码！而且，当然，一旦我们好一个网络后，它将在大多数平台上运行的非常快。例如，一旦我们为一个网络学到了一组好的权重和偏移量，它可以很容易被移植到web浏览器的JavaScript里，或者移动设备里的原生app里。无论如何，这里是训练神经网络的部分输出。文字显示出每代训练完后神经网络识别出正确的测试图片的数量。如你所见，只是一代后就在中达到了，并且数字还在继续增长，
Epoch 0: 9129 / 10000
Epoch 1: 9295 / 10000
Epoch 2: 9348 / 10000
...
Epoch 27: 9528 / 10000
Epoch 28: 9542 / 10000
Epoch 29: 9534 / 10000
也就是说，训练的网络给出了95%的分类率——第28代说的是95.42%！这对第一次尝试来相当鼓舞人心。我需要警告你，尽管运行的代码一样，但结果不必和我的相同，因为初始化网络时用了(不同)随机的权重和偏移量。为了生成本章的结果，我取了三个中最好的。
让我们回到上面的试验，将隐藏神经元的数量改为100.像之前的情况一样，如果你一边运行一边读代码，需要警告你一下，这将花很长的一段时间（在我的机器这个试验的每一代要用10秒钟），所以代码运行的时候继续读是很明智的。
>>> net = network.Network([784, 100, 10])
>>> net.SGD(training_data, 30, 10, 3.0, test_data=test_data)
果然，结果提升到了。至少在这个例子里，使用更多的隐藏神经元帮助我们得到更好的结果【读者的反馈表明这个实验的结果有很大的不同，并且一些训练的结果更糟。使用第3章介绍的技术将显著减小我们网络在不同训练下的差异】。
当然，为了获取这些准确度我不得做特殊的选择，训练的代数、小批次大小，学习率。像我上面提及的，这些是我们网络的超参数，为了和通过我们的学习算法学到的参数（权重和偏移量）进行区分。如果我们选择的超参数不好，我们将得到不好的结果。假设，例如我们选择学习率是，
>>> net = network.Network([784, 100, 10])
>>> net.SGD(training_data, 30, 10, 0.001, test_data=test_data)
结果就不是那么另人鼓舞了，
Epoch 0: 1139 / 10000
Epoch 1: 1136 / 10000
Epoch 2: 1135 / 10000
...
Epoch 27: 2101 / 10000
Epoch 28: 2123 / 10000
Epoch 29: 2142 / 10000
但是，你可以看到网络的性能随着时间推移超来超好。这就意味着需要提高学习率，比如说。如果这样做的话，将得到比较好的结果，然后再提高一下学习率。（如果改变能提升性能，那就再做一次！）如果我们这样做了很多次，我们会将学习率终止于差不多(或者微调至)，这就和我们的之前的试验很接近了。所以即使我们一开始用了差的超参数，我们至少能获取足够的信息去提升它们。
通常，调试一个神经网络是一项挑战。尤其是当初始的超参数生成的结果还不如随机噪声好。假设我们之前成功的30个隐藏神经元的网络架构，但将学习率改成：
>>> net = network.Network([784, 30, 10])
>>> net.SGD(training_data, 30, 10, 100.0, test_data=test_data)
这点就确实有点过了，学习率太高了：
Epoch 0: 1009 / 10000
Epoch 1: 1009 / 10000
Epoch 2: 1009 / 10000
Epoch 3: 1009 / 10000
...
Epoch 27: 982 / 10000
Epoch 28: 982 / 10000
Epoch 29: 982 / 10000
现在想像一下第一次遇到这个的问题。当然，我们知道根据之前的试验，我们应该减小学习率。但如果是第一次遇到这个问题的话，并没有太多的结果指导我们应该怎样去做。我们可能不只是怀疑学习率，还有我们神经网络其他的每一部分。我们可能会想是不是初始化权重和偏移量的方式让网络学习很困难？或者可能是我们没有足够的训练数据去做有意义的学习？也许我们没有跑跃然的代数？或者用这样的神经网络架构去学习识别手写体数字是不太现实的？可能是学习率太低了？或者也可能是学习率太高了？当你第一次遇到一个问题的时候，你总是很不确定。
从中我们可以学到调试神经网络不是一件简单的事情，并且，像平常的编程一样，这是一门艺术。你需要学习这项神经网络调优技术。更普遍的说，我们需要开发一种启动式算法来选择好的超参数和架构。我们会在本书中详细讨论这些问题，包括我是怎样选择上面超参数的。
练习
- 尝试创建一个只有两层的网络——一个输入层和一个输出层，没有隐含层——分别有784和10个神经元。使用随机梯度下降算法训练网络。你能达到多少分类准确率？
之前，我跳过了下载MNIST数据的细节。它十分地简单。完整起见，这是代码。存储MNIST数据的数据结构在注释里有说明——都是简单的结构，元组和Numpy ndarray对象的列表（如果你对ndarray不是很熟悉的话，你可以把它们想像成向量）：
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
我上面说过我们的程序得到了很好的结果。这是什么意思呢？好又是相对于什么来说的呢？有一些简单的(非神经网络)基准测试可以比较，来理解它的优越性。最简单的基准当然是随机猜数字。每次有十分之一的机会是对的。我们比这好太多了！
对于不是特别简单的基准呢？让我们尝试一个特别简单的想法：我们查看图片黑暗程序。举例来说 ，典型的数字2的图片要比数字1的暗一点，只是因为更多的像素是暗的，就像下面的样例展示的那样：
这表明用训练数据来计算到每个数字灰度值的平均数。当拿到一张新图片时，我们计算它的灰度值，看跟哪一个数字更加接近。过程很简单，编码也很容易，所以我就不展示代码了——如果感兴趣可以在GitHub仓库里获取。不过相对于随机猜数有很大的提升，张测试图片对了，也就是说，的准确率。
找到其他准确率在20-50%范围的方案也不是难事。再努力一点可以超过50%。但想得到更高的准确率就需要已有的机器学习算法。让我们尝试一个已知最好的算法，支持向量机(support vector machine)或叫SVM。如果你对SVM不是很熟，也不要担心，我们不用理解SVM的工作细节。反而，我们将使用一个叫scikit-learn的Python库，它提供了一个简单的Python接口去调用一个快速的基于C的SVM库，称为LIBSVM。
如果使用默认配置运行scikit-learn的SVM分类器的话，张测试图片有张是正确的。（代码在这里）这比朴素的基于图片灰度的分类算法有巨大的提升。的确，SVM和我们的神经网络性能差不多，只是差一丁点。在后面的章节，我们将介绍新的技术，能提升我们的神经网络，将比SVM好很多。
尽管这样，但事情还没有结束。对于SVM的结果是scikit-learn的默认配置。SVM有许多可调参数，可以搜索那些可以提升这开箱即用的性能。我不会明确的去搜索这些参数 ，但如果你想了解更多的话，可以看Andreas Mueller的这篇博客。Mueller展示了通过优化SVM参数可以将性能提升到以上的准确率。换句话说，一个调试良好的SVM在个数字中只会错一个。这相当的好了！神经网络能做的更好吗？
实际上，完全可以。目前，精心设计的神经网络比每一种其他解决MNIST的技术，包括SVM。当前(2013)的纪录为图片的分类正确率。这项工作的作者是Li Wan, Matthew Zeiler, Sixin Zhang, Yann LeCun, 和 Rob Fergus。我们可以书的后面看到大部分他们用到的技术。在这种程度上很接近人类水平，可以说更好，因为有一小部分MNIST图片即使是人来识别也是很困难的，比如：
我相信你也同意它们很难分类！值得注意的是，在MNIST数据集里类似这样的图片，神经网络可以对中所有的张图片进行准确分类。通常，编程的时候我们相信解决向识别MNIST数字的问题需要一个复杂的算法。但即使是Wan et al paper里的神经网络也只用了相当简单的算法，算法的变化我们已经在本章见过了。最复杂的就是从训练数据里自动地进行学习。在某种意义上，所有我们结果的理念和那些复杂论文里，对于某些问题是这样的：
复杂算法 简单学习算法 + 好的训练数据。