利用Keras实现多层感知器（MLP）模型和卷积神经网络（CNN）模型并对手写数字图像分类

最新推荐文章于 2025-04-10 10:25:38 发布
最新推荐文章于 2025-04-10 10:25:38 发布
阅读量6.8k 收藏 20
点赞数 2
分类专栏： 深度学习与计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/davidhopper/article/details/78818156
版权

利用Keras实现多层感知器（MLP）模型和卷积神经网络（CNN）模型并对手写数字图像分类

闲来无事，利用Keras实现MLP和CNN模型并对手写数字图像分类，测试数据是大量手写的0-9数字图像，尺寸为：28x28（784）像素，来源于鼎鼎有名的Modified National Institute of Standards and Technology (MNIST)。数据获取很方便，只要保持互联网畅通，使用Keras自带的API：mnist.load_data()就可在第一次调用时自动下载至当前用户的~/.keras/datasets文件夹下（例如当前用户为：davidhopper，则在Windows系统中下载路径为：C:\Users\davidhopper.keras\datasets，Linux系统中的下载路径为：/home/davidhopper/.keras/datasets）。
文中所有源代码均来自“Develop Deep Learning Models on Theano and TensorFlow Using Keras”（Jason Brownlee）一书，我对其稍作修改，以使其更加适用于Keras 2 API。

1. MLP模型

MLP模型采用经典的“输入层-中间层（隐藏层）-输出层”结构，输入层单元数为28X28=784，输出层数为：10（0-9数字的标识号），流程图如下：

Created with Raphaël 2.1.0 开始 输入层(Input Layer, 784个输入) 隐藏层(Hidden Layer，784个神经元) 输出层(Output Layer，10个输出) 结束

实现代码如下：

# baseline MLP for mnist dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.utils import np_utils

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# flatten 28*28 images to a 784 vector for each image
num_pixels = X_train.shape[1] * X_train.shape[2] 
X_train = X_train.reshape(X_train.shape[0], num_pixels).astype("float32")
X_test = X_test.reshape(X_test.shape[0], num_pixels).astype("float32")

# normalize inputs from 0-255 to 0-1
X_train = X_train / 255
X_test = X_test / 255

# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]

# define baseline model
def baseline_model():
    # create model
    model = Sequential()
    model.add(Dense(num_pixels, input_dim = num_pixels, kernel_initializer = "normal", activation = "relu"))
    model.add(Dense(num_classes, kernel_initializer = "normal", activation = "softmax"))

    # compile model
    model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])
    return model

# build the model
model = baseline_model()

# fit the model
model.fit(X_train, y_train, validation_data = (X_test, y_test), epochs = 10, batch_size = 200, verbose = 2)

# final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose = 0)
print("Baseline Error: %.2f%%" % (100 - scores[1] * 100))

我使用普通的GeForce GT 740显卡加速，每轮（epoch）训练耗时约为3-5s，错误率为：1.79%。

(C:\Users\Administrator\Anaconda3) d:\Python\code\mlp>python mlp_for_mnist.py
Using TensorFlow backend.
Train on 60000 samples, validate on 10000 samples
Epoch 1/10
2017-12-16 10:15:04.752675: I C:\tf_jenkins\home\workspace\rel-win\M\windows-gpu\PY\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1030] Found device 0 with properties:
name: GeForce GT 740 major: 3 minor: 0 memoryClockRate(GHz): 1.0585
pciBusID: 0000:01:00.0
totalMemory: 1.00GiB freeMemory: 834.86MiB
2017-12-16 10:15:04.752806: I C:\tf_jenkins\home\workspace\rel-win\M\windows-gpu\PY\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: GeForce GT 740, pci bus id: 0000:01:00.0, compute capability: 3.0)
 - 5s - loss: 0.2811 - acc: 0.9206 - val_loss: 0.1412 - val_acc: 0.9575
Epoch 2/10
 - 3s - loss: 0.1116 - acc: 0.9680 - val_loss: 0.0919 - val_acc: 0.9709
Epoch 3/10
 - 3s - loss: 0.0714 - acc: 0.9798 - val_loss: 0.0786 - val_acc: 0.9776
Epoch 4/10
 - 3s - loss: 0.0503 - acc: 0.9857 - val_loss: 0.0743 - val_acc: 0.9770
Epoch 5/10
 - 3s - loss: 0.0371 - acc: 0.9892 - val_loss: 0.0685 - val_acc: 0.9789
