def getResnetModel(d): n = d.num_blocks sf = d.start_filter dataset = d.dataset activation = d.act advanced_act = d.aact drop_prob = d.dropout if "mnist" in dataset: inputShape = (1, 28, 28) if K.image_dim_ordering() == "th" else (28, 28, 1) else: inputShape = (3, 32, 32) if K.image_dim_ordering() == "th" else (32, 32, 3) channelAxis = 1 if K.image_data_format() == 'channels_first' else -1 filsize = (3, 3) convArgs = { "padding": "same", "use_bias": False, "kernel_regularizer": l2(0.0001), } bnArgs = {"axis": channelAxis, "momentum": 0.9, "epsilon": 1e-04} import copy convArgs_real = copy.deepcopy(convArgs) # if d.model == "real": if "real" in d.model: sf *= 2 convArgs.update({"kernel_initializer": Orthogonal(float(np.sqrt(2)))}) convArgs_real = convArgs # elif d.model == "complex": elif "complex" in d.model: convArgs.update({ "spectral_parametrization": d.spectral_param, "kernel_initializer": d.comp_init }) # # Input Layer # I = Input(shape=inputShape) # # Stage 1 # O = learnConcatRealImagBlock(I, (1, 1), (3, 3), 0, '0', convArgs, bnArgs, d) O = Concatenate(channelAxis)([I, O]) if d.model == "real": O = Conv2D(sf, filsize, name='conv1', **convArgs)(O) O = BatchNormalization(name="bn_conv1_2a", **bnArgs)(O) elif d.model == "real_dws": O = SeparableConv2D(sf, filsize, name='conv1', **convArgs)(O) O = BatchNormalization(name="bn_conv1_2a", **bnArgs)(O) elif (d.model == "real_group") or (d.model == "real_group_pwc_full") or ( d.model == "real_group_pwc_group"): O_g0 = Lambda(lambda O: O[:, :(O.shape[1] // 2), :, :])(O) O_g1 = Lambda(lambda O: O[:, (O.shape[1] // 2):, :, :])(O) O_g0 = Conv2D(sf // 2, filsize, name='conv1_g0', **convArgs)(O_g0) O_g1 = Conv2D(sf // 2, filsize, name='conv1_g1', **convArgs)(O_g1) O_g00 = Lambda(lambda O_g0: O_g0[:, :(O_g0.shape[1] // 2), :, :])(O_g0) O_g01 = Lambda(lambda O_g0: O_g0[:, (O_g0.shape[1] // 2):, :, :])(O_g0) O_g10 = Lambda(lambda O_g1: O_g1[:, :(O_g1.shape[1] // 2), :, :])(O_g1) O_g11 = Lambda(lambda O_g1: O_g1[:, (O_g1.shape[1] // 2):, :, :])(O_g1) O = Concatenate(axis=1)([O_g00, O_g11, O_g01, O_g10]) if d.model == "real_group_pwc_full": O = Conv2D(sf, (1, 1), name='conv1_pwc', **convArgs)(O) elif d.model == "real_group_pwc_group": O_g0 = Lambda(lambda O: O[:, :(O.shape[1] // 2), :, :])(O) O_g1 = Lambda(lambda O: O[:, (O.shape[1] // 2):, :, :])(O) O_g0 = Conv2D(int(O.shape[1] // 2), (1, 1), name='conv1_pwc_g0', **convArgs_real)(O_g0) O_g1 = Conv2D(int(O.shape[1] // 2), (1, 1), name='conv1_pwc_g1', **convArgs_real)(O_g1) O = Concatenate(axis=1)([O_g0, O_g1]) O = BatchNormalization(name="bn_conv1_2a", **bnArgs)(O) elif d.model == "complex": O = ComplexConv2D(sf, filsize, name='conv1', **convArgs)(O) O = ComplexBN(name="bn_conv1_2a", **bnArgs)(O) elif (d.model == "complex_concat") or (d.model == "complex_concat_pwc_group"): O = ComplexConvConcat2D(sf // 2, filsize, name='conv1', **convArgs)(O) O = ComplexBN(name="bn_conv1_2a", **bnArgs)(O) if d.model == "complex_concat_pwc_group": O_g0 = Lambda(lambda O: O[:, :(O.shape[1] // 2), :, :])(O) O_g1 = Lambda(lambda O: O[:, (O.shape[1] // 2):, :, :])(O) O_g0 = Conv2D(int(O.shape[1] // 2), (1, 1), name='conv1_pwc_g0', **convArgs_real)(O_g0) O_g1 = Conv2D(int(O.shape[1] // 2), (1, 1), name='conv1_pwc_g1', **convArgs_real)(O_g1) O = Concatenate(axis=1)([O_g0, O_g1]) else: print("Error: unknown model type") exit(-1) if d.aact == "complex_joint_relu": O = Lambda(ComplexJointReLU)(O) else: O = Activation(activation)(O) # # Stage 2 # for i in xrange(n): O = getResidualBlock(O, filsize, [sf, sf], 2, str(i), 'regular', convArgs, convArgs_real, bnArgs, d) if i == n // 2 and d.spectral_pool_scheme == "stagemiddle": O = applySpectralPooling(O, d) # # Stage 3 # O = getResidualBlock(O, filsize, [sf, sf], 3, '0', 'projection', convArgs, convArgs_real, bnArgs, d) if d.spectral_pool_scheme == "nodownsample": O = applySpectralPooling(O, d) for i in xrange(n - 1): O = getResidualBlock(O, filsize, [sf * 2, sf * 2], 3, str(i + 1), 'regular', convArgs, convArgs_real, bnArgs, d) if i == n // 2 and d.spectral_pool_scheme == "stagemiddle": O = applySpectralPooling(O, d) # # Stage 4 # O = getResidualBlock(O, filsize, [sf * 2, sf * 2], 4, '0', 'projection', convArgs, convArgs_real, bnArgs, d) if d.spectral_pool_scheme == "nodownsample": O = applySpectralPooling(O, d) for i in xrange(n - 1): O = getResidualBlock(O, filsize, [sf * 4, sf * 4], 4, str(i + 1), 'regular', convArgs, convArgs_real, bnArgs, d) if i == n // 2 and d.spectral_pool_scheme == "stagemiddle": O = applySpectralPooling(O, d) # # Pooling # if d.spectral_pool_scheme == "nodownsample": O = applySpectralPooling(O, d) if "mnist" in dataset: O = AveragePooling2D(pool_size=(28, 28))(O) else: O = AveragePooling2D(pool_size=(32, 32))(O) else: if "mnist" in dataset: O = AveragePooling2D(pool_size=(7, 7))(O) else: O = AveragePooling2D(pool_size=(8, 8))(O) # # Flatten # O = Flatten()(O) # # Dense # if dataset == 'cifar10': O = Dense(10, activation='softmax', kernel_regularizer=l2(0.0001))(O) elif dataset == 'cifar100': O = Dense(100, activation='softmax', kernel_regularizer=l2(0.0001))(O) elif dataset == 'svhn': O = Dense(10, activation='softmax', kernel_regularizer=l2(0.0001))(O) elif dataset == 'mnist': O = Dense(10, activation='softmax', kernel_regularizer=l2(0.0001))(O) elif dataset == 'fashion_mnist': O = Dense(10, activation='softmax', kernel_regularizer=l2(0.0001))(O) else: raise ValueError("Unknown dataset " + d.dataset) # Return the model return Model(I, O)
padding="same", activation='linear', name='conv2d_8', kernel_regularizer=regularizers.l2(0.0005))) model.add(BatchNormalization(name='batch_normalization_8')) model.add(LeakyReLU(alpha=0.01, name='leaky_re_lu_8')) """256 Layers""" model.add(MaxPooling2D(pool_size=3, strides=(2, 2), name='max_pooling2d_3')) #model.add(Dropout(0.25)) model.add( Conv2D(256, (3, 3), padding="same", activation='linear', kernel_initializer=Orthogonal(gain=1.0), name='conv2d_9', bias_initializer=Constant(value=0.05), kernel_regularizer=regularizers.l2(0.0005))) model.add(BatchNormalization(name='batch_normalization_11')) model.add(LeakyReLU(alpha=0.01, name='leaky_re_lu_12')) model.add( Conv2D(256, (3, 3), padding="same", activation='linear', kernel_initializer=Orthogonal(gain=1.0), name='conv2d_10', bias_initializer=Constant(value=0.05), kernel_regularizer=regularizers.l2(0.0005))) model.add(BatchNormalization(name='batch_normalization_12'))
AUGMENTATIONS = strong_aug(p=0.9) seed_everything() model = Sequential() #,padding="same" , strides=(2, 2) model.add(Conv2D(32, (5, 5),padding="same",strides=(2, 2), activation='linear', input_shape=(128, 128, 3), data_format="channels_last", kernel_initializer=Orthogonal(gain=1.0), bias_initializer=Constant(value=0.05),kernel_regularizer=regularizers.l2(0.0005))) model.add(BatchNormalization()) model.add(LeakyReLU(alpha=0.01)) model.add(Conv2D(32, (3, 3),padding="same", activation='linear', kernel_initializer=Orthogonal(gain=1.0), bias_initializer=Constant(value=0.05),kernel_regularizer=regularizers.l2(0.0005))) model.add(BatchNormalization()) model.add(LeakyReLU(alpha=0.01)) model.add(FractionalPooling2D(pooling_ratio=(1, 1.8, 1.8, 1),pseudo_random = True,overlap=True)) model.add(Conv2D(64, (5, 5),padding="same", strides=(2, 2), activation='linear', kernel_initializer=Orthogonal(gain=1.0), bias_initializer=Constant(value=0.05),kernel_regularizer=regularizers.l2(0.0005)))
def get_ohm_net(dim, conv_depth, hourglass_depth, num_output_classes=cg.num_classes, input_channels=1, train=True): ## ## Inputs ## gt_matrix = [] gt_matrix += [Input((2, ), name='mat_translation')] gt_matrix += [Input((1, ), name='mat_rotation')] gt_matrix += [Input((1, ), name='mat_scaling')] model_inputs = [] model_inputs += [Input((dim, dim, input_channels), name='image')] model_inputs += [Input((dim, dim, input_channels), name='image_cp')] model_inputs += gt_matrix train_outputs = [] predict_outputs = [] # image translation loss input_true_translated = STN(downsample_factor=1.0, transform_type='translation', name='true_inp_xy')([ model_inputs[1], gt_matrix[0], gt_matrix[0], gt_matrix[0] ]) # image rotation loss input_true_rotated = STN(downsample_factor=1.0, transform_type='rotation', name='true_inp_rt')([ model_inputs[1], gt_matrix[0], gt_matrix[1], gt_matrix[1] ]) # image sclaing loss input_true_scaled = STN(downsample_factor=cg.downsampling_factor, transform_type='uniform_scale', name='true_inp_zm')([ model_inputs[1], gt_matrix[0], gt_matrix[1], gt_matrix[2] ]) ## ## First UNet ## unet1_pool5, _, unet1_seg_pred = get_unet(dim, num_output_classes, conv_depth[0], 1)(model_inputs[0]) train_outputs += [unet1_seg_pred] predict_outputs += [unet1_seg_pred] ## ## STN ## pool5_flat = Flatten()(unet1_pool5) # Loc Networks. pool5_dense1 = Dense(384, kernel_initializer=Orthogonal(gain=1.0), kernel_regularizer=l2(weight_decay), activation='relu', name='loc')(pool5_flat) # translation matrix loss stn_translation = Dense(3, kernel_initializer=Orthogonal(gain=1e-1), kernel_regularizer=l2(weight_decay), name='mat_xy')(pool5_dense1) # rotation matrix loss stn_rotation = Dense(1, kernel_initializer=Orthogonal(gain=1e-1), kernel_regularizer=l2(weight_decay), name='mat_rt')(pool5_dense1) rotation_loss = dvpy.tf.wrapped_phase_difference_loss # scaling matrix loss stn_scaling = Dense(1, kernel_initializer=Orthogonal(gain=1e-1), bias_initializer=my_init, kernel_regularizer=l2(weight_decay), name='mat_zm')(pool5_dense1) train_outputs += [stn_translation] train_outputs += [stn_rotation] train_outputs += [stn_scaling] predict_outputs += [stn_translation] predict_outputs += [stn_rotation] predict_outputs += [stn_scaling] # image translation loss input_pred_translated = STN(downsample_factor=1.0, transform_type='translation', name='pred_inp_xy')([ model_inputs[1], stn_translation, stn_translation, stn_translation ]) # image rotation loss input_pred_rotated = STN(downsample_factor=1.0, transform_type='rotation', name='pred_inp_rt')([ model_inputs[1], stn_translation, stn_rotation, stn_rotation ]) # image sclaing loss input_pred_scaled = STN(downsample_factor=cg.downsampling_factor, transform_type='uniform_scale', name='pred_inp_zm')([ model_inputs[1], stn_translation, stn_rotation, stn_scaling ]) predict_outputs += [input_pred_scaled] current_input = input_pred_scaled if hourglass_depth > 0: model_inputs += [ Input((dim, dim, num_output_classes), name='output_mask') ] # image sclaing loss mask_scaled = STN(downsample_factor=cg.downsampling_factor, transform_type='uniform_scale', name='pred_mask_zm')([ model_inputs[-1], stn_translation, stn_rotation, stn_scaling ]) predict_outputs += [mask_scaled] ## ## Define Ground Truth for All Subsequent UNets ## for i in range(2, hourglass_depth + 2): _, current_input, seg_pred = get_unet( dim // cg.downsampling_factor, num_output_classes, conv_depth[i - 1], i)(current_input) predict_outputs += [seg_pred] train_outputs += [ Categorical_Crossentropy_Layer(name='seg%d_zm' % (i))([mask_scaled, seg_pred]) ] train_outputs += [ Categorical_Crossentropy_Acc_Layer(name='seg%d_zm_acc' % (i))( [mask_scaled, seg_pred]) ] ## ## Compile Model ## if train == True: train_outputs += [ Mean_Square_Error_Layer(name='translation_mse')( [input_true_translated, input_pred_translated]) ] train_outputs += [ Mean_Square_Error_Layer(name='rotation_mse')( [input_true_rotated, input_pred_rotated]) ] train_outputs += [ Mean_Square_Error_Layer(name='scaling_mse')( [input_true_scaled, input_pred_scaled]) ] model = Model(inputs=model_inputs, outputs=train_outputs) opt = Adam(lr=1e-3) dummy_losses = { 'seg%d_zm' % (i): dummy_loss for i in range(2, hourglass_depth + 2) } dummy_acc = { 'seg%d_zm_acc' % (i): dummy_loss for i in range(2, hourglass_depth + 2) } dummy_zooms = { 'seg%d_zm' % (i): 1.0 for i in range(2, hourglass_depth + 2) } losses = { 'img_sg1': 'categorical_crossentropy', 'mat_xy': 'mse', 'mat_zm': 'mse', 'mat_rt': rotation_loss, 'translation_mse': dummy_loss, 'rotation_mse': dummy_loss, 'scaling_mse': dummy_loss, } losses.update(dummy_losses) #??? losses.update(dummy_acc) losses_weights = { 'img_sg1': 100.0, 'mat_xy': 100.0, 'mat_rt': 50.0, 'mat_zm': 100.0, 'translation_mse': 0.1, 'rotation_mse': 0.1, 'scaling_mse': 0.1, } losses_weights.update(dummy_zooms) model.compile(optimizer=opt, loss=losses, metrics={'img_sg1': 'acc'}, loss_weights=losses_weights) else: predict_outputs += gt_matrix predict_outputs += [input_true_scaled] model = Model(inputs=model_inputs, outputs=predict_outputs) return model
def _get_model(input_dim, output_dim, one_hot, filters=32, max_filters=128, subtract_embeddings=False, dropout=False, learn_rate=0.001, optimizer="rmsprop", kernel_size=3, lr_decay=0): if optimizer == "rmsprop": optimizer = RMSprop(lr=learn_rate, decay=lr_decay) elif optimizer == "adam": optimizer = Adam(lr=learn_rate, decay=lr_decay) elif optimizer == "sgd": optimizer = SGD(lr=learn_rate, momentum=0.9, decay=lr_decay) else: raise ValueError("Invalid argument optimizer") initializer = Orthogonal(np.sqrt(2)) model = Sequential() dropout = dropout if isinstance(dropout, float) else (0.5 if dropout else 0) if not subtract_embeddings: # Reshape to 2D, do 2D conv and reshape to 1D model.add( Reshape(input_shape=(input_dim, ), target_shape=(2, input_dim // 2, 1))) model.add( Conv2D(filters=filters, kernel_size=[2, 7], strides=[1, 2], padding="VALID", activation="relu", kernel_initializer=initializer)) model.add(BatchNormalization()) else: # Reshape to add single channel model.add( Reshape(input_shape=(input_dim, ), target_shape=(input_dim, 1))) model.add( Conv1D(filters=filters, kernel_size=7, strides=2, padding="VALID", activation="relu", kernel_initializer=initializer)) model.add(BatchNormalization()) model.add(Reshape((-1, filters))) if dropout: model.add(Dropout(dropout)) # Half conv with kernel size 3 until not greater than 3 while model.layers[-1].output_shape[1] > 3: filters = min(filters * 2, max_filters) model.add( Conv1D(filters=filters, kernel_size=kernel_size, strides=2, padding="SAME", activation="relu", kernel_initializer=initializer)) model.add(BatchNormalization()) if dropout: model.add(Dropout(dropout)) # Conv valid so output is 1 if necessary if model.layers[-1].output_shape[1] != 1: filters = min(filters * 2, max_filters) model.add( Conv1D(filters=filters, kernel_size=(model.layers[-1].output_shape[1], ), padding="VALID", activation="relu", kernel_initializer=initializer)) model.add(BatchNormalization()) if dropout: model.add(Dropout(dropout)) # Dense sigmoid output model.add(Flatten()) #model.add(Dropout(0.5)) model.add( Dense(output_dim, activation="softmax" if one_hot else "sigmoid", kernel_initializer="orthogonal")) print(model.summary()) all_metrics = [ "categorical_accuracy" if one_hot else "binary_accuracy" ] for class_id in range(output_dim): all_metrics += make_metrics(class_id, one_hot) model.compile(optimizer=optimizer, loss="categorical_crossentropy" if one_hot else "binary_crossentropy", metrics=all_metrics) return model
from data import _seed import numpy as np np.random.seed(_seed) import sys from keras.layers import Dense, merge, Dropout, RepeatVector, Embedding from keras.layers import recurrent, Input, Activation from keras.models import Model from keras.initializers import RandomNormal, Orthogonal from experiment import evaluate_model, handlesysargs from model import model as modelwrapper print("MTL model sharing everything but output, based on gru") INITIALIZER = RandomNormal(mean=0.0, stddev=0.05, seed=_seed) RINITIALIZER = Orthogonal(gain=1.0, seed=_seed) RNN = recurrent.GRU EMBED_HIDDEN_SIZE = 30 #50 SENT_HIDDEN_SIZE = 100 QUERY_HIDDEN_SIZE = 100 def compile_model(inputs, repeat): (vocab_size, story_maxlen, query_maxlen) = inputs[0] #(vocab_size2, story_maxlen2, query_maxlen2) = inputs[1] #mvocab_size = vocab_size1 #if (vocab_size2 > mvocab_size): # mvocab_size = vocab_size2 ensinput = Input((story_maxlen, )) sentemb = Embedding(vocab_size, EMBED_HIDDEN_SIZE,
def __init__(self, eps_std=0.05, seed=None): self.eps_std = eps_std self.seed = seed self.orthogonal = Orthogonal()
def generator_network(self, filters, name): def resblock(feature_in, filters, num): #init = RandomNormal(stddev=0.02) init = Orthogonal(gain=1) temp = ConvSN2D(filters, (3, 3), strides=1, padding='SAME', name=('resblock_%d_CONV_1' % num), kernel_initializer=init)(feature_in) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) temp = ConvSN2D(filters, (3, 3), strides=1, padding='SAME', name=('resblock_%d_CONV_2' % num), kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) return Add()([temp, feature_in]) #init = RandomNormal(stddev=0.02) init = Orthogonal(gain=1) image = Input(self.img_shape) y = Lambda(lambda x: 2.0 * x - 1.0, output_shape=lambda x: x)(image) b1_in = ConvSN2D(filters, (9, 9), strides=1, padding='SAME', name='CONV_1', activation='relu', kernel_initializer=init)(y) b1_in = LeakyReLU(alpha=0.2)(b1_in) # residual blocks b1_out = resblock(b1_in, filters, 1) b2_out = resblock(b1_out, filters, 2) b3_out = resblock(b2_out, filters, 3) b4_out = resblock(b3_out, filters, 4) # conv. layers after residual blocks temp = ConvSN2D(filters, (3, 3), strides=1, padding='SAME', name='CONV_2', kernel_initializer=init)(b4_out) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) temp = ConvSN2D(filters, (3, 3), strides=1, padding='SAME', name='CONV_3', kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) temp = ConvSN2D(filters, (3, 3), strides=1, padding='SAME', name='CONV_4', kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) temp = Conv2D(3, (9, 9), strides=1, padding='SAME', name='CONV_5', kernel_initializer=init)(temp) temp = Activation('tanh')(temp) temp = Lambda(lambda x: 0.5 * x + 0.5, output_shape=lambda x: x)(temp) return Model(inputs=image, outputs=temp, name=name)
def discriminator_network(self, name, preprocess='gray'): #The main modification from the original approach is the use of the InstanceNormalisation layer #init = RandomNormal(stddev=0.02) init = Orthogonal(gain=1) image = Input(self.img_shape) if preprocess == 'gray': #convert to grayscale image print("Discriminator-texture") #output_shape=(image.shape[0], image.shape[1], 1) gray_layer = Conv2D(1, (1, 1), strides=1, padding="SAME", use_bias=False, name="Gray_layer") image_processed = gray_layer(image) gray_layer.set_weights([self.texture_weights]) gray_layer.trainable = False #image_processed=Lambda(rgb2gray, output_shape = output_gray_shape)(image) #print(image_processed.shape) #image_processed = rgb_to_grayscale(image) elif preprocess == 'blur': print("Discriminator-color (blur)") g_layer = DepthwiseConv2D(self.kernel_size, use_bias=False, padding='same') image_processed = g_layer(image) g_layer.set_weights([self.blur_kernel_weights]) g_layer.trainable = False else: print("Discriminator-color (none)") image_processed = image # conv layer 1 d = Lambda(lambda x: 2.0 * x - 1.0, output_shape=lambda x: x)(image_processed) temp = ConvSN2D(48, (11, 11), strides=4, padding='SAME', name='CONV_1', kernel_initializer=init)(d) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) # conv layer 2 temp = ConvSN2D(128, (5, 5), strides=2, padding='SAME', name='CONV_2', kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) # conv layer 3 temp = ConvSN2D(192, (3, 3), strides=1, padding='SAME', name='CONV_3', kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) # conv layer 4 temp = ConvSN2D(192, (3, 3), strides=1, padding='SAME', name='CONV_4', kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) # conv layer 5 temp = ConvSN2D(128, (3, 3), strides=2, padding='SAME', name='CONV_5', kernel_initializer=init)(temp) #temp = BatchNormalization(axis=-1)(temp) temp = LeakyReLU(alpha=0.2)(temp) # FC layer 1 fc_in = Flatten()(temp) fc_out = Dense(512)(fc_in) fc_out = LeakyReLU(alpha=0.2)(fc_out) # FC layer 2 logits = Dense(1)(fc_out) #prob = Activation('sigmoid')(logits) #probability = sigmoid(logits) return Model(inputs=image, outputs=logits, name=name)
######### base = InceptionV3(weights = "imagenet", include_top = False, input_shape = (299, 299, 3)) ######### x = base.output x = MaxPooling2D()(x) x = Flatten()(x) x = Dropout(rate = 0.5)(x) x = Dense(128, activation = "relu", kernel_initializer = Orthogonal())(x) x = Dropout(rate = 0.5)(x) predictions = Dense(5, activation = "softmax", kernel_initializer = Orthogonal())(x) model = Model(inputs = base.input, outputs = predictions) ######### for layer in model.layers: layer.trainable = True ######### model.compile(optimizer = "SGD", loss = "categorical_crossentropy", metrics = ["accuracy"])
base = InceptionResNetV2(weights="imagenet", include_top=False, input_shape=(299, 299, 3)) ######### x = base.output x = MaxPooling2D()(x) x = Flatten()(x) x = Dropout(rate=0.5)(x) x = Dense(128, activation="relu", kernel_initializer=Orthogonal())(x) x = Dropout(rate=0.5)(x) predictions = Dense(5, activation="softmax", kernel_initializer=Orthogonal())(x) model = Model(inputs=base.input, outputs=predictions) ######### for layer in model.layers: layer.trainable = True #########
def dilated_module(input_layer): conv_size = (3, 3) n_filters = 32 conv1 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(1, 1), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(input_layer) norm1 = BatchNormalization()(conv1) conv2 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(1, 1), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm1) norm2 = BatchNormalization()(conv2) conv3 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(2, 2), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm2) norm3 = BatchNormalization()(conv3) conv4 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(4, 4), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm3) norm4 = BatchNormalization()(conv4) conv5 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(8, 8), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm4) norm5 = BatchNormalization()(conv5) conv6 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(16, 16), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm5) norm6 = BatchNormalization()(conv6) conv7 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(32, 32), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm6) norm7 = BatchNormalization()(conv7) conv8 = Conv2D(n_filters, conv_size, activation='relu', dilation_rate=(1, 1), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm7) norm8 = BatchNormalization()(conv8) conv9 = Conv2D(n_filters, (1, 1), activation='relu', dilation_rate=(1, 1), kernel_initializer=Orthogonal(), bias_initializer=Zeros())(norm8) norm9 = BatchNormalization()(conv9) drop = Dropout(0.5)(norm9) return drop
def get_model(config: dict): """ """ cfg = ED(deepcopy(config)) model = Sequential(name='TI_CNN') vgg_block_cfg = deepcopy(vgg_block_basic) for block_idx, (num_convs, filters) in enumerate( zip(vgg16.num_convs, vgg16.num_filters)): for idx in range(num_convs): if block_idx == idx == 0: model.add( Conv1D( input_shape=(cfg.input_len, 12), filters=filters, kernel_size=vgg_block_cfg.filter_length, strides=vgg_block_cfg.subsample_length, padding='same', kernel_initializer=he_normal(SEED), )) else: model.add( Conv1D( filters=filters, kernel_size=vgg_block_cfg.filter_length, strides=vgg_block_cfg.subsample_length, padding='same', kernel_initializer=he_normal(SEED), )) model.add(BatchNormalization()) model.add(ReLU()) model.add( MaxPooling1D( pool_size=vgg_block_cfg.pool_size, strides=vgg_block_cfg.pool_size, )) if cfg.tranches_for_training: nb_classes = len(cfg.tranche_classes[cfg.tranches_for_training]) else: nb_classes = len(cfg.classes) for units in [256, 64]: model.add( Bidirectional( LSTM( units, kernel_initializer=Orthogonal(seed=SEED), return_sequences=True, ))) model.add( Bidirectional( LSTM( nb_classes, kernel_initializer=Orthogonal(seed=SEED), return_sequences=False, ))) model.add(Dense(nb_classes, activation='sigmoid')) return model
def getSimpleConvnetModel(d): n = d.num_blocks sf = d.start_filter dataset = d.dataset activation = d.act advanced_act = d.aact drop_prob = d.dropout if "mnist" in dataset: inputShape = (1, 28, 28) if K.image_dim_ordering() == "th" else (28, 28, 1) else: inputShape = (3, 32, 32) if K.image_dim_ordering() == "th" else (32, 32, 3) channelAxis = 1 if K.image_data_format() == 'channels_first' else -1 filsize = (3, 3) convArgs = { "padding": "same", "use_bias": False, "kernel_regularizer": l2(0.0001), } bnArgs = {"axis": channelAxis, "momentum": 0.9, "epsilon": 1e-04} if d.model == "real": sf *= 2 convArgs.update({"kernel_initializer": Orthogonal(float(np.sqrt(2)))}) elif d.model == "complex": convArgs.update({ "spectral_parametrization": d.spectral_param, "kernel_initializer": d.comp_init }) from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D from keras.layers.normalization import BatchNormalization batch_size = 256 num_classes = 10 epochs = 50 # input image dimensions img_rows, img_cols = 28, 28 I = Input(shape=inputShape) O = Conv2D(32, kernel_size=(3, 3), activation='relu', kernel_initializer='he_normal', input_shape=inputShape)(I) O = MaxPooling2D(pool_size=(2, 2))(O) O = Dropout(0.25)(O) O = Conv2D(64, (3, 3), activation='relu')(O) O = MaxPooling2D(pool_size=(2, 2))(O) O = Dropout(0.25)(O) O = Conv2D(128, (3, 3), activation='relu')(O) O = Dropout(0.4)(O) O = Flatten()(O) O = Dense(128, activation='relu')(O) O = Dropout(0.3)(O) O = Dense(num_classes, activation='softmax')(O) # Return the model return Model(I, O)
def getResnetModel(d): n = d.num_blocks sf = d.start_filter dataset = d.dataset activation = d.act advanced_act = d.aact drop_prob = d.dropout inputShape = (3, 32, 32) if K.image_dim_ordering() == "th" else (32, 32, 3) channelAxis = 1 if K.image_data_format() == 'channels_first' else -1 filsize = (3, 3) convArgs = { "padding": "same", "use_bias": False, "kernel_regularizer": l2(0.0001), } bnArgs = {"axis": channelAxis, "momentum": 0.9, "epsilon": 1e-04} if d.model == "real": sf *= 2 convArgs.update({"kernel_initializer": Orthogonal(float(np.sqrt(2)))}) elif d.model == "complex": convArgs.update({ "spectral_parametrization": d.spectral_param, "kernel_initializer": d.comp_init }) # # Input Layer # I = Input(shape=inputShape) # # Stage 1 # O = learnConcatRealImagBlock(I, (1, 1), (3, 3), 0, '0', convArgs, bnArgs, d) O = Concatenate(channelAxis)([I, O]) if d.model == "real": O = Conv2D(sf, filsize, name='conv1', **convArgs)(O) O = BatchNormalization(name="bn_conv1_2a", **bnArgs)(O) else: O = ComplexConv2D(sf, filsize, name='conv1', **convArgs)(O) O = ComplexBN(name="bn_conv1_2a", **bnArgs)(O) O = Activation(activation)(O) # # Stage 2 # for i in xrange(n): O = getResidualBlock(O, filsize, [sf, sf], 2, str(i), 'regular', convArgs, bnArgs, d) if i == n // 2 and d.spectral_pool_scheme == "stagemiddle": O = applySpectralPooling(O, d) # # Stage 3 # O = getResidualBlock(O, filsize, [sf, sf], 3, '0', 'projection', convArgs, bnArgs, d) if d.spectral_pool_scheme == "nodownsample": O = applySpectralPooling(O, d) for i in xrange(n - 1): O = getResidualBlock(O, filsize, [sf * 2, sf * 2], 3, str(i + 1), 'regular', convArgs, bnArgs, d) if i == n // 2 and d.spectral_pool_scheme == "stagemiddle": O = applySpectralPooling(O, d) # # Stage 4 # O = getResidualBlock(O, filsize, [sf * 2, sf * 2], 4, '0', 'projection', convArgs, bnArgs, d) if d.spectral_pool_scheme == "nodownsample": O = applySpectralPooling(O, d) for i in xrange(n - 1): O = getResidualBlock(O, filsize, [sf * 4, sf * 4], 4, str(i + 1), 'regular', convArgs, bnArgs, d) if i == n // 2 and d.spectral_pool_scheme == "stagemiddle": O = applySpectralPooling(O, d) # # Pooling # if d.spectral_pool_scheme == "nodownsample": O = applySpectralPooling(O, d) O = AveragePooling2D(pool_size=(32, 32))(O) else: O = AveragePooling2D(pool_size=(8, 8))(O) # # Flatten # O = Flatten()(O) # # Dense # if dataset == 'cifar10': O = Dense(10, activation='softmax', kernel_regularizer=l2(0.0001))(O) elif dataset == 'cifar100': O = Dense(100, activation='softmax', kernel_regularizer=l2(0.0001))(O) elif dataset == 'svhn': O = Dense(10, activation='softmax', kernel_regularizer=l2(0.0001))(O) else: raise ValueError("Unknown dataset " + d.dataset) # Return the model return Model(I, O)
def conv_layer(filters, kernel_size, strides): return Conv2D(filters=filters, kernel_size=kernel_size, strides=(strides, strides), activation='relu', kernel_initializer=Orthogonal())
def createModel(self): '''Creates model architecture Input: Data input dimensions, eventually architecture specifications parsed from a config file? (activations, costFunction, hyperparameters (nr layers), dropout....) Output: Keras Model''' #seed = 1337 #mod1 = Input((self.dpatch,self.dpatch,self.dpatch, self.num_channels)) mod1 = Input((None, None, None, self.num_channels)) # last channel is the individual TPM ############# Normal pathway ################## # reduces 57 into 9 ( - 48) x1 = Cropping3D(cropping=((16, 16), (16, 16), (16, 16)), input_shape=(None, None, None, self.num_channels))(mod1) # 25 , to 9 = -16 for feature in self.conv_features: x1 = Conv3D( filters=feature, kernel_size=(3, 3, 3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=he_normal(), kernel_regularizer=regularizers.l2(self.L2))(x1) x1 = LeakyReLU()(x1) x1 = BatchNormalization()(x1) ############# Downsampled pathway ################## #x2 = MaxPooling3D(pool_size=(self.d_factor,self.d_factor,self.d_factor), padding="same")(mod1) x2 = AveragePooling3D(pool_size=(self.d_factor, self.d_factor, self.d_factor), padding="same")(mod1) # Reduces into by 1/3 = 19, then down to 3 : -16 for feature in self.conv_features: x2 = Conv3D( filters=feature, kernel_size=(3, 3, 3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=he_normal(), kernel_regularizer=regularizers.l2(self.L2))(x2) x2 = LeakyReLU()(x2) x2 = BatchNormalization()(x2) x2 = UpSampling3D(size=(3, 3, 3))(x2) ############# Fully connected layers ################## x = concatenate([x1, x2]) x = Conv3D( filters=self.fc_features[0], kernel_size=(1, 1, 1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) x = Conv3D( filters=self.fc_features[1], kernel_size=(1, 1, 1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) # # x = Conv3D(filters = self.output_classes, # kernel_size = (1,1,1), # #kernel_initializer=he_normal(seed=seed), # kernel_initializer=Orthogonal(), # kernel_regularizer=regularizers.l2(self.L2))(x) # #x = BatchNormalization()(x) # tpm = Input((None,None,None,6)) #x4 = Cropping3D(cropping = ((24,24),(24,24),(24,24)), input_shape=(None, None, None, self.num_channels))(mod1) #x = concatenate([x,tpm])#,x4]) # MIXING ONLY CHANNELS + CHANNELS. # Skipping this bandfilter and going straigth to the softmax makes everything pointless (no nonlinearity besides softmax), and pushes performance to the floor. # x = Conv3D(filters = self.fc_features[1], # kernel_size = (1,1,1), # kernel_initializer=Orthogonal(), # kernel_regularizer=regularizers.l2(self.L2))(x) # x = LeakyReLU()(x) # x = BatchNormalization()(x) # # x = Conv3D(filters = self.fc_features[1], # kernel_size = (1,1,1), # kernel_initializer=Orthogonal(), # kernel_regularizer=regularizers.l2(self.L2))(x) # x = LeakyReLU()(x) x = Conv3D(filters=self.output_classes, kernel_size=(1, 1, 1), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = Activation(softmax)(x) model = Model(inputs=[mod1], outputs=x) #print_summary(model, positions=[.33, .6, .67,1]) #rmsprop = RMSprop(lr=self.learning_rate, rho=0.9, epsilon=1e-8, decay=self.optimizer_decay) if self.loss_function == 'Multinomial': model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5, dice_coef_multilabel6 ]) elif self.loss_function == 'Dice2': model.compile( loss=Generalised_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0, dice_coef_multilabel1]) elif self.loss_function == 'Dice6': model.compile(loss=dice_coef_multilabel6, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'wDice6': model.compile(loss=w_dice_coef_multilabel6, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'wDice2': model.compile( loss=w_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0, dice_coef_multilabel1]) elif self.loss_function == 'Dice7': model.compile(loss=Generalised_dice_coef_multilabel7, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5, dice_coef_multilabel6 ]) return model #dm = MultiPriors_noTPM_Model(7, 1, 0.001, [0], 0.01, 0, 'Dice7' ) #model = dm.createModel() #model.summary() #from keras.utils import plot_model #plot_model(model, to_file='/home/hirsch/Documents/projects/brainSegmentation/DeepPriors' +'/multiscale_TPM_noTPM.png', show_shapes=True) # ## #X = np.random.randn(1,57,57,57,1) #y = np.random.binomial(n=1, p=0.5,size=9**3*7).reshape(1,9,9,9,7) #y.shape # #TPM = np.random.randn(1,9,9,9,6) # #yhat = model.predict([X,TPM]) #yhat.shape # #model.fit([X,TPM], y)
def fc_layer(units, activation_fn='relu'): return Dense(units=units, activation=activation_fn, kernel_initializer=Orthogonal())
def createModel(self): '''Creates model architecture Input: Data input dimensions, eventually architecture specifications parsed from a config file? (activations, costFunction, hyperparameters (nr layers), dropout....) Output: Keras Model''' #seed = 1337 mod1 = Input( (self.dpatch, self.dpatch, self.dpatch, self.num_channels)) ############# Normal pathway ################## x1 = Cropping3D(cropping=((13, 13), (13, 13), (13, 13)), input_shape=(self.dpatch, self.dpatch, self.dpatch, self.num_channels))(mod1) x1 = Conv3D( filters=self.conv_features[0], kernel_size=(3, 3, 3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x1) x1 = BatchNormalization()(x1) #x1 = Activation('relu')(x1) x1 = PReLU()(x1) #x1 = BatchNormalization()(x1) for feature in self.conv_features[1:]: x1 = Conv3D( filters=feature, kernel_size=(3, 3, 3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x1) x1 = BatchNormalization()(x1) #x1 = Activation('relu')(x1) x1 = PReLU()(x1) #x1 = BatchNormalization()(x1) ############# Downsampled pathway ################## #x2 = MaxPooling3D(pool_size=(self.d_factor,self.d_factor,self.d_factor), padding="same")(mod1) x2 = AveragePooling3D(pool_size=(self.d_factor, self.d_factor, self.d_factor), padding="same")(mod1) x3 = Conv3D( filters=5, kernel_size=(7, 7, 7), padding="same", strides=(3, 3, 3), kernel_initializer=Orthogonal(), )(mod1) x3 = BatchNormalization()(x3) x3 = PReLU()(x3) x2 = concatenate([x2, x3]) x2 = Conv3D( filters=self.conv_features[0], kernel_size=(3, 3, 3), #kernel_initializer=he_normal(seed=seed), #dilation_rate = (17,17,17), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x2) x2 = BatchNormalization()(x2) #x2 = Activation('relu')(x2) x2 = PReLU()(x2) #x2 = BatchNormalization()(x2) for feature in (self.conv_features[1:]): x2 = Conv3D( filters=feature, kernel_size=(3, 3, 3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x2) x2 = BatchNormalization()(x2) #x2 = Activation('relu')(x2) x2 = PReLU()(x2) #x2 = BatchNormalization()(x2) x2 = UpSampling3D(size=(9, 9, 9))(x2) ############# Fully connected layers ################## x = concatenate([x1, x2]) #x = Reshape(target_shape = (1, 60))(x) # do I need this? '''x = Flatten()(x) x = Dense(units = self.fc_features[0], activation = 'elu')(x) x = Dropout(rate = 0.5)(x) x = Dense(units = self.fc_features[1], activation = 'elu')(x) x = Dropout(rate = 0.5)(x) x = Dense(units = self.fc_features[2], activation = 'softmax', name = 'softmax')(x)''' # Fully convolutional variant #tpm = Input((9,9,9,6)) #x = Dropout(rate = self.dropout[0])(x) x = Conv3D( filters=self.fc_features[0], kernel_size=(1, 1, 1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = BatchNormalization()(x) #x = Activation('relu')(x) x = PReLU()(x) #x = BatchNormalization()(x) #x = Dropout(rate = self.dropout[0])(x) x = Conv3D( filters=self.fc_features[1], kernel_size=(1, 1, 1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = BatchNormalization()(x) #x = Activation('relu')(x) x = PReLU()(x) #x = BatchNormalization()(x) #x = Dropout(rate = self.dropout[1])(x) #x = Flatten()(x) x = Dense(units=self.fc_features[2], activation='softmax', name='softmax')(x) model = Model(inputs=[mod1], outputs=x) #print_summary(model, positions=[.33, .6, .67,1]) #rmsprop = RMSprop(lr=self.learning_rate, rho=0.9, epsilon=1e-8, decay=self.optimizer_decay) if self.loss_function == 'Multinomial': model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'Dice2': model.compile( loss=Generalised_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0, dice_coef_multilabel1]) elif self.loss_function == 'Dice6': model.compile(loss=dice_coef_multilabel6, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'wDice6': model.compile(loss=w_dice_coef_multilabel6, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'wDice2': model.compile( loss=w_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0, dice_coef_multilabel1]) return model
def createModel(self): '''Creates model architecture Input: Data input dimensions, eventually architecture specifications parsed from a config file? (activations, costFunction, hyperparameters (nr layers), dropout....) Output: Keras Model''' highRes = Input( (None, None, None, self.num_channels )) # Dim = 25^3 (from a 57^3 cube, cropped 16 per side) lowRes = Input( (None, None, None, self.num_channels )) # Dim = 19^3 (from a 57^3 cube downsampled by three) ############# Normal pathway ################## # This input is now already cropped = -32 x1 = highRes # 25 --> 9 = -16 for kernels in self.conv_features: x1 = Conv3D(filters=kernels, kernel_size=(3, 3, 3), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x1) x1 = LeakyReLU()(x1) x1 = BatchNormalization()(x1) ############# Downsampled pathway ################## # This input is already downsampled = /3 x2 = lowRes # in total (x/3 - 16)*3 = -66 # -22 for kernels in self.conv_features: x2 = Conv3D(filters=kernels, kernel_size=(3, 3, 3), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x2) x2 = LeakyReLU()(x2) x2 = BatchNormalization()(x2) x2 = UpSampling3D(size=(3, 3, 3))(x2) ############# Fully connected layers ################## tpm = Input((None, None, None, 6)) x = concatenate([x1, x2, tpm]) for feature in self.fc_features: x = Conv3D(filters=feature, kernel_size=(1, 1, 1), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) x = Conv3D(filters=self.output_classes, kernel_size=(1, 1, 1), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = Activation(softmax)(x) model = Model(inputs=[highRes, lowRes, tpm], outputs=x) if self.loss_function == 'Multinomial': model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5, dice_coef_multilabel6 ]) elif self.loss_function == 'Dice2': model.compile( loss=Generalised_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0, dice_coef_multilabel1]) elif self.loss_function == 'Dice6': model.compile(loss=dice_coef_multilabel6, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'wDice6': model.compile(loss=w_dice_coef_multilabel6, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5 ]) elif self.loss_function == 'wDice2': model.compile( loss=w_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0, dice_coef_multilabel1]) elif self.loss_function == 'Dice7': model.compile(loss=Generalised_dice_coef_multilabel7, optimizer=Adam(lr=self.learning_rate), metrics=[ dice_coef_multilabel0, dice_coef_multilabel1, dice_coef_multilabel2, dice_coef_multilabel3, dice_coef_multilabel4, dice_coef_multilabel5, dice_coef_multilabel6 ]) return model
def createModel(self): T1post = Input((None,None,None, 1),name = 'T1post_input') ######################## T1 post pathway ######################### x = AveragePooling3D(pool_size=(1, 3, 3), name='T1post_Context')(T1post) # (13, 25, 25) for _ in range(6): x = Conv3D(filters = 30, kernel_size = (3,3,3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) for _ in range(5): x = Conv3D(filters = 30, kernel_size = (1,3,3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) x = UpSampling3D(size=(1,3,3))(x) ######################## FC Parts ############################# for feature in (self.fc_features[0:2]): x = Conv3D(filters = 60, kernel_size = (1,1,1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) x = Conv3D(filters = 100, kernel_size = (1,1,1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = LeakyReLU()(x) x = BatchNormalization()(x) x = Conv3D(filters = 2, kernel_size = (1,1,1), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = Activation('sigmoid')(x) model = Model(inputs=[T1post], outputs=x) #model = multi_gpu_model(model, gpus=4) if self.loss_function == 'Dice': model.compile(loss=Generalised_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=['acc', dice_coef_multilabel0, dice_coef_multilabel1]) elif self.loss_function == 'Multinomial': model.compile(loss='binary_crossentropy', optimizer=Adam(lr=self.learning_rate), metrics=['acc', dice_coef_multilabel0, dice_coef_multilabel1]) return model
def lstm_layer(self): """Create a LSTM layer of a model.""" if self.pooling: ret_seq = True else: ret_seq = False ker_in = glorot_uniform(seed=self.seed) rec_in = Orthogonal(seed=self.seed) if self.type_of_weights == "shared": if self.recurrent == "bilstm" or self.recurrent is None: out_a = Bidirectional(LSTM(self.hidden_dim, input_shape=( self.max_sequence_length, self.embedding_dim, ), kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=ret_seq), merge_mode='concat') elif self.recurrent == "lstm": out_a = LSTM(self.hidden_dim, input_shape=( self.max_sequence_length, self.embedding_dim, ), kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=ret_seq) return out_a, out_a elif self.type_of_weights == "separate": if self.recurrent == "bilstm" or self.recurrent is None: out_a = Bidirectional(LSTM(self.hidden_dim, input_shape=( self.max_sequence_length, self.embedding_dim, ), kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=ret_seq), merge_mode='concat') out_b = Bidirectional(LSTM(self.hidden_dim, input_shape=( self.max_sequence_length, self.embedding_dim, ), kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=ret_seq), merge_mode='concat') elif self.recurrent == "lstm": out_a = LSTM(self.hidden_dim, input_shape=( self.max_sequence_length, self.embedding_dim, ), kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=ret_seq) out_b = LSTM(self.hidden_dim, input_shape=( self.max_sequence_length, self.embedding_dim, ), kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=ret_seq) return out_a, out_b
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.compat.v1.name_scope('generator'): x = X L = self.layers n_filters = [ 128, 256, 512, 512, 512, 512, 512, 512] n_blocks = [ 128, 64, 32, 16, 8] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print('building model...') def _make_normalizer(x_in, n_filters, n_block): """applies an lstm layer on top of x_in""" x_shape = tf.shape(input=x_in) n_steps = x_shape[1] / int(n_block) # will be 32 at training # first, apply standard conv layer to reduce the dimension # input of (-1, 4096, 128) becomes (-1, 32, 128) # input of (-1, 512, 512) becomes (-1, 32, 512) x_in_down = (MaxPooling1D(pool_size=int(n_block), padding='valid'))(x_in) # pooling to reduce dimension x_shape = tf.shape(input=x_in_down) x_rnn = LSTM(units = n_filters, return_sequences = True)(x_in_down) # output: (-1, n_steps, n_filters) return x_rnn def _apply_normalizer(x_in, x_norm, n_filters, n_block): x_shape = tf.shape(input=x_in) n_steps = x_shape[1] / int(n_block) # will be 32 at training # reshape input into blocks x_in = tf.reshape(x_in, shape=(-1, n_steps, int(n_block), n_filters)) x_norm = tf.reshape(x_norm, shape=(-1, n_steps, 1, n_filters)) # multiply x_out = x_norm * x_in # return to original shape x_out = tf.reshape(x_out, shape=x_shape) return x_out # downsampling layers for l, nf, fs in zip(list(range(L)), n_filters, n_filtersizes): with tf.compat.v1.name_scope('downsc_conv%d' % l): x = (Conv1D(filters=nf, kernel_size=fs, dilation_rate = DRATE, activation=None, padding='same', kernel_initializer=Orthogonal()))(x) x = (MaxPooling1D(pool_size=self.pool_size, padding='valid', strides=self.strides))(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**l) params_before = np.sum([np.prod(v.get_shape().as_list()) for v in tf.compat.v1.trainable_variables()]) x_norm = _make_normalizer(x, nf, nb) params_after = np.sum([np.prod(v.get_shape().as_list()) for v in tf.compat.v1.trainable_variables()]) x = _apply_normalizer(x, x_norm, nf, nb) print('D-Block: ', x.get_shape()) downsampling_l.append(x) # bottleneck layer with tf.compat.v1.name_scope('bottleneck_conv'): x = (Conv1D(filters=n_filters[-1], kernel_size=n_filtersizes[-1], dilation_rate = DRATE, activation=None, padding='same', kernel_initializer=Orthogonal))(x) x = (MaxPooling1D(pool_size=self.pool_size, padding='valid', strides=self.strides))(x) x = Dropout(rate=0.5)(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**L) x_norm = _make_normalizer(x, n_filters[-1], nb) x = _apply_normalizer(x, x_norm, n_filters[-1], nb) # upsampling layers for l, nf, fs, l_in in reversed(list(zip(list(range(L)), n_filters, n_filtersizes, downsampling_l))): with tf.compat.v1.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (Conv1D(filters=2*nf, kernel_size=fs, dilation_rate = DRATE, activation=None, padding='same', kernel_initializer=Orthogonal()))(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # create and apply the normalizer x_norm = _make_normalizer(x, nf, nb) x = _apply_normalizer(x, x_norm, nf, nb) # (-1, n, 2f) x = Concatenate()([x, l_in]) print('U-Block: ', x.get_shape()) # final conv layer with tf.compat.v1.name_scope('lastconv'): x = Conv1D(filters=2, kernel_size=9, activation=None, padding='same', kernel_initializer=RandomNormal(stddev=1e-3))(x) x = SubPixel1D(x, r=2) g = Add()([x, X]) return g
def build_model(): input_1 = Input(batch_shape=(batch_size, num_channels, input_width, input_height)) conv_1_1 = Conv2D(32, kernel_size=(7, 7), strides=(2, 2), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv1_1')(input_1) relu_1_1 = LeakyReLU(leakiness)(conv_1_1) pool_1_1 = MaxPool2D((3, 3), strides=(2, 2), data_format='channels_first', batch_size=batch_size)(relu_1_1) conv_2_1 = Conv2D(32, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv2_1')(pool_1_1) relu_2_1 = LeakyReLU(leakiness)(conv_2_1) conv_2_2 = Conv2D(32, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv2_2')(relu_2_1) relu_2_2 = LeakyReLU(leakiness)(conv_2_2) pool_2_2 = MaxPool2D((3, 3), strides=(2, 2), data_format='channels_first', batch_size=batch_size)(relu_2_2) conv_3_1 = Conv2D(64, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv3_1')(pool_2_2) relu_3_1 = LeakyReLU(leakiness)(conv_3_1) conv_3_2 = Conv2D(64, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv3_2')(relu_3_1) relu_3_2 = LeakyReLU(leakiness)(conv_3_2) pool_3_2 = MaxPool2D((3, 3), strides=(2, 2), data_format='channels_first', batch_size=batch_size)(relu_3_2) conv_4_1 = Conv2D(128, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv4_1')(pool_3_2) relu_4_1 = LeakyReLU(leakiness)(conv_4_1) conv_4_2 = Conv2D(128, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv4_2')(relu_4_1) relu_4_2 = LeakyReLU(leakiness)(conv_4_2) conv_4_3 = Conv2D(128, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv4_3')(relu_4_2) relu_4_3 = LeakyReLU(leakiness)(conv_4_3) conv_4_4 = Conv2D(128, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv4_4')(relu_4_3) relu_4_4 = LeakyReLU(leakiness)(conv_4_4) pool_4_4 = MaxPool2D((3, 3), strides=(2, 2), data_format='channels_first', batch_size=batch_size)(relu_4_4) conv_5_1 = Conv2D(256, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv5_1')(pool_4_4) relu_5_1 = LeakyReLU(leakiness)(conv_5_1) conv_5_2 = Conv2D(256, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv5_2')(relu_5_1) relu_5_2 = LeakyReLU(leakiness)(conv_5_2) conv_5_3 = Conv2D(256, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv5_3')(relu_5_2) relu_5_3 = LeakyReLU(leakiness)(conv_5_3) conv_5_4 = Conv2D(256, (3, 3), padding='same', use_bias=True, activation='linear', data_format='channels_first', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='conv5_4')(relu_5_3) relu_5_4 = LeakyReLU(leakiness)(conv_5_4) pool_5_4 = MaxPool2D((3, 3), strides=(2, 2), data_format='channels_first', batch_size=batch_size, name='coarse_last_pool')(relu_5_4) dropout_1 = Dropout(0.5)(pool_5_4) flatten_1 = Flatten()(dropout_1) maxout_dense_0 = MaxoutDense(output_dim=512, dtype='float32', init='orthogonal', name='first_fc_0')(flatten_1) new_batch = batch_size // 2 reshape_tensor = Lambda(reshape_batch, arguments={'batch_size': new_batch})(maxout_dense_0) dropout_2 = Dropout(0.5)(reshape_tensor) maxout_dense_1 = MaxoutDense(output_dim=512, init='orthogonal', name='first_fc_1')(dropout_2) dropout_3 = Dropout(0.5)(maxout_dense_1) dense_1 = Dense(4, kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), name='last_dense')(dropout_3) reshape_tensor = Lambda(reshape_batch, arguments={'batch_size': batch_size})(dense_1) predictions = Activation('softmax', name='last_out')(reshape_tensor) model = Model(inputs=input_1, outputs=predictions) return model
from keras import optimizers from skimage import io from keras.callbacks import CSVLogger, Callback, EarlyStopping from keras.callbacks import ModelCheckpoint, LearningRateScheduler, ReduceLROnPlateau from keras.callbacks import TensorBoard, ModelCheckpoint base = load_model('Xception_model(71).h5') top_model = Sequential() top_model.add(base) top_model.add(MaxPooling2D(pool_size=(2, 2))) top_model.add(Flatten()) top_model.add(Dropout(0.5)) top_model.add(Dense(128, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(3, activation='softmax', kernel_initializer=Orthogonal())) top_model.summary() top_model.compile(optimizer="SGD", loss="categorical_crossentropy", metrics=["accuracy"]) top_model.load_weights('./Xception/Xception_decay.hdf5') import cv2 import numpy as np from sklearn import cross_validation, metrics test_folders = [ './raw/test/cancer cell/', './raw/test/lymphocyte/', './raw/test/plasma cell/'
def model(input_shape): model = Sequential() model.add(Cropping2D(cropping=(2, 4), input_shape=input_shape)) model.add( Conv2D(32, (5, 5), strides=(2, 2), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(32, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) #model.add(Conv2D(32, (3,3), strides=(1,1), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) #model.add(Conv2D(32, (3,3), strides=(2,2), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(64, (5, 5), strides=(2, 2), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2))) model.add(Flatten()) model.add( Dense(1024, kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) model.add(LeakyReLU(0.01)) model.add( Lambda(lambda x: maxout(x, 512), lambda shp: maxout_shape(shp, 512))) model.add( Dense(1, kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), kernel_regularizer=regularizers.l2(0.0005))) return model
def createModel(self): '''Creates model architecture Input: Data input dimensions, eventually architecture specifications parsed from a config file? (activations, costFunction, hyperparameters (nr layers), dropout....) Output: Keras Model''' #seed = 1337 #mod1 = Input(input_shape=(None,None,None, self.num_channels)) mod1 = Input((self.dpatch[0],self.dpatch[1],self.dpatch[2], self.num_channels)) ############# Downsampled pathway ################## #x2 = AveragePooling3D(pool_size=(d_factor[0],d_factor[1],d_factor[2]), padding="same")(mod1) x3 = Conv3D(filters = 30, kernel_size = (3,3,3), dilation_rate = (1,1,1), padding = 'same', kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(mod1) x3 = BatchNormalization()(x3) #x3 = Activation('relu')(x3) x3 = LeakyReLU()(x3) x3 = Conv3D(filters = 30, kernel_size = (3,3,3), dilation_rate = (1,1,1), padding = 'same', kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x3) x3 = BatchNormalization()(x3) #x3 = Activation('relu')(x3) x3 = LeakyReLU()(x3) # ------------------- Dilation Pyramid x3 = Conv3D(filters = 40, kernel_size = (3,3,3), dilation_rate = (1,2,2), padding = 'valid', #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x3) x3 = BatchNormalization()(x3) #x3 = Activation('relu')(x3) x3 = LeakyReLU()(x3) x3 = Conv3D(filters = 40, kernel_size = (3,3,3), dilation_rate = (1,4,4), padding = 'valid', #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x3) x3 = BatchNormalization()(x3) #x3 = Activation('relu')(x3) x3 = LeakyReLU()(x3) x3 = Conv3D(filters = 50, kernel_size = (3,3,3), dilation_rate = (1,8,8), padding = 'valid', #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x3) x3 = BatchNormalization()(x3) #x3 = Activation('relu')(x3) x3 = LeakyReLU()(x3) x3 = Conv3D(filters = 50, kernel_size = (3,3,3), dilation_rate = (1,16,16), padding = 'valid', #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x3) x3 = BatchNormalization()(x3) #x3 = Activation('relu')(x3) x3 = LeakyReLU()(x3) ############# High res pathway ################## x1 = Cropping3D(cropping = ((0,0),(22,22),(22,22)), input_shape=(self.dpatch[0],self.dpatch[1],self.dpatch[2], self.num_channels))(mod1) for feature in self.conv_features[0:8]: x1 = Conv3D(filters = feature, kernel_size = (2,3,3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x1) x1 = BatchNormalization()(x1) #x1 = Activation('relu')(x1) x1 = LeakyReLU()(x1) ############# Fully connected layers ################## x = concatenate([x1,x3]) # Fully convolutional variant for feature in (self.conv_features[10:12]): x = Conv3D(filters = feature, kernel_size = (3,3,3), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = BatchNormalization()(x) #x = Activation('relu')(x) x = LeakyReLU()(x) #x = BatchNormalization()(x) #x = Dropout(rate = self.dropout[0])(x) x = Conv3D(filters = 100, kernel_size = (1,3,3), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) #x = Activation('relu')(x) x = LeakyReLU()(x) #coords_x = Input((1,9,9,1)) coords_y = Input((1,9,9,1)) coords_z = Input((1,9,9,1)) #x = concatenate([x, coords_y, coords_z]) for fc_filters in self.fc_features: x = Conv3D(filters = fc_filters, kernel_size = (1,1,1), #kernel_initializer=he_normal(seed=seed), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = BatchNormalization()(x) #x = Activation('relu')(x) x = LeakyReLU()(x) # Final Softmax Layer x = Conv3D(filters = self.output_classes, kernel_size = (1,1,1), kernel_initializer=Orthogonal(), kernel_regularizer=regularizers.l2(self.L2))(x) x = Activation(softmax)(x) model = Model(inputs=[mod1,coords_y,coords_z], outputs=x) model.compile(loss=Generalised_dice_coef_multilabel2, optimizer=Adam(lr=self.learning_rate), metrics=[dice_coef_multilabel0,dice_coef_multilabel1]) return model
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.compat.v1.name_scope('generator'): x = X L = self.layers # dim/layer: 4096, 2048, 1024, 512, 256, 128, 64, 32, n_filters = [128, 384, 512, 512, 512, 512, 512, 512] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print('building model...') # downsampling layers for l, nf, fs in zip(list(range(L)), n_filters, n_filtersizes): with tf.compat.v1.name_scope('downsc_conv%d' % l): x = (Conv1D(filters=nf, kernel_size=fs, activation=None, padding='same', init=Orthogonal(), subsample_length=2))(x) # if l > 0: x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) print('D-Block: ', x.get_shape()) downsampling_l.append(x) # bottleneck layer with tf.compat.v1.name_scope('bottleneck_conv'): x = (Conv1D(filters=n_filters[-1], kernel_size=n_filtersizes[-1], activation=None, padding='same', init=Orthogonal(), subsample_length=2))(x) x = Dropout(rate=0.5)(x) x = LeakyReLU(0.2)(x) # upsampling layers for l, nf, fs, l_in in reversed( list( zip(list(range(L)), n_filters, n_filtersizes, downsampling_l))): with tf.compat.v1.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (Conv1D(filters=2 * nf, kernel_size=fs, activation=None, padding='same', init=Orthogonal()))(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # (-1, n, 2f) x = K.concatenate(tensors=[x, l_in], axis=2) print('U-Block: ', x.get_shape()) # final conv layer with tf.compat.v1.name_scope('lastconv'): x = Convolution1D(filters=2, kernel_size=9, activation=None, padding='same', init=RandomNormal(stdev=1e-3))(x) x = SubPixel1D(x, r=2) print(x.get_shape()) g = merge([x, X], mode='sum') return g
def model(input_shape): model = Sequential() model.add(Cropping2D(cropping=(2, 4), input_shape=input_shape)) model.add( Conv2D(32, (7, 7), strides=(2, 2), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) #model.add(Conv2D(32, (3,3), strides=(1,1), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1))) #model.add(Conv2D(32, (3,3), strides=(1,1), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1))) #model.add(Conv2D(32, (3,3), strides=(2,2), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(32, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(32, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add(Dropout(0.5)) model.add(GlobalMaxPooling2D()) model.add( Dense(1, kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1), activation='sigmoid')) return model
def model(input_shape): model = Sequential() model.add(Cropping2D(cropping=(2, 4), input_shape=input_shape)) model.add( Conv2D(32, (7, 7), strides=(2, 2), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) #model.add(Conv2D(32, (3,3), strides=(1,1), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1))) #model.add(Conv2D(32, (3,3), strides=(1,1), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1))) #model.add(Conv2D(32, (3,3), strides=(2,2), padding='same', kernel_initializer=Orthogonal(1.0), # bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(32, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(32, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(LeakyReLU(0.5)) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2))) model.add(Dropout(0.5)) model.add(GlobalMaxPooling2D()) model.add( Dense(1, kernel_initializer=Orthogonal(1.0), bias_initializer=Constant(0.1))) model.add(Activation('sigmoid')) sgd = SGD(lr=0.01, momentum=0.9, nesterov=True) model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy']) return model