1、BP神经网络算法应用——简单非线性数据集测试（异或：XOR）

将BP神经网络算法应用（上）写好的NeuralNetwork.py文件与要测试的文件XOC_test.py文件放到同一目录下，并在XOC_test.py文件里面包含NeuralNetwork模块

代码如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

from NeuralNetwork import NeuralNetwork
import numpy as np

#实例化一个神经网络
nn = NeuralNetwork([2,2,1],'tanh')
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0,1,1,0])
nn.fit(X,y)
for i in [[0,0],[0,1],[1,0],[1,1]]:
    print(i,nn.predict(i))

运行结果：每个点以及对应的权重

[0, 0] [ 0.00373644]
[0, 1] [ 0.99822259]
[1, 0] [ 0.99815927]
[1, 1] [-0.02115078]

2、BP神经网络算法应用——手写数字识别

每个图片大小为：8*8，识别数字：0,1,2,3,4,5,6,7,8,9

sk-learn数据包里面有该数据集模块，通过代码查看该数据集的相关信息

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

from sklearn.datasets import load_digits    #加载数字图片数据集
digits = load_digits()
print(digits.data.shape)       #打印该数据集的维度

import pylab as pl
pl.gray()                       #灰度化
pl.matshow(digits.images[0])    #打印出第一张图片
pl.show()

运行结果：

(1797, 64)

表示：该数据集有1797张图片，每张图片采用8*8=64个像素点方式。打印出数据集第一张图片如下：

代码：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

import numpy as np
from sklearn.datasets import load_digits   #手写阿拉伯数字的数据集
from sklearn.metrics import confusion_matrix,classification_report    #混淆矩阵，一种特定的矩阵用来呈现算法性能的可视化效果
from sklearn.preprocessing import LabelBinarizer    #sklearn中每个数字用0,1表示，数字是几，第几位为1，其他位是0
from NeuralNetwork import NeuralNetwork
from sklearn.cross_validation import train_test_split     #交叉验证，分为K份，其中一份为训练集，其他为测试集

digits = load_digits()
X = digits.data        #特征量
y = digits.target      #分类标签
#标准化，时数据在0,1之间
X -= X.min()
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)   #0,1数据类型转化
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])        #测试集中每一行预测其标签为多少，范围在0,1之间
    predictions.append(np.argmax(o))     #取0-9中预测y值（0-1之间的数字）对应最大的数
print(confusion_matrix(y_test,predictions))    #混淆矩阵查看预测正确的数目
print(classification_report(y_test,predictions))    #预测的精确度

运行结果：

start fitting
[[52  0  0  0  0  0  0  0  0  0]
 [ 0 36  0  0  0  1  1  0  8  7]
 [ 0  0 49  0  0  0  0  0  3  0]
 [ 0  0  0 38  0  0  0  0  1  0]
 [ 0  2  0  0 42  0  0  0  0  1]
 [ 0  0  0  0  0 44  0  0  1  1]
 [ 0  0  0  0  0  0 37  0  0  0]
 [ 0  0  0  0  0  0  0 34  0  0]
 [ 0  2  0  0  0  1  0  0 49  0]
 [ 0  0  0  0  0  1  0  0  1 38]]
             precision    recall  f1-score   support

          0       1.00      1.00      1.00        52
          1       0.90      0.68      0.77        53
          2       1.00      0.94      0.97        52
          3       1.00      0.97      0.99        39
          4       1.00      0.93      0.97        45
          5       0.94      0.96      0.95        46
          6       0.97      1.00      0.99        37
          7       1.00      1.00      1.00        34
          8       0.78      0.94      0.85        52
          9       0.81      0.95      0.87        40

avg / total       0.94      0.93      0.93       450

注：第一个矩阵中，横向表示：预测值；纵向表示：真实值；对角线表示：预测对的实例情况。

precision：预测是某个数，的确是这个数的概率；recall：真实值为某个数，确实预测是这个数的概率；这两个值都是准确度的一个衡量。