minist手写数据集识别（没用神经网络）（附源码，训练准确率94%，测试准确率91%）

一、说一下

我想水一篇博客，然后就水一篇minist手写数据集的识别。这个模型就两层，输入层和输出层，输入层400个特征（吴恩达提供的minist数据集，5000个样本，每个样本是20*20的灰度图），输出层十个逻辑回归单元，因为是十分类嘛。然后，激活函数用了softmax，正则化方法用了L2，因为dropout有点麻烦也没必要，毕竟这也不是个神经网路。数据集三七分，70%作为训练集，30%作为测试集。经过试验，模型对手写数字识别的训练准确率达到94%，测试准确率达到91%。

二、参数设置

1.学习率alpha=1.3

2.正则化参数lamd=1

3.迭代次数iters=500

4.权重矩阵W初始化为0（偏置放到了X矩阵，跟样本放一起了；偏置的权重b放到了W矩阵）

三、代码

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import scipy.io as scio #用来读取matlab格式的数据集
from sklearn.preprocessing import OneHotEncoder


###1.读取数据集函数定义
def Load_data(path):
	data = scio.loadmat(path)
	X=data['X'] #大写
	Y=data['y']
	return X,Y
	

###2.数据预处理
def Datapre(X,Y):
    X=np.insert(X.T,[0],np.ones(5000),axis=0) #把X转置并加一行1
    encoder=OneHotEncoder(sparse=False) #把Y编码并转置
    Y=(np.matrix(encoder.fit_transform(Y))).T 
    return X,Y
	
###3.获取训练集
def Get_Trainingset(X_data,Y_data):
	n=Y_data.shape[0]
	X_train=X_data[:,0:350]
	Y_train=Y_data[:,0:350]
	i=1
	while i<n:
		X_train=np.hstack((X_train,X_data[:,500*i:500*i+350]))
		Y_train=np.hstack((Y_train,Y_data[:,500*i:500*i+350]))
		i+=1
	return X_train,Y_train


###4.获取测试集
def Get_Testset(X_data,Y_data):
	n=Y.data.shape[0]
	X_test=X_data[:,350:500]
	Y_test=Y_data[:,350:500]
	i=1
	while i<n:
		X_test=np.hstack((X_test,X_data[:,500*i-150:500*i]))
		Y_test=np.hstack((Y_test,Y_data[:,500*i-150:500*i]))
		i+=1
	return X_test,Y_test
	

###5.softmax函数
def Softmax(Z):
    col=Z.shape[1]
    Z=np.exp(Z)
    for i in range(col):
        Z[:,i]=Z[:,i]/np.sum(Z[:,i])
    return Z
    
    
###6.costfunction函数
def Costcompute(Y,A,W,lamd):
    m=Y.shape[1]
    J=(-1/m)*np.sum(np.multiply(Y,np.log(A)))+(np.sum(np.multiply(W,W)))*(lamd/(2*m))
    return J


###7.梯度下降函数
def Gradiendescent(X,Y,W,alpha,lamd,iters):
    m=Y.shape[1]
    W_der=np.matrix(np.zeros(W.shape))
    cost=np.zeros(iters)
    for i in range(iters):
        Z=np.dot(W,X)
        A=Softmax(Z)
        cost[i]=Costcompute(Y,A,W,lamd)
        W_der=(1/m)*np.dot((A-Y),X.T)+(np.sum(W))*(lamd/m)
        W=W-alpha*W_der
    return cost,W,A
	
	
###8.计算准确率
def Computeaccuracy(A,Y):
	m=A.shape[1]
	n=A.shape[0]
	for i in range(m):
		loc=np.argmax(A[:,i])
		A[:,i]=np.matrix(np.zeros((n,1)))
		A[loc,i]=1
	accuray=np.sum(np.multiply(A,Y))/m
	return accuray
	
	
###9.读数据并预处理，初始化参数
path='E:\\Expe\\Expe-2\\ex4data1.mat' #读数据并预处理
X_data,Y_data=Load_data(path)
X_data,Y_data=Datapre(X_data,Y_data)
W=np.zeros((10,401)) #初始化参数
alpha=1.3
lamd=1
iters=500



###10.获取训练集，梯度下降训练,计算训练准确率
X,Y=Get_Trainingset(X_data,Y_data)
cost,W_result,A=Gradiendescent(X,Y,W,alpha,lamd,iters) #梯度下降 
accuray=Computeaccuracy(A,Y) #计算训练准确率
print("Training accuray:",accuray*100,"%",'\n')


###11.获取测试集，计算测试准确率
X,Y=Get_Testset(X_data,Y_data) #获取测试数据集
Z=np.dot(W_result,X) #计算模型对测试集的预测结果
A=Softmax(Z)
accuray=Computeaccuracy(A,Y) #计算测试准确率
print("Test accuray:",accuray*100,"%",'\n')


###12.画训练时代价函数与迭代次数的曲线图
plt.figure()
plt.plot(np.arange(iters), cost, 'r')
plt.xlabel('Iterations')
plt.ylabel('Cost')
plt.title('Error vs. Training Epoch')
plt.show()

四、结果图

图4.1 运行结果图

 

 

左肩理想右肩担当，君子不怨永远不会停下脚步！