用神经网络分类数字代码

代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import random
import cPickle
import gzip
import numpy as np 

class Network(object):

    def __init__(self, sizes):
        self.num_layers = len(sizes)
        self.sizes = sizes
        """
        1. np.random.randn函数来生成均值为0，标准差为1的高斯分布
        2. zip()
            x = [1, 2, 3]
            y = [4, 5, 6]
            z = zip(x, y)
            print z
            [(1, 4), (2, 5), (3, 6)]
        """
        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:])]

        #print self.biases
        #print sizes
        #print zip(sizes[:-1], sizes[1:])
        #print self.weights

    def feedforward(self, a):
        for b, w in zip(self.biases, self.weights):
            a = sigmoid(np.dot(w, a) + b)
        return a

    # 随机梯度下降
    """
    training_data是一个代表着训练输入和对应的期望输出的元组（x,y）的列表。
    epochs和mini_batch_size是你期望的训练的迭代次数和取样时所用的mini-batch块的大小。
    eta是学习率 η。
    如果可选参数test_data被提供，那么程序将会在每次训练迭代之后评价网络，并输出我们的局部进展。
    """
    def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):
        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):
        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)

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

# 求导
def sigmoid_prime(z):
    return sigmoid(z)*(1-sigmoid(z))

def load_data():
    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 vectorized_result(j):
    e = np.zeros((10, 1))
    e[j] = 1.0
    return e

def load_data_wrapper():
    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)

training_data, validation_data, test_data = load_data_wrapper()
net = Network([784, 30, 10])
net.SGD(training_data, 30, 10, 3.0, test_data=test_data)

运行结果

Epoch 0: 9093 / 10000
Epoch 1: 9239 / 10000
Epoch 2: 9253 / 10000
Epoch 3: 9354 / 10000
Epoch 4: 9375 / 10000
Epoch 5: 9369 / 10000
Epoch 6: 9411 / 10000
Epoch 7: 9408 / 10000
Epoch 8: 9426 / 10000
Epoch 9: 9396 / 10000
Epoch 10: 9380 / 10000
Epoch 11: 9436 / 10000
Epoch 12: 9455 / 10000
Epoch 13: 9491 / 10000
Epoch 14: 9462 / 10000
Epoch 15: 9473 / 10000
Epoch 16: 9453 / 10000
Epoch 17: 9461 / 10000
Epoch 18: 9472 / 10000
Epoch 19: 9498 / 10000
Epoch 20: 9431 / 10000
Epoch 21: 9474 / 10000
Epoch 22: 9460 / 10000
Epoch 23: 9463 / 10000
Epoch 24: 9459 / 10000
Epoch 25: 9471 / 10000
Epoch 26: 9461 / 10000
Epoch 27: 9479 / 10000
Epoch 28: 9485 / 10000
Epoch 29: 9448 / 10000

参考

• https://hit-scir.gitbooks.io/neural-networks-and-deep-learning-zh_cn/content/chap1/c1s6.html
• https://github.com/mnielsen/neural-networks-and-deep-learning.git