def get_Inception_classifier(): inputs = Input((CLASSIFY_INPUT_WIDTH, CLASSIFY_INPUT_HEIGHT, CLASSIFY_INPUT_DEPTH, CLASSIFY_INPUT_CHANNEL)) print('inputs') print(inputs.get_shape()) # Make inception base x = inception_base(inputs) for i in range(INCEPTION_BLOCKS): x = inception_block(x, filters=INCEPTION_KEEP_FILTERS) if (i + 1) % INCEPTION_REDUCTION_STEPS == 0 and i != INCEPTION_BLOCKS - 1: x = reduction_block(x, filters=INCEPTION_KEEP_FILTERS // 2) print('top') x = GlobalMaxPooling3D()(x) print(x.get_shape()) x = Dropout(INCEPTION_DROPOUT)(x) x = Dense(2, activation='softmax')(x) print(x.get_shape()) model_s = Model(inputs=inputs, outputs=x) model = multi_gpu_model(model_s, gpus=4) model.compile(optimizer=Adam(lr=TRAIN_CLASSIFY_LEARNING_RATE), loss='binary_crossentropy', metrics=['accuracy']) return model,model_s
def get_model(n_ch=32): input = Input(shape=(96, 160, 160, 1)) C1_0 = Conv3D(n_ch, (3, 3, 3), padding="valid")(input) C1_0 = BatchNormalization()(C1_0) C1_0 = Activation('relu')(C1_0) C1_1 = Conv3D(n_ch, (3, 3, 3), padding="valid", activation='relu')(C1_0) C1_0 = BatchNormalization()(C1_0) C1_0 = Activation('relu')(C1_0) MP1 = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2))(C1_1) D1 = Dropout(0.25)(MP1) C2_0 = Conv3D(2*n_ch, (3, 3, 3), padding="valid", activation='relu')(D1) C2_1 = Conv3D(2*n_ch, (3, 3, 3), padding="valid", activation='relu')(C2_0) MP2 = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2))(C2_1) D2 = Dropout(0.25)(MP2) C3_0 = Conv3D(4 * n_ch, (3, 3, 3), padding="valid", activation='relu')(D2) C3_1 = Conv3D(4 * n_ch, (3, 3, 3), padding="valid", activation='relu')(C3_0) MP3 = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2))(C3_1) D3 = Dropout(0.25)(MP3) C4_0 = Conv3D(8 * n_ch, (3, 3, 3), padding="valid", activation='relu')(D3) C4_1 = Conv3D(8 * n_ch, (3, 3, 3), padding="valid", activation='relu')(C4_0) MP4 = GlobalMaxPooling3D()(C4_1) D4 = Dropout(0.25)(MP4) Den2 = Dense(600, activation='softmax')(D4) model = Model(inputs=input, outputs=Den2) return model
def get_ResNet_classifier(): inputs = Input((CLASSIFY_INPUT_WIDTH, CLASSIFY_INPUT_HEIGHT, CLASSIFY_INPUT_DEPTH, CLASSIFY_INPUT_CHANNEL)) x = conv_bn_relu(inputs, RESNET_INITIAL_FILTERS) print('base') print(x.get_shape()) for i in range(RESNET_BLOCKS): x = bottleneck(x, shrinkage=(i % RESNET_SHRINKAGE_STEPS == 0)) print('top') x = GlobalMaxPooling3D()(x) print(x.get_shape()) x = Dense(2, activation='softmax')(x) print(x.get_shape()) model = Model(inputs=inputs, outputs=x) model.compile(optimizer=Adam(lr=TRAIN_CLASSIFY_LEARNING_RATE), loss='binary_crossentropy', metrics=['accuracy']) return model
def attention_block(input, iter, depth): global_pool = GlobalMaxPooling3D(data_format='channels_first')(input) global_pool1 = Reshape((depth, 1, 1, 1))(global_pool) conv_1x1 = Conv3D(depth, (1, 1, 1), padding='same', data_format='channels_first')(global_pool1) relu_out = Activation('relu')(conv_1x1) conv_2x1 = Conv3D(depth, (1, 1, 1), strides=(1, 1, 1), padding='same', data_format='channels_first')(relu_out) sigmoid_out = Activation('sigmoid')(conv_2x1) concat1 = sigmoid_out #print("***********1") #print(concat1.shape) for i in range(4 - 1): concat1 = concatenate([concat1, sigmoid_out], axis=2) concat2 = concat1 for j in range(iter - 1): concat2 = concatenate([concat2, concat1], axis=3) concat3 = concat2 for k in range(iter - 1): concat3 = concatenate([concat3, concat2], axis=4) #print("************2") #print(concat3.shape) out = Multiply()([input, concat3]) return out
def objdet_model_fn(mc_input_shape): """ Returns an instance of the 1x1 simulated tile MC """ mc_input = Input(shape=mc_input_shape, name="objdet/input") mc_output = Conv2D(128, 1, strides=(1, 1), padding="same", activation="relu", name="objdet/conv1")(mc_input) mc_output = Conv2D(64, 1, strides=(1, 1), padding="same", activation="relu", name="objdet/conv2")(mc_output) mc_output = Conv2D(64, 1, strides=(1, 1), padding="same", name="objdet/conv3")(mc_output) cur_shape = keras.backend.int_shape(mc_output) mc_output = Reshape([*cur_shape[1:], 1], name="objdet/reshape")(mc_output) mc_output = GlobalMaxPooling3D(data_format="channels_last", name="objdet/maxpool")(mc_output) mc_output = Activation("sigmoid")(mc_output) mc_model = Model(inputs=mc_input, outputs=mc_output, name="objdet") return mc_model
def model(input_shape=(103, 50, 50, 1), classes=9): X_input = Input(input_shape) print(X_input.shape) X = feature_extraction(X_input) X = GlobalMaxPooling3D()(X) print(X.shape) X = Dense(classes, input_dim=256, activation='softmax', name='fc' + str(classes), kernel_initializer=glorot_uniform(seed=0))(X) model = Model(inputs=X_input, outputs=X, name="3D-SRNet") return model
def get_full_VGG_classifier(): inputs = Input((CLASSIFY_INPUT_WIDTH, CLASSIFY_INPUT_HEIGHT, CLASSIFY_INPUT_DEPTH, CLASSIFY_INPUT_CHANNEL)) x = inputs x = Conv3D(32, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(32, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) if TRAIN_CLASSIFY_USE_BN: x = BatchNormalization()(x) x = Conv3D(64, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(64, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) if TRAIN_CLASSIFY_USE_BN: x = BatchNormalization()(x) x = Conv3D(128, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(128, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(128, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) if TRAIN_CLASSIFY_USE_BN: x = BatchNormalization()(x) x = Conv3D(256, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(256, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(256, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) if TRAIN_CLASSIFY_USE_BN: x = BatchNormalization()(x) x = Conv3D(512, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(512, (3, 3, 3), padding='same', activation='relu')(x) x = Conv3D(512, (3, 3, 3), padding='same', activation='relu')(x) x = GlobalMaxPooling3D()(x) x = Dense(32, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(2, activation='softmax')(x) model = Model(inputs=inputs, outputs=x) model.compile(optimizer=Adam(lr=TRAIN_CLASSIFY_LEARNING_RATE), loss='binary_crossentropy', metrics=['accuracy']) return model
def squeezenet(input_dim, num_classes): img_input = Input(shape=input_dim) x = Convolution3D( 64, kernel_size=(3, 3, 3), strides=(2, 2, 2), padding="same", # kernel_regularizer=l2(l2_lambda), # kernel_initializer='he_uniform', activation="relu", name='sqconv1')(img_input) x = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name='maxpool1', padding="valid")(x) x = firemodule(x, (16, 64, 64), None) x = firemodule(x, (16, 64, 64), None) x = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name='maxpool3', padding="valid")(x) x = firemodule(x, (32, 128, 128), None) x = firemodule(x, (32, 128, 128), None) x = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name='maxpool5', padding="valid")(x) x = firemodule(x, (48, 192, 192), None) x = firemodule(x, (48, 192, 192), None) x = firemodule(x, (64, 256, 256), None) x = firemodule(x, (64, 256, 256), None) # Dropout after the last Fire Module # x = Dropout(0.2)(x) # x = BatchNormalization()(x) x = GlobalMaxPooling3D(name="maxpool10")(x) x = Dense( num_classes, init='normal', # kernel_regularizer=l2(l2_lambda), # kernel_initializer='he_uniform', )(x) x = Activation('softmax')(x) model = Model(img_input, x, name="squeezenet3d") return model
def cnn_3d(self): # input_shape = self.train_data.shape[1:] # Create CNN architecture self.kernel_size = 3 self.activation = 'relu' # self.activation = LeakyReLU(alpha=0.3) self.stride = 1 self.num_conv_layers = 2 self.curr_resblock = [] inputs = Input(shape=(None, None, None, 1)) # conv_input = Conv3D(filters=8, kernel_size=7, strides=self.stride, # padding='same', kernel_initializer=keras.initializers.he_normal(seed=7), kernel_regularizer=l2(1e-4)) # c1 = conv_input(inputs) # c1 = BatchNormalization(axis=4)(c1) # c1 = Activation(self.activation)(c1) for res_block in range(self.depth): self.curr_resblock = res_block print('Creating ResBlock: ', res_block) if res_block == 0: x = BuildNetwork.res_block_3d(self, inputs) else: x = BuildNetwork.res_block_3d(self, x) self.num_filters *= 2 gp = GlobalMaxPooling3D()(x) FC1 = Dense( 6, activation=self.activation, kernel_initializer=keras.initializers.he_normal(seed=7))(gp) DP1 = Dropout(0.5)(FC1) outputs = Dense(self.num_class, activation='softmax')(DP1) cnn3d = Model(inputs=inputs, outputs=outputs) cnn3d.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.lr, beta_1=0.9, beta_2=0.999, epsilon=1e-6, amsgrad=True), metrics=['accuracy']) plot_model(cnn3d, to_file='CNN3D.png') return cnn3d
def squeeze_excite_block(input, ratio=8): init = input channel_axis = 1 if K.backend.image_data_format( ) == "channels_first" else -1 filters = init._keras_shape[channel_axis] se_shape = (1, 1, filters) se = GlobalMaxPooling3D()(init) se = Reshape(se_shape)(se) se = Dense(filters // ratio, activation='relu', kernel_initializer='he_normal', use_bias=False)(se) se = Dense(filters, activation='sigmoid', kernel_initializer='he_normal', use_bias=False)(se) if K.backend.image_data_format() == 'channels_first': se = Permute((3, 1, 2))(se) x = multiply([init, se]) return x
def get_model(self, learning_rate): inputs = Input((CLASSIFY_INPUT_WIDTH, CLASSIFY_INPUT_HEIGHT, CLASSIFY_INPUT_DEPTH, CLASSIFY_INPUT_CHANNEL)) x = inputs x = Conv3D(32, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) x = BatchNormalization()(x) x = Conv3D(64, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) x = BatchNormalization()(x) x = Conv3D(128, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) x = BatchNormalization()(x) x = Conv3D(256, (3, 3, 3), padding='same', activation='relu')(x) x = MaxPooling3D(pool_size=(2, 2, 2))(x) x = BatchNormalization()(x) x = Conv3D(512, (3, 3, 3), padding='same', activation='relu')(x) x = GlobalMaxPooling3D()(x) x = Dense(32, activation='relu')(x) #x = Dropout(0.5)(x) x = Dense(CLASSIFY_OUTPUT_CHANNEL, activation='softmax')(x) model = Model(inputs=inputs, outputs=x) #optimizer=Adam(lr=TRAIN_CLASSIFY_LEARNING_RATE) model.compile(optimizer=RMSprop(lr=learning_rate), loss='categorical_crossentropy', metrics=[categorical_accuracy]) return model
def channel_att(input_feature, ratio=8): print(K.image_data_format()) channel_axis = 1 if K.image_data_format() == "channels_first" else -1 channel = input_feature._keras_shape[channel_axis] shared_layer_one = Dense(channel // ratio, activation='relu', kernel_initializer='he_normal', use_bias=True, bias_initializer='zeros') shared_layer_two = Dense(channel, kernel_initializer='he_normal', use_bias=True, bias_initializer='zeros') avg_pool = GlobalAveragePooling3D()(input_feature) avg_pool = Reshape((1, 1, 1, channel))(avg_pool) assert avg_pool._keras_shape[1:] == (1, 1, 1, channel) avg_pool = shared_layer_one(avg_pool) assert avg_pool._keras_shape[1:] == (1, 1, 1, channel // ratio) avg_pool = shared_layer_two(avg_pool) assert avg_pool._keras_shape[1:] == (1, 1, 1, channel) max_pool = GlobalMaxPooling3D()(input_feature) max_pool = Reshape((1, 1, 1, channel))(max_pool) assert max_pool._keras_shape[1:] == (1, 1, 1, channel) max_pool = shared_layer_one(max_pool) assert max_pool._keras_shape[1:] == (1, 1, 1, channel // ratio) max_pool = shared_layer_two(max_pool) assert max_pool._keras_shape[1:] == (1, 1, 1, channel) cbam_feature = Add()([avg_pool, max_pool]) cbam_feature = Activation('sigmoid')(cbam_feature) if K.image_data_format() == "channels_first": cbam_feature = Permute((3, 1, 2))(cbam_feature) return multiply([input_feature, cbam_feature])
def resnet3d_model(input_shape=(dimz, dimx, dimy, channelNum), num_outputs=4, n_base_filters=16, depth=5, dropout_rate=0.3, optimizer=Adam, initial_learning_rate=5e-4, loss_function=weighted_dice_coefficient_loss, kernel_reg_factor=1e-4, ifbase=False): """ :param input_shape: :param n_base_filters: :param depth: :param dropout_rate: :param n_labels: :param optimizer: :param initial_learning_rate: :param loss_function: :param activation_name: :return: """ inputs = Input(input_shape) current_layer = inputs level_output_layers = list() level_filters = list() for level_number in range(depth): n_level_filters = (2**level_number) * n_base_filters level_filters.append(n_level_filters) if current_layer is inputs: in_conv = create_convolution_block(current_layer, n_level_filters, kernel=(5, 5, 5), strides=(2, 2, 2)) # in_conv = create_convolution_block(in_conv, n_level_filters, kernel=(5, 5, 5), strides=(2, 2, 2)) in_conv = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), padding="same")(in_conv) else: in_conv = create_convolution_block(current_layer, n_level_filters, kernel=(3, 3, 3), strides=(2, 2, 2)) context_output_layer = create_context_module(in_conv, n_level_filters, dropout_rate=dropout_rate) summation_layer = Add()([in_conv, context_output_layer]) level_output_layers.append(summation_layer) current_layer = summation_layer output_layer = create_convolution_block(summation_layer, n_level_filters, kernel=(1, 1, 1)) pool1 = GlobalMaxPooling3D(data_format='channels_last')(output_layer) if ifbase == True: model = Model(inputs=inputs, outputs=pool1) return model else: flatten1 = Flatten()(pool1) if num_outputs > 1: dense = Dense(units=num_outputs, kernel_initializer="he_normal", activation="softmax", kernel_regularizer=l2(kernel_reg_factor))(flatten1) else: dense = Dense(units=num_outputs, kernel_initializer="he_normal", activation="sigmoid", kernel_regularizer=l2(kernel_reg_factor))(flatten1) model = Model(inputs=inputs, outputs=dense) model.compile(optimizer=optimizer(lr=initial_learning_rate), loss=loss_function) return model
def res_next32(input_shape, initial_learning_rate=0.00001, batch_normalization=True, activation_name="sigmoid", activation=ReLU, opt='Adam'): base_filters = 16 inputs = Input(input_shape) current_layer = inputs print(current_layer._keras_shape) layer1 = create_convolution_block(input_layer=current_layer, kernel=(3, 3, 3), n_filters=base_filters, padding='same', batch_normalization=batch_normalization, activation=activation) print(layer1._keras_shape) ############# resx1 = create_next_block(input_layer=layer1, n_filters=base_filters * 2, padding='same', batch_normalization=batch_normalization, activation=activation) rex1_match = create_convolution_block( input_layer=layer1, kernel=(1, 1, 1), n_filters=base_filters * 4, padding='same', batch_normalization=batch_normalization, activation=None) rex1_out = create_elewise_block(input1=resx1, input2=rex1_match, activation=activation) ############# resx2 = create_next_block(input_layer=rex1_out, n_filters=base_filters * 2, padding='same', batch_normalization=batch_normalization, activation=activation) rex2_out = create_elewise_block(input1=resx2, input2=rex1_out, activation=activation) print(rex2_out._keras_shape) ############# resx3 = create_next_block(input_layer=rex2_out, n_filters=base_filters * 4, strides=(2, 2, 2), padding='same', batch_normalization=batch_normalization, activation=activation) rex3_match = create_convolution_block( input_layer=rex2_out, kernel=(1, 1, 1), strides=(2, 2, 2), n_filters=base_filters * 8, padding='same', batch_normalization=batch_normalization, activation=None) rex3_out = create_elewise_block(input1=resx3, input2=rex3_match, activation=activation) ############# resx4 = create_next_block(input_layer=rex3_out, n_filters=base_filters * 4, padding='same', batch_normalization=batch_normalization, activation=activation) rex4_out = create_elewise_block(input1=resx4, input2=rex3_out, activation=activation) print(rex4_out._keras_shape) ############# resx5 = create_next_block(input_layer=rex4_out, n_filters=base_filters * 8, strides=(2, 2, 2), padding='same', batch_normalization=batch_normalization, activation=activation) rex5_match = create_convolution_block( input_layer=rex4_out, kernel=(1, 1, 1), strides=(2, 2, 2), n_filters=base_filters * 16, padding='same', batch_normalization=batch_normalization, activation=None) rex5_out = create_elewise_block(input1=resx5, input2=rex5_match, activation=activation) ############# resx6 = create_next_block(input_layer=rex5_out, n_filters=base_filters * 8, padding='same', batch_normalization=batch_normalization, activation=activation) rex6_out = create_elewise_block(input1=resx6, input2=rex5_out, activation=activation) print(rex6_out._keras_shape) ############# resx7 = create_next_block(input_layer=rex6_out, n_filters=base_filters * 16, strides=(2, 2, 2), padding='same', batch_normalization=batch_normalization, activation=activation) rex7_match = create_convolution_block( input_layer=rex6_out, kernel=(1, 1, 1), strides=(2, 2, 2), n_filters=base_filters * 32, padding='same', batch_normalization=batch_normalization, activation=None) rex7_out = create_elewise_block(input1=resx7, input2=rex7_match, activation=activation) ############# resx8 = create_next_block(input_layer=rex7_out, n_filters=base_filters * 16, padding='same', batch_normalization=batch_normalization, activation=activation) rex8_out = create_elewise_block(input1=resx8, input2=rex7_out, activation=activation) print(rex8_out._keras_shape) layer7 = GlobalMaxPooling3D(data_format="channels_first")(rex8_out) print(layer7._keras_shape) layer7 = Dropout(rate=0.3)(layer7) layer8 = Dense(1, activation='sigmoid')(layer7) print(layer8._keras_shape) model = Model(inputs=inputs, outputs=layer8) if opt == 'Adam': model.compile(optimizer=Adam(lr=initial_learning_rate), loss=[focal_loss_fixed], metrics=['accuracy']) elif opt == 'SGD': model.compile(optimizer=SGD(lr=initial_learning_rate), loss=[focal_loss_fixed], metrics=['accuracy']) return model
def buildModel(inputShape, args): print inputShape nChannels = inputShape[-1] input_img = Input(shape=inputShape) x = input_img if args.batchNorm: x = BatchNormalization()(x) fo = args.filters fi = fo * 2 b = args.bconv b = 5 firstPool = (4, 4, 4) secondPool = (2, 2, 2) #x = MaxPooling3D(pool_size=(2,2,2))(x) x = AveragePooling3D(pool_size=(2, 2, 2))(x) a = 5 x = Convolution3D(4, (a, a, a), activation='relu', padding='same')(x) x = MaxPooling3D(name='pool1', pool_size=(3, 3, 3))(x) s1 = Dense(4, activation='sigmoid')(Flatten()(x)) nodule1 = Dense(1, activation='sigmoid', name='cancer1')(s1) b = 3 x = Convolution3D(4, (b, b, b), activation='relu', padding='same')(x) x = MaxPooling3D(pool_size=(3, 3, 3))(x) s2 = Dense(4, activation='sigmoid')(Flatten()(x)) nodule2 = Dense(1, activation='sigmoid', name='cancer2')(s2) #x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(pool1) #if args.doubleLayers: x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) #pool2 = MaxPooling3D(name='pool2', pool_size=secondPool)(x) #x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(pool2) #if args.doubleLayers: x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) #pool3 = MaxPooling3D(pool_size=(2,2,2))(x) #l = Convolution3D(16, (1, 1, 1), activation='relu', padding='same')(pool3) #x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(pool2) #if args.doubleLayers: x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) #pool3 = MaxPooling3D(name='pool3', pool_size=(2,2,2))(x) #x = Convolution3D(fi, (5, 5, 5), activation='relu', padding='same')(pool3) #pool4 = MaxPooling3D(pool_size=(2,2,2))(x) encoded = x encoder = Model(inputs=[input_img], outputs=[encoded]) ''' if args.flat=='flat': flat = Flatten()(encoded) else: #flat = GlobalAveragePooling3D()(encoded) flat = GlobalMaxPooling3D()(encoded) ''' #flat = Flatten()(encoded) #flat = GlobalAveragePooling3D()(encoded) flat = GlobalMaxPooling3D()(encoded) if args.dropout: flat = Dropout(args.dropout)(flat) shared = Dense(args.sharedNeurons, activation='sigmoid')(flat) #shared = Dense(args.sharedNeurons, bias_initializer='zero')(flat) #if args.dropout: shared = Dropout(args.dropout)(shared) nodule = Dense(1, activation='sigmoid', name='cancer')(shared) loss = { 'cancer': 'binary_crossentropy', 'cancer1': 'binary_crossentropy', 'cancer2': 'binary_crossentropy' } metrics = {'cancer': 'accuracy'} if args.autoencoder: loss['imgOut'] = 'mse' metrics['imgOut'] = 'mae' x = UpSampling3D(size=secondPool)(pool2) #x = UpSampling3D(size=(5,5,5))(pool2) x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) if args.doubleLayers: x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) #x = UpSampling3D()(x) #x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) #if args.doubleLayers: x = Convolution3D(fi, (3, 3, 3), activation='relu', padding='same')(x) x = UpSampling3D(size=firstPool)(x) #x = UpSampling3D(size=(3,3,3))(x) if args.doubleLayers: x = Convolution3D(fo, (3, 3, 3), activation='relu', padding='same')(x) decoded = Convolution3D(nChannels, (3, 3, 3), activation='relu', padding='same', name='imgOut')(x) model = Model(inputs=[input_img], outputs=[nodule, decoded], name='multiOut') else: model = Model(inputs=[input_img], outputs=[nodule, nodule1, nodule2], name='multiOut') print 'hidden layer shape: ', encoder.output_shape # optomizers: adadelta, sgd, rmsprop, adam, nadam model.compile(optimizer=args.optimizer, loss=loss, metrics=metrics) print model.summary() return model
def model_3d_1(input_shape, initial_learning_rate=0.00001, batch_normalization=True, instance_normalization=False, activation_name="sigmoid", opt='Adam'): base_fiters = 64 inputs = Input(input_shape) current_layer = inputs print(current_layer._keras_shape) layer1_1 = create_convolution_block( input_layer=current_layer, kernel=(3, 3, 3), n_filters=base_fiters, name='1_1', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) layer1_2 = create_convolution_block( input_layer=layer1_1, kernel=(3, 3, 3), n_filters=base_fiters, name='1_2', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) print(layer1_2._keras_shape) pool1 = MaxPooling3D(pool_size=(2, 2, 2), name='pool1')(layer1_2) print('pool1:', pool1._keras_shape) layer2_1 = create_convolution_block( input_layer=pool1, kernel=(3, 3, 3), n_filters=base_fiters * 2, name='2_1', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) layer2_2 = create_convolution_block( input_layer=layer2_1, kernel=(3, 3, 3), n_filters=base_fiters * 2, name='2_2', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) print(layer2_2._keras_shape) pool2 = MaxPooling3D(pool_size=(2, 2, 2), name='pool2')(layer2_2) print('pool2:', pool2._keras_shape) layer3_1 = create_convolution_block( input_layer=pool2, kernel=(3, 3, 3), n_filters=base_fiters * 4, name='3_1', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) layer3_2 = create_convolution_block( input_layer=layer3_1, kernel=(3, 3, 3), n_filters=base_fiters * 4, name='3_2', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) print(layer3_2._keras_shape) pool3 = MaxPooling3D(pool_size=(2, 2, 2), name='pool3')(layer3_2) print('pool3:', pool3._keras_shape) layer4_1 = create_convolution_block( input_layer=pool3, kernel=(3, 3, 3), n_filters=base_fiters * 8, name='4_1', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) layer4_2 = create_convolution_block( input_layer=layer4_1, kernel=(3, 3, 3), n_filters=base_fiters * 8, name='4_2', padding='same', batch_normalization=batch_normalization, instance_normalization=instance_normalization, activation=LeakyReLU) print(layer4_2._keras_shape) ############# layer7 = GlobalMaxPooling3D(data_format="channels_first", name='Gpool')(layer4_2) print(layer7._keras_shape) layer7 = Dropout(rate=0.3, name='dropout1')(layer7) layer8 = Dense(1, activation='sigmoid', name='dense1')(layer7) print(layer8._keras_shape) model = Model(inputs=inputs, outputs=layer8) if opt == 'Adam': model.compile(optimizer=Adam(lr=initial_learning_rate), loss="binary_crossentropy", metrics=['accuracy']) elif opt == 'SGD': model.compile(optimizer=SGD(lr=initial_learning_rate), loss=[focal_loss(alpha=.25, gamma=2)], metrics=['accuracy']) return model
def YOPO_feature(image_size): kernel_initializer = keras.initializers.orthogonal() bias_initializer = keras.initializers.zeros() input_shape = (image_size, image_size, image_size, 1) main_input = Input(shape= input_shape, name='input_1') x = GaussianDropout(0.5)(main_input) x = Conv3D(64, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m1 = GlobalMaxPooling3D()(x) x = Conv3D(80, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m2 = GlobalMaxPooling3D()(x) x = Conv3D(96, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m3 = GlobalMaxPooling3D()(x) x = Conv3D(112, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m4 = GlobalMaxPooling3D()(x) x = Conv3D(128, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m5 = GlobalMaxPooling3D()(x) x = Conv3D(144, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m6 = GlobalMaxPooling3D()(x) x = Conv3D(160, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m7 = GlobalMaxPooling3D()(x) x = Conv3D(176, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m8 = GlobalMaxPooling3D()(x) x = Conv3D(192, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m9 = GlobalMaxPooling3D()(x) x = Conv3D(208, (3, 3, 3), dilation_rate=(1, 1, 1), padding='valid', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(x) x = ELU()(x) x = BatchNormalization()(x) m10 = GlobalMaxPooling3D()(x) m = Concatenate()([m1,m2,m3,m4,m5,m6,m7,m8,m9,m10]) m = BatchNormalization()(m) out = Dense(1024, name='fc2', kernel_initializer=kernel_initializer, bias_initializer=bias_initializer)(m) mod = keras.models.Model(input=main_input, output=out) return mod
def protein_network(t): t = Conv3D_layer(filters=16, kernel_size=4)(t) t = Conv3D_layer(filters=32, kernel_size=6)(t) t = GlobalMaxPooling3D(data_format='channels_last')(t) return t
def _create_se_resnet(num_outputs, img_input, include_top, initial_conv_filters, filters, depth, width, bottleneck, weight_decay, pooling, activation="softmax", padding="same"): """Creates a SE ResNet model with specified parameters Args: initial_conv_filters: number of features for the initial convolution include_top: Flag to include the last fc layer filters: number of filters per block, defined as a list. filters = [64, 128, 256, 512 depth: number or layers in the each block, defined as a list. ResNet-50 = [3, 4, 6, 3] ResNet-101 = [3, 6, 23, 3] ResNet-152 = [3, 8, 36, 3] width: width multiplier for network (for Wide ResNet) bottleneck: adds a bottleneck conv to reduce computation weight_decay: weight_decay (l2 norm) pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` means that the output of the model will be the 4D tensor output of the last convolutional layer. - `avg` means that global average pooling will be applied to the output of the last convolutional layer, and thus the output of the model will be a 3D tensor. - `max` means that global max pooling will be applied. Returns: a Keras Model """ channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 N = list(depth) # block 1 (initial conv block) x = Conv3D(initial_conv_filters, (7, 7, 7), padding=padding, use_bias=False, strides=(2, 2, 2), kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay))(img_input) x = MaxPooling3D((3, 3, 3), strides=(2, 2, 2), padding=padding)(x) # block 2 (projection block) for i in range(N[0]): if bottleneck: x = _resnet_bottleneck_block(x, filters[0], width) else: x = _resnet_block(x, filters[0], width) # block 3 - N for k in range(1, len(N)): if bottleneck: x = _resnet_bottleneck_block(x, filters[k], width, strides=(2, 2, 2)) else: x = _resnet_block(x, filters[k], width, strides=(2, 2, 2)) for i in range(N[k] - 1): if bottleneck: x = _resnet_bottleneck_block(x, filters[k], width) else: x = _resnet_block(x, filters[k], width) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) if include_top: x = GlobalAveragePooling3D()(x) x = Dense(num_outputs, use_bias=False, kernel_regularizer=l2(weight_decay), activation=activation)(x) else: if pooling == 'avg': x = GlobalAveragePooling3D()(x) elif pooling == 'max': x = GlobalMaxPooling3D()(x) return x
def c3d(x): x = Conv3D(64, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(648, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = Conv3D(128, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) _x = Conv3D(128, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) a = Conv3D(256, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(_x) a = BatchNormalization(axis=channel_axis)(a) a = Activation('relu')(a) a = GlobalMaxPooling3D(data_format='channels_last')(a) # first auxiliary network out1 = Dense(7, activation='softmax')(a) x = Conv3D(256, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(_x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(512, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) __x = Conv3D(512, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) c = Conv3D(512, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(__x) c = BatchNormalization(axis=channel_axis)(c) c = Activation('relu')(c) c = GlobalMaxPooling3D(data_format='channels_last')(c) # second auxiliary network out2 = Dense(7, activation='softmax')(c) x = Conv3D(512, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(__x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(512, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) ___x = Conv3D(512, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) b = Conv3D(1024, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(___x) b = BatchNormalization(axis=channel_axis)(b) b = Activation('relu')(b) b = Conv3D(1024, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(b) b = BatchNormalization(axis=channel_axis)(b) b = Activation('relu')(b) b = GlobalMaxPooling3D(data_format='channels_last')(b) out3 = Dense(7, activation='softmax')(b) return out1, out2, out3
def __create_dense_net(nb_classes, img_input, include_top, depth=40, nb_dense_block=3, growth_rate=12, nb_filter=-1, nb_layers_per_block=-1, bottleneck=False, reduction=0.0, dropout_rate=None, weight_decay=1e-4, subsample_initial_block=False, pooling=None, activation='softmax', transition_pooling='avg'): ''' Build the DenseNet model # Arguments nb_classes: number of classes img_input: tuple of shape (channels, rows, columns) or (rows, columns, channels) include_top: flag to include the final Dense layer depth: number or layers nb_dense_block: number of dense blocks to add to end (generally = 3) growth_rate: number of filters to add per dense block nb_filter: initial number of filters. Default -1 indicates initial number of filters is 2 * growth_rate nb_layers_per_block: number of layers in each dense block. Can be a -1, positive integer or a list. If -1, calculates nb_layer_per_block from the depth of the network. If positive integer, a set number of layers per dense block. If list, nb_layer is used as provided. Note that list size must be (nb_dense_block + 1) bottleneck: add bottleneck blocks reduction: reduction factor of transition blocks. Note : reduction value is inverted to compute compression dropout_rate: dropout rate weight_decay: weight decay rate subsample_initial_block: Changes model type to suit different datasets. Should be set to True for ImageNet, and False for CIFAR datasets. When set to True, the initial convolution will be strided and adds a MaxPooling3D before the initial dense block. pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` means that the output of the model will be the 4D tensor output of the last convolutional layer. - `avg` means that global average pooling will be applied to the output of the last convolutional layer, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. activation: Type of activation at the top layer. Can be one of 'softmax' or 'sigmoid'. Note that if sigmoid is used, classes must be 1. transition_pooling: `avg` for avg pooling (default), `max` for max pooling, None for no pooling during scale transition blocks. Please note that this default differs from the DenseNetFCN paper in accordance with the DenseNet paper. # Returns a keras tensor # Raises ValueError: in case of invalid argument for `reduction` or `nb_dense_block` ''' with K.name_scope('DenseNet'): concat_axis = 1 if K.image_data_format() == 'channels_first' else -1 if reduction != 0.0: if not (reduction <= 1.0 and reduction > 0.0): raise ValueError('`reduction` value must lie between 0.0 and 1.0') # layers in each dense block if type(nb_layers_per_block) is list or type(nb_layers_per_block) is tuple: nb_layers = list(nb_layers_per_block) # Convert tuple to list if len(nb_layers) != nb_dense_block: raise ValueError('If `nb_dense_block` is a list, its length must match ' 'the number of layers provided by `nb_layers`.') final_nb_layer = nb_layers[-1] nb_layers = nb_layers[:-1] else: if nb_layers_per_block == -1: assert (depth - 4) % 3 == 0, ('Depth must be 3 N + 4 ' 'if nb_layers_per_block == -1') count = int((depth - 4) / 3) if bottleneck: count = count // 2 nb_layers = [count for _ in range(nb_dense_block)] final_nb_layer = count else: final_nb_layer = nb_layers_per_block nb_layers = [nb_layers_per_block] * nb_dense_block # compute initial nb_filter if -1, else accept users initial nb_filter if nb_filter <= 0: nb_filter = 2 * growth_rate # compute compression factor compression = 1.0 - reduction # Initial convolution if subsample_initial_block: initial_kernel = (7, 7, 7) initial_strides = (2, 2, 2) else: initial_kernel = (3, 3, 3) initial_strides = (1, 1, 1) x = Conv3D(nb_filter, initial_kernel, kernel_initializer='he_normal', padding='same', name='initial_Conv3D', strides=initial_strides, use_bias=False, kernel_regularizer=l2(weight_decay))(img_input) if subsample_initial_block: x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5, name='initial_bn')(x) x = Activation('relu')(x) x = MaxPooling3D((3, 3, 3), strides=(2, 2, 2), padding='same')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): x, nb_filter = __dense_block(x, nb_layers[block_idx], nb_filter, growth_rate, bottleneck=bottleneck, dropout_rate=dropout_rate, weight_decay=weight_decay, block_prefix='dense_%i' % block_idx) # add transition_block x = __transition_block(x, nb_filter, compression=compression, weight_decay=weight_decay, block_prefix='tr_%i' % block_idx, transition_pooling=transition_pooling) nb_filter = int(nb_filter * compression) # The last dense_block does not have a transition_block x, nb_filter = __dense_block(x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck, dropout_rate=dropout_rate, weight_decay=weight_decay, block_prefix='dense_%i' % (nb_dense_block - 1)) x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5, name='final_bn')(x) x = Activation('relu')(x) if include_top: if pooling == 'avg': x = GlobalAveragePooling3D()(x) elif pooling == 'max': x = GlobalMaxPooling3D()(x) x = Dense(nb_classes, activation=activation)(x) else: if pooling == 'avg': x = GlobalAveragePooling3D()(x) elif pooling == 'max': x = GlobalMaxPooling3D()(x) return x
def ligand_network(t): t = Conv3D_layer(filters=8, kernel_size=2)(t) t = Conv3D_layer(filters=16, kernel_size=4)(t) t = GlobalMaxPooling3D(data_format='channels_last')(t) return t
def model3d_layers(sz=48, alpha=1.5, do_features=False): layers = [] def conv3dparams(**replace_params): params = { 'activation': ELU(), 'border_mode': 'valid', 'init': 'he_normal' } params.update(replace_params) return params layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") sz = int(sz * alpha) # if vsize == (32,32,32): # layers.append( Convolution3D(sz, 3, 3, 3, subsample=(2,2,2), **conv3dparams()) ) # else: layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") # if vsize == (32,32,32): # layers.append( Convolution3D(sz, 3, 3, 3, **conv3dparams()) ) # else: layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(SpatialDropout3D(0.2)) sz = int(sz * alpha) layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(SpatialDropout3D(0.2)) sz = int(sz * alpha) layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 3, 3, 3, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(SpatialDropout3D(0.5)) sz = int(sz * alpha) layers.append(Convolution3D(sz, 2, 2, 2, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append(Convolution3D(sz, 1, 1, 1, **conv3dparams())) layers.append("BatchNormalization") layers.append( Convolution3D(1, 1, 1, 1, **conv3dparams(activation='linear', border_mode='same'))) layers.append(GlobalMaxPooling3D()) layers.append(Activation('sigmoid')) return layers
name='conv1')(img_input) x = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name='maxpool1', padding="valid")(x) x = firemodule(x, (16, 64, 64), name="fire2") x = firemodule(x, (16, 64, 64), name="fire3") x = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name='maxpool3', padding="valid")(x) x = firemodule(x, (32, 128, 128), name="fire4") x = firemodule(x, (32, 128, 128), name="fire5") x = MaxPooling3D(pool_size=(3, 3, 3), strides=(2, 2, 2), name='maxpool5', padding="valid")(x) x = firemodule(x, (48, 192, 192), name="fire6") x = firemodule(x, (48, 192, 192), name="fire7") x = firemodule(x, (64, 256, 256), name="fire8") x = firemodule(x, (64, 256, 256), name="fire9") x = GlobalMaxPooling3D(name="maxpool10")(x) x = Dense(3, init='normal')(x) x = Activation('softmax')(x) model = Model(img_input, x, name="squeezenet") model.summary()
def InceptionResNetV2(input_shape=None, classes=3): _inputs = Input(shape=input_shape) x = stem_block(_inputs) # Mixed 5b (Inception-A block): 17x21x14x320 branch_0 = conv3d_bn(x, 96, 1) branch_1 = conv3d_bn(x, 48, 1) branch_1 = conv3d_bn(branch_1, 64, 5) branch_2 = conv3d_bn(x, 64, 1) branch_2 = conv3d_bn(branch_2, 96, 3) branch_2 = conv3d_bn(branch_2, 96, 3) branch_pool = AveragePooling3D(3, strides=1, padding='same')(x) branch_pool = conv3d_bn(branch_pool, 64, 1) branches = [branch_0, branch_1, branch_2, branch_pool] x = Concatenate(name='mixed_5b')(branches) # 10x block35 (Inception-ResNet-A block): 17x21x14x320 for block_idx in range(1, 11): x = inception_resnet_block(x, scale=0.17, block_type='block35', block_idx=block_idx) branch_0 = conv3d_bn(x, 384, 3, strides=2, padding='valid') branch_1 = conv3d_bn(x, 256, 1) branch_1 = conv3d_bn(branch_1, 256, 3) branch_1 = conv3d_bn(branch_1, 384, 3, strides=2, padding='valid') branch_pool = MaxPooling3D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_pool] x = Concatenate(name='mixed_6a')(branches) # 20x block17 (Inception-ResNet-B block): 7 x 9 x 5 x 1088 for block_idx in range(1, 21): x = inception_resnet_block(x, scale=0.1, block_type='block17', block_idx=block_idx) # Mixed 6a (Reduction-A block): 7 x 9 x 5 x 1088 x = Concatenate(name='mixed_6a')(branches) # 10x block8 (Inception-ResNet-C block): 7 x 9 x 5 x 1088 for block_idx in range(1, 10): x = inception_resnet_block(x, scale=0.2, block_type='block8', block_idx=block_idx) x = inception_resnet_block(x, scale=1., activation=None, block_type='block8', block_idx=10) # Final convolution block: 7 x 9 x 5 x 1536 x = conv3d_bn(x, 1800, 1, name='conv_7b') x = GlobalMaxPooling3D()(x) # x = Flatten()(x) # Create model model = Model(_inputs, x, name='inception_resnet_v2_3d') return model
def dual_path_net(initial_conv_filters, filter_increment, depth, cardinality, width, pooling='max-avg', bias_flag=False): ''' Args: initial_conv_filters: number of features for the initial convolution 初始化输出的张量通道数 include_top: Flag to include the last dense layer initial_conv_filters: number of features for the initial convolution filter_increment: number of filters incremented per block, defined as a list. DPN-92 = [16, 32, 24, 128] DON-98 = [16, 32, 32, 128] DPN-131 = [16, 32, 32, 128] DPN-107 = [20, 64, 64, 128] depth: number or layers in the each block, defined as a list. DPN-92 = [3, 4, 20, 3] DPN-98 = [3, 6, 20, 3] DPN-131 = [4, 8, 28, 3] DPN-107 = [4, 8, 20, 3] width: width multiplier for network 分组卷积每组的卷积核数量,所以也就是直接指定每组包括多少卷积核和组数即可,不过确实有点绕,因为这样做则要求dpn block函数中的参数pointwise_filters_a和grouped_conv_filters_b相同 pooling: Optional pooling mode for feature extraction - `avg` means that global average pooling will be applied to the output of the last convolutional layer, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. - `max-avg` means that both global average and global max pooling will be applied to the output of the last convolution layer Returns: a Keras Model ''' channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 # N = list(depth) # base_filters = 256 # # input set img_input = Input(shape=(280, 280, 16, 1)) # # block 1 (initial conv block) x = _initial_conv_block_inception(img_input, initial_conv_filters, bias_flag=bias_flag) # print('BLOCK 1 init shape :', x.shape) # # block 2 (projection block) filter_inc = filter_increment[0] # # filter_increment: number of filters incremented per block, defined as a list. # DPN-92 = [16, 32, 24, 128] filters = int(cardinality * width) # x = _dual_path_block(x, pointwise_filters_a=filters, grouped_conv_filters_b=filters, pointwise_filters_c=base_filters, filter_increment=filter_inc, cardinality=cardinality, block_type='projection', bias_flag=bias_flag) # for i in range(N[0] - 1): x = _dual_path_block(x, pointwise_filters_a=filters, grouped_conv_filters_b=filters, pointwise_filters_c=base_filters, filter_increment=filter_inc, cardinality=cardinality, block_type='normal', bias_flag=bias_flag) # print("BLOCK 1 out shape : res_path:", x[0].shape, " vs. dense_path", x[1].shape) # # remaining blocks for k in range(1, len(N)): filter_inc = filter_increment[k] # filters *= 2 # 进入到下一个大的Block(注意不是dpn block),filters(等于分组卷积的通道数)也要翻倍 base_filters *= 2 # 这个参数相当于把densepath的通道数改变一下,有点过度模块的意思,因此这个参数要不断增加,因为原始dense net的过度模块也是随着网络深入而逐渐卷积核变多的 x = _dual_path_block(x, pointwise_filters_a=filters, grouped_conv_filters_b=filters, pointwise_filters_c=base_filters, filter_increment=filter_inc, cardinality=cardinality, block_type='downsample', bias_flag=bias_flag) # print("BLOCK", (k + 1), "d_sample shape : res_path:", x[0].shape, " vs. dense_path", x[1].shape) # for i in range(N[k] - 1): x = _dual_path_block(x, pointwise_filters_a=filters, grouped_conv_filters_b=filters, pointwise_filters_c=base_filters, filter_increment=filter_inc, cardinality=cardinality, block_type='normal', bias_flag=bias_flag) # print("BLOCK", (k + 1), "out shape : res_path:", x[0].shape, " vs. dense_path", x[1].shape) # x = concatenate(x, axis=channel_axis) # print("CONCAT out shape : ", x.shape) if pooling == 'avg': x = GlobalAveragePooling3D(data_format='channels_last')(x) elif pooling == 'max': x = GlobalMaxPooling3D(data_format='channels_last')(x) elif pooling == 'max-avg': a = GlobalMaxPooling3D(data_format='channels_last')(x) b = GlobalAveragePooling3D(data_format='channels_last')(x) x = add([a, b]) x = Lambda(lambda z: 0.5 * z)(x) print("GApooling shape:", x.shape) out_drop = Dropout(rate=0.3)(x) out = Dense(1, name='fc1', use_bias=bias_flag)(out_drop) print("out shape:", out.shape) output = Activation(activation='sigmoid')(out) model = Model(input=img_input, output=output) return model
def c3da_ae(x): # encoder x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(32, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = Conv3D(64, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(64, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = Conv3D(128, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(128, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x_1 = Conv3D(128, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = Conv3D(256, (3, 3, 3), strides=(2, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x_1) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(256, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = Conv3D(256, (3, 3, 3), strides=(2, 2, 2), padding='same', kernel_initializer='he_normal', data_format='channels_last')(x) # decoder-1 y = UpSampling3D(size=(2, 2, 2), data_format='channels_last')(x_1) y = Conv3D(128, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(y) y = BatchNormalization(axis=channel_axis)(y) y = Activation('relu')(y) y = Conv3D(64, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(y) y = BatchNormalization(axis=channel_axis)(y) y = Activation('relu')(y) y = UpSampling3D(size=(2, 2, 2), data_format='channels_last')(y) y = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(y) y = BatchNormalization(axis=channel_axis)(y) y = Activation('relu')(y) y = UpSampling3D(size=(2, 2, 2), data_format='channels_last')(y) y = Conv3D(1, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer='he_normal', data_format='channels_last')(y) y = BatchNormalization(axis=channel_axis)(y) out1 = Activation('sigmoid')(y) # decoder-2 out2 = GlobalMaxPooling3D(data_format='channels_last')(x) out2 = Dense(7, activation='softmax')(out2) return out1, out2