使用DNN实现手写数字识别

使用mnist 数据集，基于python基础库，用含一层隐藏层的神经网络训练一个简单的模型来识别手写数字。
准确率 90%以上。
并用自己的手写数字的图片验证。

加载所需的库

import sys ,os 
import numpy as np
import matplotlib.pyplot as plt
sys.path.append(os.pardir) #加入当前目录，要用到mnist.py
from dataset.mnist import load_mnist
from PIL import Image

加载mnist数据集

#（训练图像，训练标签），（测试图像，测试标签）
# mnist的图像均为28*28尺寸的数据，通道为1
(x_train_origin,t_train_origin),(x_test_origin,t_test_origin) = load_mnist(normalize=True,flatten=False,one_hot_label=True)

m_train = x_train_origin.shape[0] #训练集大小
m_test = x_test_origin.shape[0] #测试集大小
num_px = x_train_origin.shape[2] #px = height = width

num_category = 10 #分类类别个数总共有10个0-9

print("number of trainning sample is :"+repr(m_train))
print("number of test sample is :"+repr(m_test))

print("shape of x_train is :"+repr(x_train_origin.shape))
print("shape of t_train is :"+repr(t_train_origin.shape))
print("shape of x_test is :"+repr(x_test_origin.shape))
print("shape of t_test is :"+repr(t_test_origin.shape))

number of trainning sample is :60000
number of test sample is :10000
shape of x_train is :(60000, 1, 28, 28)
shape of t_train is :(60000, 10)
shape of x_test is :(10000, 1, 28, 28)
shape of t_test is :(10000, 10)

reshape

将数据集的shape转变成(nx,m) ,nx为特征数量，这里即像素个数，m为数据大小.
方便神经网络的计算

train_set_x = x_train_origin.reshape(x_train_origin.shape[0],-1).T
train_set_y = t_train_origin.T
test_set_x = x_test_origin.reshape(x_test_origin.shape[0],-1).T
test_set_y  = t_test_origin.T

print("shape of train_set_x is :"+repr(train_set_x.shape))
print("shape of train_set_y is :"+repr(train_set_y.shape))
print("shape of test_set_x is :"+repr(test_set_x.shape))
print("shape of test_set_y is :"+repr(test_set_y.shape))

shape of train_set_x is :(784, 60000)
shape of train_set_y is :(10, 60000)
shape of test_set_x is :(784, 10000)
shape of test_set_y is :(10, 10000)

显示图像

index = 0
plt.imshow(x_train_origin[index].reshape((28,28)),cmap = plt.cm.gray)
print("y is:"+str(np.argmax(t_train_origin[index])))

y is:5

output_8_1.png

sigmoid函数

1/(1+exp(-z))

def sigmoid(z):
    """
    计算z的sigmoid 值
    Arguments:
    z -- 实数或任意数组
    Return:
    s --  返回类型与z一致
   """
    
    s = 1 / (1+np.exp(-z))
    return s    

s = sigmoid(0)
print("s is :"+str(s))

s is :0.5

初始化参数 w ,b

def initilize_params(dim,num_categories) :
    """
    init w and b 
    Arguments:
        dim -- size of w
        num_categories: number of total categories
    Return :
    w -- shape of (dim,num_categories)
    b -- shape of (num_categories,1)
     """
    w = np.zeros((dim,num_categories))
    b = np.zeros((num_categories,1))
    assert(w.shape == (dim,num_categories))
    assert(b.shape == (num_categories,1))
    return w,b

前向传播与反向传播

 def propagate(w,b,X,Y): 
    """
    Arguments:
        w-- weights,numpy array of shape(num_px*num_px,num_categories)
        b -- bias of shape (num_categories,1)
        X -- data of shape (num_px*num_px,number of examples)
        Y -- tag of shape (num_categories, number of example)
        
        Return :
            grads -- a dict ,derivative of dw,db
            cost  -- current cost 
    """
    m = X.shape[1]
    #前向传播 START 计算损失
    #caculate W^T*X +b
    z = np.dot(w.T,X) + b  #shape is:(num_categories,number of examples)
    yhat = sigmoid(z)  # 每个样本0-9的预测概率,shape is same as z 
    #计算损失
    cost = -np.sum((Y * np.log(yhat) + (1-Y)*np.log(1-yhat)))/m
    # 前向传播 END
    
    # 反向传播 START
    dw = np.dot(X , (yhat - Y).T)/m #shape is same with w
    db =  np.sum((yhat - Y),axis = 1)/m #shape is same with b
    db = db.reshape(b.shape)
    #反向传播 END
    
    assert(dw.shape == w.shape)
    assert(db.shape == b.shape)
    
    grads = {"dw":dw,
                "db":db}
    
        
    return grads, cost 

优化

def optimize(w,b,X,Y,number_iterations,learning_rate):
        """
        optimize w and b by running gradient descent algorithm
    Arguments:
        w-- weights,numpy array of shape(num_px*num_px,num_categories)
        b -- bias of shape (num_categories,1)
        X -- data of shape (num_px*num_px,number of examples)
        Y -- tag of shape (num_categories, number of example)
        number_iterations -- number of iterate for gradient descent 
        learning_rate -- learning rate for gradient descent   
        
        Return :
            params -- a dict ,include w ,b 
            grads -- a dict ,derivative of dw,db
            cost  -- current cost 
    """
        costs= []
        for i in range(number_iterations):
        
            grads, cost = propagate(w,b,X,Y)
    
            dw = grads["dw"]
            db = grads["db"]
        
            #update w and b 
            w = w -  learning_rate*dw
            b = b  -learning_rate*db    
        
            if(i % 100) == 0:
                costs.append(cost)
                print ("cost after iteration %i is :%f" %(i,cost))

        params = {"w":w,
                     "b": b}
        grads = {"dw":dw,
                "db":db}
        return params,grads,costs
    

