def build_model(input_layer=None): ################# # Regular model # ################# l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"]) l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"]) # Add an axis to concatenate over later l_4chr = nn.layers.ReshapeLayer(l_4ch, ( batch_size, 1, ) + l_4ch.output_shape[1:]) l_2chr = nn.layers.ReshapeLayer(l_2ch, ( batch_size, 1, ) + l_2ch.output_shape[1:]) # Cut the images in half, flip the left ones l_4ch_left = nn.layers.SliceLayer(l_4chr, indices=slice(image_size // 2 - 1, None, -1), axis=-1) l_4ch_right = nn.layers.SliceLayer(l_4chr, indices=slice(image_size // 2, None, 1), axis=-1) l_2ch_left = nn.layers.SliceLayer(l_2chr, indices=slice(image_size // 2 - 1, None, -1), axis=-1) l_2ch_right = nn.layers.SliceLayer(l_2chr, indices=slice(image_size // 2, None, 1), axis=-1) # Concatenate over second axis l_24lr = nn.layers.ConcatLayer( [l_4ch_left, l_4ch_right, l_2ch_left, l_2ch_right], axis=1) # b, 4, t, h, w # Subsample frames SUBSAMPLING_FACTOR = 2 nr_subsampled_frames = nr_frames // SUBSAMPLING_FACTOR l_24lr_ss = nn.layers.SliceLayer(l_24lr, indices=slice(None, None, SUBSAMPLING_FACTOR), axis=2) # Move frames and halves to batch, process them all in the same way, add channel axis l_halves = nn.layers.ReshapeLayer(l_24lr_ss, (batch_size * 4 * nr_subsampled_frames, 1, image_size, image_size // 2)) # First, do some convolutions in all directions l1a = nn.layers.dnn.Conv2DDNNLayer(l_halves, W=nn.init.Orthogonal("relu"), filter_size=(3, 3), num_filters=16, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3, 3), num_filters=16, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(1, 2), stride=(1, 2)) # Then, only use the last axis l2a = nn.layers.dnn.Conv2DDNNLayer(l1, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=32, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l2b = nn.layers.dnn.Conv2DDNNLayer(l2a, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=32, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(1, 2), stride=(1, 2)) l3a = nn.layers.dnn.Conv2DDNNLayer(l2, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=64, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l3b = nn.layers.dnn.Conv2DDNNLayer(l3a, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=64, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l3c = nn.layers.dnn.Conv2DDNNLayer(l3b, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=64, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(1, 2), stride=(1, 2)) l4a = nn.layers.dnn.Conv2DDNNLayer(l3, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=128, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l4b = nn.layers.dnn.Conv2DDNNLayer(l4a, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=128, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l4c = nn.layers.dnn.Conv2DDNNLayer(l4b, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=128, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(1, 2), stride=(1, 2)) # Now, process each row seperately, by flipping the channel and height axis, and then putting height in the batch l4shuffle = nn.layers.DimshuffleLayer(l4, pattern=(0, 2, 1, 3)) l4rows = nn.layers.ReshapeLayer( l4shuffle, (batch_size * 4 * nr_subsampled_frames * image_size, l4shuffle.output_shape[-2], l4shuffle.output_shape[-1])) # Systole ld1 = nn.layers.DenseLayer(l4rows, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) ld1drop = nn.layers.dropout(ld1, p=0.5) ld2 = nn.layers.DenseLayer(ld1drop, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) ld2drop = nn.layers.dropout(ld2, p=0.5) ld3mu = nn.layers.DenseLayer(ld2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(16.0), nonlinearity=None) ld3sigma = nn.layers.DenseLayer(ld2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(4.0), nonlinearity=lb_softplus(.01)) ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1) # Get the four halves back l_24lr_musigma = nn.layers.ReshapeLayer( ld3musigma, (batch_size, 4, nr_subsampled_frames, image_size, 2)) l_24lr_musigma_shuffle = nn.layers.DimshuffleLayer(l_24lr_musigma, pattern=(0, 2, 1, 3, 4)) l_24lr_musigma_re = nn.layers.ReshapeLayer( l_24lr_musigma_shuffle, (batch_size * nr_subsampled_frames, 4, image_size, 2)) l_4ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=0, axis=1) l_4ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=1, axis=1) l_2ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=2, axis=1) l_2ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=3, axis=1) l_4ch_musigma = layers.SumGaussLayer( [l_4ch_left_musigma, l_4ch_right_musigma]) l_2ch_musigma = layers.SumGaussLayer( [l_2ch_left_musigma, l_2ch_right_musigma]) l_musigma_frames = layers.IraLayerNoTime(l_4ch_musigma, l_2ch_musigma) # Minmax over time print l_musigma_frames.output_shape l_musigmas = nn.layers.ReshapeLayer(l_musigma_frames, (-1, nr_subsampled_frames, 2)) l_musigma_sys = layers.ArgmaxAndMaxLayer(l_musigmas, mode='min') l_musigma_dia = layers.ArgmaxAndMaxLayer(l_musigmas, mode='max') l_systole = layers.MuSigmaErfLayer(l_musigma_sys) l_diastole = layers.MuSigmaErfLayer(l_musigma_dia) return { "inputs": { "sliced:data:chanzoom:4ch": l_4ch, "sliced:data:chanzoom:2ch": l_2ch, }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": {}, "meta_outputs": {} }
def build_model(input_layer=None): ################# # Regular model # ################# l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"]) l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"]) # Add an axis to concatenate over later l_4chr = nn.layers.ReshapeLayer(l_4ch, ( -1, 1, ) + l_4ch.output_shape[1:]) l_2chr = nn.layers.ReshapeLayer(l_2ch, ( -1, 1, ) + l_2ch.output_shape[1:]) # Cut the images in half, flip the left ones l_4ch_left = nn.layers.SliceLayer(l_4ch, indices=slice(image_size // 2 - 1, None, -1), axis=-1) l_4ch_right = nn.layers.SliceLayer(l_4ch, indices=slice(image_size // 2, None, 1), axis=-1) l_2ch_left = nn.layers.SliceLayer(l_2ch, indices=slice(image_size // 2 - 1, None, -1), axis=-1) l_2ch_right = nn.layers.SliceLayer(l_2ch, indices=slice(image_size // 2, None, 1), axis=-1) # Concatenate over second axis l_24lr = nn.layers.ConcatLayer( [l_4ch_left, l_4ch_right, l_2ch_left, l_2ch_right], axis=1) # Move second axis to batch, process them all in the same way l_halves = nn.layers.ReshapeLayer( l_24lr, (-1, nr_frames, image_size, image_size // 2)) # First, do some convolutions in all directions l1a = nn.layers.dnn.Conv2DDNNLayer(l_halves, W=nn.init.Orthogonal("relu"), filter_size=(3, 3), num_filters=32, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3, 3), num_filters=32, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(1, 2), stride=(1, 2)) # Then, only use the last axis l2a = nn.layers.dnn.Conv2DDNNLayer(l1, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=64, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l2b = nn.layers.dnn.Conv2DDNNLayer(l2a, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=64, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(1, 2), stride=(1, 2)) l3a = nn.layers.dnn.Conv2DDNNLayer(l2, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=128, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l3b = nn.layers.dnn.Conv2DDNNLayer(l3a, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=128, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l3c = nn.layers.dnn.Conv2DDNNLayer(l3b, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=128, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(1, 2), stride=(1, 2)) l4a = nn.layers.dnn.Conv2DDNNLayer(l3, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=256, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l4b = nn.layers.dnn.Conv2DDNNLayer(l4a, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=256, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l4c = nn.layers.dnn.Conv2DDNNLayer(l4b, W=nn.init.Orthogonal("relu"), filter_size=(1, 3), num_filters=256, stride=(1, 1), pad="same", nonlinearity=nn.nonlinearities.rectify) l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(1, 2), stride=(1, 2)) # Now, process each row seperately, by flipping the channel and height axis, and then putting height in the batch l4shuffle = nn.layers.DimshuffleLayer(l4, pattern=(0, 2, 1, 3)) l4rows = nn.layers.ReshapeLayer( l4shuffle, (-1, l4shuffle.output_shape[-2], l4shuffle.output_shape[-1])) # Systole ldsys1 = nn.layers.DenseLayer(l4rows, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) ldsys1drop = nn.layers.dropout(ldsys1, p=0.5) ldsys2 = nn.layers.DenseLayer(ldsys1drop, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) ldsys2drop = nn.layers.dropout(ldsys2, p=0.5) ldsys3mu = nn.layers.DenseLayer(ldsys2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(16.0), nonlinearity=None) ldsys3sigma = nn.layers.DenseLayer(ldsys2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(4.0), nonlinearity=lb_softplus(.01)) ldsys3musigma = nn.layers.ConcatLayer([ldsys3mu, ldsys3sigma], axis=1) l_24lr_sys_musigma = nn.layers.ReshapeLayer(ldsys3musigma, (-1, 4, image_size, 2)) l_4ch_left_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma, indices=0, axis=1) l_4ch_right_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma, indices=1, axis=1) l_2ch_left_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma, indices=2, axis=1) l_2ch_right_sys_musigma = nn.layers.SliceLayer(l_24lr_sys_musigma, indices=3, axis=1) l_4ch_sys_musigma = layers.SumGaussLayer( [l_4ch_left_sys_musigma, l_4ch_right_sys_musigma]) l_2ch_sys_musigma = layers.SumGaussLayer( [l_2ch_left_sys_musigma, l_2ch_right_sys_musigma]) l_sys_musigma = layers.IraLayerNoTime(l_4ch_sys_musigma, l_2ch_sys_musigma) l_systole = layers.MuSigmaErfLayer(l_sys_musigma) # Systole lddia1 = nn.layers.DenseLayer(l4rows, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) lddia1drop = nn.layers.dropout(lddia1, p=0.5) lddia2 = nn.layers.DenseLayer(lddia1drop, num_units=256, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) lddia2drop = nn.layers.dropout(lddia2, p=0.5) lddia3mu = nn.layers.DenseLayer(lddia2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(16.0), nonlinearity=None) lddia3sigma = nn.layers.DenseLayer(lddia2drop, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(4.0), nonlinearity=lb_softplus(.01)) lddia3musigma = nn.layers.ConcatLayer([lddia3mu, lddia3sigma], axis=1) l_24lr_dia_musigma = nn.layers.ReshapeLayer(lddia3musigma, (-1, 4, image_size, 2)) l_4ch_left_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma, indices=0, axis=1) l_4ch_right_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma, indices=1, axis=1) l_2ch_left_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma, indices=2, axis=1) l_2ch_right_dia_musigma = nn.layers.SliceLayer(l_24lr_dia_musigma, indices=3, axis=1) l_4ch_dia_musigma = layers.SumGaussLayer( [l_4ch_left_dia_musigma, l_4ch_right_dia_musigma]) l_2ch_dia_musigma = layers.SumGaussLayer( [l_2ch_left_dia_musigma, l_2ch_right_dia_musigma]) l_dia_musigma = layers.IraLayerNoTime(l_4ch_dia_musigma, l_2ch_dia_musigma) l_diastole = layers.MuSigmaErfLayer(l_dia_musigma) return { "inputs": { "sliced:data:chanzoom:4ch": l_4ch, "sliced:data:chanzoom:2ch": l_2ch, }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": {}, "meta_outputs": {} }
def build_model(input_layer = None): ################# # Regular model # ################# l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"]) l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"]) # Add an axis to concatenate over later l_4chr = nn.layers.ReshapeLayer(l_4ch, (batch_size, 1, ) + l_4ch.output_shape[1:]) l_2chr = nn.layers.ReshapeLayer(l_2ch, (batch_size, 1, ) + l_2ch.output_shape[1:]) # Cut the images in half, flip the left ones l_4ch_left = nn.layers.SliceLayer(l_4chr, indices=slice(image_size//2-1, None, -1), axis=-1) l_4ch_right = nn.layers.SliceLayer(l_4chr, indices=slice(image_size//2, None, 1), axis=-1) l_2ch_left = nn.layers.SliceLayer(l_2chr, indices=slice(image_size//2-1, None, -1), axis=-1) l_2ch_right = nn.layers.SliceLayer(l_2chr, indices=slice(image_size//2, None, 1), axis=-1) # Concatenate over second axis l_24lr = nn.layers.ConcatLayer([l_4ch_left, l_4ch_right, l_2ch_left, l_2ch_right], axis=1) # b, 4, t, h, w # Subsample frames SUBSAMPLING_FACTOR = 2 nr_subsampled_frames = nr_frames // SUBSAMPLING_FACTOR l_24lr_ss = nn.layers.SliceLayer(l_24lr, indices=slice(None, None, SUBSAMPLING_FACTOR), axis=2) # Move frames and halves to batch, process them all in the same way, add channel axis l_halves = nn.layers.ReshapeLayer(l_24lr_ss, (batch_size * 4 * nr_subsampled_frames, 1, image_size, image_size//2)) # First, do some convolutions in all directions num_channels = 64 l1a = nn.layers.dnn.Conv2DDNNLayer(l_halves, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=num_channels, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify) l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=num_channels, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify) # Then, put an rnn over the last axis l1_shuffle = nn.layers.DimshuffleLayer(l1b, pattern=(0, 2, 3, 1)) l1_r = nn.layers.ReshapeLayer(l1_shuffle, (batch_size * 4 * nr_subsampled_frames * image_size, image_size//2, num_channels)) l_rnn = rnn_layer(l1_r, 1024) ld3mu = nn.layers.DenseLayer(l_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(16.0), nonlinearity=None) ld3sigma = nn.layers.DenseLayer(l_rnn, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(4.0), nonlinearity=lb_softplus(.01)) ld3musigma = nn.layers.ConcatLayer([ld3mu, ld3sigma], axis=1) # Get the four halves back l_24lr_musigma = nn.layers.ReshapeLayer(ld3musigma, (batch_size, 4, nr_subsampled_frames, image_size, 2)) l_24lr_musigma_shuffle = nn.layers.DimshuffleLayer(l_24lr_musigma, pattern=(0, 2, 1, 3, 4)) l_24lr_musigma_re = nn.layers.ReshapeLayer(l_24lr_musigma_shuffle, (batch_size * nr_subsampled_frames, 4, image_size, 2)) l_4ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=0, axis=1) l_4ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=1, axis=1) l_2ch_left_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=2, axis=1) l_2ch_right_musigma = nn.layers.SliceLayer(l_24lr_musigma_re, indices=3, axis=1) l_4ch_musigma = layers.SumGaussLayer([l_4ch_left_musigma, l_4ch_right_musigma]) l_2ch_musigma = layers.SumGaussLayer([l_2ch_left_musigma, l_2ch_right_musigma]) l_musigma_frames = layers.IraLayerNoTime(l_4ch_musigma, l_2ch_musigma) # Minmax over time print(l_musigma_frames.output_shape) l_musigmas = nn.layers.ReshapeLayer(l_musigma_frames, (-1, nr_subsampled_frames, 2)) l_musigma_sys = layers.ArgmaxAndMaxLayer(l_musigmas, mode='min') l_musigma_dia = layers.ArgmaxAndMaxLayer(l_musigmas, mode='max') l_systole = layers.MuSigmaErfLayer(l_musigma_sys) l_diastole = layers.MuSigmaErfLayer(l_musigma_dia) return { "inputs":{ "sliced:data:chanzoom:4ch": l_4ch, "sliced:data:chanzoom:2ch": l_2ch, }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": { }, "meta_outputs": { } }