【Lasagne速成】Lasagne/Theano图像分类从模型自定义到测试

欢迎来到专栏《2小时玩转开源框架系列》，这是我们第11篇，前面已经说过了caffe，tensorflow，pytorch，mxnet，keras，paddlepaddle，cntk，chainer，deeplearning4j，matconvnet。

今天说Lasagne，本文所用到的数据，代码请参考我们官方git

https://github.com/longpeng2008/LongPeng_ML_Course

作者&编辑 | 言有三

 

1 Lasagne是什么

说了这么久的开源框架，我们好像一直忘了一个很老牌的框架，就是theano对不对，在2008年的时候，这个框架就由Yoshua Bengio领导的蒙特利尔LISA组开源了。

一直没说theano是因为它的使用成本真的有点高，需要从底层开始写代码构建模型，不过今天说的这个是封装了theano的高层框架，即Lasagen，它使得theano使用起来更简单。

官网地址：http://lasagne.readthedocs.io/en/latest/index.html

GitHub： https://github.com/Lasagne/Lasagne

 

2 Lasagne训练准备

2.1 Lasagne安装

Lasagne安装很简单，只需要在终端输入下面命令即可安装：

pip install Lasagne

2.2 数据读取

由于没有特别好的接口，因此我们自己定义一个类就行了，实现从数据集中读取，以及产生list，格式就是每一个类存在一个单独的文件夹下，主体代码如下。

class Dataset:

    def __init__(self, rootpath, imgwidth, imgheight, trainratio=0.9):

        self.rootpath = rootpath

        list_dirs = os.walk(self.rootpath)

        count = 0

        numofclasses = 0

        self.subdirs = []

        ##遍历文件夹

        for root, dirs, files in list_dirs:

            for d in dirs:

                self.subdirs.append(os.path.join(root,d))

        label = 0

        self.imagedatas = []

        self.labeldatas = []

        for subdir in self.subdirs:

            images = glob.iglob(os.path.join(subdir,'*.jpg'))

            for image in images: 

                  imagedata = cv2.imread(image,1)

                  imagedata = cv2.resize(imagedata,(imgwidth,imgheight))

                  imagedata = imagedata.astype(np.float) / 255.0

                  imagedata = imagedata - [0.5,0.5,0.5]

                  imagedata = imagedata.transpose((2,0,1))

        self.imagedatas.append(imagedata)

        self.labeldatas.append(label)

        label = label + 1

        self.imagedatas = np.array(self.imagedatas).astype(np.float32)

        self.labeldatas = np.array(self.labeldatas).astype(np.int32)

        indices = np.arange(len(self.imagedatas))

        np.random.shuffle(indices)

        splitindex = int(trainratio*self.imagedatas.shape[0])

        self.imagetraindatas = self.imagedatas[0:splitindex].copy()

        self.labeltraindatas = self.labeldatas[0:splitindex].copy()

        self.imagevaldatas = self.imagedatas[splitindex:].copy()   

        self.labelvaldatas = self.labeldatas[splitindex:].copy()   

    ##定义数据迭代接口

    def iterate_minibatches(self, inputs, targets, batchsize, shuffle=False):

        assert len(inputs) == len(targets)

        if shuffle:

            indices = np.arange(len(inputs))

            print "indices type=",type(indices)

            np.random.shuffle(indices)

        for start_idx in range(0, len(inputs) - batchsize + 1, batchsize):

            if shuffle:

                excerpt = indices[start_idx:start_idx + batchsize]

            else:

                excerpt = slice(start_idx, start_idx + batchsize)

            yield inputs[excerpt], targets[excerpt]

以上就实现了将一个数据集下的不同子文件夹的图片随机分成了训练集和测试集，并提供了统一的接口。当然这里只做了最简单的数据预处理而没有做数据增强，这就留待读者自己去完成了。

2.3 网络定义

基本上和所有python库的方法是一样的，调用接口就行。

