add model zoo

modelzoo/cifar10_nin.py

@@ -0,0 +1,52 @@
+# Network in Network CIFAR10 Model
+# Original source: https://gist.github.com/mavenlin/e56253735ef32c3c296d
+# License: unknown
+
+# Download pretrained weights from:
+# https://s3.amazonaws.com/lasagne/recipes/pretrained/cifar10/model.pkl
+
+from lasagne.layers import InputLayer, DropoutLayer, FlattenLayer
+from lasagne.layers.dnn import Conv2DDNNLayer as ConvLayer
+from lasagne.layers import Pool2DLayer as PoolLayer
+
+
+def build_model():
+    net = {}
+    net['input'] = InputLayer((None, 3, 32, 32))
+    net['conv1'] = ConvLayer(net['input'],
+                             num_filters=192,
+                             filter_size=5,
+                             pad=2)
+    net['cccp1'] = ConvLayer(net['conv1'], num_filters=160, filter_size=1)
+    net['cccp2'] = ConvLayer(net['cccp1'], num_filters=96, filter_size=1)
+    net['pool1'] = PoolLayer(net['cccp2'],
+                             pool_size=3,
+                             stride=2,
+                             mode='max',
+                             ignore_border=False)
+    net['drop3'] = DropoutLayer(net['pool1'], p=0.5)
+    net['conv2'] = ConvLayer(net['drop3'],
+                             num_filters=192,
+                             filter_size=5,
+                             pad=2)
+    net['cccp3'] = ConvLayer(net['conv2'], num_filters=192, filter_size=1)
+    net['cccp4'] = ConvLayer(net['cccp3'], num_filters=192, filter_size=1)
+    net['pool2'] = PoolLayer(net['cccp4'],
+                             pool_size=3,
+                             stride=2,
+                             mode='average_exc_pad',
+                             ignore_border=False)
+    net['drop6'] = DropoutLayer(net['pool2'], p=0.5)
+    net['conv3'] = ConvLayer(net['drop6'],
+                             num_filters=192,
+                             filter_size=3,
+                             pad=1)
+    net['cccp5'] = ConvLayer(net['conv3'], num_filters=192, filter_size=1)
+    net['cccp6'] = ConvLayer(net['cccp5'], num_filters=10, filter_size=1)
+    net['pool3'] = PoolLayer(net['cccp6'],
+                             pool_size=8,
+                             mode='average_exc_pad',
+                             ignore_border=False)
+    net['output'] = FlattenLayer(net['pool3'])
+
+    return net

modelzoo/googlenet.py