Epoch 6/10
 - 4s - loss: 0.0268 - acc: 0.9927 - val_loss: 0.0631 - val_acc: 0.9798
Epoch 7/10
 - 3s - loss: 0.0205 - acc: 0.9947 - val_loss: 0.0624 - val_acc: 0.9808
Epoch 8/10
 - 3s - loss: 0.0141 - acc: 0.9969 - val_loss: 0.0618 - val_acc: 0.9797
Epoch 9/10
 - 3s - loss: 0.0107 - acc: 0.9978 - val_loss: 0.0583 - val_acc: 0.9818
Epoch 10/10
 - 3s - loss: 0.0082 - acc: 0.9984 - val_loss: 0.0581 - val_acc: 0.9821
Baseline Error: 1.79%

2. 稍简单的CNN模型

首先实现稍简单的CNN模型，采用“输入层-卷积层-最大汇聚层-丢弃层-扁平层-隐藏层-输出层”结构，输入层采用三维向量：1x28X28，输出层为10个输出（0-9数字的标识号），流程图如下：

Created with Raphaël 2.1.0 开始 输入层(Input Layer, 1x28x28) 卷积层(Convolutional Layer, 32映射，卷积核：5x5) 最大汇聚层(Max Pooling Layer, 2x2) 丢弃层(丢弃20%) 扁平层(将矩阵转换为向量) 隐藏层(128个神经元) 输出层(10个输出) 结束

实现代码如下：

# Simple CNNfor the MNIST Dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Convolution2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K
K.set_image_dim_ordering("th")

# fix randoom seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# reshape to be [samples] [channels] [width] [height]
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype("float32")
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype("float32")

# normalize inputs from 0-255 to 0-1
X_train = X_train / 255
X_test = X_test / 255

# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]

# define a simple CNN model
def simple_cnn_model():
    # create the model
    model = Sequential()
    model.add(Convolution2D(32, (5, 5), input_shape = (1, 28, 28), activation = "relu", padding = "valid"))
    model.add(MaxPooling2D(pool_size = (2, 2)))
    model.add(Dropout(0.2))
    model.add(Flatten())
    model.add(Dense(128, activation = "relu"))
    model.add(Dense(num_classes, activation = "softmax"))

    # compile the model
    model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

    return model

# build the model
model = simple_cnn_model()

# fit the model 
model.fit(X_train, y_train, validation_data = (X_test, y_test), epochs = 10, batch_size = 200, verbose = 2)

# evaluate the model
scores = model.evaluate(X_test, y_test, verbose = 0)
print("CNN error: %.2f%%" % (100 - scores[1] * 100))

我使用普通的GeForce GT 740显卡加速，每轮（epoch）训练耗时约为11-13s，错误率为：1.04%。

(C:\Users\Administrator\Anaconda3) d:\Python\code\mlp>python simple_cnn_for_mnist.py
Using TensorFlow backend.
2017-12-16 08:43:05.851596: I C:\tf_jenkins\home\workspace\rel-win\M\windows-gpu\PY\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1030] Found device 0 with properties:
name: GeForce GT 740 major: 3 minor: 0 memoryClockRate(GHz): 1.0585
pciBusID: 0000:01:00.0
totalMemory: 1.00GiB freeMemory: 834.86MiB
2017-12-16 08:43:05.852300: I C:\tf_jenkins\home\workspace\rel-win\M\windows-gpu\PY\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: GeForce GT 740, pci bus id: 0000:01:00.0, compute capability: 3.0)
Train on 60000 samples, validate on 10000 samples
Epoch 1/10
 - 13s - loss: 0.2340 - acc: 0.9342 - val_loss: 0.0818 - val_acc: 0.9742
Epoch 2/10
 - 13s - loss: 0.0734 - acc: 0.9782 - val_loss: 0.0468 - val_acc: 0.9843
Epoch 3/10
 - 12s - loss: 0.0533 - acc: 0.9837 - val_loss: 0.0434 - val_acc: 0.9859
Epoch 4/10
 - 12s - loss: 0.0405 - acc: 0.9876 - val_loss: 0.0406 - val_acc: 0.9866
Epoch 5/10
 - 13s - loss: 0.0338 - acc: 0.9892 - val_loss: 0.0341 - val_acc: 0.9881
