利用mxnet自定义一个简单的神经网络（很简单的） - 简书
利用mxnet自定义一个简单的神经网络（很简单的）
神经网络简介
训练一个神经网络需要六步：(1).搭建神经网络的框架(2).初始化神经网（输入输出的shape，各个weight以及bias的初始值）(3).利用train data，forward产生每一层每一个神经元的激活值(4).backword，计算每一层对输出的差值？？（有待再定）(5). 利用优化算法去更新weights和bias(6).计算准确率并输出。
mxnet设计神经网络步骤
注意一下的1-6，每一步都对应了上面的六步
create network
initial 2.1
loaddate &&知道输入输出的shape，进行迭代设置，并SimpleBind，为network分配空间2.2 初始化 需：获取参数列表，对weights和bias初始化（使用mxnet.init.Uniform()）
产生激活值
for epoch in epoch_num:
for batch in iter:
backwordforward之后就可以进行backword。
updata 神经网络中有很多常见的优化算法，当然这些所谓的优化，其实就是去计算偏导数（梯度）。于是我们在更新前，都需要对这个优化做出定义，当然在mxnet实现神经网络中，已经有了很多。我们需要挑选优化函数，然后进行update
最后计算真确度，可以利用mxnet中的mx.metric.Accuracy()进行准确度计算，无需自己去定义和设计了。
这是一个写的很详细，而且特别棒！
以下是一个简单的代码，几乎和上面教学代码相同，只是做了一些自己的笔记
def myNN(datapath,net,batch_size,epochs, learningrate):
create network Symbol(just a graph no any space)
1.initial the element in the network
注意：the initial is not only give the first weight and bias, we need tell the computer to
allocate the memory for the element in the network
所以 ：SimpleBind let mxnet give related memory for network
train_iter, test_iter = loaddata2DataIter(datapath,batchsize=batch_size)
# loaddata2DataIter：定义在下面#download data to mxnet.io.NDIter 下载数据并转成相应的mx的type
train_info = train_iter.provide_data+train_iter.provide_label
input_info = dict(train_info)
#data:softmax_label:shape#train_itera.provide_data的数据的长度是1，元素是('data', (60, 784)
# allocate memory by Simplebind in net
exe = net.simple_bind(ctx=mx.cpu(), **input_info)
#combile network arguments and simple_bind allocate array
exe_info = dict(zip(net.list_arguments(), exe.arg_arrays))
#initial weight and bias
init = mx.init.Uniform(scale=0.08)
for i,j in exe_info.items():
if i not in input_info:
updater = update_SGD(learningrate,train_iter) #具体定义在下面，建立更新器（使用的优化算法是SGD）
#caculate mericy
metric = mx.metric.Accuracy()
# train loop
for epoch in range(epochs):
train_iter.reset()
metric.reset()
for batch in train_iter:
exe_info['data'][:]=batch.data[0]
#[:] is very important but why，没有他就会错，全部复制
exe_info['softmax_label'][:]= batch.label[0]
exe.forward(is_train=True)
exe.backward()
for index, args in enumerate(zip(exe.arg_arrays,exe.grad_arrays)):
weight, grad = args
updater(index,grad,weight)#update each weight and grad
metric.update(batch.label,exe.outputs)
# if num % 60 == 0:
# print 'epoch',epoch,'iter',num,'metric',metric.get()
for batch in test_iter:
exe_info['data'][:] = batch.data[0]
exe_info['softmax_label'][:] = batch.label[0]
exe.forward()
metric.update(batch.label,exe.outputs)
print 'epoch',epoch,'test',metric.get()
def update_SGD(learnigrate,train_iter):
opt_SGD = mx.optimizer.SGD(
learning_rate=learnigrate,
momentum=0.8,
wd=0.00001,
rescale_grad=1.0/(train_iter.batch_size )#True or False
update = mx.optimizer.get_updater(opt_SGD)
return update
def loaddata2DataIter(datapath,batchsize):
#:param datapath: all data path
#:param batchsize:
#:return: train_iter, test_iter
train_d, train_l, test_d, test_l = load_data(datapath)
train_iter = mx.io.NDArrayIter(train_d, train_l, batch_size=batchsize)
test_iter = mx.io.NDArrayIter(test_d, test_l, batch_size=batchsize)
# test_iter.
# mxnet.io.NDArrayIter encapsulate the data ,help us get information from data easily
return train_iter, test_iter
def createNetWorkL1(hidden):
create a one layer network,
#:param hidden: fullyconnected layer hidden_num
imput_layer = mx.sym.Variable('data')
# output_layer = mx.sym.Variable('out')
# layer1: fullyconnected
fc = mx.sym.FullyConnected(data=imput_layer, name='fullconnectlayer', num_hidden=hidden)
act = mx.sym.Activation(data=fc, name='actlayer', act_type='relu')
net = mx.sym.SoftmaxOutput(data=act, name='softmax')
return net
每一天都比前一天好！Mxnet训练自己的数据集并测试
使用Mxnet训练图片分类类器
１、准备数据：
(1)建立一个根目录然后，再为每一个类别的图片建立一个子文件夹，把每一类图片放入对应的子文件夹即可。
----class1
----class2
----classn
首先生成训练集和测试集的list,命令如下：
~/mxnet/tools/im2rec.py －－list True －－recursive True －－train-ratio 0.9 myData /home/xxx/root/
&list：当要生成list文件时，这个参数一定要设为True，表示当前用来生成的list文件；默认是生成rec文件；
&recursive：递归的遍历你的所有数据集，要设为True；
&train-ratio：用来将你的全部数据集拆分成两部分：训练集（train）和交叉验证集（val），具体多少作为训练集，多少作为验证集，就由这个参数来确定；
&test-ratio：同上，分成训练集和测试集两部分；
&exts：这个是你数据的后缀（注，这里我们一般说的图片数据），目前的MXNet只支持两种图片格式：jpg和jpeg。
执行完这个命令，你会发现生成两个文件：myData_train.lst和myData_val.lst
(2)生成rec文件:
python ~/mxnet/tools/im2rec.py &num-thread 4 &pass-through 1 myData /home/xxx/root/
&pass-through: 设为1，即跳过矩阵变换，否则会报错：未知的array type；
myData就是第一步中生成.lst文件的前缀，这里用它来生成rec；
执行完这条命令，你就会看到两个文件：myData_train.rec和myData_val.rec
２、加载训练数据以及验证数据集：
def get_iterators(batch_size, data_shape=(3, 224, 224)):
train = mx.io.ImageRecordIter(
path_imgrec
= './ld_train/my_images_train.rec',
= 'data',
label_name
= 'softmax_label',
batch_size
= batch_size,
data_shape
= data_shape,
rand_mirror
val = mx.io.ImageRecordIter(
path_imgrec
= './ld_train/my_images_val.rec',
= 'data',
label_name
= 'softmax_label',
batch_size
= batch_size,
data_shape
= data_shape,
rand_mirror
return (train, val)
train,val=get_iterators(128,(3,128,128))＃指定Batch_size以及图片大小。
３、定义网络结构：
这里以resnet为例：
'''
Adapted from /tornadomeet/ResNet/blob/master/symbol_resnet.py
Original author Wei Wu
Implemented the following paper:
Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun. &Identity Mappings in Deep Residual Networks&
'''
import mxnet as mx
import numpy as np
def residual_unit(data, num_filter, stride, dim_match, name, bottle_neck=True, bn_mom=0.9, workspace=256, memonger=False):
&&&Return ResNet Unit symbol for building ResNet
Parameters
----------
data : str
Input data
num_filter : int
Number of output channels
Bottle neck channels factor with regard to num_filter
stride : tupe
Stride used in convolution
dim_match : Boolen
True means channel number between input and output is the same, otherwise means differ
name : str
Base name of the operators
workspace : int
Workspace used in convolution operator
if bottle_neck:
# the same as /facebook/fb.resnet.torch#notes, a bit difference with origin paper
bn1 = mx.sym.BatchNorm(data=data, fix_gamma=False, eps=2e-5, momentum=bn_mom, name=name + '_bn1')
act1 = mx.sym.Activation(data=bn1, act_type='relu', name=name + '_relu1')
weight = mx.symbol.Variable(name=name + '_conv1_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
conv1 = mx.sym.Convolution(data=act1, weight=weight, num_filter=int(num_filter*0.25), kernel=(1,1), stride=(1,1), pad=(0,0),
no_bias=True, workspace=workspace, name=name + '_conv1')
bn2 = mx.sym.BatchNorm(data=conv1, fix_gamma=False, eps=2e-5, momentum=bn_mom, name=name + '_bn2')
act2 = mx.sym.Activation(data=bn2, act_type='relu', name=name + '_relu2')
weight = mx.symbol.Variable(name=name + '_conv2_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
conv2 = mx.sym.Convolution(data=act2, weight=weight, num_filter=int(num_filter*0.25), kernel=(3,3), stride=stride, pad=(1,1),
no_bias=True, workspace=workspace, name=name + '_conv2')
bn3 = mx.sym.BatchNorm(data=conv2, fix_gamma=False, eps=2e-5, momentum=bn_mom, name=name + '_bn3')
act3 = mx.sym.Activation(data=bn3, act_type='relu', name=name + '_relu3')
weight = mx.symbol.Variable(name=name + '_conv3_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
conv3 = mx.sym.Convolution(data=act3, weight=weight, num_filter=num_filter, kernel=(1,1), stride=(1,1), pad=(0,0), no_bias=True,
workspace=workspace, name=name + '_conv3')
if dim_match:
shortcut = data
weight = mx.symbol.Variable(name=name + '_sc_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
shortcut = mx.sym.Convolution(data=act1, weight=weight, num_filter=num_filter, kernel=(1,1), stride=stride, no_bias=True,
workspace=workspace, name=name+'_sc')
if memonger:
shortcut._set_attr(mirror_stage='True')
return conv3 + shortcut
bn1 = mx.sym.BatchNorm(data=data, fix_gamma=False, momentum=bn_mom, eps=2e-5, name=name + '_bn1')
act1 = mx.sym.Activation(data=bn1, act_type='relu', name=name + '_relu1')
weight = mx.symbol.Variable(name=name + '_conv1_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
conv1 = mx.sym.Convolution(data=act1, weight=weight, num_filter=num_filter, kernel=(3,3), stride=stride, pad=(1,1),
no_bias=True, workspace=workspace, name=name + '_conv1')
bn2 = mx.sym.BatchNorm(data=conv1, fix_gamma=False, momentum=bn_mom, eps=2e-5, name=name + '_bn2')
act2 = mx.sym.Activation(data=bn2, act_type='relu', name=name + '_relu2')
weight = mx.symbol.Variable(name=name + '_conv2_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
conv2 = mx.sym.Convolution(data=act2, weight=weight, num_filter=num_filter, kernel=(3,3), stride=(1,1), pad=(1,1),
no_bias=True, workspace=workspace, name=name + '_conv2')
if dim_match:
shortcut = data
weight = mx.symbol.Variable(name=name + '_sc_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
shortcut = mx.sym.Convolution(data=act1, weight=weight, num_filter=num_filter, kernel=(1,1), stride=stride, no_bias=True,
workspace=workspace, name=name+'_sc')
if memonger:
shortcut._set_attr(mirror_stage='True')
return conv2 + shortcut
def resnet(units, num_stages, filter_list, num_classes, image_shape, bottle_neck=True, bn_mom=0.9, workspace=256, memonger=False):
&&&Return ResNet symbol of
Parameters
----------
units : list
Number of units in each stage
num_stages : int
Number of stage
filter_list : list
Channel size of each stage
num_classes : int
Ouput size of symbol
dataset : str
Dataset type, only cifar10 and imagenet supports
workspace : int
Workspace used in convolution operator
num_unit = len(units)
assert(num_unit == num_stages)
data = mx.sym.Variable(name='data')
data = mx.symbol.Cast(data=data, dtype=np.float16)
data = mx.sym.BatchNorm(data=data, fix_gamma=True, eps=2e-5, momentum=bn_mom, name='bn_data')
(nchannel, height, width) = image_shape
weight = mx.symbol.Variable(name='conv0_weight', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
if height &= 32:
# such as cifar10
body = mx.sym.Convolution(data=data, weight=weight, num_filter=filter_list[0], kernel=(3, 3), stride=(1,1), pad=(1, 1),
no_bias=True, name=&conv0&, workspace=workspace)
# often expected to be 224 such as imagenet
body = mx.sym.Convolution(data=data, weight=weight, num_filter=filter_list[0], kernel=(7, 7), stride=(2,2), pad=(3, 3),
no_bias=True, name=&conv0&, workspace=workspace)
body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
body = mx.sym.Activation(data=body, act_type='relu', name='relu0')
body = mx.symbol.Pooling(data=body, kernel=(3, 3), stride=(2,2), pad=(1,1), pool_type='max')
for i in range(num_stages):
body = residual_unit(body, filter_list[i+1], (1 if i==0 else 2, 1 if i==0 else 2), False,
name='stage%d_unit%d' % (i + 1, 1), bottle_neck=bottle_neck, workspace=workspace,
memonger=memonger)
for j in range(units[i]-1):
body = residual_unit(body, filter_list[i+1], (1,1), True, name='stage%d_unit%d' % (i + 1, j + 2),
bottle_neck=bottle_neck, workspace=workspace, memonger=memonger)
bn1 = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn1')
relu1 = mx.sym.Activation(data=bn1, act_type='relu', name='relu1')
# Although kernel is not used here when global_pool=True, we should put one
pool1 = mx.symbol.Pooling(data=relu1, global_pool=True, kernel=(7, 7), pool_type='avg', name='pool1')
flat = mx.symbol.Flatten(data=pool1)
weight = mx.symbol.Variable(name='fc1_weight', dtype=np.float32)
bias = mx.symbol.Variable(name='fc1_bias', dtype=np.float32)
weight = mx.symbol.Cast(data=weight, dtype=np.float16)
bias = mx.symbol.Cast(data=bias, dtype=np.float16)
fc1 = mx.symbol.FullyConnected(data=flat, weight=weight, bias=bias, num_hidden=num_classes, name='fc1')
fc1 = mx.symbol.Cast(data=fc1, dtype=np.float32)
return mx.symbol.SoftmaxOutput(data=fc1, name='softmax')
def get_symbol(num_classes, num_layers, image_shape, conv_workspace=256, **kwargs):
Adapted from /tornadomeet/ResNet/blob/master/train_resnet.py
Original author Wei Wu
image_shape = [int(l) for l in image_shape.split(',')]
(nchannel, height, width) = image_shape
if height &= 28:
num_stages = 3
if (num_layers-2) % 9 == 0 and num_layers &= 164:
per_unit = [(num_layers-2)//9]
filter_list = [16, 64, 128, 256]
bottle_neck = True
elif (num_layers-2) % 6 == 0 and num_layers & 164:
per_unit = [(num_layers-2)//6]
filter_list = [16, 16, 32, 64]
bottle_neck = False
raise ValueError(&no experiments done on num_layers {}, you can do it youself&.format(num_layers))
units = per_unit * num_stages
if num_layers &= 50:
filter_list = [64, 256, 512, ]
bottle_neck = True
filter_list = [64, 64, 128, 256, 512]
bottle_neck = False
num_stages = 4
if num_layers == 18:
units = [2, 2, 2, 2]
elif num_layers == 34:
units = [3, 4, 6, 3]
elif num_layers == 50:
units = [3, 4, 6, 3]
elif num_layers == 101:
units = [3, 4, 23, 3]
elif num_layers == 152:
units = [3, 8, 36, 3]
elif num_layers == 200:
units = [3, 24, 36, 3]
elif num_layers == 269:
units = [3, 30, 48, 8]
raise ValueError(&no experiments done on num_layers {}, you can do it youself&.format(num_layers))
return resnet(units
num_stages
= num_stages,
filter_list = filter_list,
num_classes = num_classes,
image_shape = image_shape,
bottle_neck = bottle_neck,
= conv_workspace)
resnet18=get_symbol(2,18,'3,128,128')
４、训练并保存模型：
# construct a callback function to save checkpoints
model_prefix = 'resnet18'
checkpoint = mx.callback.do_checkpoint(model_prefix)
mod = mx.mod.Module(symbol=lenet,context=mx.gpu(0))
mod.fit(train,
eval_data=val,
optimizer='sgd',
optimizer_params={'learning_rate':0.001, 'momentum': 0.9},
eval_metric='acc',
num_epoch=30,
epoch_end_callback=checkpoint)
５、加载模型准备测试：
sym, arg_params, aux_params = mx.model.load_checkpoint('resnet18', 30)
mod = mx.mod.Module(symbol=sym, context=mx.gpu(0), label_names=None)
mod.bind(for_training=False, data_shapes=[('data', (1,3,128,128))],
label_shapes=mod._label_shapes)
mod.set_params(arg_params, aux_params, allow_missing=True)
６、测试数进行预测：
%matplotlib inline
import matplotlib.pyplot as plt
import cv2
import numpy as np
# define a simple data batch
from collections import namedtuple
Batch = namedtuple('Batch', ['data'])
def get_image(path, show=False):
# download and show the image
img = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)
if img is None:
return None
plt.imshow(img)
plt.axis('off')
# convert into format (batch, RGB, width, height)
img = cv2.resize(img, (128, 128))
img = np.swapaxes(img, 0, 2)
img = np.swapaxes(img, 1, 2)
img = img[np.newaxis, :]
return img
def predict(path):
img = get_image(path, show=True)
# compute the predict probabilities
mod.forward(Batch([mx.nd.array(img)]))
prob = mod.get_outputs()[0].asnumpy()
# print the top-5
prob = np.squeeze(prob)
a = np.argsort(prob)[::-1]
for i in a[0:5]:
print((prob[i]))
predict('/home/test_images/cat.jpg')13440人阅读
深度学习基础（11）
由于caffe依赖性太多，配置极其复杂，所以将接下来的学习转向mxnet.因此本文主要记录我的学习历程，如果描述有什么问题，欢迎大家的指正。
mxnet的优点很明显，简洁灵活效率高 ，多机多卡支持好。
mxnet的github下载链接：
mxnet的开发文档链接：
开发文档清晰易读，包含安装、语法、示例等，并且还在不断丰富当中
1- linux下安装mxnet和python接口配置
mxnet可以安装到linux、OSX和windows下。由于windows下配置相对较为复杂，故这里选择安装在linux下。
具体我的linux版本为64位的ubuntu14.04LTS，之前使用ubuntu15时发现不是很稳定。还有，这里我是在笔记本上安装的，因此没有安装CUDA、CUDNN之类的GPU管理程序。
mxnet支持在线安装，在终端中单步依次执行以下代码：
sudo apt-get update
sudo apt-get install -y build-essential git libatlas-base-dev libopencv-dev
git clone --recursive https:
python接口的配置:
mxnet目前主要支持python、R和Julia这3种接口。我选择了相对熟悉的python。
mxnet要求2.7及以上版本的python和numpy库，一般linux都自带python编译器，因此我们只需要再检查一下是否缺少numpy库。可以直接输入下面的numpy安装代码：
sudo apt-get install python-numpy
上面处理完成之后可以尝试一下能否运行官方提供的一个案例：在mnist数据集上训练一个多层感知器MLP。
python mxnet/example/image-classification/train_mnist.py
如果之前配置过GPU(如何配置可以参考官方文档)，可以尝试用GPU测试一下网络：
python mxnet/example/image-classification/train_mnist.py --network lenet --gpus 0
注意：上述过程完成后，直接在python中执行以下代码(如 import mxnet as mx)可能会提示“no module named ”,这可能是因为未添加路径导致的。可以通过单步依次执行下面代码解决：
export PYTHONPATH=~/mxnet/python
cp -r ~/mxnet/python/mxnet .
cp ~/mxnet/lib/libmxnet.so mxnet/
2- 如何将训练图片转换格式并送入网络
就好像在caffe中训练模型之前要现将训练图片转化为leveldb或者LMDB格式数据一样，mxnet在训练之前也要先将图片转化为REC格式的数据。
这里直接记录转换过程，后续会详细讲解REC数据格式的编码以及最终如何将REC格式数据再加载到网络当中。
linux下转换使用的工具是mxnet/bin下名为“im2rec”的可执行文件，该文件的源码可以查看mxnet/tools/im2rec.cc
首先，来说明以下im2rec这个转换工具有哪些输入参数：
首先是必须输入的3个参数，依次是
image_lst:
//保存图片和标签信息的文本的名字
image_root_dir：
output_rec：
可选的输入参数有：
label_width:
%%例如图片尺寸为300*200，resize=100,那么调整之后图片尺寸为150*100.
center_crop：
%%注意，这里只是大概平分，例如12个训练图片，nsplit=3，实际分块为5+4+3，而不是预想中的4+4+4.（关于这一点我也还没搞明白）
这里举一个实际应用的例子
（1）首先是保存图片和标签信息的文本，这里我的文件是train.txt.
编号 标签 图片名
1 0 FY2D1.bmp
2 1 FY2E1.bmp
3 0 FY2D2.bmp
4 1 FY2E2.bmp
（2）为了方便运行和调整参数，这里写了一个类似于windows批处理命令一样的可执行文件，来调用im2rec。这里我的可执行文件名为convert.sh，训练图片存储于data文件夹，转换后的结果保存到当前文件夹下，命名为train.rec
/home/zfan/mxnet/bin/im2rec train.txt data/ train.rec quality=90 resize=1000
（3）打开终端，cd到convert.sh所在文件夹，输入
./convert.sh
回车。运行提示如下：
[15:44:19] tools/im2rec.cc:54: New Image Size: Short Edge 1000
[15:44:19] tools/im2rec.cc:76: Write to output: train.rec
[15:44:19] tools/im2rec.cc:78: Output: train.rec
[15:44:19] tools/im2rec.cc:86: JPEG encoding quality: 90
[15:44:19] tools/im2rec.cc:160: Total: 4 images processed, 0.166033 sec elapsed
迭代器-将转换后的数据送入网络:
总体来说，开始一项训练，需要3个部分：训练参数、网络模型和训练数据。在上一小节，我已经详细介绍了如何将原始图片数据转化为mxnet可以接受的REC格式数据。但是，实际训练的时候我们还需要一个工具来将REC数据送入我们的训练网络中。这个工具就是“迭代器”-iterator
mxnet为我们提供了快速构建迭代器的函数ImageRecordIter，该函数位于python/mxnet/io.py中，其返回一个迭代器对象。或者可以在python命令窗中键入以下命令来获取io函数的位置以及说明：
import mxnet as mx
help(mx.io)
接下来说明ImageRecordIter的几个常用参数：（更多的参数可以通过上面的help查看）
path_imgrec：rec图像数据的存储路径；string型数据；默认为'./data/imgrec.rec'
data_shape：迭代器产生的每一个实例的形状，即图片数据的形状；元组型数据；必选参数
mean_img：图像均值文件的存放路径；string型数据；默认为空
batch_size：batch的大小；int型数据；必选参数
shuffle：是否打乱数据；布尔型数据；默认为F
mirror：是否对图片执行镜像操作；布尔型数据；默认为F
rand_mirror：是否随机地对图片执行镜像操作；布尔型数据；默认为F
rand_crop：是否随机地对图片执行剪切操作；布尔型数据；默认为F
label_width：图片的标签个数；int型数据；默认为1
mean_r、 mean_g、 mean_b:3个颜色通道的均值；float型数据；默认为0
num_parts：将训练数据分为几份；int型数据；默认为1
part_index:第几部分数据将会被读取；int型数据；默认为0
接下来以实例来说明怎样构建迭代器，该例子位于example/image-classification/train_imagenet.py中
def get_iterator(args, kv):
train = mx.io.ImageRecordIter(
path_imgrec = args.data_dir + "train.rec",
= args.data_dir + "mean.bin",
data_shape
= data_shape,
batch_size
= args.batch_size,
rand_mirror = True,
= kv.num_workers,
part_index
= kv.rank)
val = mx.io.ImageRecordIter(
path_imgrec = args.data_dir + "val.rec",
= args.data_dir + "mean.bin",
rand_mirror = False,
data_shape
= data_shape,
batch_size
= args.batch_size,
= kv.num_workers,
part_index
= kv.rank)
return (train, val)
3- 构建一个网络模型
一个网络模型是一层一层连接器来的，因此想要构建一个网络模型，首先我们得知道mxnet中都有哪些可以用的层。(以下按照使用频率来排序)
下面介绍一些比较常用的层，更多的层大家可以在python命令窗执行以下代码来查询
import mxnet as mx
help(mx.symbol)
(1)Activation：激活函数
data: 输入数据，symbol型变量
act_type: {'relu', 'sigmoid', 'tanh'}, 可选的3种激活函数
(2)Convolution:卷积层
data:输入数据，symbol型变量
weight：权重矩阵，symbol型变量
bias:偏置，symbol型变量
kernal:卷积核的尺寸（y,x）,二维tuple型变量
stride：卷积步长（y,x）,二维tuple型变量，默认为（1,1）
pad：卷积的填补量（y,x）,二维tuple型变量，默认为（0,0）
num_filter ：卷积滤波器(通道)个数，int型变量
no_bias ：是否取消偏置，布尔型变量，默认为False
num_group：groups划分的个数，int型变量，默认为1.该选项不被CUDNN所支持， you can use SliceChannel to num_group,apply convolution and concat instead to achieve the same need.
workspace：卷积的Tmp工作空间的大小MB。long型变量，默认为512
(3)Deconvolution：反卷积层
参数同卷积层一致
(4)Dropout：
data:输入数据，symbol型变量
p : 训练时对输入数据进行dropped out的比例，float型变量，默认为0.5
(5)Flatten:将N维数据变为1维
data:输入数据，symbol型变量
name : string, optional. Name of the resulting symbol.
(6)FullyConnected：全连接层
data:输入数据，symbol型变量
weight：权重矩阵，symbol型变量
bias:偏置，symbol型变量
no_bias ：是否取消偏置，布尔型变量，默认为False
num_hidden：输出隐藏节点的个数，int型变量
data:输入数据，symbol型变量
alpha : float, optional, default=0.0001.value of the alpha variance scaling parameter in the normalization formula
beta : float, optional, default=0.75.value of the beta power parameter in the normalization formula
knorm : float, optional, default=2.value of the k parameter in normalization formula
nsize : int (non-negative), required.normalization window width in elements.
(8)Pooling
data:输入数据，symbol型变量
kernal:pooling核的尺寸（y,x）,二维tuple型变量
stride：pooling步长（y,x）,二维tuple型变量，默认为（1,1）
pad：pooling的填补量（y,x）,二维tuple型变量，默认为（0,0）
pool_type : pooling的类型，可选的3种{'avg', 'max', 'sum'}
(9)SoftmaxOutput：使用logloss进行BP
data:输入数据，symbol型变量
grad_scale : 为梯度乘以一个比例系数，float型变量，默认为1
multi_output : 布尔型变量，默认为False
(10)Variable：定义一个symbol型变量
name : 变量的名字，str型变量
attr : dict of string -& string.Additional attributes to set on the variable.
mxnet/example/image-classification文件夹下以symbol开头的几个.py文件都是定义好的网络模型。我们可以任意打开一个来具体了解一下如何构建一个网络。
有一点需要注意的是：mxnet中通常要在卷积层和全连接层之间价加一个Flatten层用于衔接
4- 开始训练
首先，来总结一下我们现在都有了什么：保存网络模型的.py文件、REC格式的训练数据、将数据送入网络的迭代器。
在此基础上，我们缺少的就只剩下网络训练的一些控制参数：如学习率、训练日志、GPU选择等等。
在初期，我们往往可以先快速的拿来用，而不用在意其细节。那么，最简单的办法就是直接修改套用mxnet中的示例。示例主要集中在/example/image-classification和/tests/python当中。下面就简单的介绍如何快速开始训练：
（1）新建一个文件夹，将/example/image-classification文件夹下find_mxnet.py、symbol_alexnet.py、train_imagenet.py和train_model.py这4个文件copy进来；
（2）保持find_mxnet.py文件不变，在symbol_alexnet.py中按照里面Alexnet网络的构建方法来建立自己的网络。最后最好再把文件名改为自己的网络名，如mynet.
（3）将train_imagenet.py最好也修改一下名字，如改为train_xx.py.将第40行代码中的’symbol’删除，否则你的网络文件就必须以‘symbol’开始命名，如symbol_mynet.py.
net = importlib.import_module('symbol_' + args.network).get_symbol(args.num_classes)
net = importlib.import_module(args.network).get_symbol(args.num_classes)
剩下的就是要在parser.add_argument中修改默认值了，否则你在调用mynet.py就必须准确的指定每一个参数。
（4）写一个脚本文件，运行脚本文件就可以开始训练了。如
python train_xx.py --data-dir=xx --model-prefix==xx --gpus=0
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：284084次
积分：3781
积分：3781
排名：第8414名
原创：83篇
转载：10篇
评论：359条
(2)(1)(3)(4)(10)(2)(8)(5)(2)(7)(4)(12)(2)(1)(4)(13)(2)(2)(3)(1)(2)(5)}