@@ -0,0 +1,100 @@
+# BLVC Googlenet, model from the paper:
+# "Going Deeper with Convolutions"
+# Original source:
+# https://github.com/BVLC/caffe/tree/master/models/bvlc_googlenet
+# License: unrestricted use
+
+# Download pretrained weights from:
+# https://s3.amazonaws.com/lasagne/recipes/pretrained/imagenet/blvc_googlenet.pkl
+
+from lasagne.layers import InputLayer
+from lasagne.layers import DenseLayer
+from lasagne.layers import ConcatLayer
+from lasagne.layers import NonlinearityLayer
+from lasagne.layers import GlobalPoolLayer
+from lasagne.layers.dnn import Conv2DDNNLayer as ConvLayer
+from lasagne.layers.dnn import MaxPool2DDNNLayer as PoolLayerDNN
+from lasagne.layers import MaxPool2DLayer as PoolLayer
+from lasagne.layers import LocalResponseNormalization2DLayer as LRNLayer
+from lasagne.nonlinearities import softmax, linear
+
+
+def build_inception_module(name, input_layer, nfilters):
+    # nfilters: (pool_proj, 1x1, 3x3_reduce, 3x3, 5x5_reduce, 5x5)
+    net = {}
+    net['pool'] = PoolLayerDNN(input_layer, pool_size=3, stride=1, pad=1)
+    net['pool_proj'] = ConvLayer(net['pool'], nfilters[0], 1)
+
+    net['1x1'] = ConvLayer(input_layer, nfilters[1], 1)
+
+    net['3x3_reduce'] = ConvLayer(input_layer, nfilters[2], 1)
+    net['3x3'] = ConvLayer(net['3x3_reduce'], nfilters[3], 3, pad=1)
+
+    net['5x5_reduce'] = ConvLayer(input_layer, nfilters[4], 1)
+    net['5x5'] = ConvLayer(net['5x5_reduce'], nfilters[5], 5, pad=2)
+
+    net['output'] = ConcatLayer([
+        net['1x1'],
+        net['3x3'],
+        net['5x5'],
+        net['pool_proj'],
+        ])
+
+    return {'{}/{}'.format(name, k): v for k, v in net.items()}
+
+
+def build_model():
+    net = {}
+    net['input'] = InputLayer((None, 3, None, None))
+    net['conv1/7x7_s2'] = ConvLayer(net['input'], 64, 7, stride=2, pad=3)
+    net['pool1/3x3_s2'] = PoolLayer(net['conv1/7x7_s2'],
+                                    pool_size=3,
+                                    stride=2,
+                                    ignore_border=False)
+    net['pool1/norm1'] = LRNLayer(net['pool1/3x3_s2'], alpha=0.00002, k=1)
+    net['conv2/3x3_reduce'] = ConvLayer(net['pool1/norm1'], 64, 1)
+    net['conv2/3x3'] = ConvLayer(net['conv2/3x3_reduce'], 192, 3, pad=1)
+    net['conv2/norm2'] = LRNLayer(net['conv2/3x3'], alpha=0.00002, k=1)
+    net['pool2/3x3_s2'] = PoolLayer(net['conv2/norm2'], pool_size=3, stride=2)
+
+    net.update(build_inception_module('inception_3a',
+                                      net['pool2/3x3_s2'],
+                                      [32, 64, 96, 128, 16, 32]))
+    net.update(build_inception_module('inception_3b',
+                                      net['inception_3a/output'],
+                                      [64, 128, 128, 192, 32, 96]))
+    net['pool3/3x3_s2'] = PoolLayer(net['inception_3b/output'],
+                                    pool_size=3, stride=2)
+
+    net.update(build_inception_module('inception_4a',
+                                      net['pool3/3x3_s2'],
+                                      [64, 192, 96, 208, 16, 48]))
+    net.update(build_inception_module('inception_4b',
+                                      net['inception_4a/output'],
+                                      [64, 160, 112, 224, 24, 64]))
+    net.update(build_inception_module('inception_4c',
+                                      net['inception_4b/output'],
+                                      [64, 128, 128, 256, 24, 64]))
+    net.update(build_inception_module('inception_4d',
+                                      net['inception_4c/output'],
+                                      [64, 112, 144, 288, 32, 64]))
+    net.update(build_inception_module('inception_4e',
+                                      net['inception_4d/output'],
+                                      [128, 256, 160, 320, 32, 128]))
+    net['pool4/3x3_s2'] = PoolLayer(net['inception_4e/output'],
+                                    pool_size=3, stride=2)
+
+    net.update(build_inception_module('inception_5a',
+                                      net['pool4/3x3_s2'],
+                                      [128, 256, 160, 320, 32, 128]))
+    net.update(build_inception_module('inception_5b',
+                                      net['inception_5a/output'],
+                                      [128, 384, 192, 384, 48, 128]))
+
+    net['pool5/7x7_s1'] = GlobalPoolLayer(net['inception_5b/output'])
+    net['loss3/classifier'] = DenseLayer(net['pool5/7x7_s1'],
+                                         num_units=1000,
+                                         nonlinearity=linear)
+    net['prob'] = NonlinearityLayer(net['loss3/classifier'],
+                                    nonlinearity=softmax)
+    return net

modelzoo/vgg16.py

