Example #1
0
def build_model():

    #################
    # Regular model #
    #################
    data_size = data_sizes["sliced:data:ax:noswitch"]

    l0 = InputLayer(data_size)
    l0r = batch_norm(reshape(l0, (
        -1,
        1,
    ) + data_size[1:]))

    # (batch, channel, axis, time, x, y)

    # convolve over time
    l1 = batch_norm(
        ConvolutionOverAxisLayer(
            l0r,
            num_filters=4,
            filter_size=(3, ),
            axis=(3, ),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.0),
        ))
    l1m = batch_norm(MaxPoolOverAxisLayer(l1, pool_size=(4, ), axis=(3, )))

    # convolve over x and y
    l2a = batch_norm(
        ConvolutionOver2DAxisLayer(
            l1m,
            num_filters=8,
            filter_size=(3, 3),
            axis=(4, 5),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.0),
        ))
    l2b = batch_norm(
        ConvolutionOver2DAxisLayer(
            l2a,
            num_filters=8,
            filter_size=(3, 3),
            axis=(4, 5),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.0),
        ))
    l2m = batch_norm(MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2),
                                            axis=(4, 5)))

    # convolve over x, y, time
    l3a = batch_norm(
        ConvolutionOver3DAxisLayer(
            l2m,
            num_filters=64,
            filter_size=(3, 3, 3),
            axis=(3, 4, 5),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.1),
        ))

    l3b = batch_norm(
        ConvolutionOver2DAxisLayer(
            l3a,
            num_filters=64,
            filter_size=(3, 3),
            axis=(4, 5),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.1),
        ))
    l3m = batch_norm(MaxPoolOver2DAxisLayer(l3b, pool_size=(2, 2),
                                            axis=(4, 5)))

    # convolve over time
    l4 = batch_norm(
        ConvolutionOverAxisLayer(
            l3m,
            num_filters=64,
            filter_size=(3, ),
            axis=(3, ),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.1),
        ))
    l4m = batch_norm(MaxPoolOverAxisLayer(l4, pool_size=(2, ), axis=(2, )))

    # maxpool over axis
    l5 = batch_norm(MaxPoolOverAxisLayer(l3m, pool_size=(4, ), axis=(2, )))

    # convolve over x and y
    l6a = batch_norm(
        ConvolutionOver2DAxisLayer(
            l5,
            num_filters=128,
            filter_size=(3, 3),
            axis=(4, 5),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.1),
        ))
    l6b = batch_norm(
        ConvolutionOver2DAxisLayer(
            l6a,
            num_filters=128,
            filter_size=(3, 3),
            axis=(4, 5),
            channel=1,
            W=lasagne.init.Orthogonal(),
            b=lasagne.init.Constant(0.1),
        ))
    l6m = batch_norm(MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2),
                                            axis=(4, 5)))

    # convolve over time and x,y
    l7 = ConvolutionOver3DAxisLayer(
        l6m,
        num_filters=128,
        filter_size=(3, 3, 3),
        axis=(3, 4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )

    l8 = lasagne.layers.DropoutLayer(l7, p=0.5)

    l_d3a = lasagne.layers.DenseLayer(l8, num_units=128)

    l_d3b = lasagne.layers.DropoutLayer(l_d3a)

    l_systole = CumSumLayer(
        lasagne.layers.DenseLayer(l_d3b,
                                  num_units=600,
                                  nonlinearity=lasagne.nonlinearities.softmax))

    l_d3c = lasagne.layers.DenseLayer(l8, num_units=128)

    l_d3d = lasagne.layers.DropoutLayer(l_d3c)

    l_diastole = CumSumLayer(
        lasagne.layers.DenseLayer(l_d3d,
                                  num_units=600,
                                  nonlinearity=lasagne.nonlinearities.softmax))

    return {
        "inputs": {
            "sliced:data:ax:noswitch": l0
        },
        "outputs": {
            "systole": l_systole,
            "diastole": l_diastole,
        },
        "regularizable": {
            l_d3a: 0.25,
            l_d3c: 0.25,
            l_systole: 0.25,
            l_diastole: 0.25,
        }
    }
Example #2
0
def build_model():

    #################
    # Regular model #
    #################
    l0 = InputLayer(data_sizes["sliced:data:ax"])
    l0r = reshape(l0, (
        -1,
        1,
    ) + data_sizes["sliced:data:ax"][1:])

    # (batch, channel, time, axis, x, y)

    # convolve over time
    l1 = ConvolutionOverAxisLayer(
        l0r,
        num_filters=4,
        filter_size=(3, ),
        axis=(2, ),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l1b = ConvolutionOverAxisLayer(
        l1,
        num_filters=4,
        filter_size=(3, ),
        axis=(2, ),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l1m = MaxPoolOverAxisLayer(l1b, pool_size=(2, ), axis=(2, ))

    # convolve over x and y
    l2a = ConvolutionOver2DAxisLayer(
        l1m,
        num_filters=32,
        filter_size=(3, 3),
        axis=(4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l2b = ConvolutionOver2DAxisLayer(
        l2a,
        num_filters=32,
        filter_size=(3, 3),
        axis=(4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l2m = MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4, 5))

    # convolve over x, y and axis
    l3a = ConvolutionOver3DAxisLayer(
        l2m,
        num_filters=64,
        filter_size=(3, 3, 3),
        axis=(3, 4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )

    l3b = ConvolutionOver3DAxisLayer(
        l3a,
        num_filters=64,
        filter_size=(3, 3, 3),
        axis=(3, 4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l3c = ConvolutionOver3DAxisLayer(
        l3b,
        num_filters=64,
        filter_size=(3, 3, 3),
        axis=(3, 4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l3m = MaxPoolOver3DAxisLayer(l3c, pool_size=(2, 2, 2), axis=(3, 4, 5))

    # convolve over time
    l4 = ConvolutionOverAxisLayer(
        l3m,
        num_filters=64,
        filter_size=(3, ),
        axis=(2, ),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l4m = MaxPoolOverAxisLayer(l4, pool_size=(2, ), axis=(2, ))

    # convolve over axis
    l5 = ConvolutionOverAxisLayer(
        l4m,
        num_filters=128,
        filter_size=(3, ),
        axis=(3, ),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )

    # convolve over x and y
    l6a = ConvolutionOver2DAxisLayer(
        l5,
        num_filters=128,
        filter_size=(3, 3),
        axis=(4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l6b = ConvolutionOver2DAxisLayer(
        l6a,
        num_filters=128,
        filter_size=(3, 3),
        axis=(4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )
    l6m = MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4, 5))

    # convolve over time and x,y
    l7 = ConvolutionOver3DAxisLayer(
        l6m,
        num_filters=32,
        filter_size=(3, 3, 3),
        axis=(2, 4, 5),
        channel=1,
        W=lasagne.init.Orthogonal(),
        b=lasagne.init.Constant(0.1),
    )

    l8 = lasagne.layers.DropoutLayer(l7)

    l_d3a = lasagne.layers.DenseLayer(l8, num_units=600)

    l_d3b = lasagne.layers.DropoutLayer(l_d3a)

    l_systole = lasagne.layers.DenseLayer(
        l_d3b, num_units=600, nonlinearity=lasagne.nonlinearities.softmax)

    l_d3c = lasagne.layers.DenseLayer(l8, num_units=600)

    l_d3d = lasagne.layers.DropoutLayer(l_d3c)

    l_diastole = lasagne.layers.DenseLayer(
        l_d3d, num_units=600, nonlinearity=lasagne.nonlinearities.softmax)

    return {
        "inputs": {
            "sliced:data:ax": l0
        },
        "outputs": {
            "systole:onehot": l_systole,
            "diastole:onehot": l_diastole,
        },
        "regularizable": {
            l_d3a: 0.25,
            l_d3c: 0.25,
            l_systole: 0.25,
            l_diastole: 0.25,
        }
    }
Example #3
0
def build_model():

    #################
    # Regular model #
    #################
    l0 = InputLayer(data_sizes["sliced:data:ax"])
    l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][1:])

    # (batch, channel, time, axis, x, y)

    # convolve over time
    l1 = ConvolutionOverAxisLayer(l0r, num_filters=2, filter_size=(5,), axis=(2,), channel=1,
                                   W=lasagne.init.Orthogonal(),
                                   b=lasagne.init.Constant(0.1),
                                   )
    l1m = MaxPoolOverAxisLayer(l1, pool_size=(2,), axis=(2,))

    # convolve over x and y
    l2a = ConvolutionOver2DAxisLayer(l1m, num_filters=32, filter_size=(5, 5), stride=(2,2),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     )
    l2b = ConvolutionOver2DAxisLayer(l2a, num_filters=32, filter_size=(5, 5),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     )
    l2m = MaxPoolOver2DAxisLayer(l2b, pool_size=(3, 3), axis=(4,5))

    # convolve over x, y and axis
    l3a = ConvolutionOver3DAxisLayer(l2m, num_filters=32, filter_size=(3, 3, 3),
                                     axis=(3,4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     )

    l3b = ConvolutionOver3DAxisLayer(l3a, num_filters=32, filter_size=(3, 3, 3),
                                     axis=(3,4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     )
    l3m = MaxPoolOver3DAxisLayer(l3b, pool_size=(2, 2, 2), axis=(3,4,5))

    # convolve over time
    l4 = ConvolutionOverAxisLayer(l3m, num_filters=32, filter_size=(5,), axis=(2,), channel=1,
                                   W=lasagne.init.Orthogonal(),
                                   b=lasagne.init.Constant(0.1),
                                   )
    l4m = MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,))

    # convolve over axis
    l5 = ConvolutionOverAxisLayer(l4m, num_filters=32, filter_size=(3,), axis=(3,), channel=1,
                                   W=lasagne.init.Orthogonal(),
                                   b=lasagne.init.Constant(0.1),
                                   )

    """
    l_d3 = lasagne.layers.DenseLayer(l3m,
                              num_units=2,
                              nonlinearity=lasagne.nonlinearities.identity)
    l_systole = MuLogSigmaErfLayer(l_d3)

    l_d3b = lasagne.layers.DenseLayer(l3m,
                              num_units=2,
                              nonlinearity=lasagne.nonlinearities.identity)
    l_diastole = MuLogSigmaErfLayer(l_d3b)
    """
    l_d3 = lasagne.layers.DenseLayer(l5,
                              num_units=600,
                              nonlinearity=lasagne.nonlinearities.softmax)
    l_systole = CumSumLayer(l_d3)

    l_d3b = lasagne.layers.DenseLayer(l5,
                              num_units=600,
                              nonlinearity=lasagne.nonlinearities.softmax)
    l_diastole = CumSumLayer(l_d3b)

    return {
        "inputs":{
            "sliced:data:ax": l0
        },
        "outputs":{
            "systole": l_systole,
            "diastole": l_diastole
        }
    }
Example #4
0
def build_model():

    #################
    # Regular model #
    #################
    input_key = "sliced:data:ax:noswitch"
    data_size = data_sizes[input_key]

    l0 = InputLayer(data_size)
    l0r = batch_norm(reshape(l0, (-1, 1, ) + data_size[1:]))

    # (batch, channel, axis, time, x, y)

    # convolve over time
    l1 = batch_norm(ConvolutionOverAxisLayer(l0r, num_filters=8, filter_size=(3,), axis=(3,), channel=1,
                                   W=lasagne.init.Orthogonal(),
                                   b=lasagne.init.Constant(0.0),
                                   ))
    l1m = batch_norm(MaxPoolOverAxisLayer(l1, pool_size=(4,), axis=(3,)))

    # convolve over x and y
    l2a = batch_norm(ConvolutionOver2DAxisLayer(l1m, num_filters=8, filter_size=(3, 3),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.0),
                                     ))
    l2b = batch_norm(ConvolutionOver2DAxisLayer(l2a, num_filters=8, filter_size=(3, 3),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.0),
                                     ))
    l2m = batch_norm(MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4,5)))


    # convolve over x, y, time
    l3a = batch_norm(ConvolutionOver3DAxisLayer(l2m, num_filters=32, filter_size=(3, 3, 3),
                                     axis=(3,4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     ))

    l3b = batch_norm(ConvolutionOver2DAxisLayer(l3a, num_filters=32, filter_size=(3, 3),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     ))
    l3m = batch_norm(MaxPoolOver2DAxisLayer(l3b, pool_size=(2, 2), axis=(4,5)))

    # convolve over time
    l4 = batch_norm(ConvolutionOverAxisLayer(l3m, num_filters=32, filter_size=(3,), axis=(3,), channel=1,
                                   W=lasagne.init.Orthogonal(),
                                   b=lasagne.init.Constant(0.1),
                                   ))
    l4m = batch_norm(MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,)))

    # maxpool over axis
    l5 = batch_norm(MaxPoolOverAxisLayer(l3m, pool_size=(4,), axis=(2,)))

    # convolve over x and y
    l6a = batch_norm(ConvolutionOver2DAxisLayer(l5, num_filters=128, filter_size=(3, 3),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     ))
    l6b = batch_norm(ConvolutionOver2DAxisLayer(l6a, num_filters=128, filter_size=(3, 3),
                                     axis=(4,5), channel=1,
                                     W=lasagne.init.Orthogonal(),
                                     b=lasagne.init.Constant(0.1),
                                     ))
    l6m = batch_norm(MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4,5)))

    # convolve over time and x,y, is sparse reduction layer
    l7 = ConvolutionOver3DAxisLayer(l6m, num_filters=32, filter_size=(3,3,3), axis=(3,4,5), channel=1,
                                   W=lasagne.init.Orthogonal(),
                                   b=lasagne.init.Constant(0.1),
                                   )

    key_scale = "area_per_pixel:sax"
    l_scale = InputLayer(data_sizes[key_scale])

    # Systole Dense layers
    ldsys1 = lasagne.layers.DenseLayer(l7, num_units=512,
                                  W=lasagne.init.Orthogonal("relu"),
                                  b=lasagne.init.Constant(0.1),
                                  nonlinearity=lasagne.nonlinearities.rectify)

    ldsys1drop = lasagne.layers.dropout(ldsys1, p=0.5)
    ldsys2 = lasagne.layers.DenseLayer(ldsys1drop, num_units=128,
                                       W=lasagne.init.Orthogonal("relu"),
                                       b=lasagne.init.Constant(0.1),
                                       nonlinearity=lasagne.nonlinearities.rectify)

    ldsys2drop = lasagne.layers.dropout(ldsys2, p=0.5)
    ldsys3 = lasagne.layers.DenseLayer(ldsys2drop, num_units=1,
                                       b=lasagne.init.Constant(0.1),
                                       nonlinearity=lasagne.nonlinearities.identity)

    l_systole = layers.MuConstantSigmaErfLayer(layers.ScaleLayer(ldsys3, scale=l_scale), sigma=0.0)

    # Diastole Dense layers
    lddia1 = lasagne.layers.DenseLayer(l7, num_units=512,
                                       W=lasagne.init.Orthogonal("relu"),
                                       b=lasagne.init.Constant(0.1),
                                       nonlinearity=lasagne.nonlinearities.rectify)

    lddia1drop = lasagne.layers.dropout(lddia1, p=0.5)
    lddia2 = lasagne.layers.DenseLayer(lddia1drop, num_units=128,
                                       W=lasagne.init.Orthogonal("relu"),
                                       b=lasagne.init.Constant(0.1),
                                       nonlinearity=lasagne.nonlinearities.rectify)

    lddia2drop = lasagne.layers.dropout(lddia2, p=0.5)
    lddia3 = lasagne.layers.DenseLayer(lddia2drop, num_units=1,
                                       b=lasagne.init.Constant(0.1),
                                       nonlinearity=lasagne.nonlinearities.identity)

    l_diastole = layers.MuConstantSigmaErfLayer(layers.ScaleLayer(lddia3, scale=l_scale), sigma=0.0)

    return {
        "inputs":{
            input_key: l0,
            key_scale: l_scale,
        },
        "outputs": {
            "systole": l_systole,
            "diastole": l_diastole,
        },
        "regularizable": {
            ldsys1: l2_weight,
            ldsys2: l2_weight,
            ldsys3: l2_weight,
            lddia1: l2_weight,
            lddia2: l2_weight,
            lddia3: l2_weight,
        },
    }