Epoch 6/10
 - 11s - loss: 0.0278 - acc: 0.9912 - val_loss: 0.0325 - val_acc: 0.9892
Epoch 7/10
 - 13s - loss: 0.0236 - acc: 0.9926 - val_loss: 0.0359 - val_acc: 0.9884
Epoch 8/10
 - 12s - loss: 0.0207 - acc: 0.9938 - val_loss: 0.0336 - val_acc: 0.9885
Epoch 9/10
 - 12s - loss: 0.0170 - acc: 0.9946 - val_loss: 0.0308 - val_acc: 0.9896
Epoch 10/10
 - 12s - loss: 0.0144 - acc: 0.9957 - val_loss: 0.0333 - val_acc: 0.9896
CNN error: 1.04%

3. 更复杂的CNN模型

接下来实现更复杂的CNN模型，采用“输入层-卷积层-最大汇聚层-卷积层-最大汇聚层-丢弃层-扁平层-隐藏层-隐藏层-输出层”结构，输入层采用三维向量：1x28X28，输出层为10个输出（0-9数字的标识号），流程图如下：

Created with Raphaël 2.1.0 开始 输入层(Input Layer, 1x28x28) 卷积层(Convolutional Layer, 30映射，卷积核：5x5) 最大汇聚层(Max Pooling Layer, 2x2) 卷积层(Convolutional Layer, 15映射，卷积核：3x3) 最大汇聚层(Max Pooling Layer, 2x2) 丢弃层(Dropout Layer，丢弃20%) 扁平层(Flatten Layer，将矩阵转换为向量) 隐藏层(Hidden Layer，128个神经元) 隐藏层(Hidden Layer，50个神经元) 输出层(10个输出) 结束

实现代码如下：

# Large CNN for the MNIST Dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Convolution2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K
K.set_image_dim_ordering("th")

# fix random seed fro reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# reshape to be [samples] [channels] [width] [height]
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype("float32")
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype("float32")

# normalize inputs from 0-255 to 0-1
X_train = X_train / 255
X_test = X_test / 255

# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]

# define the large CNN model
def large_cnn_model():
    # create the model
    model = Sequential()
    model.add(Convolution2D(30, (5, 5), input_shape = (1, 28, 28), activation = "relu", padding = "valid"))
    model.add(MaxPooling2D(pool_size = (2, 2)))
    model.add(Convolution2D(15, (3, 3), activation = "relu"))
    model.add(MaxPooling2D(pool_size = (2, 2)))
    model.add(Dropout(0.2))
    model.add(Flatten())
    model.add(Dense(128, activation = "relu"))
    model.add(Dense(50, activation = "relu"))
    model.add(Dense(num_classes, activation = "softmax"))

    # Compile the model
    model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

    return model

# build the model
model = large_cnn_model()
# fit the model
model.fit(X_train, y_train, validation_data = (X_test, y_test), epochs = 10, batch_size = 200, verbose = 2)

# evalute the model 
scores = model.evaluate(X_test, y_test, verbose = 0) 
print("Large CNN Error: %.2f%%" % (100 - scores[1] * 100))

我使用普通的GeForce GT 740显卡加速，每轮（epoch）训练耗时约为11-13s，错误率为：0.80%。

(C:\Users\Administrator\Anaconda3) d:\Python\code\mlp>python large_cnn_for_mnist.py
Using TensorFlow backend.
2017-12-16 09:09:36.676635: I C:\tf_jenkins\home\workspace\rel-win\M\windows-gpu\PY\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1030] Found device 0 with properties:
name: GeForce GT 740 major: 3 minor: 0 memoryClockRate(GHz): 1.0585
pciBusID: 0000:01:00.0
totalMemory: 1.00GiB freeMemory: 834.86MiB
2017-12-16 09:09:36.676757: I C:\tf_jenkins\home\workspace\rel-win\M\windows-gpu\PY\35\tensorflow\core\common_runtime\gpu\gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: GeForce GT 740, pci bus id: 0000:01:00.0, compute capability: 3.0)
Train on 60000 samples, validate on 10000 samples
Epoch 1/10
 - 13s - loss: 0.3966 - acc: 0.8776 - val_loss: 0.1004 - val_acc: 0.9681
Epoch 2/10
 - 11s - loss: 0.0941 - acc: 0.9706 - val_loss: 0.0593 - val_acc: 0.9811