@@ -0,0 +1,41 @@
+# VGG-16, 16-layer model from the paper:
+# "Very Deep Convolutional Networks for Large-Scale Image Recognition"
+# Original source: https://gist.github.com/ksimonyan/211839e770f7b538e2d8
+# License: non-commercial use only
+
+# Download pretrained weights from:
+# https://s3.amazonaws.com/lasagne/recipes/pretrained/imagenet/vgg16.pkl
+
+from lasagne.layers import InputLayer, DenseLayer, NonlinearityLayer
+from lasagne.layers.dnn import Conv2DDNNLayer as ConvLayer
+from lasagne.layers import Pool2DLayer as PoolLayer
+from lasagne.nonlinearities import softmax
+
+
+def build_model():
+    net = {}
+    net['input'] = InputLayer((None, 3, 224, 224))
+    net['conv1_1'] = ConvLayer(net['input'], 64, 3, pad=1)
+    net['conv1_2'] = ConvLayer(net['conv1_1'], 64, 3, pad=1)
+    net['pool1'] = PoolLayer(net['conv1_2'], 2)
+    net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=1)
+    net['conv2_2'] = ConvLayer(net['conv2_1'], 128, 3, pad=1)
+    net['pool2'] = PoolLayer(net['conv2_2'], 2)
+    net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=1)
+    net['conv3_2'] = ConvLayer(net['conv3_1'], 256, 3, pad=1)
+    net['conv3_3'] = ConvLayer(net['conv3_2'], 256, 3, pad=1)
+    net['pool3'] = PoolLayer(net['conv3_3'], 2)
+    net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=1)
+    net['conv4_2'] = ConvLayer(net['conv4_1'], 512, 3, pad=1)
+    net['conv4_3'] = ConvLayer(net['conv4_2'], 512, 3, pad=1)
+    net['pool4'] = PoolLayer(net['conv4_3'], 2)
+    net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=1)
+    net['conv5_2'] = ConvLayer(net['conv5_1'], 512, 3, pad=1)
+    net['conv5_3'] = ConvLayer(net['conv5_2'], 512, 3, pad=1)
+    net['pool5'] = PoolLayer(net['conv5_3'], 2)
+    net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
+    net['fc7'] = DenseLayer(net['fc6'], num_units=4096)
+    net['fc8'] = DenseLayer(net['fc7'], num_units=1000, nonlinearity=None)
+    net['prob'] = NonlinearityLayer(net['fc8'], softmax)
+
+    return net

modelzoo/vgg19.py

@@ -0,0 +1,44 @@
+# VGG-19, 19-layer model from the paper:
+# "Very Deep Convolutional Networks for Large-Scale Image Recognition"
+# Original source: https://gist.github.com/ksimonyan/3785162f95cd2d5fee77
+# License: non-commercial use only
+
+# Download pretrained weights from:
+# https://s3.amazonaws.com/lasagne/recipes/pretrained/imagenet/vgg19.pkl
+
+from lasagne.layers import InputLayer, DenseLayer, NonlinearityLayer
+from lasagne.layers.dnn import Conv2DDNNLayer as ConvLayer
+from lasagne.layers import Pool2DLayer as PoolLayer
+from lasagne.nonlinearities import softmax
+
+
+def build_model():
+    net = {}
+    net['input'] = InputLayer((None, 3, 224, 224))
+    net['conv1_1'] = ConvLayer(net['input'], 64, 3, pad=1)
+    net['conv1_2'] = ConvLayer(net['conv1_1'], 64, 3, pad=1)
+    net['pool1'] = PoolLayer(net['conv1_2'], 2)
+    net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=1)
+    net['conv2_2'] = ConvLayer(net['conv2_1'], 128, 3, pad=1)
+    net['pool2'] = PoolLayer(net['conv2_2'], 2)
+    net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=1)
+    net['conv3_2'] = ConvLayer(net['conv3_1'], 256, 3, pad=1)
+    net['conv3_3'] = ConvLayer(net['conv3_2'], 256, 3, pad=1)
+    net['conv3_4'] = ConvLayer(net['conv3_3'], 256, 3, pad=1)
+    net['pool3'] = PoolLayer(net['conv3_4'], 2)
+    net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=1)
+    net['conv4_2'] = ConvLayer(net['conv4_1'], 512, 3, pad=1)
+    net['conv4_3'] = ConvLayer(net['conv4_2'], 512, 3, pad=1)
+    net['conv4_4'] = ConvLayer(net['conv4_3'], 512, 3, pad=1)
+    net['pool4'] = PoolLayer(net['conv4_4'], 2)
+    net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=1)
+    net['conv5_2'] = ConvLayer(net['conv5_1'], 512, 3, pad=1)
+    net['conv5_3'] = ConvLayer(net['conv5_2'], 512, 3, pad=1)
+    net['conv5_4'] = ConvLayer(net['conv5_3'], 512, 3, pad=1)
+    net['pool5'] = PoolLayer(net['conv5_4'], 2)
+    net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
+    net['fc7'] = DenseLayer(net['fc6'], num_units=4096)
+    net['fc8'] = DenseLayer(net['fc7'], num_units=1000, nonlinearity=None)
+    net['prob'] = NonlinearityLayer(net['fc8'], softmax)
+
+    return net

