Esempio n. 1
0
def build_cnn24(input_var, num_classes, conv, max_pool):
    network12 = lasagne.layers.InputLayer(shape=(None, 3, 12, 12),
                                          input_var=input_var[1])
    network12 = lasagne.layers.dropout(network12, p=.1)
    network12 = conv(network12, num_filters=16, filter_size=(3, 3))
    network12 = batchnorm.batch_norm(network12)
    network12 = max_pool(network12)
    network12 = GoodDenseLayer(lasagne.layers.dropout(network12, p=.3),
                               num_units=16)
    network12 = batchnorm.batch_norm(network12)

    network = lasagne.layers.InputLayer(shape=(None, 3, 24, 24),
                                        input_var=input_var[0])
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=64, filter_size=(5, 5))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.3),
                             num_units=128)
    network = batchnorm.batch_norm(network)

    network = lasagne.layers.ConcatLayer([network, network12])
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.3),
                                num_units=num_classes)
    return network
Esempio n. 2
0
def build_cnn24_cal(input_var, num_classes, conv, max_pool):
    network = lasagne.layers.InputLayer(shape=(None, 3, 24, 24), input_var=input_var)
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=32, filter_size=(5, 5))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.5), num_units=64)
    network = batchnorm.batch_norm(network)
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.5), num_units=num_classes)
    return network
Esempio n. 3
0
def build_cnn12_cal(input_var, num_classes, conv, max_pool):
    network = lasagne.layers.InputLayer(shape=(None, 3, 12, 12), input_var=input_var)
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=16, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.3), num_units=128)
    network = batchnorm.batch_norm(network)
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.3), num_units=num_classes)
    return network
Esempio n. 4
0
def build_cnn24_cal(input_var, num_classes, conv, max_pool):
    network = lasagne.layers.InputLayer(shape=(None, 3, 24, 24),
                                        input_var=input_var)
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=32, filter_size=(5, 5))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.5),
                             num_units=64)
    network = batchnorm.batch_norm(network)
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.5),
                                num_units=num_classes)
    return network
Esempio n. 5
0
def build_cnn12_cal(input_var, num_classes, conv, max_pool):
    network = lasagne.layers.InputLayer(shape=(None, 3, 12, 12),
                                        input_var=input_var)
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=16, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.3),
                             num_units=128)
    network = batchnorm.batch_norm(network)
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.3),
                                num_units=num_classes)
    return network
Esempio n. 6
0
def conv2d(X, w, sigmoid=False, bn=False):
    with tf.variable_scope('conv2d'):
        X = tf.nn.conv2d(X, w, [1, 1, 1, 1], 'SAME')
        if bn:
            X = batch_norm(X, w.get_shape()[3])
        if sigmoid:
            return tf.sigmoid(X)
        else:
            X = tf.nn.relu(X)
            return tf.maximum(0.01 * X, X)
Esempio n. 7
0
def build_cnn24(input_var, num_classes, conv, max_pool):
    network12 = lasagne.layers.InputLayer(shape=(None, 3, 12, 12), input_var=input_var[1])
    network12 = lasagne.layers.dropout(network12, p=.1)
    network12 = conv(network12, num_filters=16, filter_size=(3, 3))
    network12 = batchnorm.batch_norm(network12)
    network12 = max_pool(network12)
    network12 = GoodDenseLayer(lasagne.layers.dropout(network12, p=.3), num_units=16)
    network12 = batchnorm.batch_norm(network12)

    network = lasagne.layers.InputLayer(shape=(None, 3, 24, 24), input_var=input_var[0])
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=64, filter_size=(5, 5))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.3), num_units=128)
    network = batchnorm.batch_norm(network)

    network = lasagne.layers.ConcatLayer([network, network12])
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.3), num_units=num_classes)
    return network
