def _pad_or_crop_to_shape_3D(x, in_shape, tgt_shape): ''' in_shape, tgt_shape are both 2x1 numpy arrays ''' im_diff = np.asarray(in_shape[:3]) - np.asarray(tgt_shape[:3]) if im_diff[0] < 0: pad_amt = (int(np.ceil(abs(im_diff[0]) / 2.0)), int(np.floor(abs(im_diff[0]) / 2.0))) x = ZeroPadding3D(( pad_amt, (0, 0), (0, 0) ))(x) if im_diff[1] < 0: pad_amt = (int(np.ceil(abs(im_diff[1]) / 2.0)), int(np.floor(abs(im_diff[1]) / 2.0))) x = ZeroPadding3D(((0, 0), pad_amt, (0, 0)))(x) if im_diff[2] < 0: pad_amt = (int(np.ceil(abs(im_diff[2]) / 2.0)), int(np.floor(abs(im_diff[2]) / 2.0))) x = ZeroPadding3D(((0, 0), (0, 0), pad_amt))(x) if im_diff[0] > 0: crop_amt = (int(np.ceil(im_diff[0] / 2.0)), int(np.floor(im_diff[0] / 2.0))) x = Cropping3D((crop_amt, (0, 0), (0, 0)))(x) if im_diff[1] > 0: crop_amt = (int(np.ceil(im_diff[1] / 2.0)), int(np.floor(im_diff[1] / 2.0))) x = Cropping3D(((0, 0), crop_amt, (0, 0)))(x) if im_diff[2] > 0: crop_amt = (int(np.ceil(im_diff[2] / 2.0)), int(np.floor(im_diff[2] / 2.0))) x = Cropping3D(((0, 0), (0, 0), crop_amt))(x) return x
def ClassNet_MultiScale(): inputs = Input((1,48,48,48)) #noise=GaussianNoise(stddev=0.01,input_shape=(1,48,48,48))(inputs) ch1=inputs #ch1=inputs#add([inputs,noise]) ch2=Cropping3D(((8,8),(8,8),(8,8)))(inputs) ch3=Cropping3D(((16,16),(16,16),(16,16)))(inputs) #ch2=UpSampling3D(size=(2,2,2))(ch2) #ch3=UpSampling3D(size=(4,4,4))(ch3) ch1=ConvNet48(ch1) ch2=ConvNet32(ch2) ch3=ConvNet16(ch3) #ch2=ConvNet32(ch2) #ch3=ConvNet12(ch3) #fusion=add([ch1,ch2,ch3]) fusion=concatenate([ch1,ch2,ch3],axis=1) fusion=Dense(2)(fusion)#Conv3D(2,(1,1,1), padding='same',activation='relu')(fusion) fusion=core.Reshape((2,1))(fusion) #a=core.Reshape((6,1))(fusion) a=core.Permute((2,1))(fusion) act=Activation('softmax')(a) model = Model(inputs=inputs, outputs=act) model.compile(optimizer=Adam(lr=config["initial_learning_rate"]), loss='mean_squared_error',metrics=['accuracy']) return model
def resnet_like(in_sz=None): """ returns a model that uses residual components """ in_sz = fplutils.to3d(in_sz) in_sz = in_sz + (1, ) inputs = Input(shape=in_sz) conv1 = Conv3D(32, (3, 3, 3), use_bias=False)(inputs) # 16x16x16 conv1 = _bn_relu(conv1) pool1 = MaxPooling3D(pool_size=(2, 2, 2))(conv1) # 8x8x8 conv2 = Conv3D(32, (3, 3, 3), use_bias=False)(pool1) # 6x6x6 conv2 = _bn_relu(conv2) conv2 = Conv3D(32, (1, 1, 1), use_bias=False)(conv2) # 6x6x6 conv2 = BatchNormalization()(conv2) crop_pool1 = Cropping3D(cropping=((1, 1), (1, 1), (1, 1)))(pool1) conv2 = add([crop_pool1, conv2]) conv2 = Activation("relu")(conv2) pool2 = MaxPooling3D(pool_size=(2, 2, 2))(conv2) # 3x3x3 conv3 = Conv3D(64, (3, 3, 3), use_bias=False)(pool2) # 1x1x1 conv3 = _bn_relu(conv3) conv3 = Conv3D(64, (1, 1, 1), use_bias=False)(conv3) # 1x1x1 pool2_shortcut = Conv3D(64, (1, 1, 1), use_bias=False)(pool2) crop_pool2 = Cropping3D(cropping=((1, 1), (1, 1), (1, 1)))(pool2_shortcut) conv3 = BatchNormalization()(conv3) conv3 = add([crop_pool2, conv3]) conv3 = Activation("relu")(conv3) predictions = Conv3D(1, (1, 1, 1), activation='sigmoid')(conv3) model = Model(inputs=inputs, outputs=predictions) return model, (18, 7, 4), 102, None
def manipulate_input_stack(self, inputlayer): pad_crop = ((0, 0), (0, 0), hp.calculate_pad_crop_value(self.e_v)) if self.manipulation == MANIPULATION.SPATIAL_UP: output = ZeroPadding3D(padding=pad_crop, data_format="channels_last")(inputlayer) elif self.manipulation == MANIPULATION.SPATIAL_DOWN: output = Cropping3D(cropping=pad_crop, data_format="channels_last")(inputlayer) elif self.manipulation == MANIPULATION.SPATIAL_MIN: x = hp.calculate_stack_resize(self.vol_depth, 'min')[0] if 2**x < self.vol_depth: output = Cropping3D(cropping=pad_crop, data_format="channels_last")(inputlayer) else: output = ZeroPadding3D(padding=pad_crop, data_format="channels_last")(inputlayer) elif self.manipulation == MANIPULATION.FREQUENCY_UP: print('MANIPULATION.FREQUENCY_UP not yet implemented') self.fourier_transform(inputlayer, pad_crop) elif self.manipulation == MANIPULATION.FREQUENCY_DOWN: print('MANIPULATION.FREQUENCY_DOWN not yet implemented') elif self.manipulation == MANIPULATION.FREQUENCY_MIN: print('MANIPULATION.FREQUENCY_MIN not yet implemented') return output
def get_unet(lr=1e-6): # , l2_constant=0.002 # model_id = "unet3d_same" image_depth = 44 # 38 image_rows = 120 #80 #200 # 140 image_columns = 132 #80 #220 # 140 inputs = Input((1, image_depth, image_rows, image_columns)) conv1 = Convolution3D(32, 3, 3, 3, activation='relu', border_mode='valid')(inputs) # ,W_regularizer=l2(l2_constant) conv1 = Convolution3D(32, 3, 3, 3, activation='relu', border_mode='valid')(conv1) # ,,W_regularizer=l2(l2_constant) pool1 = MaxPooling3D(pool_size=(1, 2, 2), padding='valid')(conv1) # strides=(2, 2, 2), conv2 = Convolution3D(64, 3, 3, 3, activation='relu', border_mode='valid')(pool1) # W_regularizer=l2(l2_constant), conv2 = Convolution3D(64, 3, 3, 3, activation='relu', border_mode='valid')(conv2) pool2 = MaxPooling3D(pool_size=(1, 2, 2), padding='valid')(conv2) # strides=(2, 2, 2), conv3 = Convolution3D(128, 3, 3, 3, activation='relu', border_mode='valid')(pool2) # W_regularizer=l2(l2_constant), conv3 = Convolution3D(128, 3, 3, 3, activation='relu', border_mode='valid')(conv3) # W_regularizer=l2(l2_constant), conv2_cropped = Cropping3D(((2, 2), (4, 4), (4, 4)))(conv2) up4 = merge([UpSampling3D(size=(1, 2, 2))(conv3), conv2_cropped], mode='concat', concat_axis=1) conv4 = Convolution3D(64, 3, 3, 3, activation='relu', border_mode='valid')(up4) # W_regularizer=l2(l2_constant), conv4 = Convolution3D(64, 3, 3, 3, activation='relu', border_mode='valid')(conv4) # W_regularizer=l2(l2_constant), conv1_cropped = Cropping3D(((6, 6), (16, 16), (16, 16)))(conv1) up5 = merge([UpSampling3D(size=(1, 2, 2))(conv4), conv1_cropped], mode='concat', concat_axis=1) conv5 = Convolution3D(32, 3, 3, 3, activation='relu', border_mode='valid')(up5) # W_regularizer=l2(l2_constant), conv5 = Convolution3D(32, 3, 3, 3, activation='relu', border_mode='valid')(conv5) # W_regularizer=l2(l2_constant), conv6 = Convolution3D(1, 1, 1, 1, activation='sigmoid')(conv5) model = Model(input=inputs, output=conv6) model.compile(optimizer=Adam(lr=lr), loss=dice_coef_loss, metrics=[dice_coef]) return model # , model_id
def make_flood_fill_network(input_fov_shape, output_fov_shape, network_config): """Construct a stacked convolution module flood filling network. """ if network_config.convolution_padding != 'same': raise ValueError('ResNet implementation only supports same padding.') image_input = Input(shape=tuple(input_fov_shape) + (1, ), dtype='float32', name='image_input') if network_config.rescale_image: ffn = Lambda(lambda x: (x - 0.5) * 2.0)(image_input) else: ffn = image_input mask_input = Input(shape=tuple(input_fov_shape) + (1, ), dtype='float32', name='mask_input') ffn = concatenate([ffn, mask_input]) # Convolve and activate before beginning the skip connection modules, # as discussed in the Appendix of He et al 2016. ffn = Conv3D(network_config.convolution_filters, tuple(network_config.convolution_dim), kernel_initializer=network_config.initialization, activation=network_config.convolution_activation, padding='same')(ffn) if network_config.batch_normalization: ffn = BatchNormalization()(ffn) contraction = (input_fov_shape - output_fov_shape) // 2 if np.any(np.less(contraction, 0)): raise ValueError( 'Output FOV shape can not be larger than input FOV shape.') contraction_cumu = np.zeros(3, dtype=np.int32) contraction_step = np.divide(contraction, float(network_config.num_modules)) for i in range(0, network_config.num_modules): ffn = add_convolution_module(ffn, network_config) contraction_dims = np.floor(i * contraction_step - contraction_cumu).astype(np.int32) if np.count_nonzero(contraction_dims): ffn = Cropping3D( zip(list(contraction_dims), list(contraction_dims)))(ffn) contraction_cumu += contraction_dims if np.any(np.less(contraction_cumu, contraction)): remainder = contraction - contraction_cumu ffn = Cropping3D(zip(list(remainder), list(remainder)))(ffn) mask_output = Conv3D(1, tuple(network_config.convolution_dim), kernel_initializer=network_config.initialization, padding='same', name='mask_output', activation=network_config.output_activation)(ffn) ffn = Model(inputs=[image_input, mask_input], outputs=[mask_output]) return ffn
def dense_block(num_fms, x, filter_size, kernel_initializer, kernel_regularizer, dropout): """ 4-layer dense block Each layer is connected to the layer before it In the DenseNet paper, they specify the following order: BN --> ReLU --> Conv on the concatenation """ # Layer 1 d1 = BatchNormalization()(x) d1 = Activation("relu")(d1) d1 = Conv3D(num_fms, filter_size, padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(d1) if dropout is not None: d1 = Dropout(dropout)(d1) # Layer 2 d2 = BatchNormalization()(d1) d2 = Activation("relu")(d2) d2 = Conv3D(num_fms, filter_size, padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(d2) if dropout is not None: d2 = Dropout(dropout)(d2) # Layer 3 # Concatenate layers 1, 2, output r1 = Cropping3D(cropping=((1, 1), (1, 1), (1, 1)))(d1) d3 = Concatenate()([r1, d2]) d3 = BatchNormalization()(d3) d3 = Activation("relu")(d3) d3 = Conv3D(num_fms, filter_size, padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(d3) if dropout is not None: d3 = Dropout(dropout)(d3) # Layer 4 # Concatenate layers 1, 2, 3 output r1 = Cropping3D(cropping=((2, 2), (2, 2), (2, 2)))(d1) r2 = Cropping3D(cropping=((1, 1), (1, 1), (1, 1)))(d2) d4 = Concatenate(axis=4)([r1, r2, d3]) d4 = BatchNormalization()(d4) d4 = Activation("relu")(d4) d4 = Conv3D(num_fms, filter_size, padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(d4) if dropout is not None: d4 = Dropout(dropout)(d4) return d4
def unet_like4(in_sz=40): ''' construct a u-net style network ''' in_sz = fplutils.to3d(in_sz) in_sz = in_sz + (1, ) inputs = Input(shape=in_sz) # 40^2 # down-sample conv1 = Conv3D(32, (3, 3, 3), use_bias=False)(inputs) # 38 conv1 = _bn_relu(conv1) conv1 = Conv3D(32, (3, 3, 3), use_bias=False)(conv1) # 36 conv1 = _bn_relu(conv1) pool1 = MaxPooling3D(pool_size=(2, 2, 2))(conv1) # 18 conv2 = Conv3D(64, (3, 3, 3), use_bias=False)(pool1) # 16 conv2 = _bn_relu(conv2) conv2 = Conv3D(64, (3, 3, 3), use_bias=False)(conv2) # 14 conv2 = _bn_relu(conv2) pool2 = MaxPooling3D(pool_size=(2, 2, 2))(conv2) # 7 conv3 = Conv3D(128, (3, 3, 3), use_bias=False)(pool2) # 5 conv3 = _bn_relu(conv3) conv3 = Conv3D(128, (3, 3, 3), use_bias=False)(conv3) # 3 conv3 = _bn_relu(conv3) # up-sample crop_conv2 = Cropping3D(cropping=((4, 4), (4, 4), (4, 4)))(conv2) up4 = concatenate([UpSampling3D(size=(2, 2, 2))(conv3), crop_conv2]) # 6 conv4 = Conv3D(64, (3, 3, 3), use_bias=False)(up4) # 4 conv4 = _bn_relu(conv4) conv4 = Conv3D(64, (1, 1, 1), use_bias=False)(conv4) # 4 conv4 = _bn_relu(conv4) crop_conv1 = Cropping3D(cropping=((14, 14), (14, 14), (14, 14)))(conv1) up5 = concatenate([UpSampling3D(size=(2, 2, 2))(conv4), crop_conv1]) # 8x8x8 conv5 = Conv3D(32, (3, 3, 3), use_bias=False)(up5) # 6 conv5 = _bn_relu(conv5) conv5 = Conv3D(32, (1, 1, 1), use_bias=False)(conv5) # 6 conv5 = _bn_relu(conv5) predictions = Conv3D(1, (1, 1, 1), activation='sigmoid', use_bias=False)(conv5) # 6 model = Model(inputs=inputs, outputs=predictions) compile_args = { 'loss': masked_focal_loss, #masked_binary_crossentropy, 'optimizer': 'adam', 'metrics': [masked_accuracy, lb0l1err, lb1l1err] } return model, (40, 17, 1), 100, compile_args
def CroppingTest(): inputs = Input((1,48,48,48)) #noise=GaussianNoise(stddev=0.01,input_shape=(1,48,48,48))(inputs) ch1=inputs ch2=Cropping3D(((12,12),(12,12),(12,12)))(inputs)#(inputs) ch3=Cropping3D(((18,18),(18,18),(18,18)))(inputs)#(inputs) ch2=UpSampling3D(size=(2,2,2))(ch2) ch3=UpSampling3D(size=(4,4,4))(ch3) fusion=concatenate([ch1,ch2,ch3],axis=1) model = Model(inputs=inputs, outputs=fusion) return model
def residual_block(num_fms, x, filter_size, kernel_initializer, kernel_regularizer, dropout): x = Conv3D(num_fms, filter_size, activation="relu", padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(x) x = BatchNormalization()(x) if dropout is not None: x = Dropout(dropout)(x) y = Conv3D(num_fms, filter_size, activation="relu", padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(x) if dropout is not None: x = Dropout(dropout)(x) y = BatchNormalization()(y) y = Conv3D(num_fms, filter_size, padding="valid", kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer)(y) if dropout is not None: x = Dropout(dropout)(x) y = BatchNormalization()(y) r = Cropping3D(cropping=((2, 2), (2, 2), (2, 2)))(x) y = Add()([y, r]) y = Activation("relu")(y) return y
def crop3D_layer(inp, cropping=((1, 1), (1, 1), (1, 1)), data_format=None, time_dist=False): assert type(cropping) in (int, tuple) input_shape = get_data_shape(inp) cropping = get_cropping_tuple(cropping=cropping, patch_topology='2D') if time_dist: crop_op = TimeDistributed(Cropping3D(cropping=cropping))(inp) else: crop_op = Cropping3D(cropping=cropping)(inp) return crop_op
def new_instance(input_shape, learning_rate): x, y, time, spectral = input_shape inputLayer = Input(shape=input_shape) cnn_model = Conv3D(256, kernel_size=(3, 3, 5), padding='same')(inputLayer) cnn_model = Conv3D(256, kernel_size=(3, 3, 1), padding='valid')(cnn_model) cnn_model = BatchNormalization()(cnn_model) cnn_model = Activation('relu')(cnn_model) cnn_model = Flatten()(cnn_model) lstm_model = Cropping3D(cropping=(1, 1, 0))(inputLayer) lstm_model = Reshape(target_shape=(time, spectral))(lstm_model) lstm_model = BatchNormalization()(lstm_model) lstm_model = Bidirectional(CuDNNLSTM(256, return_sequences=True))(lstm_model) lstm_model = Flatten()(lstm_model) conc_model = concatenate([lstm_model, cnn_model]) conc_model = Dense(256, activation='relu')(conc_model) conc_model = Dropout(0.3)(conc_model) conc_model = Dense(64, activation='relu')(conc_model) conc_model = Dense(2, activation='sigmoid')(conc_model) conc_model = Model(inputLayer, conc_model) optimizer = optimizers.Nadam(lr=learning_rate) conc_model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) return conc_model
def build_discriminator(self): def d_layer(layer_input, filters, f_size=3, bn=True, scale=True, name=''): #change the bn to False """Discriminator layer""" d = Conv3D(filters, kernel_size=f_size, strides=1, padding='same', name=name + '_conv3d')(layer_input) if bn: d = BatchNormalization(momentum=0.8, name=name + '_bn', scale=scale)(d) d = LeakyReLU(alpha=0.2, name=name + '_leakyrelu')(d) return d img_A = Input(shape=self.input_shape_d, name='input_img_A') # 24x24x24 warped_img or reference img_T = Input(shape=self.input_shape_g, name='input_img_T') # 64x64x64 template img_T_cropped = Cropping3D(cropping=20)(img_T) # 24x24x24 # Concatenate image and conditioning image by channels to produce input #combined_imgs = Concatenate(axis=-1, name='combine_imgs_d')([img_A, img_T_cropped]) combined_imgs = Add(name='combine_imgs_d')([img_A, img_T_cropped]) d1 = d_layer(combined_imgs, self.df, bn=False, name='d1') # 24x24x24 d2 = d_layer(d1, self.df * 2, name='d2') # 24x24x24 pool = MaxPooling3D(pool_size=(2, 2, 2), name='d2_pool')(d2) # 12x12x12 d3 = d_layer(pool, self.df * 4, name='d3') # 12x12x12 d4 = d_layer(d3, self.df * 8, name='d4') # 12x12x12 pool = MaxPooling3D(pool_size=(2, 2, 2), name='d4_pool')(d4) # 6x6x6 d5 = d_layer(pool, self.df * 8, name='d5') # 6x6x6 # ToDo: Use FC layer at the end like specified in the paper validity = Conv3D(1, kernel_size=4, strides=1, padding='same', activation='sigmoid', name='validity')(d5) #6x6x6 #d6 = Conv3D(1, kernel_size=4, strides=1, padding='same', name='validity')(d5) # 6x6x6 #validity = Flatten(data_format='channels_last')(d6) #x = Reshape((6*6*6*512,))(d5) # hack to avoid flatten bug #validity = Dense(1, activation='sigmoid')(x) # Use FC layer #d6 = Flatten(input_shape=(self.batch_sz,) + (6,6,6,512))(d5) #validity = Dense(1, activation='sigmoid')(d5) return Model([img_A, img_T], validity, name='discriminator_model')
def build_discriminator(self): def d_layer(layer_input, filters, f_size=4, bn=True): """Discriminator layer""" d = Conv3D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) if bn: d = BatchNormalization(momentum=0.8)(d) d = LeakyReLU(alpha=0.2)(d) return d img_S = Input(shape=self.input_shape_d) #128 S img_T = Input(shape=self.img_shape) #256 T img_T_cropped = Cropping3D(cropping=64)(img_T) # 128 combined_imgs = Concatenate(axis=-1)([img_S, img_T_cropped]) #combined_imgs = Add()([img_S, img_T]) d1 = d_layer(combined_imgs, self.df, bn=False) d2 = d_layer(d1, self.df*2) d3 = d_layer(d2, self.df*4) d4 = d_layer(d3, self.df*8) validity = Conv3D(1, kernel_size=4, strides=1, padding='same', name='disc_sig')(d4) #original is linear activation no sigmoid return Model([img_S, img_T], validity, name='discriminator_model')
def unet3d_generator(self): inputs = Input((self.color_type, self.depth, self.height, self.width)) conv1 = Convolution3D(128, 3, 3, 3, activation='relu')(inputs) conv2 = Convolution3D(128, 3, 3, 3, activation='relu')(conv1) conv3 = Convolution3D(128, 3, 3, 3, activation='relu')(conv2) pool1 = MaxPooling3D(pool_size=(2, 2, 2))(conv3) conv4 = Convolution3D(128, 3, 3, 3, activation='relu')(pool1) conv5 = Convolution3D(128, 3, 3, 3, activation='relu')(conv4) conv6 = Convolution3D(128, 3, 3, 3, activation='relu')(conv5) conv7 = Convolution3D(128, 3, 3, 3, activation='relu')(conv6) up1 = merge([ UpSampling3D(size=(2, 2, 2))(conv7), Cropping3D(cropping=((8, 8), (8, 8), (8, 8)))(conv3) ], mode='concat', concat_axis=1) conv8 = Convolution3D(256, 3, 3, 3, activation='relu')(up1) conv9 = Convolution3D(128, 3, 3, 3, activation='relu')(conv8) conv10 = Convolution3D(128, 3, 3, 3, activation='relu')(conv9) conv11 = Convolution3D(128, 3, 3, 3, activation='relu')(conv10) conv12 = Convolution3D(128, 3, 3, 3, activation='relu')(conv11) model = Model(input=inputs, output=conv12) model.compile(optimizer=Adam(lr=1e-5), loss=dice_coef_loss, metric=[dice_coef]) return model
def model_flat(input_shape, learning_rate, training=True): input_layer = Input(shape=input_shape, name='input_layer') width = input_shape[1] height = input_shape[2] # For the flat model occupancy is index 0 if training: x = keras.layers.Lambda(whitten)(input_layer) else: x = input_layer mask = keras.layers.Reshape( (10, width, height, 1))(input_layer[:, 10:, :, :, 1]) # last 10 visibility grids x = keras.layers.Lambda(whitten)(input_layer) x = TimeDistributed( Conv2D(8, kernel_size=(7, 7), activation=leaky_relu, padding='same'))(x) x = ConvLSTM2D(16, kernel_size=(5, 5), padding='same', activation=leaky_relu, return_sequences=True)(x) x = Cropping3D(((10, 0), (0, 0), (0, 0)))(x) x = TimeDistributed(Conv2D(1, (7, 7), padding='same'))(x) out = keras.layers.Activation(activation='sigmoid')(x) model = Model(inputs=[input_layer], outputs=[out]) if not training: for layer in model.layers: layer.trainable = False model.compile(loss=loss_fun_flat(mask, width, height), optimizer=keras.optimizers.Adam(lr=learning_rate), metrics=['mse']) return model
def _vshifted_conv(x, num_filters, name): """ Vertically shifted 3-d convolution """ filter_size = [3, 3, 3] # Assumes the height is the second dimension k = filter_size[1] // 2 ### 2d code ### # x = ZeroPadding2D([[k,0],[0,0]])(x) # x = Conv2D(filters=num_filters, kernel_size=filter_size, padding='same', kernel_initializer='he_normal', name=name)(x) # x = LeakyReLU(0.1)(x) # x = Cropping2D([[0,k],[0,0]])(x) ### 3d adaptation ### # assumes first tuple is frame number, second is height, 3rd is width # padding on height x = ZeroPadding3D([[0, 0], [k, 0], [0, 0]])(x) x = Conv3D(filters=num_filters, kernel_size=filter_size, padding='same', kernel_initializer='he_normal', name=name)(x) x = LeakyReLU(0.1)(x) x = Cropping3D([[0, 0], [0, k], [0, 0]])(x) return x
def make_model(num_classes, conv_dropout_p=0.75, dense_dropout_p=0.5, name='conv_2_layer_pass_through', **kwargs): name = name + '_' + str(conv_dropout_p) + '_' + str(dense_dropout_p) input_shape = (25, 25, 25) k_input_shape = (input_shape[0], input_shape[1], input_shape[2], 1) inputs = Input(shape=(input_shape[0], input_shape[1], input_shape[2], 1)) processed = all_preprocessing(inputs, 'all', functional_api=True, **kwargs) conv_1 = Conv3D(48, (5, 5, 5), padding='valid')(processed) conv_1 = Activation('relu')(conv_1) pool_1 = MaxPooling3D(pool_size=(3, 3, 3))(conv_1) drop_1a = Dropout(conv_dropout_p)(pool_1) crop_1 = Cropping3D((7, 7, 7))(conv_1) drop_1b = Dropout(conv_dropout_p)(crop_1) conc_1 = Concatenate(axis=4)([drop_1a, drop_1b]) conv_2 = Conv3D(96, (3, 3, 3), padding='valid')(conc_1) conv_2 = Activation('relu')(conv_2) pool_2 = MaxPooling3D(pool_size=(3, 3, 3))(conv_2) drop_2a = Dropout(conv_dropout_p)(pool_2) crop_2 = Cropping3D((2, 2, 2))(conv_2) drop_2b = Dropout(conv_dropout_p)(crop_2) conc_2 = Concatenate(axis=4)([drop_2a, drop_2b]) flat = Flatten()(conc_2) fc_1 = Dense(150)(flat) fc_1 = Activation('relu')(fc_1) drop_3 = Dropout(dense_dropout_p)(fc_1) fc_2 = Dense(num_classes)(drop_3) predictions = Activation('softmax')(fc_2) model = Model(inputs=inputs, outputs=predictions) return model, name, input_shape
def model_col(input_shape, learning_rate): input_layer_remote = Input(shape=input_shape, name='remote_input') x = TimeDistributed(Conv2D(8, kernel_size=(7, 7), activation='relu', padding='same'), name='remote_1')(input_layer_remote) x = TimeDistributed(Conv2D(16, kernel_size=(7, 7), activation='relu', padding='same'), name='remote_2')(x) x = TimeDistributed(Conv2D(1, kernel_size=(7, 7), activation='sigmoid', padding='same'), name='remote_3')(x) # x = keras.layers.Activation(activation = 'tanh', name = 'enforce_range')(x) # x = keras.layers.Activation(activation = 'relu', name = 'positive_filters')(x) out_remote = keras.layers.Lambda( filter_input, arguments={'input_layer_remote': input_layer_remote}, name='filter_input_remote')(x) input_layer_local = Input(shape=input_shape, name='input_layer_local') new_input = keras.layers.Add(name='concat_inputs')( [input_layer_local, out_remote]) new_input = keras.layers.Lambda(range_inputs, name='normalize_inputs')(new_input) mask = keras.layers.Reshape((10, 64, 64, 1))(new_input[:, 10:, :, :, 1]) x2 = TimeDistributed(Conv2D(8, kernel_size=(7, 7), activation=leaky_relu, padding='same'), trainable=False, name='local_1')(new_input) x2 = ConvLSTM2D(16, kernel_size=(5, 5), padding='same', activation=leaky_relu, return_sequences=True, trainable=False, name='local_2')(x2) x2 = Cropping3D(((10, 0), (0, 0), (0, 0)))(x2) x2 = TimeDistributed(Conv2D(1, (7, 7), padding='same'), trainable=False, name='local_3')(x2) out = keras.layers.Activation(activation='sigmoid')(x2) model = Model(inputs=[input_layer_local, input_layer_remote], outputs=[out]) model.compile(loss=loss_fun_flat_collab(mask), optimizer=keras.optimizers.Adam(lr=learning_rate), metrics=['mse']) return model
def build_model(input_shape, layers): print("Build model ...") model = Sequential() # design model : CONV Layers for c in layers: if c[0] == 'crop3D': model.add( Cropping3D(cropping=((0, 0), (c[1], 0), (0, 0)), input_shape=input_shape)) if c[0] == 'crop2D': model.add( Cropping2D(cropping=((c[1], 0), (0, 0)), input_shape=input_shape)) if c[0] == 'norm': model.add(Lambda(lambda x: x / 255.0 - 0.5)) if c[0] == 'conv2D': model.add( Conv2D(filters=c[1], kernel_size=c[2], strides=c[3], padding='valid')) model.add(BatchNormalization()) model.add(Activation(c[4])) if c[0] == 'conv3D': model.add( Conv3D(filters=c[1], kernel_size=c[2], strides=c[3], padding='valid')) model.add(BatchNormalization()) model.add(Activation(c[4])) if c[0] == 'maxpooling2D': model.add(MaxPooling2D(pool_size=c[1], strides=c[2])) if c[0] == 'avgpooling2D': model.add(AveragePooling2D(pool_size=c[1], strides=c[2])) if c[0] == 'maxpooling3D': model.add(MaxPooling3D(pool_size=c[1], strides=c[2])) if c[0] == 'avgpooling3D': model.add(AveragePooling3D(pool_size=c[1], strides=c[2])) if c[0] == 'dropout': model.add(Dropout(c[1])) if c[0] == 'batchnorm': model.add(BatchNormalization()) if c[0] == 'flatten': model.add(Flatten()) if c[0] == 'fc': model.add(Dense(c[1], activity_regularizer=l2(c[3]))) model.add(BatchNormalization()) model.add(Activation(c[2])) if c[0] == 'fc_wo_bn': model.add(Dense(c[1], activity_regularizer=l2(c[3]))) model.add(Activation(c[2])) print("Done.") # summarize model. model.summary() # out return model
def dolz_1(size_x, size_y, size_z, num_classes): init_input = Input((size_x, size_y, size_z, 1)) x = Conv3D(25, kernel_size=(3, 3, 3))(init_input) x = PReLU()(x) x = Conv3D(25, kernel_size=(3, 3, 3))(x) x = PReLU()(x) x = Conv3D(25, kernel_size=(3, 3, 3))(x) x = PReLU()(x) y = Conv3D(50, kernel_size=(3, 3, 3))(x) y = PReLU()(y) y = Conv3D(50, kernel_size=(3, 3, 3))(y) y = PReLU()(y) y = Conv3D(50, kernel_size=(3, 3, 3))(y) y = PReLU()(y) z = Conv3D(75, kernel_size=(3, 3, 3))(y) z = PReLU()(z) z = Conv3D(75, kernel_size=(3, 3, 3))(z) z = PReLU()(z) x_crop = Cropping3D(cropping=((5, 5), (5, 5), (5, 5)))(x) y_crop = Cropping3D(cropping=((2, 2), (2, 2), (2, 2)))(y) concat = concatenate([x_crop, y_crop, z], axis=4) fc = Conv3D(400, kernel_size=(1, 1, 1))(concat) fc = PReLU()(fc) fc = Conv3D(200, kernel_size=(1, 1, 1))(fc) fc = PReLU()(fc) fc = Conv3D(150, kernel_size=(1, 1, 1))(fc) fc = PReLU()(fc) pred = Conv3D(num_classes, kernel_size=(1, 1, 1))(fc) pred = PReLU()(pred) pred = Reshape( (num_classes, (size_x - 16) * (size_z - 16) * (size_y - 16)))(pred) pred = Permute((2, 1))(pred) pred = Activation('softmax')(pred) model = Model(inputs=init_input, outputs=pred) return model
def build_transformation(self): img_S = Input(shape=self.img_shape, name='input_img_S_transform') # 256 phi = Input(shape=self.output_shape_g, name='input_phi_transform') # 128 img_S_cropped = Cropping3D(cropping=64)(img_S) # 128 warped_S = Lambda(dense_image_warp_3D, output_shape=(128, 128, 128, 1))([img_S_cropped, phi]) return Model([img_S, phi], warped_S, name='transformation_layer')
def HyperDenseNet(kernelshapes, numkernelsperlayer, input_shape, activation_name="sigmoid", dropout_rate=0.3, n_labels=2, optimizer=Adam, initial_learning_rate=5e-4, loss_function="categorical_crossentropy"): n_conv_layer = 0 for kernel in kernelshapes: if len(kernel) == 3: n_conv_layer += 1 layers = [] inputs = Input(input_shape) current_layer = inputs layers.append(current_layer) for i in range(n_conv_layer): current_layer = Conv3D(numkernelsperlayer[i], kernelshapes[i], strides=(1, 1, 1), padding='valid', activation=activation_name, data_format='channels_first')(current_layer) layers.append(current_layer) cropped_layers = [] n_layers = len(layers) for count, layer in enumerate(layers): cropped_layer = Cropping3D(cropping=(n_layers - 1 - count), data_format="channels_first")(layer) cropped_layers.append(cropped_layer) current_layer = Concatenate(axis=1)(cropped_layers) for i in range(n_conv_layer, len(kernelshapes)): current_layer = Conv3D(numkernelsperlayer[i], [1, 1, 1], strides=(1, 1, 1), padding='valid', activation=activation_name, data_format='channels_first')(current_layer) current_layer = SpatialDropout3D( rate=dropout_rate, data_format='channels_first')(current_layer) current_layer = Conv3D(n_labels, [1, 1, 1], strides=(1, 1, 1), padding="valid", activation=None, data_format='channels_first')(current_layer) current_layer = Softmax(axis=1)(current_layer) model = Model(inputs=inputs, outputs=current_layer) model.compile(optimizer=optimizer(lr=initial_learning_rate), loss=loss_function) return model
def concat(self, x1, x2): dx = (x1._keras_shape[_row_axis] - x2._keras_shape[_row_axis]) / 2 dy = (x1._keras_shape[_col_axis] - x2._keras_shape[_col_axis]) / 2 dz = (x1._keras_shape[_depth_axis] - x2._keras_shape[_depth_axis]) / 2 crop_size = ((floor(dx), ceil(dx)), (floor(dy), ceil(dy)), (floor(dz), ceil(dz))) x12 = Concatenate(axis=_channel_axis)([Cropping3D(crop_size)(x1), x2]) return x12
def build_transformation(self): img_S = Input(shape=self.input_shape_g, name='input_img_S_transform') # 64x64x64 phi = Input(shape=self.output_shape_g, name='input_phi_transform') # 24x24x24 img_S_cropped = Cropping3D(cropping=20)(img_S) # 24x24x24 warped_S = Lambda(dense_image_warp_3D, output_shape=(24, 24, 24, 1))([img_S_cropped, phi]) return Model([img_S, phi], warped_S, name='transformation_layer')
def get_autoencoder_model(): from keras.layers import Convolution3D, MaxPooling3D, UpSampling3D, GaussianNoise, Cropping3D, Input from keras.regularizers import l2 from keras.models import Model img_channels = 1 noise_factor = 0.02 # ---------------------------------------- START MODEL ------------------------------------------------------------ input_img = Input(shape=(img_channels, ) + image_dimension) x = GaussianNoise(noise_factor)(input_img) x = Convolution3D(64, (7, 7, 7), padding='same', activation='relu')(x) x = MaxPooling3D(strides=(2, 2, 2), padding='same')(x) x = Convolution3D(32, (5, 5, 5), padding='same', activation='relu', kernel_regularizer=l2(0.0001))(x) x = MaxPooling3D(strides=(2, 2, 2), padding='same')(x) x = Convolution3D(32, (5, 5, 5), padding='same', activation='relu', kernel_regularizer=l2(0.0001))(x) encoded = MaxPooling3D(strides=(2, 2, 2), padding='same')(x) # Bottleneck x = Convolution3D(32, (5, 5, 5), padding='same', activation='relu', kernel_regularizer=l2(0.0001))(encoded) x = UpSampling3D(size=(2, 2, 2))(x) x = Convolution3D(32, (5, 5, 5), padding='same', activation='relu', kernel_regularizer=l2(0.0001))(x) x = UpSampling3D(size=(2, 2, 2))(x) x = Convolution3D(64, (5, 5, 5), padding='same', activation='relu', kernel_regularizer=l2(0.0001))(x) x = UpSampling3D(size=(2, 2, 2))(x) decoded = Convolution3D(1, (7, 7, 7), padding='same')(x) decoded_cropped = Cropping3D(((1, 1), (3, 3), (3, 3)))(decoded) encoder = Model(input_img, encoded) autoencoder = Model(input_img, decoded_cropped) # ------------------------------------------- END MODEL ------------------------------------------------------------ return encoder, autoencoder
def cae_decoder(): # 3D Convolutional Auto-Decoder inputs = Input(shape=(cae_output_count, 1)) x = Reshape(cae_output_shape)(inputs) x = Conv3DTranspose(cae_filter_count * 2, conv_size, padding='same', activation=activation_function)(x) x = UpSampling3D(pool_size)(x) x = Conv3DTranspose(cae_filter_count * 16, conv_size, padding='same', activation=activation_function)(x) x = UpSampling3D(pool_size)(x) x = Conv3DTranspose(cae_filter_count * 8, conv_size, padding='same', activation=activation_function)(x) x = UpSampling3D(pool_size)(x) x = Conv3DTranspose(cae_filter_count * 4, conv_size, padding='same', activation=activation_function)(x) x = Cropping3D()(x) x = UpSampling3D(pool_size)(x) x = Conv3DTranspose(cae_filter_count * 2, conv_size, padding='same', activation=activation_function)(x) x = UpSampling3D(pool_size)(x) x = Conv3DTranspose(cae_filter_count, conv_size, padding='same', activation=activation_function)(x) decoder = Conv3DTranspose(1, conv_size, padding='same', activation='sigmoid', name='decoded')(x) model = Model(inputs=inputs, outputs=decoder) model.summary() return model
def unet_like2(in_sz=24): ''' construct a u-net style network ''' in_sz = fplutils.to3d(in_sz) in_sz = in_sz + (1, ) inputs = Input(shape=in_sz) # 24x24x24 # down-sample conv1 = Conv3D(32, (3, 3, 3), use_bias=False)(inputs) # 22x22x22 conv1 = _bn_relu(conv1) conv1 = Conv3D(32, (3, 3, 3), use_bias=False)(conv1) # 20x20x20 conv1 = _bn_relu(conv1) pool1 = MaxPooling3D(pool_size=(2, 2, 2))(conv1) # 10x10x10 conv2 = Conv3D(64, (3, 3, 3), use_bias=False)(pool1) # 8x8x8 conv2 = _bn_relu(conv2) conv2 = Conv3D(64, (3, 3, 3), use_bias=False)(conv2) # 6x6x6 conv2 = _bn_relu(conv2) pool2 = MaxPooling3D(pool_size=(2, 2, 2))(conv2) # 3x3x3 conv3 = Conv3D(128, (1, 1, 1), use_bias=False)(pool2) # 3x3x3 conv3 = _bn_relu(conv3) # up-sample up4 = concatenate([UpSampling3D(size=(2, 2, 2))(conv3), conv2]) # 6x6x6 conv4 = Conv3D(64, (3, 3, 3), use_bias=False)(up4) # 4x4x4 conv4 = _bn_relu(conv4) conv4 = Conv3D(64, (1, 1, 1), use_bias=False)(conv4) # 4x4x4 conv4 = _bn_relu(conv4) crop_conv1 = Cropping3D(cropping=((6, 6), (6, 6), (6, 6)))(conv1) up5 = concatenate([UpSampling3D(size=(2, 2, 2))(conv4), crop_conv1]) # 8x8x8 conv5 = Conv3D(32, (3, 3, 3), use_bias=False)(up5) # 6x6x6 conv5 = _bn_relu(conv5) conv5 = Conv3D(32, (1, 1, 1), use_bias=False)(conv5) # 6x6x6 conv5 = _bn_relu(conv5) predictions = Conv3D(1, (1, 1, 1), activation='sigmoid', use_bias=False)(conv5) # 6x6x6 model = Model(inputs=inputs, outputs=predictions) compile_args = { 'loss': masked_binary_crossentropy, 'optimizer': 'adam', 'metrics': [masked_accuracy, lb0l1err, lb1l1err] } return model, (24, 10, 1), 100, compile_args
def convolutional_blocks(s, f_list, k_size_list, d=None, conv_list=None): for l, (filters, kernel_size) in enumerate(zip(f_list, k_size_list)): conv = Conv3D(filters, kernel_size=kernel_size, activation='relu', data_format='channels_first') s = BatchNormalization(axis=1)(conv(s)) if d is not None: d = BatchNormalization(axis=1)(conv(d)) d_crop = Cropping3D(cropping=len(filters_list) - l - 1, data_format='channels_first')(d) if conv_list is not None: conv_list.append(d_crop) return s
def Combine(gen, disc, input_shape, sequence_crop, new_sequence): input = Input(shape=input_shape) generated_image = gen(input) cropped = Cropping3D(cropping=(sequence_crop, 0, 0))(input) reshaped = Reshape(new_sequence)(generated_image) DCGAN_output = disc([cropped, reshaped]) DCGAN = Model(inputs=[input], outputs=[generated_image, DCGAN_output], name="Combined") return DCGAN