modelzoo/vgg_cnn_s.py

@@ -0,0 +1,60 @@
+# VGG_CNN_S, model from the paper:
+# "Return of the Devil in the Details: Delving Deep into Convolutional Nets"
+# 13.1% top-5 error on ILSVRC-2012-val
+# Original source: https://gist.github.com/ksimonyan/fd8800eeb36e276cd6f9
+# License: non-commercial use only
+
+# Download pretrained weights from:
+# https://s3.amazonaws.com/lasagne/recipes/pretrained/imagenet/vgg_cnn_s.pkl
+
+from lasagne.layers import InputLayer, DenseLayer, DropoutLayer
+from lasagne.layers import NonlinearityLayer
+from lasagne.layers.dnn import Conv2DDNNLayer as ConvLayer
+from lasagne.layers import MaxPool2DLayer as PoolLayer
+from lasagne.layers import LocalResponseNormalization2DLayer as NormLayer
+from lasagne.nonlinearities import softmax
+
+
+def build_model():
+    net = {}
+
+    net['input'] = InputLayer((None, 3, 224, 224))
+    net['conv1'] = ConvLayer(net['input'],
+                             num_filters=96,
+                             filter_size=7,
+                             stride=2)
+    # caffe has alpha = alpha * pool_size
+    net['norm1'] = NormLayer(net['conv1'], alpha=0.0001)
+    net['pool1'] = PoolLayer(net['norm1'],
+                             pool_size=3,
+                             stride=3,
+                             ignore_border=False)
+    net['conv2'] = ConvLayer(net['pool1'], num_filters=256, filter_size=5)
+    net['pool2'] = PoolLayer(net['conv2'],
+                             pool_size=2,
+                             stride=2,
+                             ignore_border=False)
+    net['conv3'] = ConvLayer(net['pool2'],
+                             num_filters=512,
+                             filter_size=3,
+                             pad=1)
+    net['conv4'] = ConvLayer(net['conv3'],
+                             num_filters=512,
+                             filter_size=3,
+                             pad=1)
+    net['conv5'] = ConvLayer(net['conv4'],
+                             num_filters=512,
+                             filter_size=3,
+                             pad=1)
+    net['pool5'] = PoolLayer(net['conv5'],
+                             pool_size=3,
+                             stride=3,
+                             ignore_border=False)
+    net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
+    net['drop6'] = DropoutLayer(net['fc6'], p=0.5)
+    net['fc7'] = DenseLayer(net['drop6'], num_units=4096)
+    net['drop7'] = DropoutLayer(net['fc7'], p=0.5)
+    net['fc8'] = DenseLayer(net['drop7'], num_units=1000, nonlinearity=None)
+    net['prob'] = NonlinearityLayer(net['fc8'], softmax)
+
+    return net