采用的是python中机器学习库sklearn图片数据

sklearn简要介绍：

#sklearn是Python中的一个机器学习包

from sklearn.datasets import load_digits #载入Sklearn

import pylab as pl

digits=load_digits()#载入数据集(都是数字图片)

print(digits.data.shape)

#一共有1797张图片

#把8*8的图片以64列排放

pl.gray()#灰度化图片

pl.matshow(digits.images[0])

pl.show()

结果：

数字识别代码部分：

import numpy as np

from sklearn.datasets import load_digits#载入Sklearn

from sklearn.preprocessing import LabelBinarizer#标签二值化

from sklearn.cross_validation import train_test_split#切分数据，把数据切分为训练数据与测试数据

#激活函数 目前新的神经网络已经不用此激活函数了，太旧了

def sigmoid(x):

return 1/(1+np.exp(-x))

def dsigmoid(x):#激活函数的倒数

return x*(1-x)

return x*(1-x)

class NeuralNetwork:#定义神经元类

def __init__(self,layers):##(64,100,10) 输入，隐藏层，输出层

#权值的初始化，范围-1到1

self.V = np.random.random((layers[0]+1,layers[1]+1))*2-1#"+1"是偏置

self.W = np.random.random((layers[1]+1,layers[2]))*2-1

def train(self,X,y,lr=0.11,epochs=10000):#输入，标签，学习率，迭代次数

#添加偏置

temp = np.ones([X.shape[0],X.shape[1]+1])

#添加偏置

temp = np.ones([X.shape[0],X.shape[1]+1])#构建一个比X多一列的矩阵，矩阵元素值均为1

temp[:,0:-1] = X

X = temp

#训练思想

#10000个数据分成100个批次训练，每次训练100个，可以加快训练速度

for n in range(epochs+1):

i = np.random.randint(X.shape[0]) #随机选取训练集里面的一行，即一个数据

x = [X[i]]

x = np.atleast_2d(x)#转为2维数据

L1 = sigmoid(np.dot(x,self.V))#隐层输出

L2 = sigmoid(np.dot(L1,self.W))#输出层输出

#L2的倒数=理想输出-实际输出*L2经过激活函数的倒数 i代表标签

#L1的倒数=L2的倒数*权值(上一层的反馈)*L1进过激活函数的倒数

L2_delta = (y[i]-L2)*dsigmoid(L2)

L1_delta= L2_delta.dot(self.W.T)*dsigmoid(L1)

self.W += lr*L1.T.dot(L2_delta)

self.V += lr*x.T.dot(L1_delta)

#每训练1000次预测一次准确率

if n%1000==0:

predictions = []

for j in range(X_test.shape[0]):

o = self.predict(X_test[j])

predictions.append(np.argmax(o))#获取预测结果

accuracy = np.mean(np.equal(predictions,y_test))#求平均

print('epoch:',n,'accuracy:',accuracy)#打印循环周期和准确率

def predict(self,x):

#添加偏置

temp = np.ones(x.shape[0]+1)#构建一个比X多一列的矩阵，矩阵元素值均为1

temp[0:-1] = x

x = temp

x = np.atleast_2d(x)#转为2维数据

L1 = sigmoid(np.dot(x,self.V))#隐层输出

L2 = sigmoid(np.dot(L1,self.W))#输出层输出

return L2

#主程序开始

#载入数据

digits = load_digits()#载入数据

X = digits.data#数据

y = digits.target#标签

#输入数据归一化

X -= X.min()#X的数据都减去X的最小值  然后/最大值 把X归一化到0-1之间

X /= X.max()

nm = NeuralNetwork([64,100,10])#创建网络

X_train,X_test,y_train,y_test = train_test_split(X,y) #分割数据1/4为测试数据，3/4为训练数据

labels_train = LabelBinarizer().fit_transform(y_train)#标签二值化     0,8,6   0->1000000000  3->0001000000

labels_test = LabelBinarizer().fit_transform(y_test)#标签二值化

print('start')

nm.train(X_train,labels_train,epochs=20000)

print('end')

结果：迭代20000次，准确率的变化

start

epoch: 0 accuracy: 0.0822222222222

epoch: 1000 accuracy: 0.697777777778

epoch: 2000 accuracy: 0.82

epoch: 3000 accuracy: 0.891111111111

epoch: 4000 accuracy: 0.895555555556

epoch: 5000 accuracy: 0.924444444444

epoch: 6000 accuracy: 0.931111111111

epoch: 7000 accuracy: 0.931111111111

epoch: 8000 accuracy: 0.944444444444

epoch: 9000 accuracy: 0.94

epoch: 10000 accuracy: 0.957777777778

epoch: 11000 accuracy: 0.942222222222

epoch: 12000 accuracy: 0.955555555556

epoch: 13000 accuracy: 0.957777777778

epoch: 14000 accuracy: 0.955555555556

epoch: 15000 accuracy: 0.962222222222

epoch: 16000 accuracy: 0.953333333333

epoch: 17000 accuracy: 0.953333333333

epoch: 18000 accuracy: 0.966666666667

epoch: 19000 accuracy: 0.96

epoch: 20000 accuracy: 0.964444444444

end