神经网络实现简单的手写数字识别

使用74行python代码实现简单的手写数字识别神经网络。 输出值为10000个测试样本中识别正确的图像数量。

“““
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 50000 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 50000 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 10000 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 50000
    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 10000
    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_

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件    17051982  2016-11-12 12:49  data\mnist.pkl.gz
     文件        3480  2017-08-18 15:09  mnist_loader.py
     文件        6449  2017-08-18 15:36  network.py
     文件         199  2017-08-18 16:26  recognize.py
     目录           0  2017-08-18 15:09  data\