手写数字识别mxnet官网例子.docx

手写数字识别mxnet官网例子.docx

《手写数字识别mxnet官网例子.docx》由会员分享，可在线阅读，更多相关《手写数字识别mxnet官网例子.docx（7页珍藏版）》请在冰豆网上搜索。

手写数字识别mxnet官网例子

手写数字识别

简介：

通过MNIST数据集建立一个手写数字分类器。

（MNIST对于手写数据分类任务是一个广泛使用的数据集）。

1.前提：

mxnet0.10及以上、python、jupyternotebook（有时间可以jupyternotebook的用法，如：

PPT的制作）

pipinstallrequestsjupyter——python下jupyternotebook的安装

2.加载数据集：

importmxnetasmx

mnist=mx.test_utils.get_mnist（）

此时MXNET数据集已完全加载到内存中（注：

此法对于大型数据集不适用）

考虑要素：

快速高效地从源直接流数据+输入样本的顺序

图像通常用4维数组来表示：

（batch_size，num_channels，width，height）

对于MNIST数据集，因为是28*28灰度图像，所以只有1个颜色通道，width=28，height=28，本例中batch=100（批处理100），即输入形状是（batch_size，1，28，28）

数据迭代器通过随机的调整输入来解决连续feed相同样本的问题。

测试数据的顺序无关紧要。

batch_size=100

train_iter=mx.io.NDArrayIter（mnist['train_data'],mnist['train_label'],batch_size,shuffle=True）

val_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）

——初始化MNIST数据集的数据迭代器（2个：

训练数据+测试数据）

3.训练+预测：

（2种方法）（CNN优于MLP）

1）传统深度神经网络结构——MLP（多层神经网络）

MLP——MXNET的符号接口

为输入的数据创建一个占位符变量

data=mx.sym.var（'data'）

data=mx.sym.flatten（data=data）

——将数据从4维变成2维（batch_size,num_channel*width*height）

fc1=mx.sym.FullyConnected（data=data,num_hidden=128）

act1=mx.sym.Activation（data=fc1,act_type="relu"）

——第一个全连接层及相应的激活函数

fc2=mx.sym.FullyConnected（data=act1,num_hidden=64）

act2=mx.sym.Activation（data=fc2,act_type="relu"）

——第二个全连接层及相应的激活函数

（声明2个全连接层，每层有128个和64个神经元）

fc3=mx.sym.FullyConnected（data=act2,num_hidden=10）

——声明大小10的最终完全连接层

mlp=mx.sym.SoftmaxOutput（data=fc3,name='softmax'）

——softmax的交叉熵损失

MNIST的MLP网络结构

以上，已完成了数据迭代器和神经网络的申明，下面可以进行训练。

超参数：

处理大小、学习速率

importlogging

logging.getLogger（）.setLevel（logging.DEBUG）——记录到标准输出

mlp_model=mx.mod.Module（symbol=mlp,context=mx.cpu（））

——在CPU上创建一个可训练的模块

mlp_model.fit（train_iter——训练数据

eval_data=val_iter,——验证数据

optimizer='sgd',——使用SGD训练optimizer_params={'learning_rate':

0.1},——使用固定的学习速率

eval_metric='acc',——训练过程中报告准确性batch_end_callback=mx.callback.Speedometer（batch_size,100）,——每批次100数据输出的进展num_epoch=10）——训练至多通过10个数据

预测：

test_iter=mx.io.NDArrayIter（mnist['test_data'],None,batch_size）

prob=mlp_model.predict（test_iter）

assertprob.shape==（10000,10）

——计算每一个测试图像可能的预测得分（prob[i][j]第i个测试图像包含j输出类）

test_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）——预测精度的方法

acc=mx.metric.Accuracy（）

mlp_model.score（test_iter,acc）

print（acc）

assertacc.get（）[1]>0.96

如果一切顺利的话，我们将看到一个准确的值大约是0.96，这意味着我们能够准确地预测96%的测试图像中的数字。

2）卷积神经网络（CNN）

卷积层+池化层

data=mx.sym.var（'data'）

conv1=mx.sym.Convolution（data=data,kernel=（5,5）,num_filter=20）

tanh1=mx.sym.Activation（data=conv1,act_type="tanh"）

pool1=mx.sym.Pooling（data=tanh1,pool_type="max",kernel=（2,2）,stride=（2,2））

——第一个卷积层、池化层

conv2=mx.sym.Convolution（data=pool1,kernel=（5,5）,num_filter=50）——第二个卷积层

tanh2=mx.sym.Activation（data=conv2,act_type="tanh"）

pool2=mx.sym.Pooling（data=tanh2,pool_type="max",kernel=（2,2）,stride=（2,2））

flatten=mx.sym.flatten（data=pool2）——第一个全连接层