预测

def predicate (X ,w ,b):
    """
    predicate of data
    Arguments:
        w-- weights,numpy array of shape(num_px*num_px,num_categories)
        b -- bias of shape (num_categories,1)
        X -- data of shape (num_px*num_px,number of examples)
        
        Return :
        Y_pred_one_hot_label -- the predicate result of X,shape is :(num_categories,number of examples) 
        Y_pred_number -- a vector ,the predicate with a excactly number for each X
    """
    m = X.shape[1]
    z = np.dot(w.T,X)+b
    yhats = sigmoid(z).T
    Y_pred_one_hot_label = np.zeros((b.shape[0],m)) #one-hot-label 
    Y_pred_number =np.zeros((1,m)) #a number that it predicate
    for i in range(yhats.shape[0]):
        max_index = np.argmax(yhats[i])
        Y_pred_one_hot_label[max_index,i] = 1
        Y_pred_number[0,i] = int(max_index)
    return Y_pred_one_hot_label,Y_pred_number
        
    

构建模型

把所有东西整合起来，构建模型

def nurvus_network_model(train_set_x, train_set_y, test_set_x, test_set_y, num_categories, number_iterations=2000, learning_rate=0.5):
        """
    construct a model to predicate number picture
    Arguments:
        train_set_x-- training data,numpy array of shape(num_px*num_px,number of examples)
        train_set_y -- the tag of trainning data  of shape (num_categories,number of examples)
        test_set_x -- test examples,numpy array of shape (num_px*num_px,number of examples)
        test_set_y -- the tag of test  data  of shape (num_categories,number of examples)
        num_categories -- number of categories
        number_iterations -- the number of iterate for optimize
        learning_rate --

        Return :
        d -- dictionary contain info for model
    """
        dim = train_set_x.shape[0]
        # init w and b
        w, b = initilize_params(dim, num_categories)
        params, grads, costs = optimize(
            w, b, train_set_x, train_set_y, number_iterations=number_iterations, learning_rate=learning_rate)
        w = params["w"]
        b = params["b"]

        Y_pred_train_one_hot_label, Y_pred_train_number = predicate(
            train_set_x, w, b)
        Y_pred_test_one_hot_label, Y_pred_test_number = predicate(
            test_set_x, w, b)

        print("train accuracy: {} %".format(
            100 - np.mean(np.sum(np.abs(Y_pred_train_one_hot_label - train_set_y), axis=0)/2) * 100))
        print("test accuracy: {} %".format(
            100 - np.mean(np.sum(np.abs(Y_pred_test_one_hot_label - test_set_y), axis=0)/2) * 100))

        d = {"w":w,
             "b":b,
            "costs":costs,
            "Y_pred_train":Y_pred_train_number,
            "Y_pred_train_one_hot":Y_pred_train_one_hot_label,
            "Y_pred_test":Y_pred_test_number,
            "Y_pred_test_one_hot":Y_pred_test_one_hot_label,
            "learning_rate":learning_rate,
            "iterations":number_iterations}
        return d

number_categories = 10 
d = nurvus_network_model(train_set_x,train_set_y,test_set_x,test_set_y,num_categories = 10,number_iterations=2000,learning_rate=0.6)

cost after iteration 0 is :6.931472
cost after iteration 100 is :0.903445
cost after iteration 200 is :0.813852
.......
cost after iteration 1800 is :0.656671
cost after iteration 1900 is :0.654527
train accuracy: 91.66 %
test accuracy: 91.82 %

index = 20
y_pred_test = d["Y_pred_test"]
plt.imshow(test_set_x[:,index].reshape((28,28)),cmap = plt.cm.gray)
print("y is:"+str(np.argmax(test_set_y[:,index])))

print("your predicate result is :"+str(int(y_pred_test[0,index])))

y is:9
your predicate result is :9

output_27_1.png

画出损失函数图

costs = d["costs"]
plt.plot(costs)
plt.xlabel("iterations/hundreds")
plt.ylabel("costs")
plt.show()

output_29_0.png

用自己的图片测试

import scipy
from PIL import Image
from scipy import ndimage

my_image_name = "5.jpeg"
#my_image_name = "2.jpeg"
#my_image_name = "7.jpeg"
fname = my_image_name
image_origin = Image.open(fname)
a = np.asarray(image_origin)
print(a.shape)
image = image_origin.convert(mode = "L")
image = image.resize((28,28),resample = Image.ANTIALIAS)

a = np.asarray(image)
plt.imshow(image,cmap=plt.cm.gray) #显示图像
a = 255 -a 
mean = np.mean(a)
a = np.where(a < mean,0,a)
a = a/255
input_x = a.reshape((28*28,1))

onehotlabel,predicate_number = predicate(input_x, d["w"],d["b"])
print("your predicate number is :"+str(int(predicate_number[0][0])))

(28, 28, 3)
your predicate number is :5

output_31_1.png