def getnet1(inshape): print("Building model 1...") print("Input shape is", inshape) # inshape is (160, 448, 500) = 35 840 000 model = Sequential() model.add( Convolution3D(1, 5, 9, 21, input_shape=inshape, activation="relu")) model.add(MaxPooling3D()) # shape is (78, 220, 240) = 4 118 400 model.add(Convolution3D(1, 7, 11, 21, activation="relu")) model.add(MaxPooling3D()) # shape is (36, 105, 110) = 415 800 model.add(Convolution3D(1, 7, 6, 11, activation="relu")) model.add(MaxPooling3D()) # shape is (15, 50, 50) = 37 500 model.add(Convolution3D(1, 6, 9, 9, activation="relu")) model.add(MaxPooling3D()) # shape is (5, 21, 21) = 2 205 model.add(Flatten()) model.add(Dense(120, activation="sigmoid")) model.add(Dense(1, activation="sigmoid")) print("Compiling model...") model.compile(RMSprop(lr=0.01), "mse") return model
def __init__(self, IMG_FRAMES, IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS, IMG_CLASSES): #build the keras model of unet #source: U-Net: Convolutional Networks for Biomedical Image Segmentation, by Ronneberger et al #make a tensor for the inputs self.inputs = Input((IMG_FRAMES, IMG_HEIGHT,IMG_WIDTH,IMG_CHANNELS)) #keras defines layers of a model, such as lambda, conv2d, etc.. s = Lambda(lambda x: x/255)(self.inputs) #128x128x1 #conv2d(filters, kernel_size,options) c1 = Conv3D(32,(3,3,3),activation='relu',kernel_initializer='Orthogonal',padding='same')(s) #9 weights * 1 channel * 32 features + 1 bias * 32 features = 320 p1 = MaxPooling3D((2,2,2))(c1) c2 = Conv3D(64,(3,3,3),activation='relu', kernel_initializer='Orthogonal', padding='same') (p1)#9 * 32 * 64 + 1 * 64 = 18496 parameters p2 = MaxPooling3D((2, 2, 2)) (c2) c3 = Conv3D(128, (3,3, 3), activation='relu', kernel_initializer='Orthogonal', padding='same') (p2) p3 = MaxPooling3D((2,2, 2)) (c3) r = Reshape((32,32,128))(p3) fc = Conv2D(512, (3, 3), kernel_initializer='Orthogonal', padding='same') (r)#16x16x512 u4 = UpSampling2D(size=(2,2))(fc) c4 = Conv2DTranspose(128, (3, 3), activation='relu', kernel_initializer='Orthogonal', padding='same') (u4) u5 = UpSampling2D(size=(2,2))(c4) c5 = Conv2DTranspose(64, (3, 3), activation='relu', kernel_initializer='Orthogonal', padding='same') (u5) u6 = UpSampling2D(size=(2,2))(c5) c6 = Conv2DTranspose(32, (3, 3), activation='relu', kernel_initializer='Orthogonal', padding='same') (u6) self.outputs = Conv2D(IMG_CLASSES, (3, 3), activation='relu', kernel_initializer='Orthogonal', padding='same') (c6)
def net3(V_1, V_2, V_3): inputs = Input((V_1, V_2, V_3, 1)) p1 = MaxPooling3D((2, 2, 1))(inputs) c1 = Conv3D(64, (2, 2, 1), strides=(2, 2, 1), activation='relu', padding='same')(p1) c1 = MaxPooling3D((2, 2, 1))(c1) c2 = Conv3D(512, (2, 2, 1), strides=(1, 1, 1), activation='relu', padding='same')(c1) c2 = Conv3D(512, (2, 2, 1), strides=(2, 2, 1), activation='relu', padding='same')(c2) c3 = MaxPooling3D((2, 2, 3))(c2) c4 = Dense(128, activation='linear')(c3) c5 = Dense(56, activation='linear')(c4) outputs = c5 return Model(inputs=[inputs], outputs=[outputs])
def build_model(dropout_rate=0.2): input_image = Input(shape=IMAGE_SHAPE, dtype='float32', name=INPUT_IMAGE) x = MaxPooling2D()(input_image) x = MaxPooling2D()(x) x = MaxPooling2D()(x) x = MaxPooling2D()(x) x = Dropout(dropout_rate)(x) x = Conv2D(32, kernel_size=3, strides=(2, 2))(x) x = MaxPooling2D()(x) x = Conv2D(32, kernel_size=3, strides=(2, 2))(x) x = MaxPooling2D()(x) x = Dropout(dropout_rate)(x) image_out = Flatten()(x) # image_out = Dense(32, activation='relu')(conv) input_lidar_panorama = Input(shape=PANORAMA_SHAPE, dtype='float32', name=INPUT_LIDAR_PANORAMA) x = pool_and_conv(input_lidar_panorama) x = pool_and_conv(x) x = Dropout(dropout_rate)(x) panorama_out = Flatten()(x) input_lidar_slices = Input(shape=SLICES_SHAPE, dtype='float32', name=INPUT_LIDAR_SLICES) x = MaxPooling3D(pool_size=(2, 2, 1))(input_lidar_slices) x = Conv3D(32, kernel_size=3, strides=(2, 2, 1))(x) x = MaxPooling3D(pool_size=(2, 2, 1))(x) x = Dropout(dropout_rate)(x) x = Conv3D(32, kernel_size=2, strides=(2, 2, 1))(x) x = MaxPooling3D(pool_size=(2, 2, 1))(x) x = Dropout(dropout_rate)(x) slices_out = Flatten()(x) x = keras.layers.concatenate([image_out, panorama_out, slices_out]) x = Dense(32, activation='relu')(x) x = Dense(32, activation='relu')(x) x = Dense(32, activation='relu')(x) pose_output = Dense(9, name=OUTPUT_POSE)(x) model = Model( inputs=[input_image, input_lidar_panorama, input_lidar_slices], outputs=[pose_output]) # Fix error with TF and Keras import tensorflow as tf tf.python.control_flow_ops = tf model.compile(loss='mean_squared_error', optimizer='adam') return model
def Unet_3d(input_img, n_filters=8, dropout=0.2, batch_norm=True): c1 = conv_block(input_img, n_filters, 3, batch_norm) p1 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c1) p1 = Dropout(dropout)(p1) c2 = conv_block(p1, n_filters * 2, 3, batch_norm) p2 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c2) p2 = Dropout(dropout)(p2) c3 = conv_block(p2, n_filters * 4, 3, batch_norm) p3 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c3) p3 = Dropout(dropout)(p3) c4 = conv_block(p3, n_filters * 8, 3, batch_norm) p4 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c4) p4 = Dropout(dropout)(p4) c5 = conv_block(p4, n_filters * 16, 3, batch_norm) u6 = Conv3DTranspose(n_filters * 8, (3, 3, 3), strides=(2, 2, 2), padding='same')(c5) u6 = concatenate([u6, c4]) c6 = conv_block(u6, n_filters * 8, 3, batch_norm) c6 = Dropout(dropout)(c6) u7 = Conv3DTranspose(n_filters * 4, (3, 3, 3), strides=(2, 2, 2), padding='same')(c6) u7 = concatenate([u7, c3]) c7 = conv_block(u7, n_filters * 4, 3, batch_norm) c7 = Dropout(dropout)(c7) u8 = Conv3DTranspose(n_filters * 2, (3, 3, 3), strides=(2, 2, 2), padding='same')(c7) u8 = concatenate([u8, c2]) c8 = conv_block(u8, n_filters * 2, 3, batch_norm) c8 = Dropout(dropout)(c8) u9 = Conv3DTranspose(n_filters, (3, 3, 3), strides=(2, 2, 2), padding='same')(c8) u9 = concatenate([u9, c1]) c9 = conv_block(u9, n_filters, 3, batch_norm) outputs = Conv3D(4, (1, 1, 1), activation='softmax')(c9) print("!!!!!!!!!!!!!!!!!!!") print(outputs.shape) model = Model(inputs=input_img, outputs=outputs) return model
def convLSTM_Model_3(): model = Sequential() model.add( ConvLSTM2D(filters=32, strides=(1, 1), kernel_size=(7, 7), recurrent_activation='hard_sigmoid', input_shape=(None, None, None, 1), padding='same', return_sequences=True)) model.add(BatchNormalization()) model.add( ConvLSTM2D(filters=16, strides=(1, 1), kernel_size=(7, 7), recurrent_activation='hard_sigmoid', input_shape=(None, None, None, 1), padding='same', return_sequences=True)) model.add(BatchNormalization()) model.add( ConvLSTM2D(filters=16, strides=(1, 1), kernel_size=(7, 7), recurrent_activation='hard_sigmoid', input_shape=(None, None, None, 1), padding='same', return_sequences=True)) model.add(BatchNormalization()) model.add( ConvLSTM2D(filters=16, strides=(1, 1), kernel_size=(7, 7), recurrent_activation='hard_sigmoid', input_shape=(None, None, None, 1), padding='same', return_sequences=True)) model.add(BatchNormalization()) #model.add(Conv3D(filters=1, kernel_size=(3, 3, 3), activation='sigmoid', padding='same', data_format='channels_last')) model.add( Conv3D(filters=1, kernel_size=(1, 1, 1), activation='sigmoid', padding='same')) model.add(BatchNormalization()) model.add(MaxPooling3D(pool_size=(2, 1, 1), padding='same')) model.add(BatchNormalization()) model.add(MaxPooling3D(pool_size=(5, 1, 1), padding='same')) #model.add(Reshape((None, None, 1), input_shape=(None,None,None,1))) print(model.summary()) return model
def inputArch_4conv_batch(): modelX = Sequential() modelX.add(BatchNormalization(input_shape=(10, 10, 10, 1))) modelX.add( Convolution3D(32, 3, 3, 3, border_mode='valid', init='he_normal', W_regularizer=l2(.05))) modelX.add(BatchNormalization()) modelX.add( Convolution3D(32, 3, 3, 3, border_mode='same', init='he_normal', W_regularizer=l2(.05))) modelX.add(MaxPooling3D()) modelX.add(BatchNormalization()) modelX.add( Convolution3D(64, 3, 3, 3, border_mode='same', init='he_normal', W_regularizer=l2(.05))) modelX.add(BatchNormalization()) modelX.add( Convolution3D(64, 3, 3, 3, border_mode='same', init='he_normal', W_regularizer=l2(.05))) modelX.add(MaxPooling3D()) modelX.add(Activation('relu')) modelX.add(Flatten()) modelX.add(BatchNormalization()) modelX.add(Dropout(0.2)) modelX.add( Dense(512, init='glorot_normal', activation='relu', W_regularizer=l2(.05))) return modelX
def inputArch_2conv_batch(defineModel_args): modelX=Sequential() modelX.add(BatchNormalization(input_shape=(10,10,10,1))) modelX.add(Convolution3D(gridkernelsLayer1,3,3,3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) modelX.add(MaxPooling3D((2,2,2))) modelX.add(Convolution3D(gridkernelsLayer1*2,3,3,3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) modelX.add(MaxPooling3D((2,2,2))) modelX.add(Flatten()) modelX.add(Dense(gridneuronsLayer1*2, activation='relu')) modelX.add(BatchNormalization()) return modelX
def my_small_model(): model = Sequential() model.add( Convolution3D(32, kernel_dim1=5, kernel_dim2=5, kernel_dim3=5, border_mode='same', activation='relu', dim_ordering='tf', input_shape=(1, 32, 32, 32))) model.add(Dropout(0.2)) model.add( Convolution3D(32, kernel_dim1=3, kernel_dim2=3, kernel_dim3=3, border_mode='same', activation='relu', dim_ordering='tf')) model.add( MaxPooling3D(pool_size=(3, 3, 3), border_mode='same', dim_ordering='tf')) #(strides=None) model.add(Flatten()) model.add(Dropout(0.3)) model.add(Dense(16, init='normal', activation='relu')) model.add(Dropout(0.4)) model.add(Dense(10, init='normal')) model.add(Activation('softmax')) return model
def conv_block(x_input, num_filters, pool=True, activation='relu', init='orthogonal'): x1 = Convolution3D(num_filters, 3, 3, 3, border_mode='same', W_regularizer=l2(1e-5), init=init)(x_input) x1 = BatchNormalization(axis=1, momentum=0.99)(x1) # x1 = Activation('relu')(x1) x1 = PReLU(shared_axes=[2, 3, 4], trainable=True)(x1) #x1 = LeakyReLU(.01)(x1) #x1 = Convolution3D(num_filters / 2,3,3,3, border_mode='same',W_regularizer=l2(1e-4))(x1) #x1 = BatchNormalization(axis=1)(x1) #x1 = LeakyReLU(.1)(x1) if pool: x1 = MaxPooling3D()(x1) x_out = x1 return x_out
def inputArch_3conv_batch_drop(defineModel_args): modelX=Sequential() modelX.add(BatchNormalization(input_shape=(10,10,10,1))) modelX.add(Convolution3D(gridkernelsLayer1,3,3,3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) #modelX.add(MaxPooling3D()) modelX.add(Convolution3D(gridkernelsLayer1*2,3,3,3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) #modelX.add(MaxPooling3D()) modelX.add(Convolution3D(gridkernelsLayer1*2,3,3,3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) modelX.add(MaxPooling3D()) modelX.add(Flatten()) modelX.add(Dense(gridneuronsLayer1*2)) modelX.add(BatchNormalization()) modelX.add(Activation(gridFullyActivations)) modelX.add(Dropout(gridDropout1)) modelX.add(Dense(gridneuronsLayer1*2)) modelX.add(BatchNormalization()) modelX.add(Activation(gridFullyActivations)) modelX.add(Dropout(gridDropout1)) return modelX
def conv_block(x_input, num_filters, pool=True, activation='relu', init='orthogonal'): x1 = Convolution3D(num_filters, 3, 3, 3, border_mode='same', W_regularizer=l2(1e-4), init=init)(x_input) x1 = BatchNormalization(axis=1, momentum=0.995)(x1) if activation == 'crelu': x1 = Lambda(leakyCReLU, output_shape=leakyCReLUShape)(x1) else: x1 = LeakyReLU(.01)(x1) # x1 = Convolution3D(num_filters,3,3,3, border_mode='same',W_regularizer=l2(1e-4))(x1) # x1 = BatchNormalization(axis=1)(x1) # x1 = LeakyReLU(.1)(x1) if pool: x1 = MaxPooling3D()(x1) x_out = x1 return x_out
def conv_block(x_input, num_filters, pool=True, activation='relu', init='orthogonal'): x1 = Convolution3D(num_filters, 3, 3, 3, border_mode='same', W_regularizer=l2(1e-5), init=init)(x_input) x1 = BatchNormalization(axis=1, momentum=0.99)(x1) x1 = LeakyReLU(.1)(x1) #experimental activation kinda like a double sided leaky relu # x1 = Activation('srelu_fixed')(x1) # x1 = Convolution3D(num_filters,3,3,3, border_mode='same',W_regularizer=l2(1e-4))(x1) # x1 = BatchNormalization(axis=1)(x1) # x1 = LeakyReLU(.1)(x1) if pool: x1 = MaxPooling3D()(x1) x_out = x1 return x_out
def inputArch_3conv_batch_drop(defineModel_args, size): modelX = Sequential() modelX.add(BatchNormalization(input_shape=(size, size, size, 1))) modelX.add(Convolution3D(gridkernelsLayer1, 3, 3, 3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) #modelX.add(MaxPooling3D()) modelX.add(Convolution3D(gridkernelsLayer1, 3, 3, 3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) #modelX.add(MaxPooling3D()) modelX.add(Convolution3D(gridkernelsLayer1, 3, 3, 3, init=gridConvInit)) modelX.add(BatchNormalization()) modelX.add(Activation(gridConvActivations)) modelX.add(MaxPooling3D()) modelX.add(Flatten()) modelX.add( Dense(gridneuronsLayer1, init=gridNeuronsInit, activation=gridFullyActivations, W_regularizer=l2(gridFullyL2penal1))) #modelX.add(Dense(gridneuronsLayer1*2)) #modelX.add(BatchNormalization()) #modelX.add(Activation(gridFullyActivations)) #modelX.add(Dropout(gridDropout1)) #modelX.add(Dense(gridneuronsLayer1*2)) #modelX.add(BatchNormalization()) #modelX.add(Activation(gridFullyActivations)) #modelX.add(Dropout(gridDropout1)) return modelX
def SqueezeModel2(input_tensor): droprate = 0.2 x = Conv3D(filters=96, kernel_size=(1, 1, 1), strides = (1, 1, 1), padding='same', activation='relu', kernel_initializer=glorot_uniform(seed=1), bias_initializer='zeros', name="conv1")(input_tensor) x = Conv3D(filters=16, kernel_size=(1, 1, 1), kernel_initializer=glorot_uniform(seed=1), activation='relu', name="fire2_squeeze")(x) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(64, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire2_expand1")(x) expand2 = Conv3D(64, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire2_expand2")(x) merge1 = concatenate([expand1, expand2], axis=4, name="merge_1") x = Conv3D(16, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire3_squeeze")(merge1) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(64, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire3_expand1")(x) expand2 = Conv3D(64, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire3_expand2")(x) merge2 = concatenate([expand1, expand2], axis=4, name="merge_2") x = Conv3D(32, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire4_squeeze")(merge2) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(128, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire4_expand1")(x) expand2 = Conv3D(128, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire4_expand2")(x) merge3 = concatenate([expand1, expand2], axis=4, name="merge_3") maxpool4 = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name="maxpool_4")(merge3) x = Conv3D(filters=32, kernel_size=(1, 1, 1), activation='relu', name="fire5_squeeze")(maxpool4) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(128, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire5_expand1")(x) expand2 = Conv3D(128, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire5_expand2")(x) merge4 = concatenate([expand1, expand2], axis=4, name="merge_4") x = Conv3D(48, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire6_squeeze")(merge4) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(192, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire6_expand1")(x) expand2 = Conv3D(192, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire6_expand2")(x) merge5 = concatenate([expand1, expand2], axis=4, name="merge_5") x = Conv3D(48, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire7_squeeze")(merge5) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(192, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire7_expand1")(x) expand2 = Conv3D(192, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire7_expand2")(x) merge6 = concatenate([expand1, expand2], axis=4, name="merge_6") x = Conv3D(64, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire8_squeeze")(merge6) x = BatchNormalization()(x) x = Dropout(droprate) expand1 = Conv3D(256, (1, 1, 1), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire8_expand1")(x) expand2 = Conv3D(256, (3, 3, 3), kernel_initializer=glorot_uniform(seed=1), padding='same', activation='relu', name="fire8_expand2")(x) merge7 = concatenate([expand1, expand2], axis=4, name="merge_7") avgpool = AveragePooling3D(pool_size=(3, 3, 3), padding='same', name="avg8")(merge7) flatten = Flatten(name="flatten")(avgpool) output = Dense(1, activation='linear', kernel_initializer=glorot_uniform(seed=1))(flatten) return output
def __init__(self, frame_count, image_channels=3, image_height=50, image_width=100, max_string=32, output_size=28): input_shape = self.get_input_shape(frame_count, image_channels, image_height, image_width) self.input_layer = Input(shape=input_shape, dtype='float32', name='input') self.zero_1 = ZeroPadding3D(padding=(1, 2, 2), name='zero_1')(self.input_layer) self.conv_1 = Conv3D(32, (3, 5, 5), strides=(1, 2, 2), kernel_initializer='he_normal', name='conv_1')(self.zero_1) self.batc_1 = BatchNormalization(name='batc_1')(self.conv_1) self.actv_1 = Activation('relu', name='actv_1')(self.batc_1) self.pool_1 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='pool_1')(self.actv_1) self.drop_1 = SpatialDropout3D(0.5, name='drop_1')(self.pool_1) self.zero_2 = ZeroPadding3D(padding=(1, 2, 2), name='zero_2')(self.drop_1) self.conv_2 = Conv3D(64, (3, 5, 5), strides=(1, 2, 2), kernel_initializer='he_normal', name='conv_2')(self.zero_2) self.batc_2 = BatchNormalization(name='batc_2')(self.conv_2) self.actv_2 = Activation('relu', name='actv_2')(self.batc_2) self.pool_2 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='pool_2')(self.actv_2) self.drop_2 = SpatialDropout3D(0.5, name='drop_2')(self.pool_2) self.zero_3 = ZeroPadding3D(padding=(1, 1, 1), name='zero_3')(self.drop_2) self.conv_3 = Conv3D(96, (3, 3, 3), strides=(1, 2, 2), kernel_initializer='he_normal', name='conv_3')(self.zero_3) self.batc_3 = BatchNormalization(name='batc_3')(self.conv_3) self.actv_3 = Activation('relu', name='actv_3')(self.batc_3) self.pool_3 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), name='pool_3')(self.actv_3) self.drop_3 = SpatialDropout3D(0.5, name='drop_3')(self.pool_3) self.res = TimeDistributed(Flatten())(self.drop_3) self.gru_1 = Bidirectional(GRU(256, return_sequences=True, activation=None, kernel_initializer='Orthogonal', name='gru_1'), merge_mode='concat')(self.res) self.gru_1_actv = Activation('relu', name='gru_1_actv')(self.gru_1) self.gru_2 = Bidirectional(GRU(256, return_sequences=True, activation=None, kernel_initializer='Orthogonal', name='gru_2'), merge_mode='concat')(self.gru_1_actv) self.gru_2_actv = Activation('relu', name='gru_2_actv')(self.gru_2) self.dense_1 = Dense(output_size, kernel_initializer='he_normal', name='dense_1')(self.gru_2_actv) self.y_pred = Activation('softmax', name='softmax')(self.dense_1) self.input_labels = Input(shape=[max_string], dtype='float32', name='labels') self.input_length = Input(shape=[1], dtype='int64', name='input_length') self.label_length = Input(shape=[1], dtype='int64', name='label_length') self.loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([self.y_pred, self.input_labels, self.input_length, self.label_length]) self.model = Model(inputs=[self.input_layer, self.input_labels, self.input_length, self.label_length], outputs=self.loss_out)
def create_model( self, rho=0.9, decay=0.0, ): inputs = Input(shape=(self.max_length, self.max_length, self.word_embedding_size, 1)) masked_inputs = MaskConv(0.0)(inputs) masked_seqs = MaskToSeq(MaskConv(0.0), 1)(inputs) conv = MaskConvNet( Conv3D( self.channel_size, (2, 2, self.conv_size), strides=(1, 1, self.conv_size), activation='tanh', padding='same', use_bias=False, ))(masked_inputs) pooling = MaskPooling(MaxPooling3D( (self.max_length, self.max_length, 1), padding='same'), pool_mode='max')(conv) encoded = ConvEncoder()([pooling, masked_seqs]) decoded = RNNDecoder( RNNCell(LSTM( self.latent_size, return_sequences=True, implementation=2, unroll=False, dropout=0., recurrent_dropout=0., ), Dense(units=self.encoding_size, activation='tanh'), dense_dropout=0.))(encoded) outputs = TimeDistributed( Dense(self.word_embedding_size, activation='tanh'))(decoded) model = Model(inputs, outputs) picked = Pick()(encoded) encoder = Model(inputs, picked) optimizer = RMSprop( lr=self.learning_rate, rho=rho, decay=decay, ) model.compile(loss='cosine_proximity', optimizer=optimizer) return model, encoder
def get_net(nb_batch, patch_z, patch_height, patch_width,n_ch): inputs = Input((patch_z, patch_height, patch_width, n_ch)) # conv1 = Conv3D(8, (3, 3, 3), activation='relu', padding='valid')(inputs) conv1 = DCNN3D(nb_batch, 1, (3, 3, 3), scope='deformconv1',norm=False)(inputs) # conv2 = Conv3D(32, (3, 3, 3), activation='relu', padding='valid')(conv1) conv2 = DCNN3D(nb_batch, 32, (3, 3, 3), scope='deformconv2')(conv1) conv2 = BatchNormalization(axis=-1)(conv2) pool2 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv2) conv2 = Conv3D(32, (3, 3, 3), activation='relu', padding='valid')(pool2) conv2 = BatchNormalization(axis=-1)(conv2) pool2 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv2) conv2 = Conv3D(32, (3, 3, 3), activation='relu', padding='valid')(pool2) conv2 = BatchNormalization(axis=-1)(conv2) pool2 = MaxPooling3D(pool_size=(2, 2, 2), padding='same')(conv2) pool3 = Flatten()(pool2) fc1 = Dense(128, activation='relu')(pool3) fc1 = Dropout(0.2)(fc1) out = Dense(10, activation='relu')(fc1) out = Lambda(lambda out: softmax(out, axis=-1))(out) # model model = Model(inputs=[inputs], outputs=[out]) model.compile(optimizer='Adadelta', loss='categorical_crossentropy',metrics=['categorical_crossentropy', 'accuracy']) return model
def getnet2(inshape): print("Building model 2...") # inshape is (160, 448, 500) = 35 840 000 model = Sequential() model.add( Convolution3D(1, 61, 49, 101, input_shape=inshape, activation="relu")) model.add(MaxPooling3D()) # shape is (50, 200, 200) = 2 000 000 model.add(Convolution3D(1, 9, 21, 21, activation="relu")) model.add(MaxPooling3D()) # shape is (21, 90, 90) = 170 100 model.add(Convolution3D(1, 10, 10, 10, activation="relu")) model.add(MaxPooling3D((3, 3, 3))) # shape is (4, 27, 27) = 2 916 model.add(Flatten()) model.add(Dense(30, activation="sigmoid")) model.add(Dense(1, activation="sigmoid")) print("Compiling model...") model.compile(RMSprop(lr=0.01), "mse") return model
def residual_block(x, nb_filter, kernel_size, b, i): y = Conv3D(nb_filter, kernel_size, padding='same', name='block%d_conv%d' % (b, i), trainable=True)(x) # x = BatchNormalization(name='block1_conv1_bn')(x) y = Activation('relu', name='block%d_conv%d_act' % (b, i))(y) y = Concatenate(axis=-1)([x, y]) print("y shape:", y.shape) y = MaxPooling3D((1, 2, 2), strides=(1, 2, 2), name='pool%d_%d' % (b, i))(y) return y
def maxpoolModelSimple(Inputs,nclasses,nregressions,dropoutRate=0.05,momentum=0.6): x=Inputs[1] globals=Inputs[0] x=BatchNormalization(momentum=momentum)(x) x = GaussianDropout(dropoutRate)(x) x=Convolution3D(12,kernel_size=(3,3,3),strides=(1,1,1),padding='valid', activation='relu',kernel_initializer='lecun_uniform',name='conv3D_0a')(x) x=Convolution3D(12,kernel_size=(3,3,3),strides=(1,1,1),padding='valid', activation='relu',kernel_initializer='lecun_uniform',name='conv3D_0')(x) x = MaxPooling3D((2,2,2))(x) x=Convolution3D(16,kernel_size=(5,5,5),strides=(1,1,1),padding='same', activation='relu',kernel_initializer='lecun_uniform',name='conv3D_1')(x) x = MaxPooling3D((2,2,2))(x) x=BatchNormalization(momentum=momentum)(x) x=Convolution3D(4,kernel_size=(3,3,5),strides=(1,1,1),padding='same', activation='relu',kernel_initializer='lecun_uniform',name='conv3D_2')(x) x = MaxPooling3D((1,1,3))(x) x=BatchNormalization(momentum=momentum)(x) x=Flatten()(x) x=Concatenate()( [globals,x]) x=Dense(128, activation='relu',kernel_initializer='lecun_uniform')(x) predictID=Dense(nclasses, activation='softmax',kernel_initializer='lecun_uniform',name='ID_pred')(x) predictE=Dense(1, activation='linear',kernel_initializer='lecun_uniform',name='pre_Epred')(x) predictions = [predictID,predictE] model = Model(inputs=Inputs, outputs=predictions) return model
def train(self, num_frames, Xtr, ytr, lr = 1e-3, reg = 0.01, lr_decay = 1e-6, optimizer = 'Adam', \ bsize = 32, epochs = 100, split_ratio = 0.2, verbose = 0): ''' Temporal feature pooling architecture based on pretrained model 3D max pooling (T, H, W) + fully-connected + fully_connected + softmax Xtr: training features data (sample_size, temporal/frames, height, width, filter_num/channels) ytr: training true lables (sample_size,) lr: learning rate reg: regularization lr_decay: learning rate decay optimizer: optimizer method bsize: minibatch size epochs: epoch to train split_ratio: validation split ratio verbose: boolean, show process stdout (1) or not (0) ''' num_classes = len(np.unique(ytr)) # create new model # Temporal max pooling x = Input(shape = (num_frames, 7, 7, 512)) mp = MaxPooling3D(pool_size=(3, 2, 2), strides=(3, 2, 2), padding='valid', data_format='channels_last')(x) mp_flat = Flatten()(mp) fc1 = Dense(units = 4096, kernel_regularizer=regularizers.l2(reg))(mp_flat) # fc2 = Dense(units = 256, kernel_regularizer=regularizers.l2(reg))(fc1) fc3 = Dense(units = num_classes, kernel_regularizer=regularizers.l2(reg))(fc1) sf = Activation('softmax')(fc3) add_model = Model(inputs=x, outputs=sf) # sgd_m = optimizers.SGD(lr=lr, decay=1e-6, momentum=0.9, nesterov=True) add_model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) ytr = to_categorical(ytr, num_classes = num_classes) print('Model is Training...') checkpointer = ModelCheckpoint(filepath='maxpool3D_classification_weights.hdf5', verbose=1, save_best_only=True) # reduce learning rate when on plateau reduceLR = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0) hist = add_model.fit(Xtr, ytr, epochs=epochs, batch_size= bsize, validation_split = split_ratio, \ verbose = verbose, callbacks=[checkpointer, reduceLR]) self.add_model = add_model self.hist = hist
def getnet3(inshape): print("Building model 3...") print("Input shape is", inshape) # inshape is (80, 224, 250) = 4 480 000 model = Sequential() model.add( Convolution3D(1, 11, 25, 31, input_shape=inshape, activation="relu")) model.add(MaxPooling3D()) # shape is (35, 100, 110) = 385 000 model.add( Convolution3D(1, 6, 21, 31, input_shape=inshape, activation="relu")) model.add(MaxPooling3D()) # shape is (15, 40, 40) = 24 000 model.add( Convolution3D(4, 6, 21, 21, input_shape=inshape, activation="relu")) model.add(MaxPooling3D()) # shape is (5, 10, 10) = 500 model.add(Flatten()) model.add(Dense(30, activation="sigmoid")) model.add(Dense(1, activation="sigmoid")) print("Compiling model...") model.compile(RMSprop(lr=0.01), "binary_crossentropy") return model
def d_layer(layer_input, filters, f_size=3, bn=True): """Discriminator layer""" # d = Conv3D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = Conv3D(filters, kernel_size=f_size, strides=1, padding='same')(layer_input) # d = AveragePooling3D(padding='same', data_format="channels_last")(d) d = MaxPooling3D(padding='same', data_format="channels_last")(d) d = LeakyReLU(alpha=0.2)(d) # add dropout for avoid momorize of the discriminator d = Dropout(rate=self.settings['DROPOUT'])(d) if bn and self.settings['BATCH_NORMALIZATION']: d = BatchNormalization(momentum=0.8)(d) return d
def FPM(self, x): x1 = MaxPooling3D((2, 2), strides=(1, 1), padding='same')(x) x1 = Conv3D(64, 1, padding='same')(x1) x2 = Conv3D(64, 3, padding='same')(x) x3 = Conv3D(64, 3, padding='same', dilation_rate=4)(x) x4 = Conv3D(64, 3, padding='same', dilation_rate=8)(x) x5 = Conv3D(64, 3, padding='same', dilation_rate=16)(x) x = keras.layers.concatenate([x1, x2, x3, x4, x5], axis=-1) x = BatchNormalization()(x) x = Activation('relu')(x) x = SpatialDropout3D(0.25)(x) return x
def conv_block(x_input, num_filters, pool=True, norm=False, drop_rate=0.0): x1 = Convolution3D(num_filters, 3, 3, 3, border_mode='same', W_regularizer=l2(1e-4))(x_input) if norm: x1 = BatchNormalization(axis=1)(x1) #x1 = Lambda(relu_norm)(x1) if drop_rate > 0.0: x1 = GaussianDropout(drop_rate)(x1) x1 = LeakyReLU(.1)(x1) if pool: x1 = MaxPooling3D()(x1) x_out = x1 return x_out
def conv3d(layer_input, filters, f_size=3, bn=True): """Layers used during downsampling""" if self.settings['POOLING'] == "MAX": d = Conv3D(filters, kernel_size=f_size, strides=1, padding='same')(layer_input) d = MaxPooling3D(padding='same', data_format="channels_last")(d) elif self.settings['POOLING'] == "AVERAGE": d = Conv3D(filters, kernel_size=f_size, strides=1, padding='same')(layer_input) d = AveragePooling3D(padding='same', data_format="channels_last")(d) elif self.settings['POOLING'] == "NONE": d = Conv3D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = LeakyReLU(alpha=0.2)(d) # GANHACKS: add dropout with specified value if self.settings['GANHACKS']: d = Dropout(rate=self.settings['DROPOUT'])(d) if bn and self.settings['BATCH_NORMALIZATION']: d = BatchNormalization(momentum=0.8)(d) # GANHACKS: adding gaussian noise to every layer of G (Zhao et. al. EBGAN) if self.settings['GANHACKS']: d = GaussianNoise(stddev=self.settings['GAUSSIAN_NOISE_TO_G'])(d) print('downsampling:\t\t\t', d.shape) return d
def get_3d_model(shape): model = Sequential() model.add( Conv3D(36, 3, strides=(2, 2, 2), padding="same", activation='relu', input_shape=shape)) model.add(BatchNormalization()) model.add(Conv3D(48, 3, padding="same", activation='relu')) model.add(BatchNormalization()) model.add(Conv3D(64, 3, padding="same", activation='relu')) model.add(BatchNormalization()) model.add(Conv3D(94, 3, padding="same", activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling3D(pool_size=(3, 3, 3), padding='valid')) model.add(Flatten()) model.add(Dense(1524)) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(Dense(750)) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(Dense(370)) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(Dense(180)) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(Dense(50)) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(Dense(2, activation='linear')) adam = Adam(lr=0.0005, clipvalue=5) model.compile(optimizer=adam, loss='mean_squared_error', metrics=['mae']) #backend.get_session().run(tf.initialize_all_variables()) return model
def VIN(sz, k, ch_i, ch_h, ch_q, ch_a): map_in = Input(shape=(sz,sz)) s1 = Input(shape=(1,), dtype='int32') s2 = Input(shape=(1,), dtype='int32') h = Conv2D(filters=ch_h, kernel_size=(3,3), padding='same', activation='relu')(map_in) r = Conv2D(filters=1, kernel_size=(3,3), padding='same', bias=False, activation=None, )(h) conv3 = Conv2D(filters=l_q, kernel_size=(3, 3), padding='same', bias=False) conv3b = Conv2D(filters=l_q, kernel_size=(3, 3), padding='same', bias=False) q = conv3(r) for _ in range(k): #v = Lambda(lambda x: K.max(x, axis=CHANNEL_AXIS, keepdims=True)), # output_shape=(sz,sz,1))(q) v = MaxPooling3D(pool_size=(1,1,ch_q))(q) rv = concatenate([r, v], axis=3) q = conv3b(rv) q_out = attention(q,s1,s2) out = Dense(ch_a, activation='softmax', bias=False)(q_out)
def Unet(img_shape, params, path='./'): # print message at runtime if (img_shape[0] == 64 and np.size(img_shape) == 3): print('Create 2D U-Net network with 3 levels...\n') elif (img_shape[0] == 128 and np.size(img_shape) == 3): print('Create 2D U-Net network with 4 levels...\n') elif (img_shape[0] == 64 and np.size(img_shape) == 4): print('Create 3D U-Net network with 3 levels...\n') elif (img_shape[0] == 128 and np.size(img_shape) == 4): print('Create 3D U-Net network with 4 levels...\n') else: print('???') def Conv2D_Layers(prev_layer, kernel_size, nr_filts, layer_name): # first layer a = Conv2D(filters=nr_filts, kernel_size=kernel_size, padding='same', kernel_initializer="he_normal", name='%s_C1' % layer_name)(prev_layer) a = BatchNormalization(name='%s_BN1' % layer_name)(a) a = Activation(params['activation'], name='relu_%s_A1' % layer_name)(a) # second layer a = Conv2D(filters=nr_filts, kernel_size=kernel_size, padding='same', kernel_initializer="he_normal", name='%s_C2' % layer_name)(a) a = BatchNormalization(name='%s_BN2' % layer_name)(a) a = Activation(params['activation'], name='relu_%s_A2' % layer_name)(a) return a def Conv3D_Layers(prev_layer, kernel_size, nr_filts, layer_name): # first layer a = Conv3D(filters=nr_filts, kernel_size=kernel_size, padding='same', kernel_initializer="he_normal", name='%s_C1' % layer_name)(prev_layer) a = BatchNormalization(name='%s_BN1' % layer_name)(a) a = Activation(params['activation'], name='relu_%s_A1' % layer_name)(a) # second layer a = Conv3D(filters=nr_filts, kernel_size=kernel_size, padding='same', kernel_initializer="he_normal", name='%s_C2' % layer_name)(a) a = BatchNormalization(name='%s_BN2' % layer_name)(a) a = Activation(params['activation'], name='relu_%s_A2' % layer_name)(a) return a img_input = Input(shape=img_shape, name='Image') # U-Net Encoder - upper level if (np.size(img_shape) == 3): # 2-D network e1c = Conv2D_Layers(prev_layer=img_input, nr_filts=int(params['coarse_dim'] / 16), kernel_size=params['kernel_size'], layer_name='E1') e1 = MaxPooling2D(pool_size=(2, 2), name='E1_P')(e1c) e1 = Dropout(params['dropout'] * 0.5, name='E1_D2')(e1) elif (np.size(img_shape) == 4): # 3-D network e1c = Conv3D_Layers(prev_layer=img_input, nr_filts=int(params['coarse_dim'] / 16), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='E1') e1 = MaxPooling3D(pool_size=(2, 2, 2), name='E1_P')(e1c) e1 = Dropout(params['dropout'] * 0.5, name='E1_D2')(e1) # U-Net Encoder - second level if (np.size(img_shape) == 3): # 2-D network e2c = Conv2D_Layers(prev_layer=e1, nr_filts=int(params['coarse_dim'] / 8), kernel_size=params['kernel_size'], layer_name='E2') e2 = MaxPooling2D(pool_size=(2, 2), name='E2_P')(e2c) e2 = Dropout(params['dropout'], name='E2_D2')(e2) elif (np.size(img_shape) == 4): # 3-D network e2c = Conv3D_Layers(prev_layer=e1, nr_filts=int(params['coarse_dim'] / 8), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='E2') e2 = MaxPooling3D(pool_size=(2, 2, 2), name='E2_P')(e2c) e2 = Dropout(params['dropout'], name='E2_D2')(e2) # U-Net Encoder - third level if (np.size(img_shape) == 3): # 2-D network e3c = Conv2D_Layers(prev_layer=e2, nr_filts=int(params['coarse_dim'] / 4), kernel_size=params['kernel_size'], layer_name='E3') e3 = MaxPooling2D(pool_size=(2, 2), name='E3_P')(e3c) e3 = Dropout(params['dropout'], name='E3_D2')(e3) elif (np.size(img_shape) == 4): # 3-D network e3c = Conv3D_Layers(prev_layer=e2, nr_filts=int(params['coarse_dim'] / 4), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='E3') e3 = MaxPooling3D(pool_size=(2, 2, 2), name='E3_P')(e3c) e3 = Dropout(params['dropout'], name='E3_D2')(e3) if (img_shape[0] >= 64 and img_shape[0] < 128): # U-Net Encoder - bottom level if (np.size(img_shape) == 3): # 2-D network b = Conv2D_Layers(prev_layer=e3, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size']), layer_name='B') d3 = Conv2DTranspose(filters=int(params['coarse_dim'] / 4), kernel_size=(params['kernel_size'], params['kernel_size']), strides=(2, 2), padding='same', name='D3_DC')(b) elif (np.size(img_shape) == 4): # 3-D network b = Conv3D_Layers(prev_layer=e3, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='B') d3 = Conv3DTranspose(filters=int(params['coarse_dim'] / 4), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), strides=(2, 2, 2), padding='same', name='D3_DC')(b) elif (img_shape[0] >= 128): if (np.size(img_shape) == 3): # 2-D network # U-Net Encoder - fourth level e4c = Conv2D_Layers(prev_layer=e3, nr_filts=int(params['coarse_dim'] / 2), kernel_size=params['kernel_size'], layer_name='E4') e4 = MaxPooling2D(pool_size=(2, 2), name='E4_P')(e4c) e4 = Dropout(params['dropout'], name='E4_D2')(e4) # U-Net Encoder - bottom level b = Conv2D_Layers(prev_layer=e4, nr_filts=params['coarse_dim'], kernel_size=params['kernel_size'], layer_name='B') # U-Net Decoder - fourth level d4 = Conv2DTranspose(filters=int(params['coarse_dim'] / 2), kernel_size=params['kernel_size'], strides=(2, 2), padding='same', name='D4_DC')(b) d4 = concatenate([d4, e4c], name='merge_layer_E4_A2') d4 = Dropout(params['dropout'], name='D4_D1')(d4) d4 = Conv2D_Layers(prev_layer=d4, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size']), layer_name='D4') # U-Net Decoder - third level d3 = Conv2DTranspose(filters=int(params['coarse_dim'] / 4), kernel_size=params['kernel_size'], strides=(2, 2), padding='same', name='D3_DC')(d4) elif (np.size(img_shape) == 4): # 3-D network # U-Net Encoder - fourth level e4c = Conv3D_Layers(prev_layer=e3, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='E4') e4 = MaxPooling3D(pool_size=(2, 2, 2), name='E4_P')(e4c) e4 = Dropout(params['dropout'], name='E4_D2')(e4) # U-Net Encoder - bottom level b = Conv3D_Layers(prev_layer=e4, nr_filts=params['coarse_dim'], kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='B') # U-Net Decoder - fourth level d4 = Conv3DTranspose(filters=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), strides=(2, 2, 2), padding='same', name='D4_DC')(b) d4 = concatenate([d4, e4c], name='merge_layer_E4_A2') d4 = Dropout(params['dropout'], name='D4_D1')(d4) d4 = Conv3D_Layers(prev_layer=d4, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='D4') # U-Net Decoder - third level d3 = Conv3DTranspose(filters=int(params['coarse_dim'] / 4), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), strides=(2, 2, 2), padding='same', name='D3_DC')(d4) else: print('ERROR: input data have wrong dimension') # U-Net Decoder - third level (continue) if (np.size(img_shape) == 3): # 2-D network d3 = concatenate([d3, e3c], name='merge_layer_E3_A2') d3 = Dropout(params['dropout'], name='D3_D1')(d3) d3 = Conv2D_Layers(prev_layer=d3, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size']), layer_name='D3') elif (np.size(img_shape) == 4): # 3-D network d3 = concatenate([d3, e3c], name='merge_layer_E3_A2') d3 = Dropout(params['dropout'], name='D3_D1')(d3) d3 = Conv3D_Layers(prev_layer=d3, nr_filts=int(params['coarse_dim'] / 2), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='D3') # U-Net Decoder - second level if (np.size(img_shape) == 3): # 2-D network d2 = Conv2DTranspose(filters=int(params['coarse_dim'] / 8), kernel_size=params['kernel_size'], strides=(2, 2), padding='same', name='D2_DC')(d3) d2 = concatenate([d2, e2c], name='merge_layer_E2_A2') d2 = Dropout(params['dropout'], name='D2_D1')(d2) d2 = Conv2D_Layers(prev_layer=d2, nr_filts=int(params['coarse_dim'] / 4), kernel_size=(params['kernel_size'], params['kernel_size']), layer_name='D2') elif (np.size(img_shape) == 4): # 3-D network d2 = Conv3DTranspose(filters=int(params['coarse_dim'] / 8), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), strides=(2, 2, 2), padding='same', name='D2_DC')(d3) d2 = concatenate([d2, e2c], name='merge_layer_E2_A2') d2 = Dropout(params['dropout'], name='D2_D1')(d2) d2 = Conv3D_Layers(prev_layer=d2, nr_filts=int(params['coarse_dim'] / 4), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='D2') # U-Net Decoder - upper level if (np.size(img_shape) == 3): d1 = Conv2DTranspose(filters=int(params['coarse_dim'] / 16), kernel_size=params['kernel_size'], strides=(2, 2), padding='same', name='D1_DC')(d2) d1 = concatenate([d1, e1c], name='merge_layer_E1_A2') d1 = Dropout(params['dropout'], name='D1_D1')(d1) d1 = Conv2D_Layers(prev_layer=d1, nr_filts=int(params['coarse_dim'] / 16), kernel_size=(params['kernel_size'], params['kernel_size']), layer_name='D1') elif (np.size(img_shape) == 4): d1 = Conv3DTranspose(filters=int(params['coarse_dim'] / 16), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), strides=(2, 2, 2), padding='same', name='D1_DC')(d2) d1 = concatenate([d1, e1c], name='merge_layer_E1_A2') d1 = Dropout(params['dropout'], name='D1_D1')(d1) d1 = Conv3D_Layers(prev_layer=d1, nr_filts=int(params['coarse_dim'] / 16), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), layer_name='D1') # Outro Layer if (np.size(img_shape) == 3): output_image = Conv2D(filters=int(img_shape[-1]), kernel_size=params['kernel_size'], strides=(1, 1), padding='same', name='out_C')(d1) elif (np.size(img_shape) == 4): output_image = Conv3D(filters=int(img_shape[-1]), kernel_size=(params['kernel_size'], params['kernel_size'], params['kernel_size']), strides=(1, 1, 1), padding='same', name='out_C')(d1) output_image = Activation("sigmoid", name='sigmoid')(output_image) model = Model(inputs=[img_input], outputs=[output_image], name='Unet') plot_model(model, to_file=path + 'model_visualization.png', show_shapes=True, show_layer_names=True) return model