fc1=mx.symbol.FullyConnected（data=flatten,num_hidden=500）

tanh3=mx.sym.Activation（data=fc1,act_type="tanh"）

fc2=mx.sym.FullyConnected（data=tanh3,num_hidden=10）——第二个全连接层

lenet=mx.sym.SoftmaxOutput（data=fc2,name='softmax'）——Softmax损失

LeNet第一个卷积层+池化层

lenet_model=mx.mod.Module（symbol=lenet,context=mx.cpu（））

——在GPU上创建一个可训练的模块

lenet_model.fit（train_iter,

eval_data=val_iter,

optimizer='sgd',

optimizer_params={'learning_rate':

0.1},

eval_metric='acc',

batch_end_callback=mx.callback.Speedometer（batch_size,100）,

num_epoch=10）

——训练（同MLP）

test_iter=mx.io.NDArrayIter（mnist['test_data'],None,batch_size）

prob=lenet_model.predict（test_iter）

test_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）

acc=mx.metric.Accuracy（）——预测LeNet的准确性

lenet_model.score（test_iter,acc）

print（acc）

assertacc.get（）[1]>0.98

使用CNN，我们能够正确地预测所有测试图像的98%左右。

附：

完整代码

1）MLP

importmxnetasmx

mnist=mx.test_utils.get_mnist（）

batch_size=100

train_iter=mx.io.NDArrayIter（mnist['train_data'],mnist['train_label'],batch_size,shuffle=True）

val_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）

data=mx.sym.var（'data'）

data=mx.sym.flatten（data=data）

fc1=mx.sym.FullyConnected（data=data,num_hidden=128）

act1=mx.sym.Activation（data=fc1,act_type="relu"）

fc2=mx.sym.FullyConnected（data=act1,num_hidden=64）

act2=mx.sym.Activation（data=fc2,act_type="relu"）

fc3=mx.sym.FullyConnected（data=act2,num_hidden=10）

mlp=mx.sym.SoftmaxOutput（data=fc3,name='softmax'）

importlogging

logging.getLogger（）.setLevel（logging.DEBUG）

mlp_model=mx.mod.Module（symbol=mlp,context=mx.cpu（））

mlp_model.fit（train_iter,

eval_data=val_iter,

optimizer='sgd',

optimizer_params={'learning_rate':

0.1},

eval_metric='acc',

batch_end_callback=mx.callback.Speedometer（batch_size,100）,

num_epoch=10）

test_iter=mx.io.NDArrayIter（mnist['test_data'],None,batch_size）

prob=mlp_model.predict（test_iter）

assertprob.shape==（10000,10）

test_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）

acc=mx.metric.Accuracy（）

mlp_model.score（test_iter,acc）

print（acc）

assertacc.get（）[1]>0.96

2）CNN

importmxnetasmx

mnist=mx.test_utils.get_mnist（）

batch_size=100

train_iter=mx.io.NDArrayIter（mnist['train_data'],mnist['train_label'],batch_size,shuffle=True）

val_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）

data=mx.sym.var（'data'）

conv1=mx.sym.Convolution（data=data,kernel=（5,5）,num_filter=20）

tanh1=mx.sym.Activation（data=conv1,act_type="tanh"）

pool1=mx.sym.Pooling（data=tanh1,pool_type="max",kernel=（2,2）,stride=（2,2））

conv2=mx.sym.Convolution（data=pool1,kernel=（5,5）,num_filter=50）

tanh2=mx.sym.Activation（data=conv2,act_type="tanh"）

pool2=mx.sym.Pooling（data=tanh2,pool_type="max",kernel=（2,2）,stride=（2,2））

flatten=mx.sym.flatten（data=pool2）

fc1=mx.symbol.FullyConnected（data=flatten,num_hidden=500）

tanh3=mx.sym.Activation（data=fc1,act_type="tanh"）

fc2=mx.sym.FullyConnected（data=tanh3,num_hidden=10）

lenet=mx.sym.SoftmaxOutput（data=fc2,name='softmax'）

lenet_model=mx.mod.Module（symbol=lenet,context=mx.cpu（））

lenet_model.fit（train_iter,

eval_data=val_iter,

optimizer='sgd',

optimizer_params={'learning_rate':

0.1},

eval_metric='acc',

batch_end_callback=mx.callback.Speedometer（batch_size,100）,

num_epoch=10）

test_iter=mx.io.NDArrayIter（mnist['test_data'],None,batch_size）

prob=lenet_model.predict（test_iter）

test_iter=mx.io.NDArrayIter（mnist['test_data'],mnist['test_label'],batch_size）

acc=mx.metric.Accuracy（）

lenet_model.score（test_iter,acc）

print（acc）

assertacc.get（）[1]>0.98