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