一、神经网络算法

1.多层向前神经网络(Multilayer Feed-Forward Neural Network)

Backpropagation被使用在多层向前神经网络上

多层向前神经网络由以下部分组成：输入层(input layer),隐藏层(hidden layers),输入层(output layers)，每层由单元(units)组成。

输入层(input layer)是由训练集的实例特征向量传入，经过连接结点的权重(weight)传入下一层，一层的输出是下一层的输入，隐藏层的个数可以是任意的，输入层有一层，输出层有一层，每个单元(unit)也可以被称作神经结点,根据生物学来源定义，一层中加权的求和，然后根据非线性方程转化输出。作为多层向前神经网络，理论上，如果有足够多的隐藏层(hidden layers) 和足够大的训练集,可以拟出任何方程 。

2.利用 Backpropagation算法来设计神经网络
（1）通过迭代性的来处理训练集中的实例
（2）对比经过神经网络后输入层预测值(predicted value)-与真实值(target value)之间
（3）反方向(从输 出层=>隐藏层=>输入层)来以最小化误差(error)来更新每个连接的权重(weight)
（4）算法详细介绍
输入: D:数据集，1学习率(learning rate)，一 个多层前向神经网络
输入: 一个训练好的神经网络(a trained neural network)
4.1初始化权重(weights)和偏向(bias):随机初始化在-1到1之间，或者-0.5到0.5之间，每个单元有
一个偏向
4.2对于每一个训练实例X，执行以下步骤:
4.3由输入层向前传送

4.4根据误差（erro)反向传送

输出层：

Ej = Oj(1-Oj)(Tj-Oj)     Oj为计算值，Tj为真实值，Ej为每层误差

隐藏层：

Ej = Oj(1-Oj)

权重更新：

偏向更新：

（5）终止条件
5.1 权重的更新低于某个阈值
5.2预测的错误率低于某个阈值
5.3达到预设一定的循环次数

import numpy as np


def tanh(x):#双曲线函数
    return np.tanh(x)


def tanh_deriv(x):#双曲线函数的导数
    return 1.0 - np.tanh(x)*np.tanh(x)


def logistic(x):#逻辑函数
    return 1/(1 + np.exp(-x))


def logistic_derivative(x):#逻辑函数的导数
    return logistic(x)*(1-logistic(x))


class NeuralNetwork:#定义了一个关于神经网络的算法类
    def __init__(self, layers, activation='tanh'):#构造函数
        """
        :param layers: A list containing the number of units in each layer.
        Should be at least two values
        :param activation: The activation function to be used. Can be
        "logistic" or "tanh"
        """
        if activation == 'logistic':#判断所使用函数的类型
            self.activation = logistic
            self.activation_deriv = logistic_derivative
        elif activation == 'tanh':
            self.activation = tanh
            self.activation_deriv = tanh_deriv

        self.weights = []#定义了一个自身的权重
        for i in range(1, len(layers) - 1):
            self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25)
            self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25)

    def fit(self, X, y, learning_rate=0.2, epochs=10000):#设定epochs为循环的最高次数，即到最高时就直接结束循环
        X = np.atleast_2d(X)#将X转换为NUMPY包下的二维数组
        temp = np.ones([X.shape[0], X.shape[1]+1])#最后的+1为偏向所在列
        temp[:, 0:-1] = X  # adding the bias unit to the input layer
        X = temp
        y = np.array(y)

        for k in range(epochs):#k在第几次的循环中
            i = np.random.randint(X.shape[0])
            a = [X[i]]

            for l in range(len(self.weights)):  #going forward network, for each layer
                a.append(self.activation(np.dot(a[l], self.weights[l])))  #Computer the node value for each layer (O_i) using activation function
            error = y[i] - a[-1]  #Computer the error at the top layer
            deltas = [error * self.activation_deriv(a[-1])] #For output layer, Err calculation (delta is updated error)

            #Staring backprobagation
            for l in range(len(a) - 2, 0, -1): # we need to begin at the second to last layer
                #Compute the updated error (i,e, deltas) for each node going from top layer to input layer

                deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))
            deltas.reverse()
            for i in range(len(self.weights)):
                layer = np.atleast_2d(a[i])
                delta = np.atleast_2d(deltas[i])
                self.weights[i] += learning_rate * layer.T.dot(delta)

    def predict(self, x):
        x = np.array(x)
        temp = np.ones(x.shape[0]+1)
        temp[0:-1] = x
        a = temp
        for l in range(0, len(self.weights)):
            a = self.activation(np.dot(a, self.weights[l]))
        return a#返回输出层
复制

二、调用已经写好的神经网络的类实现一个识别手写数字的应用

# 每个图片8x8  识别数字：0,1,2,3,4,5,6,7,8,9

import numpy as np
from sklearn.datasets import load_digits
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import LabelBinarizer
from NeuralNetwork import NeuralNetwork
from sklearn.model_selection import train_test_split


digits = load_digits()
X = digits.data
y = digits.target
X -= X.min()  # normalize the values to bring them into the range 0-1
X /= X.max()

nn = NeuralNetwork([64, 100, 10], 'logistic')
X_train, X_test, y_train, y_test = train_test_split(X, y)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)
print("start fitting")
nn.fit(X_train, labels_train, epochs=3000)
predictions = []
for i in range(X_test.shape[0]):
    o = nn.predict(X_test[i])
    predictions.append(np.argmax(o))
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))
复制

三、运行结果展示

其中对角线上的数字为正确识别的内容，其他位置不为0的都是识别错误的

 由上图可以看出本次识别的平均准确率高达93%。