用神经网络分类数字代码

代码

#!/usr/bin/python# -*- coding: UTF-8 -*-import randomimport cPickleimport gzipimport 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 edef 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 / 10000Epoch 1: 9239 / 10000Epoch 2: 9253 / 10000Epoch 3: 9354 / 10000Epoch 4: 9375 / 10000Epoch 5: 9369 / 10000Epoch 6: 9411 / 10000Epoch 7: 9408 / 10000Epoch 8: 9426 / 10000Epoch 9: 9396 / 10000Epoch 10: 9380 / 10000Epoch 11: 9436 / 10000Epoch 12: 9455 / 10000Epoch 13: 9491 / 10000Epoch 14: 9462 / 10000Epoch 15: 9473 / 10000Epoch 16: 9453 / 10000Epoch 17: 9461 / 10000Epoch 18: 9472 / 10000Epoch 19: 9498 / 10000Epoch 20: 9431 / 10000Epoch 21: 9474 / 10000Epoch 22: 9460 / 10000Epoch 23: 9463 / 10000Epoch 24: 9459 / 10000Epoch 25: 9471 / 10000Epoch 26: 9461 / 10000Epoch 27: 9479 / 10000Epoch 28: 9485 / 10000Epoch 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