def buildModel():
#this is our input layer with the inputs (None, dimensions, width, height)
l_input = layers.InputLayer((None, 3, 64, 64))
#first convolutional layer, has l_input layer as incoming and is followed by a pooling layer
l_conv1 = layers.Conv2DLayer(l_input, num_filters=32, filter_size=3, pad='same', nonlinearity=tanh)
l_pool1 = layers.MaxPool2DLayer(l_conv1, pool_size=2)
#second convolution (l_pool1 is incoming), let's increase the number of filters
l_conv2 = layers.Conv2DLayer(l_pool1, num_filters=64, filter_size=3, pad='same', nonlinearity=tanh)
l_pool2 = layers.MaxPool2DLayer(l_conv2, pool_size=2)
#third convolution (l_pool2 is incoming), even more filters
l_conv3 = layers.Conv2DLayer(l_pool2, num_filters=128, filter_size=3, pad='same', nonlinearity=tanh)
l_pool3 = layers.MaxPool2DLayer(l_conv3, pool_size=2)
#fourth and final convolution
l_conv4 = layers.Conv2DLayer(l_pool3, num_filters=256, filter_size=3, pad='same', nonlinearity=tanh)
l_pool4 = layers.MaxPool2DLayer(l_conv4, pool_size=2)
#our cnn contains 3 dense layers, one of them is our output layer
l_dense1 = layers.DenseLayer(l_pool4, num_units=128, nonlinearity=tanh)
l_dense2 = layers.DenseLayer(l_dense1, num_units=128, nonlinearity=tanh)
#the output layer has 6 units which is exactly the count of our class labels
#it has a softmax activation function, its values represent class probabilities
l_output = layers.DenseLayer(l_dense2, num_units=6, nonlinearity=softmax)
#let's see how many params our net has
print ("MODEL HAS"+ str(layers.count_params(l_output))+" PARAMS")
#we return the layer stack as our network by returning the last layer
return l_output
def layer_GatedConv2DLayer(
incoming,
num_filters,
filter_size,
stride=(1, 1),
pad=0,
nonlinearity=lasagne.nonlinearities.very_leaky_rectify,
name=''):
la = ll.Conv2DLayer(incoming,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
pad=pad,
nonlinearity=nonlinearity,
name=name + '.activation')
lg = ll.Conv2DLayer(incoming,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
pad=pad,
nonlinearity=theano.tensor.nnet.nnet.sigmoid,
name=name + '.gate')
lout = ll.ElemwiseMergeLayer([la, lg],
T.mul,
cropping=None,
name=name + '.mul_merge')
return lout
def _forward(self):
net = {}
net['input'] = layers.InputLayer(shape=(None, 1, 28, 28),
input_var=self.X)
net['conv1'] = layers.Conv2DLayer(net['input'],
32, (3, 3),
W=init.Orthogonal(),
pad=1)
net['pool1'] = layers.MaxPool2DLayer(net['conv1'], (2, 2),
stride=(2, 2))
net['conv2'] = layers.Conv2DLayer(net['pool1'],
64, (3, 3),
W=init.Orthogonal(),
pad=1)
net['pool2'] = layers.MaxPool2DLayer(net['conv2'], (2, 2),
stride=(2, 2))
net['conv3'] = layers.Conv2DLayer(net['pool2'],
128, (3, 3),
W=init.Orthogonal(),
pad=1)
net['conv4'] = layers.Conv2DLayer(net['conv3'],
128, (3, 3),
W=init.Orthogonal(),
pad=1)
net['pool3'] = layers.MaxPool2DLayer(net['conv4'], (2, 2),
stride=(2, 2))
net['flatten'] = layers.FlattenLayer(net['pool3'])
net['out'] = layers.DenseLayer(net['flatten'],
10,
b=None,
nonlinearity=nonlinearities.softmax)
return net
def build_cnn(config, use_noise=True, use_bn=True):
# NOTE: Neither Conv2DDNNLayer nor Conv2DMMLayer will not work
# with T.Rop operation, which used for the Fisher-vector product.
l_input = L.InputLayer((None, 1, config['height'], config['width']))
l_out = L.Conv2DLayer(l_input,
num_filters=config['cnn_f1'], filter_size=(6,6), stride=2,
nonlinearity=relu, W=LI.HeUniform('relu'), b=LI.Constant(0.)
)
# https://arxiv.org/pdf/1602.01407v2.pdf
# QUOTE: KFC-pre and BN can be combined synergistically.
if use_bn: l_out = L.batch_norm(l_out, beta=None, gamma=None)
l_out = L.Conv2DLayer(l_out,
num_filters=config['cnn_f2'], filter_size=(4,4), stride=2,
nonlinearity=relu, W=LI.HeUniform('relu'), b=LI.Constant(0.)
)
if use_bn: l_out = L.batch_norm(l_out, beta=None, gamma=None)
if use_noise: l_out = L.dropout(l_out)
l_out = L.Conv2DLayer(l_out,
num_filters=config['cnn_f3'], filter_size=(4,4), stride=2,
nonlinearity=relu, W=LI.HeUniform('relu'), b=LI.Constant(0.)
)
if use_bn: l_out = L.batch_norm(l_out, beta=None, gamma=None)
if use_noise: l_out = L.dropout(l_out)
return l_input, l_out
def __build_48_net__(self):
network = layers.InputLayer((None, 3, 48, 48),
input_var=self.__input_var__)
network = layers.Conv2DLayer(network,
num_filters=64,
filter_size=(5, 5),
stride=1,
nonlinearity=relu)
network = layers.MaxPool2DLayer(network, pool_size=(3, 3), stride=2)
network = layers.batch_norm(network)
network = layers.Conv2DLayer(network,
num_filters=64,
filter_size=(5, 5),
stride=1,
nonlinearity=relu)
network = layers.batch_norm(network)
network = layers.MaxPool2DLayer(network, pool_size=(3, 3), stride=2)
network = layers.Conv2DLayer(network,
num_filters=64,
filter_size=(3, 3),
stride=1,
nonlinearity=relu)
network = layers.batch_norm(network)
network = layers.MaxPool2DLayer(network, pool_size=(3, 3), stride=2)
network = layers.DenseLayer(network, num_units=256, nonlinearity=relu)
network = layers.DenseLayer(network, num_units=2, nonlinearity=softmax)
return network
def build_network(input_var=None, input_shape=227):
nf = 32
n = lasagne.nonlinearities.tanh
W_init = lasagne.init.GlorotUniform()
net = nn.InputLayer((None, 3, None, None), input_var=input_var)
# Block 1
net = nn.Conv2DLayer(net, nf, 3, W=W_init, nonlinearity=n, pad='same')
net = nn.Conv2DLayer(net, nf, 3, W=W_init, nonlinearity=n, pad='same')
net = nn.MaxPool2DLayer(net, 2)
# Block 2
net = nn.Conv2DLayer(net, nf * 2, 3, W=W_init, nonlinearity=n, pad='same')
net = nn.Conv2DLayer(net, nf * 2, 3, W=W_init, nonlinearity=n, pad='same')
net = nn.SpatialPyramidPoolingLayer(net, [4, 2, 1],
implementation='kaiming')
net = nn.DenseLayer(net, 512, W=W_init, nonlinearity=n)
net = nn.dropout(net, p=0.5)
net = nn.DenseLayer(net, 128, W=W_init, nonlinearity=n)
return nn.DenseLayer(net, 1, W=W_init, nonlinearity=T.nnet.sigmoid)
def classificationBranch(net, kernel_size):
# Post Convolution
branch = l.batch_norm(l.Conv2DLayer(net,
num_filters=int(FILTERS[-1] * RESNET_K),
filter_size=kernel_size,
nonlinearity=nl.rectify))
#log.p(("\t\tPOST CONV SHAPE:", l.get_output_shape(branch), "LAYER:", len(l.get_all_layers(branch)) - 1))
# Dropout Layer
branch = l.DropoutLayer(branch)
# Dense Convolution
branch = l.batch_norm(l.Conv2DLayer(branch,
num_filters=int(FILTERS[-1] * RESNET_K * 2),
filter_size=1,
nonlinearity=nl.rectify))
#log.p(("\t\tDENSE CONV SHAPE:", l.get_output_shape(branch), "LAYER:", len(l.get_all_layers(branch)) - 1))
# Dropout Layer
branch = l.DropoutLayer(branch)
# Class Convolution
branch = l.Conv2DLayer(branch,
num_filters=len(cfg.CLASSES),
filter_size=1,
nonlinearity=None)
return branch
def create_network(npochs):
l_in = layers.InputLayer((None, 1, 200, 250))
l_conv1 = layers.Conv2DLayer(l_in, num_filters=32, filter_size=(3, 3))
l_pool1 = layers.MaxPool2DLayer(l_conv1, pool_size=(2, 2))
l_drop1 = layers.DropoutLayer(l_pool1, p=0.1)
l_conv2 = layers.Conv2DLayer(l_drop1, num_filters=64, filter_size=(2, 2))
l_pool2 = layers.MaxPool2DLayer(l_conv2, pool_size=(2, 2))
l_drop2 = layers.DropoutLayer(l_pool2, p=0.2)
l_conv3 = layers.Conv2DLayer(l_drop2, num_filters=128, filter_size=(2, 2))
l_pool3 = layers.MaxPool2DLayer(l_conv3, pool_size=(2, 2))
l_drop3 = layers.DropoutLayer(l_pool3, p=0.3)
l_den1 = layers.DenseLayer(l_drop3, num_units=1000)
l_drop4 = layers.DropoutLayer(l_den1, p=0.5)
l_den2 = layers.DenseLayer(l_drop4, num_units=1000)
l_output = layers.DenseLayer(l_den2, num_units=8, nonlinearity=None)
net = NeuralNet(
layers=l_output,
# learning parameters
update=nesterov_momentum,
update_learning_rate=theano.shared(np.float32(0.03)),
update_momentum=theano.shared(np.float32(0.9)),
regression=True,
on_epoch_finished=[
AdjustVariable('update_learning_rate', start=0.03, stop=0.0001),
AdjustVariable('update_momentum', start=0.9, stop=0.9999),
EarlyStopping(),
],
max_epochs=npochs, # maximum iteration
train_split=TrainSplit(eval_size=0.2),
verbose=1,
)
return net
def build_auto_encoder_mnist_cnn(input_var=None):
"""
Generate an auto-encoder cnn using the Lasagne library
"""
# Build encoder part
network = lyr.InputLayer(shape=(None, 1, 28, 28), input_var=input_var)
network = lyr.Conv2DLayer(network, 64, (5, 5), W=lasagne.init.Normal())
network = lyr.MaxPool2DLayer(network, (2, 2))
network = lyr.Conv2DLayer(network, 128, (5, 5), W=lasagne.init.Normal())
network = lyr.MaxPool2DLayer(network, (2, 2))
network = lyr.FlattenLayer(network)
network = lyr.DenseLayer(network, 2048, W=lasagne.init.Normal())
network = lyr.ReshapeLayer(network, (input_var.shape[0], 2048, 1, 1))
# Build decoder part
network = lyr.TransposedConv2DLayer(network,
128, (5, 5),
W=lasagne.init.Normal())
network = lyr.Upscale2DLayer(network, (2, 2))
network = lyr.TransposedConv2DLayer(network,
64, (4, 4),
W=lasagne.init.Normal())
network = lyr.Upscale2DLayer(network, (2, 2))
network = lyr.TransposedConv2DLayer(network,
1, (3, 3),
W=lasagne.init.Normal(),
nonlinearity=None)
return network
def build_generator(input_var=None):
#D_inp = T.tensor4('ds')
G = l.InputLayer(shape=(None, 1, noise_H, noise_W), input_var=input_var)
G = batch_norm(
l.DenseLayer(G, num_units=(noise_H * noise_W * 256),
nonlinearity=reLU))
G = l.ReshapeLayer(G, shape=([0], 256, noise_H, noise_W)) #4
G = l.TransposedConv2DLayer(G,
1,
filter_size=(2, 2),
stride=(2, 2),
output_size=8) #8
G = batch_norm(l.Conv2DLayer(G, 40, (3, 3), nonlinearity=reLU,
pad='full')) #10
G = l.TransposedConv2DLayer(G,
1,
filter_size=(2, 2),
stride=(2, 2),
output_size=20) #20
G = batch_norm(l.Conv2DLayer(G, 20, (3, 3), nonlinearity=reLU,
pad='full')) #22
G = batch_norm(l.Conv2DLayer(G, 20, (5, 5), nonlinearity=reLU,
pad='full')) #26
G = batch_norm(l.Conv2DLayer(G, 1, (3, 3), nonlinearity=reLU,
pad='full')) #28
return G
def encoder(z_dim=100, input_var=None, num_units=512, vae=True):
encoder = []
lrelu = lasagne.nonlinearities.LeakyRectify(0.2)
encoder.append(ll.InputLayer(shape=(None, 3, 80, 160),
input_var=input_var))
encoder.append(
ll.Conv2DLayer(encoder[-1],
num_filters=num_units / 8,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu))
encoder.append(
ll.batch_norm(
ll.Conv2DLayer(encoder[-1],
num_filters=num_units / 4,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu)))
encoder.append(
ll.batch_norm(
ll.Conv2DLayer(encoder[-1],
num_filters=num_units / 2,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu)))
encoder.append(
ll.batch_norm(
ll.Conv2DLayer(encoder[-1],
num_filters=num_units,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu)))
encoder.append(ll.FlattenLayer(encoder[-1]))
if vae:
enc_mu = ll.DenseLayer(encoder[-1], num_units=z_dim, nonlinearity=None)
enc_logsigma = ll.DenseLayer(encoder[-1],
num_units=z_dim,
nonlinearity=None)
l_z = GaussianSampleLayer(enc_mu, enc_logsigma, name='Z layer')
encoder += [enc_mu, enc_logsigma, l_z]
for layer in encoder:
print layer.output_shape
print ""
return encoder
def build_contract_level(incoming,
num_filters,
nonlin,
W_init=lasagne.init.GlorotUniform(),
b_init=lasagne.init.Constant(0.01),
filter_size=3):
"""Builds a Conv-Conv-Pool block of the U-Net encoder."""
network = nn.Conv2DLayer(incoming,
num_filters,
filter_size,
pad='same',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
network = nn.Conv2DLayer(network,
num_filters,
filter_size,
pad='same',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
return network, nn.MaxPool2DLayer(network, 2)
def pons_cnn(params):
""""""
layers = L.InputLayer((None, 1, params['dur'], 128))
print layers.output_shape
sclr = joblib.load(params['scaler'])
layers = L.standardize(layers,
sclr.mean_.astype(np.float32),
sclr.scale_.astype(np.float32),
shared_axes=(0, 1, 2))
print layers.output_shape
layers_timbre = L.GlobalPoolLayer(
L.batch_norm(L.Conv2DLayer(layers, 64, (1, 96))))
layers_rhythm = L.GlobalPoolLayer(
L.batch_norm(L.Conv2DLayer(layers, 64, (params['dur'] - 10, 1))))
layers = L.ConcatLayer([layers_rhythm, layers_timbre], axis=-1)
layers = L.DenseLayer(layers, 64, nonlinearity=nl.rectify)
print layers.output_shape
layers = L.DenseLayer(layers, 16, nonlinearity=nl.softmax)
print layers.output_shape
return layers
def __build_48_net__(self):
model24 = self.subnet
network = layers.InputLayer((None, 3, 48, 48),
input_var=self.__input_var__)
network = layers.Conv2DLayer(network,
num_filters=64,
filter_size=(5, 5),
stride=1,
nonlinearity=relu)
network = layers.batch_norm(
layers.MaxPool2DLayer(network, pool_size=(3, 3), stride=2))
network = layers.Conv2DLayer(network,
num_filters=64,
filter_size=(5, 5),
stride=1,
nonlinearity=relu)
network = layers.BatchNormLayer(network)
network = layers.MaxPool2DLayer(network, pool_size=(3, 3), stride=2)
network = layers.DenseLayer(network, num_units=256, nonlinearity=relu)
#network = layers.Conv2DLayer(network,num_filters=256,filter_size=(1,1),stride=1,nonlinearity=relu)
denselayer24 = model24.net.input_layer
network = layers.ConcatLayer([network, denselayer24])
network = layers.DenseLayer(network, num_units=2, nonlinearity=softmax)
return network
def define_net():
net = {}
# net['input_img'] = ll.InputLayer(shape=(None, 1, 28, 28), input_var=input_img)
# net['input_noise'] = ll.InputLayer(shape=(None, 1, 28, 28), input_var=noise)
# ll.ConcatLayer([net['input_img'], net['input_noise']], axis=1)
net['input'] = ll.InputLayer(shape=(None, 2, 28, 28))
net['conv_1'] = ll.batch_norm(
ll.Conv2DLayer(net['input'],
num_filters=32,
stride=(2, 2),
filter_size=(5, 5),
pad='same'))
net['conv_2'] = ll.batch_norm(
ll.Conv2DLayer(net['conv_1'],
num_filters=64,
stride=(2, 2),
filter_size=(5, 5),
pad='same'))
net['unconv_3'] = ll.batch_norm(
ll.TransposedConv2DLayer(net['conv_2'],
filter_size=(5, 5),
num_filters=32,
stride=(2, 2),
crop=(2, 2)))
net['out'] = ll.batch_norm(
ll.TransposedConv2DLayer(net['unconv_3'],
filter_size=(4, 4),
num_filters=1,
stride=(2, 2),
crop=(0, 0),
nonlinearity=lasagne.nonlinearities.sigmoid))
return net
def init_discriminator(self, first_layer, input_var=None):
"""
Initialize the DCGAN discriminator network using lasagne
Returns the network
"""
lrelu = nonlinearities.LeakyRectify(0.2)
layers = []
l_in = lyr.InputLayer((None, 3, 64, 64), input_var)
layers.append(l_in)
l_1 = lyr.Conv2DLayer(incoming=l_in,
num_filters=first_layer,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu)
layers.append(l_1)
l_2 = lyr.batch_norm(
lyr.Conv2DLayer(incoming=l_1,
num_filters=first_layer * 2,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu))
layers.append(l_2)
l_3 = lyr.batch_norm(
lyr.Conv2DLayer(incoming=l_2,
num_filters=first_layer * 4,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu))
layers.append(l_3)
l_4 = lyr.batch_norm(
lyr.Conv2DLayer(incoming=l_3,
num_filters=first_layer * 8,
filter_size=5,
stride=2,
pad=2,
nonlinearity=lrelu))
l_4 = lyr.FlattenLayer(l_4)
layers.append(l_4)
l_out = lyr.DenseLayer(incoming=l_4,
num_units=1,
nonlinearity=nonlinearities.sigmoid)
layers.append(l_out)
if self.verbose:
for i, layer in enumerate(layers):
print 'dicriminator layer %s output shape:' % i, layer.output_shape
return l_out
def getNet6():
inputLayer = layers.InputLayer(shape=(None, 1, imageShape[0], imageShape[1])) #120x120
conv1Layer = layers.Conv2DLayer(inputLayer, num_filters=32, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #120x120
conv2Layer = layers.Conv2DLayer(conv1Layer, num_filters=32, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #120x120
pool1Layer = layers.MaxPool2DLayer(conv2Layer, pool_size=(2,2)) #60x60
conv3Layer = layers.Conv2DLayer(pool1Layer, num_filters=64, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #60x60
conv4Layer = layers.Conv2DLayer(conv3Layer, num_filters=64, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #60x60
conv5Layer = layers.Conv2DLayer(conv4Layer, num_filters=64, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #60x60
pool2Layer = layers.MaxPool2DLayer(conv5Layer, pool_size=(2,2)) #30x30
conv6Layer = layers.Conv2DLayer(pool2Layer, num_filters=128, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #30x30
conv7Layer = layers.Conv2DLayer(conv6Layer, num_filters=128, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #30x30
conv8Layer = layers.Conv2DLayer(conv7Layer, num_filters=128, filter_size=(3,3), pad=(1,1), W=HeNormal('relu'), nonlinearity=rectify) #30x30
pool3Layer = layers.MaxPool2DLayer(conv8Layer, pool_size=(2,2)) #15x15
conv9Layer = layers.Conv2DLayer(pool3Layer, num_filters=256, filter_size=(4,4), W=HeNormal('relu'), nonlinearity=rectify) #12x12
flattenLayer = layers.FlattenLayer(conv9Layer)
hidden1Layer = layers.DenseLayer(flattenLayer, num_units=1024, W=HeNormal('relu'), nonlinearity=rectify)
dropout1Layer = layers.DropoutLayer(hidden1Layer, p=0.5)
hidden2Layer = layers.DenseLayer(dropout1Layer, num_units=512, W=HeNormal('relu'), nonlinearity=rectify)
dropout2Layer = layers.DropoutLayer(hidden2Layer, p=0.5)
hidden3Layer = layers.DenseLayer(dropout2Layer, num_units=256, W=HeNormal('relu'), nonlinearity=rectify)
dropout3Layer = layers.DropoutLayer(hidden3Layer, p=0.5)
hidden4Layer = layers.DenseLayer(dropout3Layer, num_units=128, W=HeNormal('relu'), nonlinearity=rectify)
outputLayer = layers.DenseLayer(hidden4Layer, num_units=10, W=HeNormal('relu'), nonlinearity=softmax)
return outputLayer
def buildModel():
print "BUILDING MODEL TYPE..."
#default settings
filters = 16
first_stride = 2
last_filter_multiplier = 4
#input layer
net = l.InputLayer((None, IM_DIM, IM_SIZE[1], IM_SIZE[0]))
#conv layers
net = l.batch_norm(l.Conv2DLayer(net, num_filters=filters , filter_size=7, pad='same', stride=first_stride, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
net = l.MaxPool2DLayer(net, pool_size=2)
net = l.batch_norm(l.Conv2DLayer(net, num_filters=filters * 2 , filter_size=5, pad='same', stride=1, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
net = l.MaxPool2DLayer(net, pool_size=2)
net = l.batch_norm(l.Conv2DLayer(net, num_filters=filters * 4 , filter_size=3, pad='same', stride=1, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
net = l.MaxPool2DLayer(net, pool_size=2)
net = l.DropoutLayer(net, DROPOUT)
#net = l.batch_norm(l.Conv2DLayer(net, num_filters=filters * 8 , filter_size=3, pad='same', stride=1, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
#net = l.MaxPool2DLayer(net, pool_size=2)
#net = l.batch_norm(l.Conv2DLayer(net, num_filters=filters * 16 , filter_size=3, pad='same', stride=1, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
#net = l.MaxPool2DLayer(net, pool_size=2)
#net = l.batch_norm(l.Conv2DLayer(net, num_filters=filters * 32 , filter_size=7, pad='same', stride=1, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
#net = l.MaxPool2DLayer(net, pool_size=2)
#print "\tFINAL POOL OUT SHAPE:", l.get_output_shape(net)
#dense layers
net = l.batch_norm(l.DenseLayer(net, 512, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
net = l.DropoutLayer(net, DROPOUT)
net = l.batch_norm(l.DenseLayer(net, 512, W=init.HeNormal(gain=INIT_GAIN), nonlinearity=NONLINEARITY))
net = l.DropoutLayer(net, DROPOUT)
#Classification Layer
if MULTI_LABEL:
net = l.DenseLayer(net, NUM_CLASSES, nonlinearity=nonlinearities.sigmoid, W=init.HeNormal(gain=1))
else:
net = l.DenseLayer(net, NUM_CLASSES, nonlinearity=nonlinearities.softmax, W=init.HeNormal(gain=1))
print "...DONE!"
#model stats
print "MODEL HAS", (sum(hasattr(layer, 'W') for layer in l.get_all_layers(net))), "WEIGHTED LAYERS"
print "MODEL HAS", l.count_params(net), "PARAMS"
return net
def build_network(input_var, image_size=28, output_dim=10):
nonlin = lasagne.nonlinearities.rectify
W_init = lasagne.init.GlorotUniform()
b_init = lasagne.init.Constant(0.)
input_shape = (None, 1, image_size, image_size)
network = nn.InputLayer(input_shape, input_var)
network = nn.Conv2DLayer(network,
num_filters=64,
filter_size=(3, 3),
nonlinearity=nonlin,
W=W_init,
b=b_init)
network = nn.Conv2DLayer(network,
num_filters=64,
filter_size=(3, 3),
nonlinearity=nonlin,
W=W_init,
b=b_init)
network = nn.MaxPool2DLayer(network, pool_size=(2, 2))
network = nn.Conv2DLayer(network,
num_filters=128,
filter_size=(3, 3),
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.Conv2DLayer(network,
num_filters=128,
filter_size=(3, 3),
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.MaxPool2DLayer(network, pool_size=(2, 2))
network = nn.dropout(network, p=0.5)
network = nn.DenseLayer(network,
num_units=256,
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.dropout(network, p=0.5)
network = nn.DenseLayer(network,
num_units=output_dim,
W=W_init,
b=b_init,
nonlinearity=None)
return network
def discriminator(input_var=None, num_units=512):
discriminator = []
lrelu = lasagne.nonlinearities.LeakyRectify(0.2)
discriminator.append(
ll.InputLayer(shape=(None, 3, 80, 160), input_var=input_var))
discriminator.append(
ll.Conv2DLayer(discriminator[-1],
num_filters=num_units / 8,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu))
discriminator.append(
ll.batch_norm(
ll.Conv2DLayer(discriminator[-1],
num_filters=num_units / 4,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu)))
discriminator.append(
ll.batch_norm(
ll.Conv2DLayer(discriminator[-1],
num_filters=num_units / 2,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu)))
discriminator.append(
ll.batch_norm(
ll.Conv2DLayer(discriminator[-1],
num_filters=num_units,
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=lrelu)))
discriminator.append(ll.FlattenLayer(discriminator[-1]))
discriminator.append(
ll.DenseLayer(discriminator[-1], num_units=1, nonlinearity=None))
for layer in discriminator:
print layer.output_shape
print ""
return discriminator
def getNet2():
inputLayer = layers.InputLayer(shape=(None, 1, imageShape[0], imageShape[1]))
loc1Layer = layers.Conv2DLayer(inputLayer, num_filters=32, filter_size=(3,3), W=GlorotUniform('relu'), nonlinearity=rectify)
loc2Layer = layers.MaxPool2DLayer(loc1Layer, pool_size=(2,2))
loc3Layer = layers.Conv2DLayer(loc2Layer, num_filters=64, filter_size=(4,3), W=GlorotUniform('relu'), nonlinearity=rectify)
loc4Layer = layers.MaxPool2DLayer(loc3Layer, pool_size=(2,2))
loc5Layer = layers.Conv2DLayer(loc4Layer, num_filters=128, filter_size=(3,3), W=GlorotUniform('relu'), nonlinearity=rectify)
loc6Layer = layers.MaxPool2DLayer(loc5Layer, pool_size=(2,2))
loc7Layer = layers.Conv2DLayer(loc6Layer, num_filters=256, filter_size=(3,2), W=GlorotUniform('relu'), nonlinearity=rectify)
#loc7Layer = layers.DenseLayer(loc5Layer, num_units=1024, nonlinearity=rectify)
loc8Layer = layers.DenseLayer(loc7Layer, num_units=256, W=GlorotUniform('relu'), nonlinearity=rectify)
loc9Layer = layers.DenseLayer(loc8Layer, num_units=128, W=GlorotUniform('relu'), nonlinearity=rectify)
loc10Layer = layers.DenseLayer(loc9Layer, num_units=64, W=GlorotUniform('relu'), nonlinearity=rectify)
#loc11Layer = layers.DenseLayer(loc10Layer, num_units=32, nonlinearity=tanh)
#loc12Layer = layers.DenseLayer(loc11Layer, num_units=16, nonlinearity=tanh)
locOutLayer = layers.DenseLayer(loc10Layer, num_units=6, W=GlorotUniform(1.0), nonlinearity=identity)
transformLayer = layers.TransformerLayer(inputLayer, locOutLayer, downsample_factor=1.0)
conv1Layer = layers.Conv2DLayer(transformLayer, num_filters=32, filter_size=(3,3), W=GlorotNormal('relu'), nonlinearity=rectify)
pool1Layer = layers.MaxPool2DLayer(conv1Layer, pool_size=(2,2))
conv2Layer = layers.Conv2DLayer(pool1Layer, num_filters=64, filter_size=(4,3), W=GlorotUniform('relu'), nonlinearity=rectify)
pool2Layer = layers.MaxPool2DLayer(conv2Layer, pool_size=(2,2))
conv3Layer = layers.Conv2DLayer(pool2Layer, num_filters=128, filter_size=(3,3), W=GlorotUniform('relu'), nonlinearity=rectify)
pool3Layer = layers.MaxPool2DLayer(conv3Layer, pool_size=(2,2))
conv4Layer = layers.Conv2DLayer(pool3Layer, num_filters=256, filter_size=(3,2), W=GlorotNormal('relu'), nonlinearity=rectify)
hidden1Layer = layers.DenseLayer(conv4Layer, num_units=1024, W=GlorotUniform('relu'), nonlinearity=rectify)
dropout1Layer = layers.DropoutLayer(hidden1Layer, p=0.5)
hidden2Layer = layers.DenseLayer(dropout1Layer, num_units=512, W=GlorotUniform('relu'), nonlinearity=rectify)
#hidden3Layer = layers.DenseLayer(hidden2Layer, num_units=256, nonlinearity=tanh)
outputLayer = layers.DenseLayer(hidden2Layer, num_units=10, W=GlorotUniform(1.0), nonlinearity=softmax)
return outputLayer
def _invert_Conv2DLayer(self, layer, feeder):
# Warning they are swapped here
feeder = self._put_rectifiers(feeder, layer)
feeder = self._get_normalised_relevance_layer(layer, feeder)
f_s = layer.filter_size
if layer.pad == 'same':
pad = 'same'
elif layer.pad == 'valid' or layer.pad == (0, 0):
pad = 'full'
else:
raise RuntimeError("Define your padding as full or same.")
# By definition the
# Flip filters must be on to be a proper deconvolution.
num_filters = L.get_output_shape(layer.input_layer)[1]
if layer.stride == (4, 4):
# Todo: similar code gradient based explainers. Merge.
feeder = L.Upscale2DLayer(feeder, layer.stride, mode='dilate')
output_layer = L.Conv2DLayer(feeder,
num_filters=num_filters,
filter_size=f_s,
stride=1,
pad=pad,
nonlinearity=None,
b=None,
flip_filters=True)
conv_layer = output_layer
tmp = L.SliceLayer(output_layer, slice(0, -3), axis=3)
output_layer = L.SliceLayer(tmp, slice(0, -3), axis=2)
output_layer.W = conv_layer.W
else:
output_layer = L.Conv2DLayer(feeder,
num_filters=num_filters,
filter_size=f_s,
stride=1,
pad=pad,
nonlinearity=None,
b=None,
flip_filters=True)
W = output_layer.W
# Do the multiplication.
x_layer = L.ReshapeLayer(layer.input_layer,
(-1, ) + L.get_output_shape(output_layer)[1:])
output_layer = L.ElemwiseMergeLayer(incomings=[x_layer, output_layer],
merge_function=T.mul)
output_layer.W = W
return output_layer
def buildModel():
# Theinput layer with the inputs (None, dimensions, width, height)
l_input = layers.InputLayer((None, 3, 32, 32))
# First convolutional layer, has l_input layer as incoming and is followed by a pooling layer, filters = 16
l_conv1 = layers.Conv2DLayer(l_input,
num_filters=16,
filter_size=3,
pad='same',
nonlinearity=tanh)
l_pool1 = layers.MaxPool2DLayer(l_conv1, pool_size=2)
# The second convolution (l_pool1 is incoming), filters = 32
l_conv2 = layers.Conv2DLayer(l_pool1,
num_filters=32,
filter_size=3,
pad='same',
nonlinearity=tanh)
l_pool2 = layers.MaxPool2DLayer(l_conv2, pool_size=2)
# The third convolution (l_pool2 is incoming), filters = 64
l_conv3 = layers.Conv2DLayer(l_pool2,
num_filters=64,
filter_size=3,
pad='same',
nonlinearity=tanh)
l_pool3 = layers.MaxPool2DLayer(l_conv3, pool_size=2)
# The fourth and final convolution, filters = 128
l_conv4 = layers.Conv2DLayer(l_pool3,
num_filters=128,
filter_size=3,
pad='same',
nonlinearity=tanh)
l_pool4 = layers.MaxPool2DLayer(l_conv4, pool_size=2)
# The CNN contains 3 dense layers, one of them is the output layer
l_dense1 = layers.DenseLayer(l_pool4, num_units=64, nonlinearity=tanh)
l_dense2 = layers.DenseLayer(l_dense1, num_units=64, nonlinearity=tanh)
# The output layer has 43 units which is exactly the count of our class labels
# It has a softmax activation function, its values represent class probabilities
l_output = layers.DenseLayer(l_dense2, num_units=43, nonlinearity=softmax)
#print "The CNN model has ", layers.count_params(l_output), "parameters"
# Returning the layer stack by returning the last layer
return l_output
def build_cnn(num_filters, filter_sizes, strides, hidden_sizes):
print("Building CNN")
input_var = T.tensor4(name='input', dtype=theano.config.floatX) # float32
l_in = L.InputLayer(shape=(None,) + S.IMG, input_var=input_var)
S.print_shape(L.get_output_shape(l_in))
l_hid = l_in
for n_filt, filt_size, stride in zip(num_filters, filter_sizes, strides):
l_hid = L.Conv2DLayer(l_hid,
num_filters=n_filt,
filter_size=filt_size,
stride=stride)
S.print_shape(L.get_output_shape(l_hid))
for h_size in hidden_sizes:
l_hid = L.DenseLayer(l_hid, num_units=h_size)
S.print_shape(L.get_output_shape(l_hid))
l_out = L.DenseLayer(l_hid,
num_units=S.OUTPUT,
nonlinearity=lasagne.nonlinearities.softmax)
S.print_shape(L.get_output_shape(l_out))
variables = L.get_all_params(l_out)
for v in variables:
print("variable: ", v, " dtype: ", v.dtype)
return l_out, input_var
def test_conv2d(x_shape, num_filters, filter_size, flip_filters, batch_size=2):
X_var = T.tensor4('X')
l_x = L.InputLayer(shape=(None, ) + x_shape, input_var=X_var, name='x')
X = np.random.random((batch_size, ) + x_shape).astype(theano.config.floatX)
l_conv = L.Conv2DLayer(l_x,
num_filters,
filter_size=filter_size,
stride=1,
pad='same',
flip_filters=flip_filters,
untie_biases=True,
nonlinearity=None,
b=None)
conv_var = L.get_output(l_conv)
conv_fn = theano.function([X_var], conv_var)
tic()
conv = conv_fn(X)
toc("conv time for x_shape=%r, num_filters=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t"
% (x_shape, num_filters, filter_size, flip_filters, batch_size))
tic()
loop_conv = conv2d(X, l_conv.W.get_value(), flip_filters=flip_filters)
toc("loop conv time for x_shape=%r, num_filters=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t"
% (x_shape, num_filters, filter_size, flip_filters, batch_size))
assert np.allclose(conv, loop_conv, atol=1e-6)
def getNet9():
inputLayer = layers.InputLayer(shape=(None, 1, imageShape[0], imageShape[1]))
conv1Layer = layers.Conv2DLayer(inputLayer, num_filters=32, filter_size=(5,3), W=GlorotNormal('relu'), nonlinearity=rectify)
pool1Layer = layers.MaxPool2DLayer(conv1Layer, pool_size=(2,2))
conv2Layer = layers.Conv2DLayer(pool1Layer, num_filters=64, filter_size=(5,4), W=GlorotNormal('relu'), nonlinearity=rectify)
pool2Layer = layers.MaxPool2DLayer(conv2Layer, pool_size=(2,2))
conv3Layer = layers.Conv2DLayer(pool2Layer, num_filters=128, filter_size=(4,4), W=GlorotNormal('relu'), nonlinearity=rectify)
pool3Layer = layers.MaxPool2DLayer(conv3Layer, pool_size=(2,2))
conv4Layer = layers.Conv2DLayer(pool3Layer, num_filters=256, filter_size=(4,4), W=GlorotNormal('relu'), nonlinearity=rectify)
hidden1Layer = layers.DenseLayer(conv4Layer, num_units=2048, W=GlorotNormal('relu'), nonlinearity=rectify)
dropout1Layer = layers.DropoutLayer(hidden1Layer, p=0.5)
hidden2Layer = layers.DenseLayer(dropout1Layer, num_units=1024, W=GlorotNormal('relu'), nonlinearity=rectify)
dropout2Layer = layers.DropoutLayer(hidden2Layer, p=0.5)
hidden3Layer = layers.DenseLayer(dropout2Layer, num_units=512, W=GlorotNormal('relu'), nonlinearity=rectify)
outputLayer = layers.DenseLayer(hidden3Layer, num_units=10, W=GlorotNormal(1.0), nonlinearity=softmax)
return outputLayer
def _get_normalised_relevance_layer(self, layer, feeder):
def add_epsilon(Zs):
tmp = (T.cast(Zs >= 0, theano.config.floatX) * 2.0 - 1.0)
return Zs + self.epsilon * tmp
if isinstance(layer, L.DenseLayer):
forward_layer = L.DenseLayer(layer.input_layer,
layer.num_units,
W=layer.W,
b=layer.b,
nonlinearity=None)
elif isinstance(layer, L.Conv2DLayer):
forward_layer = L.Conv2DLayer(layer.input_layer,
num_filters=layer.num_filters,
W=layer.W,
b=layer.b,
stride=layer.stride,
filter_size=layer.filter_size,
flip_filters=layer.flip_filters,
untie_biases=layer.untie_biases,
pad=layer.pad,
nonlinearity=None)
else:
raise NotImplementedError()
forward_layer = L.ExpressionLayer(forward_layer,
lambda x: 1.0 / add_epsilon(x))
feeder = L.ElemwiseMergeLayer([forward_layer, feeder],
merge_function=T.mul)
return feeder
def conv(data, num_filters, name, pad):
return L.Conv2DLayer(data,
filter_size=(3, 3),
num_filters=num_filters,
nonlinearity=None,
pad=pad,
name='conv_' + name)
def init_cnn(model_file, hidden_units, num_filters, filter_hs, dropout_rate,
n_words, n_dim):
"""
initializes CNN by loading weights of a previously trained model. note that the model
trained and this model need to have same parameters. see trainCNN.py for explanation of
neural network architecture
:param model_file:
:param hidden_units:
:param num_filters:
:param filter_hs:
:param dropout_rate:
:param n_words:
:param n_dim:
:return:
"""
assert len(num_filters) == len(filter_hs)
filter_shapes = []
pool_sizes = []
for filter_h in filter_hs:
filter_shapes.append((filter_h, n_dim))
pool_sizes.append((n_words - filter_h + 1, 1))
l_in = LL.InputLayer(shape=(None, 1, n_words, n_dim))
layer_list = []
for i in range(len(filter_hs)):
l_conv = LL.Conv2DLayer(l_in,
num_filters=num_filters[i],
filter_size=filter_shapes[i],
nonlinearity=L.nonlinearities.rectify,
W=L.init.HeNormal(gain='relu'))
l_pool = LL.MaxPool2DLayer(l_conv, pool_size=pool_sizes[i])
layer_list.append(l_pool)
mergedLayer = LL.ConcatLayer(layer_list)
l_hidden1 = LL.DenseLayer(mergedLayer,
num_units=hidden_units[0],
nonlinearity=L.nonlinearities.tanh,
W=L.init.HeNormal(gain='relu'))
l_hidden1_dropout = LL.DropoutLayer(l_hidden1, p=dropout_rate[0])
l_hidden2 = LL.DenseLayer(l_hidden1_dropout,
num_units=hidden_units[1],
nonlinearity=L.nonlinearities.tanh,
W=L.init.HeNormal(gain='relu'))
l_hidden2_dropout = LL.DropoutLayer(l_hidden2, p=dropout_rate[1])
l_output = LL.DenseLayer(l_hidden2_dropout,
num_units=hidden_units[2],
nonlinearity=L.nonlinearities.tanh)
net_output = theano.function([l_in.input_var],
LL.get_output(l_output, deterministic=True))
with np.load(model_file) as f:
param_values = [f['arr_%d' % i] for i in range(len(f.files))]
LL.set_all_param_values(l_output, param_values)
return net_output
def getNet4():
inputLayer = layers.InputLayer(shape=(None, 1, imageShape[0],
imageShape[1])) #120x120
conv1Layer = layers.Conv2DLayer(inputLayer,
num_filters=32,
filter_size=(5, 5),
nonlinearity=elu) #116x116
pool1Layer = layers.MaxPool2DLayer(conv1Layer, pool_size=(2, 2)) #58x58
dropout1Layer = layers.DropoutLayer(pool1Layer, p=0.5)
conv2Layer = layers.Conv2DLayer(dropout1Layer,
num_filters=64,
filter_size=(5, 5),
nonlinearity=tanh) #54x54
pool2Layer = layers.MaxPool2DLayer(conv2Layer, pool_size=(2, 2)) #27x27
dropout2Layer = layers.DropoutLayer(pool2Layer, p=0.5)
conv3Layer = layers.Conv2DLayer(dropout2Layer,
num_filters=128,
filter_size=(4, 4),
nonlinearity=tanh) #24x24
pool3Layer = layers.MaxPool2DLayer(conv3Layer, pool_size=(2, 2)) #12x12
dropout3Layer = layers.DropoutLayer(pool3Layer, p=0.5)
conv4Layer = layers.Conv2DLayer(dropout3Layer,
num_filters=256,
filter_size=(3, 3),
nonlinearity=elu) #10x10
pool4Layer = layers.MaxPool2DLayer(conv4Layer, pool_size=(2, 2)) #5x5
dropout4Layer = layers.DropoutLayer(pool4Layer, p=0.5)
conv5Layer = layers.Conv2DLayer(dropout4Layer,
num_filters=512,
filter_size=(4, 4),
nonlinearity=tanh) #2x2
hidden1Layer = layers.DenseLayer(conv5Layer,
num_units=2048,
nonlinearity=tanh)
hidden2Layer = layers.DenseLayer(hidden1Layer,
num_units=1024,
nonlinearity=elu)
hidden3Layer = layers.DenseLayer(hidden2Layer,
num_units=512,
nonlinearity=tanh)
hidden4Layer = layers.DenseLayer(hidden3Layer,
num_units=256,
nonlinearity=tanh)
outputLayer = layers.DenseLayer(hidden4Layer,
num_units=10,
nonlinearity=softmax)
return outputLayer