Epoch 3/10
 - 12s - loss: 0.0688 - acc: 0.9786 - val_loss: 0.0381 - val_acc: 0.9884
Epoch 4/10
 - 10s - loss: 0.0564 - acc: 0.9821 - val_loss: 0.0333 - val_acc: 0.9885
Epoch 5/10
 - 10s - loss: 0.0477 - acc: 0.9851 - val_loss: 0.0294 - val_acc: 0.9906
Epoch 6/10
 - 12s - loss: 0.0426 - acc: 0.9860 - val_loss: 0.0278 - val_acc: 0.9907
Epoch 7/10
 - 12s - loss: 0.0375 - acc: 0.9883 - val_loss: 0.0253 - val_acc: 0.9918
Epoch 8/10
 - 12s - loss: 0.0336 - acc: 0.9896 - val_loss: 0.0247 - val_acc: 0.9918
Epoch 9/10
 - 12s - loss: 0.0314 - acc: 0.9902 - val_loss: 0.0227 - val_acc: 0.9928
Epoch 10/10
 - 12s - loss: 0.0271 - acc: 0.9913 - val_loss: 0.0243 - val_acc: 0.9920
Large CNN Error: 0.80%

4. 实现细节

对于一段较长的python代码，直接在交互式窗口中编写肯定不合适，我们需要借助一个文本编辑器，编写生成python源文件（如对于MLP模型，我命名为：mlp_for_mnist.py）。注意：在Windows系统中一定不要使用记事本或写字板编写源文件，因为这两个二货根本不会输出正确的UTF-8编码！我个人强烈推荐：Sublime Text: http://www.sublimetext.com/（付费软件，但不注册最多也就是偶尔弹出购买对话框，不影响使用），该编辑器对代码的高亮显示和提示都做得不错；其次推荐：notepad++: https://notepad-plus-plus.org/，提示稍差一些，不过免费，也挺好用。
源文件编写完毕后，点击“开始”菜单，打开“Anaconda3(64-bit)–>Anaconda Prompt”窗口，切换到源文件所在的文件夹，输入“python mlp_for_mnist.py”命令，就可以执行代码了。如果执行中报错，则修改、保存源文件后，继续输入“python mlp_for_mnist.py”命令执行：