def simpleconv3(input_var=None):

    network = lasagne.layers.InputLayer(shape=(None, 3, 48, 48),

                                        input_var=input_var)

    network = lasagne.layers.Conv2DLayer(

            network, num_filters=12, filter_size=(3, 3),

            nonlinearity=lasagne.nonlinearities.rectify,

            W=lasagne.init.GlorotUniform())

    network = batch_norm(network)

    network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2))

    network = lasagne.layers.Conv2DLayer(

            network, num_filters=24, filter_size=(3, 3),

            nonlinearity=lasagne.nonlinearities.rectify,

            W=lasagne.init.GlorotUniform())

    network = batch_norm(network)

    network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2))

    network = lasagne.layers.Conv2DLayer(

            network, num_filters=48, filter_size=(3, 3),

            nonlinearity=lasagne.nonlinearities.rectify,

            W=lasagne.init.GlorotUniform())

    network = batch_norm(network)

    network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2))

    network = lasagne.layers.DenseLayer(

            lasagne.layers.dropout(network, p=.5),

            num_units=128,

            nonlinearity=lasagne.nonlinearities.rectify)

    network = lasagne.layers.DenseLayer(

            lasagne.layers.dropout(network, p=.5),

            num_units=2,

            nonlinearity=lasagne.nonlinearities.softmax)

    return network

以上定义的就是一个3层卷积2层全连接的网络，使用lasagne.layers接口。

 

3 模型训练

1、首先通过Theano里的tensor对输入和输出进行定义

input_var = T.tensor4('inputs')

target_var = T.ivector('targets')

inputs是一个四维的张量，targets是一个ivector变量。

2、调用lasagne.objectives里的损失函数接口：

network = simpleconv3(input_var)

prediction = lasagne.layers.get_output(network)

loss =lasagne.objectives.categorical_crossentropy(prediction, target_var)

loss = loss.mean()

network即网络模型，prediction表示它的输出，损失函数categorical_crossentropy就是交叉熵了。

验证集和测试集上的定义与此类似，只需要更改deterministic为deterministic=True，这样会屏蔽掉所有的dropout层，如下：

test_prediction = lasagne.layers.get_output(network, deterministic=True)

test_loss = lasagne.objectives.categorical_crossentropy(test_prediction, target_var)

test_loss = test_loss.mean()

接下来就是训练方法，使用nesterov_momentum法：

params = lasagne.layers.get_all_params(network, trainable=True)

updates = lasagne.updates.nesterov_momentum( loss, params, learning_rate=0.01, momentum=0.9

)

最后定义训练函数：

train_fn = theano.function([input_var, target_var], loss, updates=updates)

接收两个输入input_var, target_var，利用updates表达式更新参数。如果是用于验证和测试，就不需要进行网络参数的更新，而且可以增加精度等变量，这时这样定义：

test_acc = T.mean(T.eq(T.argmax(test_prediction, axis=1), target_var), dtype=theano.config.floatX)

val_fn = theano.function([input_var, target_var], [test_loss, test_acc])

最后，每一个epoch取得数据训练进行训练：

train_data =  mydataset.iterate_minibatches(mydataset.imagetraindatas,mydataset.labeltraindatas,16,True)

train_batches = 0

  for input_batch, target_batch in train_data:

      train_loss += train_fn(input_batch, target_batch)

      prediction = lasagne.layers.get_output(network)

      train_batches += 1

  print("Epoch %d: Train Loss %g" % (epoch + 1, train_loss / train_batches))

结果如下，老样子，测试集合精度90%，模型过拟合。

以上就是Lasagne从数据准备，模型定义到输出结果的整个流程，想要体验可以去参考git代码。

Lasagne/Theano给我最大的感觉就是慢，比至今用过的每一个框架都要慢，不过了解一下并没有坏处，毕竟Theano曾经辉煌。

本系列完整文章：

第一篇：【caffe速成】caffe图像分类从模型自定义到测试

第二篇：【tensorflow速成】Tensorflow图像分类从模型自定义到测试

第三篇：【pytorch速成】Pytorch图像分类从模型自定义到测试

第四篇：【paddlepaddle速成】paddlepaddle图像分类从模型自定义到测试

第五篇：【Keras速成】Keras图像分类从模型自定义到测试

第六篇：【mxnet速成】mxnet图像分类从模型自定义到测试

第七篇：【cntk速成】cntk图像分类从模型自定义到测试

第八篇：【chainer速成】chainer图像分类从模型自定义到测试

第九篇：【DL4J速成】Deeplearning4j图像分类从模型自定义到测试

第十篇：【MatConvnet速成】MatConvnet图像分类从模型自定义到测试

第十一篇：【Lasagne速成】Lasagne/Theano图像分类从模型自定义到测试

第十二篇：【darknet速成】Darknet图像分类从模型自定义到测试

感谢各位看官的耐心阅读，不足之处希望多多指教。后续内容将会不定期奉上，欢迎大家关注有三公众号 有三AI！