神经网络②——python实现神经网络

上一篇博客介绍了神经网络其实就是两步，第一步是前向传输，根据输入的特征值与权重矩阵以及激活函数，不断往前计算，得到输出层的值，第二步就是后向传播，根据残差的加权求和，不断往后，直到输入层，然后更新权重，不断进行这两步，直接输出结果的误差在所要求范围内即可 。

本篇博文通过python代码实现神经网络，采用sklearn自带的手写数字集，看分类情况如何

一、导入数据集并标准化
数据集的加载非常简单，直接调用load_digits即可，常用到的数据有：
digits.data：手写数字特征向量数据集，每一个元素都是一个64维的特征向量。
digits.target：特征向量对应的标记，每一个元素都是自然是0-9的数字。
digits.images：对应着data中的数据，每一个元素都是8*8的二维数组，其元素代表的是灰度值，转化为以为是便是特征向量

            
              # python实现神经网络
from sklearn.model_selection import train_test_split
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt
import seaborn as sns

#导入数据集（dataset自带的手写数字数据集)
data = load_digits()
print(data.images.shape)
X = data.data
Y = data.target
print(X.shape,X[:2])
print(Y.shape,Y[:2])
 stander = StandardScaler() # 特征值进行标准化，得到均值为0，方差为1的分布
 X = stander.fit_transform(X)
 print(np.unique(Y,return_counts=True))  # 输出每一种类别及类别的数量

            
          

二、数据拆分

将数据拆分成80%的训练集和20%的测试集

            
              X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.2)
print(X_train.shape)
print(Y_train.shape,Y_train)
print(Y_test.shape)

            
          

三、创建神经网络

            
              V = np.random.random((64, 100))*2-1 # 输入层到隐藏层的权重矩阵，范围0~1
W = np.random.random((100,10))*2-1  # 隐藏层到输出层的权重矩阵，范围0~1

# 激活函数sigmoid函数
def sigmond(x):
    return 1/(1+ np.exp(-x))

# sigmoid函数的导数
def sigmondf(x):
    return x*(1-x)

# 预测函数
def predict(x):
    L1 = sigmond(np.dot(x, V))
    L2 = sigmond(np.dot(L1, W))
    return L2

# 神经网络分类器
def network(X, Y, steps=10000):
    global W,V  # 定义全局变量
    acc_list = []
    for lt in list(np.linspace(0.001,0.01,100)):
        acc_0 = 0
        for n in range(steps+1):
            i = np.random.randint(X.shape[0])
            X = X[i]  # 这是一个一维的矩阵，（64，）
            X = np.atleast_2d(X)  # atlease_xd变成几维，如果是2,则是2维，如果是3，就变成3维，[]，[[]],[[[]]]
            L1 = sigmond(np.dot(X,V)) # 得到一个（1，100）的矩阵
            L2 = sigmond(np.dot(L1,W)) # 得到一个（1，10）的矩阵
            L2_delta = (Y[i] - L2)*sigmondf(L2)  # 输出节点的残差： -（输出值-样本值）* 激活函数导数 （1，10）
            L1_delta = np.dot(L2_delta,W.T)*sigmondf(L1)  # 隐藏层的残差：右侧输出层的残差加权求和*隐藏层的导数 （1，10）（10，100）=（1，100）
            W += lt*np.dot(L1.T,L2_delta) # 隐藏层更新权重：(100,1)*(1,10)=(100,10)
            V += lt*np.dot(X.T,L1_delta)  # 输入层更新权重：(64,1)*(1,100)=(64,100)
            if n%1000 == 0:  # 取余，如果迭代达到1000的倍数
                predict_ = predict(X_test)
                predictions = np.argmax(predict_, axis=1) # 每一行最大值的下标,对于多分类，输出值最大的即为分类结果
                acc = np.mean(np.equal(predictions, Y_test)) # np.equal是判断是否相等，相等的变为True，不相等的就变为False,然后计算均值
                if acc>acc_0:
                    acc_0 = acc
                # print('第{}次'.format(n)+'      '+ '平均准确率:', acc)
        acc_list.append(acc_0)
    return acc_list
    
acc_list = network(X_train,Y_train)
plt.plot(np.linspace(0.001,0.1,100),acc_list)
plt.show()

            
          

跑出来准确率不高，于是不断替换学习率，发现最高的也仅能达到13%，尝试对初始权重进行调整，也没有太大的变化，不过本篇主要的目的就是想用python实现神经网络，对于分类的准确度倒在其次，后续打算会用sklearn库封装的神经网络试试看。