(C:\Users\Administrator\Anaconda3) C:\Users\Administrator>cd /D d:\Python\code\mlp
(C:\Users\Administrator\Anaconda3) d:\Python\code\mlp>python mlp_for_mnist.py
TensorFlow 2.0 keras开发深度学习模型实例：多层感知器（MLP），卷积神经网络（CNN）和递归神经网络（RNN）
拓端研究室TRL
01-24 785
最近我们被客户要求撰写关于TensorFlow的研究报告，包括一些图形和统计输出。
TensorFlow 2keras开发深度学习模型实例：多层感知器（MLP），卷积神经网络（CNN）和递归神经网络（RNN）...
拓端研究室TRL
03-02 749
原文链接：http://tecdat.cn/?p=15850在本文中，您将发现如何使用标准深度学习模型（包括多层感知器（MLP），卷积神经网络（CNN）和递归神经网络（RNN））开发，评估和做出预测（点击文末“阅读原文”获取完整代码数据）。相关视频开发多层感知器模型多层感知器模型（简称MLP）是标准的全连接神经网络模型。它由节点层组成，其中每个节点连接到上一层的所有输出，每个节点的输出连接到下一层...
多层感知机、卷积神经网络、深度卷积神经网络实现图片的二元分类
MXIAO56789的博客
07-19 351
应用范围： 1：人脸部照片性别识别 2：产品线上产品优劣识别 3：医疗照片是否患病识别 # 多层感应器神经网络模型 # 0. 调用要使用的包 from keras.utils import np_utils from keras.datasets import mnist from keras.models import Sequential from keras.layers import Dense, Activation width = 28 height = 28 # 1. 生成数据集 # 调用训
MLP（Multilayer Perceptron，多层感知机）
最新发布
weixin_63052030的博客
04-10 861
MLP（多层感知机）能够通过堆叠多个全连接层和引入非线性激活函数（如ReLU、Sigmoid），自动从原始输入数据中逐层提取并组合高阶特征表示，从而绕过传统机器学习中需要人工设计特征工程的环节，实现端到端的学习功能。*BERT（双向编码表示模型）是基于Transformer的双向预训练语言模型，通过掩码语言建模（MLM）和下一句预测（NSP）任务学习上下文相关词向量，成为NLP领域通用特征提取器，可微调适配多种语言任务。：通过隐藏层和激活函数的组合，MLP可逼近任意复杂函数，解决线性不可分问题。
动手学深度学习 图像分类实例-多层感知机(三) 多层感知机的简洁实现
Weary_PJ的博客
02-14 1063
动手学深度学习 图像分类实例-多层感知机(三) 多层感知机的简洁实现 多层感知机系列文章的链接已 放至文章开头 文章目录动手学深度学习 图像分类实例-多层感知机(三) 多层感知机的简洁实现前言正文引用资料来源 前言 本文介绍多层感知机的简洁实现 利用 pytorch的特点来实现图像分类功能 以下是本篇文章正文内容 正文 使用pytorch的Sequential来快速搭建网络 net = nn.Sequential( d2l.FlattenLayer(), nn.Linear(num
动手学深度学习 图像分类实例-多层感知机(二) 多层感知机的从零开始实现
Weary_PJ的博客
02-14 848
动手学深度学习 多层感知机(二) 多层感知机的从零开始实现 文章目录动手学深度学习 多层感知机(二) 多层感知机的从零开始实现前言正文代码引用资料来源 前言 本文介绍多层感知机的从零开始实现方法 尽量以通俗易懂的方式介绍 以下是本篇文章正文内容 正文 本文使用的数据集仍然为Fashion-MNIST数据集,并使用多层感知机对其进行图像分类 关于数据集的详细介绍已经放在下面的文章链接中 动手学深度学习 图像分类数据集(一) Fashion-MNIST的获取与查看 代码 # -*- coding: utf-
Matlab DNN多层感知机进行图像分类——附源码分享
班吉拉的博客
09-27 1884
提示：麻烦点赞，拒绝白嫖 文章目录前言一、数据来源二、使用步骤1.引入库2.读入数据总结 前言 Python不香吗？非得用matlab来搞机器学习的东西？不是不是，matlab也有集成了许多机器学习算法，当然，都是一些非常基础的机器学习算法。深度学习还是得向python看齐。今天试用了一下matlab自带的DNN模型，封装在newff函数里，寥寥几行代码，非常简洁。 提示：以下是本篇文章正文内容，下面案例可供参考 一、数据来源 打开画图软件自己画了10张图片，5张为A，5张为B，如下： 将它们再次
卷积和全连接神经网络实现手写数字识别.docx
12-30
卷积和全连接神经网络实现手写数字识别 本文档介绍了使用卷积神经网络和全连接神经网络实现...使用 Keras 实现手写数字识别可以使用 MNIST 数据集，并使用全连接神经网络和卷积神经网络两种方法来实现手写数字识别。
使用多层感知器进行图片分类
weixin_53506445的博客
11-29 1438
使用多层感知器进行图片分类
使用python多层感知机对图像分类
2301_81121233的博客
12-03 1035
在这个例子中，我们将使用著名的**MNIST数据集**，它包含从0到9的手写数字图像（28x28灰度图像）。3.**使用其他数据集**：虽然这个例子使用了MNIST，但你可以使用相似的代码来处理其他图像分类任务，只需确保数据格式一致。1.**调整模型架构**：你可以尝试增加或减少隐藏层的神经元数量，或者添加更多的隐藏层，看看对模型性能的影响。1.**加载和预处理数据**：从Keras加载MNIST数据集，并进行必要的预处理，例如归一化。3.**编译和训练模型**：指定损失函数、优化器，并对模型进行训练。
多层感知机（multi-layer perceptron）实现手写体分类（TensorFlow）
08-07
多层感知机（multi-layer perceptron）实现手写体分类（TensorFlow）
【动手学深度学习】简单多层感知机实现图像分类处理
qq_46370017的博客
03-17 649
多层感知机由多层神经元组成， 每一层与它的上一层相连，从中接收输入； 同时每一层也与它的下一层相连，影响当前层的神经元。
动手学深度学习 图像分类实例-多层感知机(一) 核心概念与激活函数的作用
Weary_PJ的博客
02-14 920
动手学深度学习 多层感知机(一) 核心概念与原理 拜年期间 没有电脑 就在亲戚家无聊的时候随手翻了翻《DIVE INTO DEEP LEARNING》 复习多层感知机的时候发现这本书讲的蛮好的, 弥补了之前以为自己懂了的一些漏洞, 于是便决定回家记录下来。 并根据书中的实例 巩固一下 多层感知机系列文章的链接已 放至文章开头 文章目录动手学深度学习 多层感知机(一) 核心概念与原理前言 前言 本文介绍多层感知机的基本概念和我的理解, 尽量以通俗易懂的方式介绍 以下是本篇文章正文内容 ...
深度学习基础（二）—— 从多层感知机（MLP）到卷积神经网络（CNN）
热门推荐
04-26 1万+
经典的多层感知机（Multi-Layer Perceptron）形式上是全连接（fully-connected）的邻接网络（adjacent network）。 That is, every neuron in the network is connected to every neuron in adjacent layers. Local receptive fields全连接的多层
3.1paddlepaddle数字识别，多层感知机（MLP）、卷积神经网络（CNN）
千寻的博客
12-11 1516
识别黑白图片中的数字 使用MNIST数据集 X是输入：MNIST图片是28×28 的二维图像，为了进行计算，我们将其转化为784维向量，即X=(x0,x1,…,x783)X=\left ( x_0, x_1, \dots, x_{783} \right )X=(x0​,x1​,…,x783​) Y是输出：分类器的输出是10类数字（0-9），即Y=(y0,y1,…,y9)Y=(y_0,y_1...
keras实现基于多层感知器的二分类
wzw12315的专栏
06-06 1012
import numpy as np from keras.models import Sequential from keras.layers import Dense,Dropout import tensorflow as tf import keras # 如果使用GPU版TensorFlow,并且在显卡高占用率的情况下训练模型， # 那要在初始化Session时为其分配固定数量的显存...
【深度学习】Keras MNIST手写识别（一）—— 多层感知器模型(MLP)
Mr-Ma Technology
03-21 4811
MNIST手写识别（一）—— keras 实现多层感知机(MLP) from keras import Sequential from keras.layers import Dense from keras.datasets import mnist from keras.utils import np_utils # 定义全连接网络模型 model = Sequential() model.add(Dense(units=500, input_shape=(784,), activation='rel
多层感知机和卷积神经网络图像识别(mnist,CIFAR-10)--tensorflow,keras--源码（22）
好好学习，天天向上
05-30 2234
一、多层感知机手写数字识别网络结构(mnist) 本源码的神经网络为单隐层神经网络，输出层的神经元数量为784，隐层为全连接层，隐元个数为1000.在隐层后接入一个dropput层，用来防止过拟合。输出层为神经元为10的softmax层。keras代码中手动转换了数据的存储形式，并且进行了归一化。而tensorflow中的数据已经进行了预处理，在tensorflow中数据直接使用。在keras的代码中batch_size是200，在tensorflow中的batch_size是100。
用卷积神经网络实现手写数字图像分类
05-20
手写数字图像分类是计算机视觉中的一个经典问题，可以使用卷积神经网络（Convolutional Neural Network, CNN）来实现。 以下是一些基本步骤： 1.准备数据集：MNIST数据集是一个经典的手写数字图像数据集，包含60,000个训练样本和10,000个测试样本。可以通过各种深度学习框架来获取。 2.构建模型：CNN是一种基于多层感知器（Multi-Layer Perceptron, MLP）的神经网络，它包括卷积层、池化层、全连接层等。可以使用各种深度学习框架来构建模型，例如TensorFlow、Keras等。 3.训练模型：使用数据集对模型进行训练，通常使用随机梯度下降（Stochastic Gradient Descent, SGD）算法进行优化。 4.评估模型：使用测试集评估模型的性能，例如准确率（accuracy）等指标。 下面是一个简单的CNN模型实现手写数字图像分类的示例代码（使用Keras框架）： ```python import tensorflow as tf from tensorflow.keras import datasets, layers, models # 加载数据集 (train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data() # 对数据进行预处理 train_images = train_images.reshape((60000, 28, 28, 1)) test_images = test_images.reshape((10000, 28, 28, 1)) train_images, test_images = train_images / 255.0, test_images / 255.0 # 构建模型 model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(10)) # 编译模型 model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) # 训练模型 model.fit(train_images, train_labels, epochs=5, validation_data=(test_images, test_labels)) # 评估模型 test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc) ``` 在上面的代码中，我们使用了卷积层、池化层和全连接层构建了一个简单的CNN模型，并使用MNIST数据集进行训练和测试。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值