Esempio n. 8
0
def colorize_net(_tensors):
    with tf.variable_scope('colorize_net'):

        # the conv5_3 layer of vgg is batch normalized, and 1x1 conv is applied on it
        # Bx14x14x512 -> batch norm -> 1x1 conv = Bx14x14x512
        conv0 = conv2d(batch_norm(_tensors["conv5_3"], 512),
                       _tensors["weights"]['wc0'],
                       sigmoid=False,
                       bn=True)
        # upscale the resulting layer to 28x28x512
        conv0 = tf.image.resize_bilinear(conv0, (28, 28))
        # add the layer to conv4_3 vgg layer
        conv0 = tf.add(conv0, batch_norm(_tensors["conv4_3"], 512))

        # the conv4_3 layer of vgg is batch normalized, and 1x1 conv is applied on it
        # Bx28x28x512 -> 1x1 conv = Bx28x28x256
        conv1 = conv2d(conv0,
                       _tensors["weights"]['wc1'],
                       sigmoid=False,
                       bn=True)
        # upscale the resulting layer to 56x56x256
        conv1 = tf.image.resize_bilinear(conv1, (56, 56))
        # add the upscaled layer to conv3_3 vgg layer
        conv1 = tf.add(conv1, batch_norm(_tensors["conv3_3"], 256))

        # Bx56x56x256 -> 3x3 conv = Bx56x56x128
        conv2 = conv2d(conv1,
                       _tensors["weights"]['wc2'],
                       sigmoid=False,
                       bn=True)
        # upscale the resulting layer to 112x112x128
        conv2 = tf.image.resize_bilinear(conv2, (112, 112))
        # add the upscaled layer to conv3_3 vgg layer
        conv2 = tf.add(conv2, batch_norm(_tensors["conv2_2"], 128))

        # Bx112x112x128 -> 3x3 conv = Bx112x112x64
        conv3 = conv2d(conv2,
                       _tensors["weights"]['wc3'],
                       sigmoid=False,
                       bn=True)
        # upscale the resulting layer to Bx224x224x64
        conv3 = tf.image.resize_bilinear(conv3, (224, 224))
        # add the upscaled layer to conv1_2 vgg layer
        conv3 = tf.add(conv3, batch_norm(_tensors["conv1_2"], 64))

        # Bx224x224x64 -> batch norm -> 3x3 conv = Bx224x224x3
        conv4 = conv2d(conv3,
                       _tensors["weights"]['wc4'],
                       sigmoid=False,
                       bn=True)
        # add the layer to greyscale image layer
        conv4 = tf.add(conv4, batch_norm(_tensors["grayscale"], 3))

        # Bx224x224x3 -> 3x3 conv = Bx224x224x3
        conv5 = conv2d(conv4,
                       _tensors["weights"]['wc5'],
                       sigmoid=False,
                       bn=True)

        # Bx224x224x3 -> 3x3 conv = Bx224x224x2
        conv6 = conv2d(conv5,
                       _tensors["weights"]['wc6'],
                       sigmoid=True,
                       bn=True)

    return conv6
Esempio n. 9
0
def build_cnn64_mp(input_var, num_classes, conv, max_pool):
    network24 = lasagne.layers.InputLayer(shape=(None, 3, 24, 24),
                                          input_var=input_var[2])
    network24 = lasagne.layers.dropout(network24, p=.1)
    network24 = conv(network24, num_filters=64, filter_size=(3, 3))
    network24 = batchnorm.batch_norm(network24)
    network24 = max_pool(network24)
    network24 = conv(network24, num_filters=64, filter_size=(3, 3))
    network24 = batchnorm.batch_norm(network24)
    network24 = conv(network24, num_filters=64, filter_size=(3, 3))
    network24 = batchnorm.batch_norm(network24)
    network24 = max_pool(network24)
    network24 = GoodDenseLayer(lasagne.layers.dropout(network24, p=.3),
                               num_units=128)
    network24 = batchnorm.batch_norm(network24)

    network48 = lasagne.layers.InputLayer(shape=(None, 3, 48, 48),
                                          input_var=input_var[1])
    network48 = lasagne.layers.dropout(network48, p=.1)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = max_pool(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = max_pool(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = max_pool(network48)
    network48 = GoodDenseLayer(lasagne.layers.dropout(network48, p=.3),
                               num_units=192)
    network48 = batchnorm.batch_norm(network48)

    network = lasagne.layers.InputLayer(shape=(None, 3, 64, 64),
                                        input_var=input_var[0])
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.3),
                             num_units=256)
    network = batchnorm.batch_norm(network)

    network = lasagne.layers.ConcatLayer([network, network48, network24])
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.3),
                                num_units=num_classes)
    return network
Esempio n. 10
0
def build_cnn64_mp(input_var, num_classes, conv, max_pool):
    network24 = lasagne.layers.InputLayer(shape=(None, 3, 24, 24), input_var=input_var[2])
    network24 = lasagne.layers.dropout(network24, p=.1)
    network24 = conv(network24, num_filters=64, filter_size=(3, 3))
    network24 = batchnorm.batch_norm(network24)
    network24 = max_pool(network24)
    network24 = conv(network24, num_filters=64, filter_size=(3, 3))
    network24 = batchnorm.batch_norm(network24)
    network24 = conv(network24, num_filters=64, filter_size=(3, 3))
    network24 = batchnorm.batch_norm(network24)
    network24 = max_pool(network24)
    network24 = GoodDenseLayer(lasagne.layers.dropout(network24, p=.3), num_units=128)
    network24 = batchnorm.batch_norm(network24)

    network48 = lasagne.layers.InputLayer(shape=(None, 3, 48, 48), input_var=input_var[1])
    network48 = lasagne.layers.dropout(network48, p=.1)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = max_pool(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = max_pool(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = conv(network48, num_filters=96, filter_size=(3, 3))
    network48 = batchnorm.batch_norm(network48)
    network48 = max_pool(network48)
    network48 = GoodDenseLayer(lasagne.layers.dropout(network48, p=.3), num_units=192)
    network48 = batchnorm.batch_norm(network48)

    network = lasagne.layers.InputLayer(shape=(None, 3, 64, 64), input_var=input_var[0])
    network = lasagne.layers.dropout(network, p=.1)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = conv(network, num_filters=128, filter_size=(3, 3))
    network = batchnorm.batch_norm(network)
    network = max_pool(network)
    network = GoodDenseLayer(lasagne.layers.dropout(network, p=.3), num_units=256)
    network = batchnorm.batch_norm(network)

    network = lasagne.layers.ConcatLayer([network, network48, network24])
    network = GoodClsDenseLayer(lasagne.layers.dropout(network, p=.3), num_units=num_classes)
    return network