【深度学习】4：多层感知器MLP结合 sklearn 库实现手写数字识别

月涌大江流丶

已于 2024-11-10 22:41:41 修改

阅读量1w

点赞数 6

CC 4.0 BY-SA版权

分类专栏：深度学习文章标签： bp神经网络 sklearn 数字识别

于 2018-01-27 18:01:07 首次发布

本文链接：https://blog.youkuaiyun.com/zzZ_CMing/article/details/79182103

深度学习专栏收录该内容

14 篇文章

订阅专栏

2024年内容：

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 加载手写数字数据集
digits = load_digits()
X, y = digits.data, digits.target

# 分割数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 构建多层感知器模型
mlp = MLPClassifier(hidden_layer_sizes=(128, 64),  # 两层隐藏层，分别有128和64个神经元
                    activation='relu',            # 激活函数使用ReLU
                    solver='adam',                # 使用Adam优化器
                    learning_rate_init=0.001,     # 初始学习率
                    max_iter=300,                 # 最大迭代次数
                    random_state=42)

# 训练模型
mlp.fit(X_train, y_train)

# 预测测试集
y_pred = mlp.predict(X_test)

# 输出结果
accuracy = accuracy_score(y_test, y_pred)
print(f"Test accuracy: {accuracy * 100:.2f}%")

# 输出分类报告
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# 输出混淆矩阵
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))

代码解释：

数据集加载和预处理：

使用 load_digits() 加载 sklearn 提供的手写数字数据集。该数据集包含1797张8x8的灰度图像，共10类（数字0-9）。
将数据集分割为训练集和测试集，70%用于训练，30%用于测试。

构建多层感知器模型：

使用 MLPClassifier 创建一个多层感知器（MLP）模型。
hidden_layer_sizes=(128, 64) 指定了两层隐藏层，第一层有128个神经元，第二层有64个神经元。
activation=‘relu’ 设置激活函数为ReLU。
solver=‘adam’ 使用Adam优化器进行权重更新。
learning_rate_init=0.001 设置初始学习率。
max_iter=300 将最大迭代次数设置为300，以防止训练时间过长。

模型训练和测试：

使用训练集 X_train 和 y_train 进行模型训练。
在测试集 X_test 上进行预测，并计算预测准确率。

输出结果：

输出测试集的准确率，分类报告和混淆矩阵，以评估模型性能。

结果解释：

accuracy_score：测试集上的准确率。
classification_report：包括精确率、召回率和F1分数。
confusion_matrix：显示模型在每个类别上的预测结果与实际结果之间的对应关系。

2018年内容：

1、载入数据集

from sklearn.datasets import load_digits
# 载入数据:8*8的数据集
digits = load_digits()
X = digits.data
Y = digits.target

这个数据集是sklearn里面带的数据集，图片大小是8*8的，将数据项存入X，将标签项存入Y。这个不要额外下载，声明就可以使用。

2、数据归一化处理

#输入数据归一化
X -= X.min()
X /= X.max()

数据为什么要归一化处理？当数据集的数值过大，即便乘以较小的权重后仍然还是一个很大的数时，当代入sigmoid激活函数中，激活函数的输出就趋近于1，不利于学习
怎么操作使数据归一化？原始数据集中每一个数据先减去最小的那个数，将得到的新数据集再除以最大的那个数既可（大家可以举个例子：2，7，5，9。试一试就知道）

3、切分数据，与标签二值化

#sklearn切分数据
X_train,X_test,y_train,y_test = train_test_split(X,Y)
#标签二值化：将原始标签(十进制)转为新标签(二进制)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)

sklearn中直接一条语句就可以切分数据了：将数据项、标签项切分出来，3/4做训练集，剩下的1/4做测试集。
为什么要标签二值化？因为我们存入的标签是0，1，2，，，9这十个数，而计算机的识别都是0-1字符串，所以满足计算机识别分类，就需要进行标签二值化。
怎么标签二值化？举例最好说明：用长度为10的字符串表示如下：
0 -->1000000000；3 -->0001000000；8 -->0000000010

4、打印输出图片

from sklearn.datasets import load_digits
import pylab as pl

#载入数据集
digits = load_digits()
print(digits.data.shape)

#灰度化图片
pl.gray()
pl.matshow(digits.images[0])
pl.show()

可以查看sklearn数据集里包含多少个数据，也可以通过改变索引，打印出不同的图片（由于图片尺寸是8*8的，图像比较模糊）

5、源码与效果展示

# -*- coding:utf-8 -*-
# -*- author：zzZ_CMing
# -*- 2018/01/24；9:09
# -*- python3.5

import numpy as np
from sklearn.datasets import load_digits
from sklearn.preprocessing import LabelBinarizer #标签二值化
from sklearn.model_selection import train_test_split   #切割数据,交叉验证法

def sigmoid(x):
    return 1/(1+np.exp(-x))

def dsigmoid(x):
    return x*(1-x)

class NeuralNetwork:
    def __init__(self,layers):#(64,100,10)
        #权重的初始化,范围-1到1：+1的一列是偏置值
        self.V = np.random.random((layers[0] + 1, layers[1]+1))*2 - 1
        self.W = np.random.random((layers[1] + 1, layers[2])) * 2 - 1

    def train(self,X,y,lr=0.11,epochs=10000):
        #添加偏置值：最后一列全是1
        temp = np.ones([X.shape[0],X.shape[1]+1])
        temp[:,0:-1] = X
        X = temp

        for n in range(epochs+1):
            #在训练集中随机选取一行(一个数据)：randint()在范围内随机生成一个int类型
            i = np.random.randint(X.shape[0])
            x = [X[i]]
            #转为二维数据：由一维一行转为二维一行
            x = np.atleast_2d(x)

            # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
            # L2：隐藏层传递到输出层的值；输出层10个节点
            L1 = sigmoid(np.dot(x, self.V))
            L2 = sigmoid(np.dot(L1, self.W))

            # L2_delta：输出层对隐藏层的误差改变量
            # L1_delta：隐藏层对输入层的误差改变量
            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))
                #np.equal()：相同返回true，不同返回false
                accuracy = np.mean(np.equal(predictions,y_test))
                print('迭代次数：',n,'准确率：',accuracy)

    def predict(self,x):
        # 添加偏置值：最后一列全是1
        temp = np.ones([x.shape[0] + 1])
        temp[0:-1] = x
        x = temp
        # 转为二维数据：由一维一行转为二维一行
        x = np.atleast_2d(x)

        # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
        # L2：隐藏层传递到输出层的值；输出层10个节点
        L1 = sigmoid(np.dot(x, self.V))
        L2 = sigmoid(np.dot(L1, self.W))
        return L2

#载入数据:8*8的数据集
digits = load_digits()
X = digits.data
Y = digits.target
#输入数据归一化：当数据集数值过大，乘以较小的权重后还是很大的数，代入sigmoid激活函数就趋近于1，不利于学习
X -= X.min()
X /= X.max()

NN = NeuralNetwork([64,100,10])
#sklearn切分数据
X_train,X_test,y_train,y_test = train_test_split(X,Y)
#标签二值化：将原始标签(十进制)转为新标签(二进制)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)

print('开始训练')
NN.train(X_train,labels_train,epochs=20000)
print('训练结束')