神经网络代码识别手写字（python3.4.3版本）

神经网络代码如下：

#coding = utf-8
"""
network.py
"""
import random   
import numpy as np  

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

def sigmoid_prime(z):  
    return sigmoid(z)*(1 - sigmoid(z))  


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:])]  

    def feedforward(self, a):   
        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):  
        if test_data: n_test = len(test_data)  
        n = len(training_data)  
        for j in range(epochs):  
            random.shuffle(training_data)  
            mini_batches = [training_data[k:k+mini_batch_size] for k in range(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):  
        nabla_b = [np.zeros(b.shape) for b in self.biases]  
        nabla_w = [np.zeros(w.shape) for w in self.weights]   
        activation = x  
        activations = [x]  
        zs = [] 
        for b, w in zip(self.biases, self.weights):  
            z = np.dot(w, activation)+b  
            zs.append(z)  
            activation = sigmoid(z)  
            activations.append(activation)    
        delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])  
        nabla_b[-1] = delta  
        nabla_w[-1] = np.dot(delta, activations[-2].transpose())   
        for l in range(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):    
        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 (output_activations-y)  

加载数据即代码：

import sys
import importlib
importlib.reload(sys)
import pickle
import gzip

import numpy as np

def load_data():

    f = gzip.open('/ysk/code/python/neural-networks-and-deep-learning/data/mnist.pkl.gz', 'rb') 
    #路径填写自己安放数据集的路径
    training_data, validation_data, test_data = pickle.load(f, encoding = "iso-8859-1") 
    f.close()
    return (training_data, validation_data, test_data)

def load_data_wrapper():

    tr_d, va_d, te_d = load_data()

    #training_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_data
    validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]
    validation_data = zip(validation_inputs, va_d[1])

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

终端执行的代码如下：

import mnist_loader
import network,
import random
import numpy as np

training_data, valid_data, test_data = mnist_loader.load_data_wrapper()
net = network.Network([784, 30, 10])
net.SGD(list(training_data), 30, 10, 3, test_data = list(test_data))

相对于最初python2版本的源码，python3代码除了几处模块名之外，数据集使用的时候不能直接使用元组，要利用list函数将元组转化为列表。

这是最初版本的代码，对参数的设置都是使用随机的方式，并且可以看出来，效果并不是太好，因为梯度下降会出现过度的现象．代码使用的代价函数为误差平方，这会导致运行的速度受斜率的影响，后面引入的交叉熵代价函数会改善此现象．总体能达到95%左右的正确率．