卷积神经网络在mnist数据集上的应用-yiteyi-C++库

CNN 基本上是一个已知的模型 卷积神经网络 近年来，由于它的实用性，它获得了大量的普及。CNN使用多层感知机进行计算工作。与其他图像分类算法相比，CNN使用的预处理相对较少。这意味着网络通过传统算法中手工设计的过滤器进行学习。因此，对于图像处理任务，CNN是最合适的选择。

null

MNIST数据集： mnist数据集是一个手写图像数据集，如下图所示。

图片[1]-卷积神经网络在mnist数据集上的应用-yiteyi-C++库

将卷积神经网络（CNN）与函数模型结合使用，可以获得99.06%的准确率。使用功能模型的原因是在连接各层时保持易用性。

首先，包括所有必要的图书馆

Python3

                           import                                        numpy as np                         
                           import                                        keras                         
                           from                                        keras.datasets                                        import                                        mnist                         
                           from                                        keras.models                                        import                                        Model                         
                           from                                        keras.layers                                        import                                        Dense,                                        Input                         
                           from                                        keras.layers                                        import                                        Conv2D, MaxPooling2D, Dropout, Flatten                         
                           from                                        keras                                        import                                        backend as k                         

创建列车数据和测试数据

测试数据： 用于测试我们的模型是如何训练的。 列车数据： 用来训练我们的模特。

Python3

(x_train, y_train), (x_test, y_test) = mnist.load_data()

在进一步推进的同时， img_行 和 img_cols 用作图像尺寸。在mnist数据集中，它是28和28。我们还需要检查数据格式，即“channels_first”或“channels_last”。在CNN中，我们可以将手头的数据标准化，这样计算的大项就可以简化为小项。比如，我们可以通过将x_序列和x_测试数据除以255来对其进行标准化。 检查数据格式：

Python3

                           img_rows, img_cols                                        =                                        28                                        ,                                        28                         
            
                           if                                        k.image_data_format()                                        =                                        =                                        'channels_first'                                        :                         
                                                     x_train                                        =                                        x_train.reshape(x_train.shape[                                        0                                        ],                                        1                                        , img_rows, img_cols)                         
                                                     x_test                                        =                                        x_test.reshape(x_test.shape[                                        0                                        ],                                        1                                        , img_rows, img_cols)                         
                                                     inpx                                        =                                        (                                        1                                        , img_rows, img_cols)                         
            
                           else                                        :                         
                                                     x_train                                        =                                        x_train.reshape(x_train.shape[                                        0                                        ], img_rows, img_cols,                                        1                                        )                         
                                                     x_test                                        =                                        x_test.reshape(x_test.shape[                                        0                                        ], img_rows, img_cols,                                        1                                        )                         
                                                     inpx                                        =                                        (img_rows, img_cols,                                        1                                        )                         
            
                           x_train                                        =                                        x_train.astype(                                        'float32'                                        )                         
                           x_test                                        =                                        x_test.astype(                                        'float32'                                        )                         
                           x_train                                        /                                        =                                        255                         
                           x_test                                        /                                        =                                        255                         

输出类的描述：

因为模型的输出可以包含0到9之间的任何数字。所以，我们需要10个类的输出。要生成10个类的输出，请使用keras。乌提尔斯。to_category函数，它将提供10列。在这10列中，只有一个值为1，其余9列为0，输出的这一个值将表示数字的类别。

Python3

y_train = keras.utils.to_categorical(y_train)

y_test = keras.utils.to_categorical(y_test)

现在，数据集已经准备好了，让我们转向CNN模型：

Python3

                           inpx                                        =                                        Input                                        (shape                                        =                                        inpx)                         
                           layer1                                        =                                        Conv2D(                                        32                                        , kernel_size                                        =                                        (                                        3                                        ,                                        3                                        ), activation                                        =                                        'relu'                                        )(inpx)                         
                           layer2                                        =                                        Conv2D(                                        64                                        , (                                        3                                        ,                                        3                                        ), activation                                        =                                        'relu'                                        )(layer1)                         
                           layer3                                        =                                        MaxPooling2D(pool_size                                        =                                        (                                        3                                        ,                                        3                                        ))(layer2)                         
                           layer4                                        =                                        Dropout(                                        0.5                                        )(layer3)                         
                           layer5                                        =                                        Flatten()(layer4)                         
                           layer6                                        =                                        Dense(                                        250                                        , activation                                        =                                        'sigmoid'                                        )(layer5)                         
                           layer7                                        =                                        Dense(                                        10                                        , activation                                        =                                        'softmax'                                        )(layer6)                         

说明中各层的工作原理 CNN模式： layer1是Conv2d层，它使用32个大小为（3*3）的过滤器卷积图像。 layer2也是一个Conv2D层，它也用于卷积图像，并使用64个大小为（3*3）的过滤器。 layer3是MaxPoolig2D层，它从大小为（3*3）的矩阵中选取最大值。第四层的辍学率为0.5。 layer5对从layer4获得的输出进行展平，该展平输出被传递到layer6。 layer6是包含250个神经元的神经网络的隐藏层。 layer7是一个输出层，有10个神经元，用于使用softmax功能的10类输出。
调用编译和拟合函数：

Python3

                           model                                        =                                        Model([inpx], layer7)                         
                           model.                                        compile                                        (optimizer                                        =                                        keras.optimizers.Adadelta(),                         
                                                     loss                                        =                                        keras.losses.categorical_crossentropy,                         
                                                     metrics                                        =                                        [                                        'accuracy'                                        ])                         
            
                           model.fit(x_train, y_train, epochs                                        =                                        12                                        , batch_size                                        =                                        500                                        )                         

图片[2]-卷积神经网络在mnist数据集上的应用-yiteyi-C++库

首先，我们制作了一个模型的对象，如上面给出的几行所示，其中[inpx]是模型的输入，layer7是模型的输出。我们使用所需的优化器、损失函数编译了模型，并打印了最后一个模型的精度和精度。fit与x_-train（表示图像向量）、y_-train（表示标签）、历元数和批量大小等参数一起调用。使用拟合函数x_-train，y_-train数据集被输入特定批量的模型。
评估功能： 模型evaluate提供测试数据的分数，即向模型提供测试数据。现在，该模型将预测数据的类别，预测的类别将与y_测试标签匹配，以提供准确度。