def buildModel(shape, dr1=0.1, dr2=0.5): """ Build a keras model to be trained. This uses the architecture discussed in the lecture that is said to be published by the NVidia Autonomous Vehicle Team. 'shape' is the input shape, assumed to be 3 dimensional. 'dr1' is the drop out rate for the convolutional layers. 'dr2' is the drop out rate for the fully connected layers. """ assert len(shape) == 3 # We import keras here to avoid importing it (and a ton of other stuff) when running # the 'show_gui.py' script (which imports this script). import keras.models as _kmod import keras.layers as _klay model = _kmod.Sequential() # First crop and normalize the image(s). # Note that this is part of the model, and not part of loading the data, since it # needs to be done when the model is invoked by the simulator (in drive.py), and I didn't # want to modify drive.py and try to keep it in sync with this. # Ignore the top 42% and the bottom 15%. cropTop = int(shape[0] * 0.42) cropBot = int(shape[0] * 0.15) model.add( _klay.Cropping2D(cropping=((cropTop, cropBot), (0, 0)), input_shape=shape)) # Use very basic image normalization to get values between -0.5 and 0.5. model.add(_klay.Lambda(lambda x: x / 255.0 - 0.5)) # Do three 5x5 convolutions with stride 2. model.add( _klay.Convolution2D(24, 5, 5, subsample=(2, 2), activation='relu')) model.add(_klay.SpatialDropout2D(dr1)) model.add( _klay.Convolution2D(36, 5, 5, subsample=(2, 2), activation='relu')) model.add(_klay.SpatialDropout2D(dr1)) model.add( _klay.Convolution2D(48, 5, 5, subsample=(2, 2), activation='relu')) # Do two 3x3 convolutions with stride 1 model.add(_klay.SpatialDropout2D(dr1)) model.add( _klay.Convolution2D(64, 3, 3, subsample=(1, 1), activation='relu')) model.add(_klay.SpatialDropout2D(dr1)) model.add( _klay.Convolution2D(64, 3, 3, subsample=(1, 1), activation='relu')) # Do three fully connected layers. model.add(_klay.Flatten()) model.add(_klay.Dropout(dr2)) model.add(_klay.Dense(100, activation='relu')) model.add(_klay.Dropout(dr2)) model.add(_klay.Dense(50, activation='relu')) model.add(_klay.Dropout(dr2)) model.add(_klay.Dense(1)) return model
def run_cnn_1(conv1, conv2, conv3, train, test, img_shape, lr=0.001, fc1=5, do=0.5, n_classes=None, model=None): model_input = layers.Input(shape=img_shape, name="Input") x = layers.Conv2D(2**(conv1), kernel_size=(3, 3), activation="relu", padding="same", name="Conv1")(model_input) x = layers.MaxPooling2D(pool_size=(2, 2), name="Pool1")(x) x = layers.SpatialDropout2D(rate=do, name='Dropout2D_1')(x) x = layers.Conv2D(2**(conv2), kernel_size=(3, 3), activation="relu", padding="same", name="Conv2")(x) x = layers.MaxPooling2D(pool_size=(2, 2), name="Pool2")(x) x = layers.SpatialDropout2D(rate=do, name='Dropout2D_2')(x) x = layers.Conv2D(2**(conv3), kernel_size=(3, 3), activation="relu", padding="same", name="Conv4")(x) x = layers.MaxPooling2D(pool_size=(2, 2), name="Pool3")(x) x = layers.SpatialDropout2D(rate=do, name='Dropout2D_3')(x) x = layers.Flatten(name="Flatten")(x) x = layers.Dense(2**(fc1), activation="relu", name="FC1")(x) x = layers.Dense(2**(fc1-1), activation="relu", name="FC2")(x) x = layers.Dropout(rate=do,name='Dropout')(x) model_output = layers.Dense(n_classes, activation='sigmoid', name="Output")(x) model = models.Model(model_input, model_output) # Inicializa o otimizador. Adam é uma variação do SGD optimizer = optimizers.Adam(lr=lr) # Compila o modelo, escolhendo a funcao de perda e a metrica principal model.compile(optimizer, loss="binary_crossentropy", metrics=["accuracy"]) model.summary() # Treina por 10 epocas com mini-batches de 32 exemplos. # A API aceita tambem dados de validacao, que sao usadas ao final # de cada epoca para medir a metrica principal history = model.fit(train[0], train[1], batch_size=8, epochs=20, validation_data=test) return history, model
def _get_deeplab_v3(self, use_cbam=False, use_se=False): img_height, img_width = self.input_shape[0], self.input_shape[1] backbone_model = self._get_backbone_model() feature_layers = _FEATURE_LAYERS[self.backbone_name] img_features = backbone_model.get_layer(feature_layers[2]).output if use_cbam: img_features = cbam(img_features) if self.cfn_model is not None: img_features = self._concatenate_cfn_features(img_features, backbone_model) x = aspp(img_features) h_t, w_t, c_t = K.int_shape(x)[1:] scale = int((img_height / 4) // h_t), int((img_width / 4) // w_t) x = self._upsample_features(x, scale, c_t) y = conv(backbone_model.get_layer(feature_layers[0]).output, 64, 1) if use_cbam: y = cbam(y) if use_se: y = se_block(y) x = layers.concatenate([x, y]) x = conv(x, num_filters=128, kernel_size=3) x = layers.SpatialDropout2D(self.dropout_rate)(x) x = conv(x, num_filters=128, kernel_size=3) if use_cbam: x = cbam(x) if use_se: x = se_block(x) h_t, w_t, c_t = K.int_shape(x)[1:] scale = img_height // h_t, img_width // w_t x = self._upsample_features(x, scale, c_t) x = layers.Conv2D(self.n_classes, (1, 1))(x) o = layers.Activation('sigmoid', name='output_layer')(x) return models.Model(inputs=backbone_model.input, outputs=o)
def conv_bn_block(inputs, filters, k_size, stride, padding, name): out = layers.Conv2D(filters=filters, kernel_size=k_size, strides=stride, padding=padding, name=name)(inputs) out = layers.BatchNormalization()(out) out = layers.ReLU()(out) return layers.SpatialDropout2D(rate=0.3)(out)
def keras_dropout(layer, rate): input_dim = len(layer.input.shape) if input_dim == 2: return layers.SpatialDropout1D(rate) elif input_dim == 3: return layers.SpatialDropout2D(rate) elif input_dim == 4: return layers.SpatialDropout3D(rate) else: return layers.Dropout(rate)
def __init__(self, filters_size, dropout_rate): self._convolution_transpose = layers.Conv2DTranspose( filters_size, kernel_size=(3, 3), padding='same', strides=(2, 2), kernel_initializer='he_normal', kernel_regularizer=regularizers.l2(1e-4)) self._concatenation = layers.Concatenate(axis=-1) self._convo_block = ConvoBlock(filters_size) self._dropout = layers.SpatialDropout2D(rate=dropout_rate)
def capsule_model(inputs, args): out = conv_bn_block(inputs, filters=64, k_size=7, stride=2, padding="same", name="conv_block_1") # out = inception_block(out, nb_channels=64, name="inception0") # out = layers.SpatialDropout2D(rate=0.3)(out) # out = inception_block(out, nb_channels=128, name="inception1") # out = layers.SpatialDropout2D(rate=0.3)(out) if args.model_type == "rc": out = residual_block(out, nb_channels=128, _project_shortcut=True) out = layers.SpatialDropout2D(rate=0.3)(out) out = residual_block(out, nb_channels=256, _project_shortcut=True) out = layers.SpatialDropout2D(rate=0.3)(out) else: out = conv_bn_block(out, filters=128, k_size=7, stride=2, padding="same", name="conv_block_2") out = conv_bn_block(out, filters=64, k_size=7, stride=2, padding="same", name="conv_block_3") out = primary_capsule(out, dim_capsule=16, name="primarycaps", args=args) out = FashionCaps(num_capsule=args.num_class, dim_capsule=args.dim_capsule, routings=3, name="fashioncaps")(out) return out
def get_keras_model(self, verbose=False): model = Sequential() model.add(layers.InputLayer(input_shape=self.input_shape)) conv_counter = 0 for conv_layer in self.conv_layers: conv_counter += 1 kernel_initializer = conv_layer[ "kernel_initializer"] if "kernel_initializer" in conv_layer else "glorot_uniform" model.add( layers.Conv2D(conv_layer["filters"], conv_layer["kernel_size"], strides=conv_layer["strides"], padding=conv_layer["padding"], activation=conv_layer["activation"], kernel_initializer=kernel_initializer, name=conv_layer_name(conv_counter), data_format=self.data_format)) model.add( layers.MaxPool2D(pool_size=conv_layer["max_pooling"]["size"], strides=conv_layer["max_pooling"].get( "strides", None), data_format=self.data_format)) if "dropout" in conv_layer: model.add( layers.SpatialDropout2D(conv_layer["dropout"], data_format='channels_first')) model.add(layers.Flatten(data_format='channels_first')) dense_counter = 0 for dense_layer in self.dense_layers: dense_counter += 1 kernel_initializer = dense_layer[ "kernel_initializer"] if "kernel_initializer" in dense_layer else "glorot_uniform" model.add( layers.Dense(dense_layer["units"], activation=dense_layer["activation"], kernel_initializer=kernel_initializer, name=dense_layer_name(dense_counter))) if "dropout" in dense_layer: model.add(layers.Dropout(dense_layer["dropout"])) if verbose: model.summary() return model
def cbam_attn_unet(n_ch, patch_height, patch_width): K.set_image_data_format('channels_first') inputs = layers.Input(shape=(n_ch, patch_height, patch_width)) conv1 = conv2d_block(inputs, n_filters=32, kernel_size=3, batchnorm=True) conv1 = layers.SpatialDropout2D(0.1)(conv1) conv1 = cbam_block(conv1) pool1 = layers.MaxPooling2D((2, 2))(conv1) # conv2 = conv2d_block(pool1, n_filters=64, kernel_size=3, batchnorm=True) conv2 = layers.SpatialDropout2D(0.1)(conv2) conv2 = cbam_block(conv2) pool2 = layers.MaxPooling2D((2, 2))(conv2) #center conv3 = conv2d_block(pool2, n_filters=128, kernel_size=3, batchnorm=True) conv3 = layers.SpatialDropout2D(0.4)(conv3) conv3 = cbam_block(conv3) up1 = layers.UpSampling2D(size=(2, 2))(conv3) up1 = layers.concatenate([conv2, up1], axis=1) conv4 = conv2d_block(up1, n_filters=64, kernel_size=3, batchnorm=True) conv4 = cbam_block(conv4) up2 = layers.UpSampling2D(size=(2, 2))(conv4) up2 = layers.concatenate([conv1, up2], axis=1) conv5 = conv2d_block(up2, n_filters=32, kernel_size=3, batchnorm=True) conv5 = cbam_block(conv5) conv6 = layers.Conv2D(2, (1, 1), activation='relu', padding='same')(conv5) conv6 = layers.core.Reshape((2, patch_height * patch_width))(conv6) conv6 = layers.core.Permute((2, 1))(conv6) ############ conv7 = layers.core.Activation('softmax')(conv6)
def keras_dropout(layer, rate): '''keras dropout layer. ''' from keras import layers input_dim = len(layer.input.shape) if input_dim == 2: return layers.SpatialDropout1D(rate) elif input_dim == 3: return layers.SpatialDropout2D(rate) elif input_dim == 4: return layers.SpatialDropout3D(rate) else: return layers.Dropout(rate)
def get_model0(Input_img_shape=(300, 300, 3)): def conv_bn(x, filt, dl_rate=(1, 1), preblock=False): y = layers.Convolution2D(filt, (3, 3), activation='linear', padding='same', dilation_rate=dl_rate, use_bias=False)(x) if preblock: return y y = layers.BatchNormalization()(y) return layers.Activation('elu')(y) #in_layer = layers.Input(t_x.shape[1:], name = 'RGB_Input') in_layer = layers.Input(Input_img_shape, name='RGB_Input') pp_in_layer = layers.GaussianNoise(GAUSSIAN_NOISE)(in_layer) pp_in_layer = layers.BatchNormalization()(pp_in_layer) c = conv_bn(pp_in_layer, BASE_DEPTH // 2) c = conv_bn(c, BASE_DEPTH // 2) c = conv_bn(c, BASE_DEPTH) skip_layers = [pp_in_layer] for j in range(BLOCK_COUNT): depth_steps = int(np.log2(Input_img_shape[0]) - 2) d = layers.concatenate(skip_layers + [ conv_bn(c, BASE_DEPTH * 2**j, (2**i, 2**i), preblock=True) for i in range(depth_steps) ]) d = layers.SpatialDropout2D(SPATIAL_DROPOUT)(d) d = layers.BatchNormalization()(d) d = layers.Activation('elu')(d) # bottleneck d = conv_bn(d, BASE_DEPTH * 2**(j + 1)) skip_layers += [c] c = d d = layers.Convolution2D(1, (1, 1), activation='sigmoid', padding='same')(d) d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d) d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d) seg_model = models.Model(inputs=[in_layer], outputs=[d]) #seg_model.summary() return seg_model
def _get_fpn(self): pyramid_features = 128 seg_features = 64 backbone_model = self._get_backbone_model() feature_layers = _FEATURE_LAYERS[self.backbone_name] img_features = backbone_model.get_layer(feature_layers[-1]).output cfn_features = None if self.cfn_model is not None: cfn_model = models.Model(inputs=self.cfn_model.input, outputs=self.cfn_model.get_layer(feature_layers[-1]).output) for layer in cfn_model.layers: layer.trainable = False cfn_features = cfn_model(backbone_model.input) skips = [backbone_model.get_layer(n).output for n in feature_layers[:-1]] p1 = fpn_block(img_features, cfn_features, pyramid_features, skips[-1]) p2 = fpn_block(p1, cfn_features, pyramid_features, skips[-2]) p3 = fpn_block(p2, cfn_features, pyramid_features, skips[-3]) s1 = conv(p1, seg_features, 3) s1 = conv(s1, seg_features, 3) s2 = conv(p2, seg_features, 3) s2 = conv(s2, seg_features, 3) s3 = conv(p3, seg_features, 3) s3 = conv(s3, seg_features, 3) s1 = layers.UpSampling2D(4, interpolation='bilinear')(s1) s2 = layers.UpSampling2D(2, interpolation='bilinear')(s2) x = layers.concatenate([s1, s2, s3]) x = layers.SpatialDropout2D(self.dropout_rate)(x) x = conv(x, seg_features, 3) x = layers.UpSampling2D(4, interpolation='bilinear')(x) x = layers.Conv2D(self.n_classes, (1, 1))(x) o = layers.Activation('sigmoid', name='output_layer')(x) return models.Model(inputs=backbone_model.input, outputs=o)
def AID_CreateModel(input_shape, alpha_hinge=0.2, Spatial_Dropout=False, BN=True, B5_FC1_neurons=1024, similarity='simCos', desc_dim=128, desc_between_0_1=False, BigDesc=False, verbose=True): # descriptor model in_desc = layers.Input(shape=input_shape, name='input_patches') x = layers.Conv2D(64, (3, 3), padding='same', name='block1_conv1')(in_desc) if BN: x = layers.BatchNormalization(name='block1_BN1')(x) x = layers.Activation('relu', name='block1_relu1')(x) x = layers.Conv2D(64, (3, 3), padding='same', name='block1_conv2')(x) if BN: x = layers.BatchNormalization(name='block1_BN2')(x) x = layers.Activation('relu', name='block1_relu2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) # Block 2 x = layers.Conv2D(64, (3, 3), padding='same', name='block2_conv1')(x) if BN: x = layers.BatchNormalization(name='block2_BN1')(x) x = layers.Activation('relu', name='block2_relu1')(x) x = layers.Conv2D(64, (3, 3), padding='same', name='block2_conv2')(x) if BN: x = layers.BatchNormalization(name='block2_BN2')(x) x = layers.Activation('relu', name='block2_relu2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) # Block 3 x = layers.Conv2D(128, (3, 3), padding='same', name='block3_conv1')(x) if BN: x = layers.BatchNormalization(name='block3_BN1')(x) x = layers.Activation('relu', name='block3_relu1')(x) x = layers.Conv2D(128, (3, 3), padding='same', name='block3_conv2')(x) if BN: x = layers.BatchNormalization(name='block3_BN2')(x) x = layers.Activation('relu', name='block3_relu2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) # Block 4 x = layers.Conv2D(128, (3, 3), padding='same', name='block4_conv1')(x) if BN: x = layers.BatchNormalization(name='block4_BN1')(x) x = layers.Activation('relu', name='block4_relu1')(x) x = layers.Conv2D(128, (3, 3), padding='same', name='block4_conv2')(x) if BigDesc == False and BN: x = layers.BatchNormalization(name='block4_BN2')(x) if Spatial_Dropout: x = layers.SpatialDropout2D(p=0.5, name='block4_Dropout1')(x) if BigDesc == False: x = layers.Activation('relu', name='block4_relu2')(x) # Block 5 x = layers.Flatten(name='block5_flatten1')(x) if BigDesc == False: if B5_FC1_neurons > 0: x = layers.Dense(B5_FC1_neurons, activation='relu', name='block5_FC1')(x) if desc_between_0_1: x = layers.Dense(desc_dim, activation='sigmoid', name='block5_FC2')(x) else: x = layers.Dense(desc_dim, name='block5_FC2')(x) desc_model = Model(in_desc, x, name='aff_desc') # similarity model if similarity[0:5] == 'simFC': if similarity[5:] == '_concat' or similarity[5:] == '_concat_BigDesc': sim_type = 'concat' desc_dim = 2 * desc_model.output_shape[1] elif similarity[5:] == '_diff': sim_type = 'diff' # 2 siamese network in_desc1 = layers.Input(shape=input_shape, name='input_patches1') in_desc2 = layers.Input(shape=input_shape, name='input_patches2') emb_1 = desc_model(in_desc1) emb_2 = desc_model(in_desc2) # Similarity model in_sim = layers.Input(shape=(desc_dim, ), name='input_diff_desc') x = layers.Dense(64, activation='relu', name='block1_FC1')(in_sim) x = layers.Dense(32, activation='relu', name='block1_FC2')(x) x = layers.Dense(1, activation='sigmoid', name='block1_FC3')(x) sim_model = Model(in_sim, x, name='sim') if sim_type == 'concat': x = layers.Concatenate(name='Concat')([emb_1, emb_2]) else: x = layers.Subtract(name='Subtract')([emb_1, emb_2]) out_net = sim_model(x) # Groundtruth Model in_GT = layers.Input(shape=(1, ), name='input_GroundTruth') GT_model = Model(in_GT, in_GT, name='GroundTruth') out_GT = GT_model(in_GT) class TopLossLayerClass(layers.Layer): def __init__(self, **kwargs): super(TopLossLayerClass, self).__init__(**kwargs) def call(self, inputs): #out_net, out_GT = inputs s, t = inputs # t=1 -> Positive class, t=0 -> Negative class loss = K.sum(t * K.log(s) + (1 - t) * K.log(1 - s)) self.add_loss(loss) return loss TopLossLayer_obj = TopLossLayerClass(name='TopLossLayer') TopLossLayer = TopLossLayer_obj([out_net, out_GT]) train_model = Model([in_desc1, in_desc2, in_GT], TopLossLayer, name='TrainModel') elif similarity == 'simCos': # hinge loss # Similarity model desc_dim = desc_model.output_shape[1] in_sim1 = layers.Input(shape=(desc_dim, ), name='input_desc1') in_sim2 = layers.Input(shape=(desc_dim, ), name='input_desc2') x = layers.Dot(axes=1, normalize=True, name='CosineProximity')([in_sim1, in_sim2]) # cosine proximity sim_model = Model([in_sim1, in_sim2], x, name='sim') # 3 siamese networks in_desc1 = layers.Input(shape=input_shape, name='input_patches_anchor') in_desc2 = layers.Input(shape=input_shape, name='input_patches_positive') in_desc3 = layers.Input(shape=input_shape, name='input_patches_negative') emb_1 = desc_model(in_desc1) emb_2 = desc_model(in_desc2) emb_3 = desc_model(in_desc3) sim_type = 'inlist' out_net_positive = sim_model([emb_1, emb_2]) out_net_negative = sim_model([emb_1, emb_3]) class TopLossLayerClass(layers.Layer): def __init__(self, alpha=0.2, **kwargs): self.alpha = alpha super(TopLossLayerClass, self).__init__(**kwargs) def call(self, inputs): out_net_positive, out_net_negative = inputs # Hinge loss computation loss = K.sum( K.maximum(out_net_negative - out_net_positive + self.alpha, 0)) #,axis=0) self.add_loss(loss) return loss TopLossLayer_obj = TopLossLayerClass(name='TopLossLayer', alpha=alpha_hinge) TopLossLayer = TopLossLayer_obj([out_net_positive, out_net_negative]) train_model = Model([in_desc1, in_desc2, in_desc3], TopLossLayer, name='TrainModel') if verbose: print( '\n\n-------> The network architecture for the affine descriptor computation !' ) desc_model.summary() print( '\n\n-------> The network architecture for the similarity computation !' ) sim_model.summary() print('\n\n-------> Train model connections') train_model.summary() return train_model, sim_type
def _reduction_a_cell(ip, p, filters, block_id=None): '''Adds a Reduction cell for NASNet-A (Fig. 4 in the paper). # Arguments ip: Input tensor `x` p: Input tensor `p` filters: Number of output filters block_id: String block_id # Returns A Keras tensor ''' channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1 with backend.name_scope('reduction_A_block_%s' % block_id): p = _adjust_block(p, ip, filters, block_id) h = layers.Activation('relu')(ip) h = layers.Conv2D(filters, (1, 1), strides=(1, 1), padding='same', kernel_regularizer=l2(weight_decay), name='reduction_conv_1_%s' % block_id, use_bias=False, kernel_initializer='he_normal')(h) if use_bn: h = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='reduction_bn_1_%s' % block_id)(h) h = layers.SpatialDropout2D(drop_p)(h) h3 = layers.ZeroPadding2D(padding=correct_pad(backend, h, 3), name='reduction_pad_1_%s' % block_id)(h) with backend.name_scope('block_1'): x1_1 = _separable_conv_block(h, filters, (5, 5), strides=(2, 2), block_id='reduction_left1_%s' % block_id) x1_2 = _separable_conv_block(p, filters, (7, 7), strides=(2, 2), block_id='reduction_right1_%s' % block_id) x1 = layers.add([x1_1, x1_2], name='reduction_add_1_%s' % block_id) with backend.name_scope('block_2'): x2_1 = layers.MaxPooling2D( (3, 3), strides=(2, 2), padding='valid', name='reduction_left2_%s' % block_id)(h3) x2_2 = _separable_conv_block(p, filters, (7, 7), strides=(2, 2), block_id='reduction_right2_%s' % block_id) x2 = layers.add([x2_1, x2_2], name='reduction_add_2_%s' % block_id) with backend.name_scope('block_3'): x3_1 = layers.AveragePooling2D( (3, 3), strides=(2, 2), padding='valid', name='reduction_left3_%s' % block_id)(h3) x3_2 = _separable_conv_block(p, filters, (5, 5), strides=(2, 2), block_id='reduction_right3_%s' % block_id) x3 = layers.add([x3_1, x3_2], name='reduction_add3_%s' % block_id) with backend.name_scope('block_4'): x4 = layers.AveragePooling2D( (3, 3), strides=(1, 1), padding='same', name='reduction_left4_%s' % block_id)(x1) x4 = layers.add([x2, x4]) with backend.name_scope('block_5'): x5_1 = _separable_conv_block(x1, filters, (3, 3), block_id='reduction_left4_%s' % block_id) x5_2 = layers.MaxPooling2D( (3, 3), strides=(2, 2), padding='valid', name='reduction_right5_%s' % block_id)(h3) x5 = layers.add([x5_1, x5_2], name='reduction_add4_%s' % block_id) x = layers.concatenate([x2, x3, x4, x5], axis=channel_dim, name='reduction_concat_%s' % block_id) return x, ip
def train_detector(train_gt, train_img_dir, fast_train=True): check = callbacks.ModelCheckpoint('facepoints_model.hdf5', save_best_only = True) picnum = len(train_gt) if fast_train==False: dataa = np.empty((picnum*4,px,px,3)) labells = np.empty((picnum*4,28)) else: dataa = np.empty((picnum,px,px,3)) labells = np.empty((picnum,28)) valueff = np.empty((28)) valuef = np.empty((28)) i = 0 for key,value in train_gt.items(): im = imread(join(train_img_dir,key)) if len(im.shape) == 2: im = np.dstack((im,im,im)) xreshape = px/im.shape[1] yreshape = px/im.shape[0] imr = resize(im,(px,px,3),anti_aliasing = False) dataa[i,:,:,:] = imr value[::2]= value[::2]*xreshape value[1::2] = value[1::2]*yreshape labells[i,:] = value i+=1 if fast_train == False: dataa[i,:,:,:] = np.fliplr(imr) valuef[1::2] = value[1::2] valuef[::2] = imr.shape[1] - value[::2] valueff[0:2] = valuef[6:8] valueff[2:4] = valuef[4:6] valueff[4:6] = valuef[2:4] valueff[6:8] = valuef[0:2] valueff[8:10] = valuef[18:20] valueff[10:12] = valuef[16:18] valueff[12:14] = valuef[14:16] valueff[14:16] = valuef[12:14] valueff[16:18] = valuef[10:12] valueff[18:20] = valuef[8:10] valueff[20:22] = valuef[20:22] valueff[22:24] = valuef[26:28] valueff[24:26] = valuef[24:26] valueff[26:28] = valuef[22:24] labells[i,:] = valueff print(i) i+=1 dataa[i,:,:,:] = np.flipud(imr) valuef[::2] = value[::2] valuef[1::2] = imr.shape[0] - value[1::2] valueff[0:2] = valuef[6:8] valueff[2:4] = valuef[4:6] valueff[4:6] = valuef[2:4] valueff[6:8] = valuef[0:2] valueff[8:10] = valuef[18:20] valueff[10:12] = valuef[16:18] valueff[12:14] = valuef[14:16] valueff[14:16] = valuef[12:14] valueff[16:18] = valuef[10:12] valueff[18:20] = valuef[8:10] valueff[20:22] = valuef[20:22] valueff[22:24] = valuef[26:28] valueff[24:26] = valuef[24:26] valueff[26:28] = valuef[22:24] labells[i,:] = valueff print(i) i+=1 dataa[i,:,:,:] = np.transpose(imr,(1,0,2)) valuef[::2] = value[1::2] valuef[1::2] = value[::2] valueff[0:2] = valuef[6:8] valueff[2:4] = valuef[4:6] valueff[4:6] = valuef[2:4] valueff[6:8] = valuef[0:2] valueff[8:10] = valuef[18:20] valueff[10:12] = valuef[16:18] valueff[12:14] = valuef[14:16] valueff[14:16] = valuef[12:14] valueff[16:18] = valuef[10:12] valueff[18:20] = valuef[8:10] valueff[20:22] = valuef[20:22] valueff[22:24] = valuef[26:28] valueff[24:26] = valuef[24:26] valueff[26:28] = valuef[22:24] labells[i,:] = valueff print(i) i+=1 for j in range (3): mean = np.mean(dataa[:,:,:,j],axis = 0) std = np.std(dataa[:,:,:,j],axis = 0) for i in range(len(dataa)): dataa[i,:,:,j] = (dataa[i,:,:,j]-mean)/std model = Sequential() model.add(layers.BatchNormalization()) model.add(layers.Conv2D(24,(5,5),data_format="channels_last",activation='relu',input_shape = (px,px,3))) model.add(layers.MaxPooling2D()) model.add(layers.BatchNormalization()) model.add(layers.SpatialDropout2D(0.2)) model.add(layers.Conv2D(36,(5,5),data_format="channels_last",activation='relu')) model.add(layers.MaxPooling2D()) model.add(layers.BatchNormalization()) model.add(layers.SpatialDropout2D(0.2)) model.add(layers.Conv2D(48,(5,5),data_format="channels_last",activation='relu')) model.add(layers.MaxPooling2D(padding = 'same')) model.add(layers.BatchNormalization()) model.add(layers.SpatialDropout2D(0.2)) model.add(layers.Conv2D(128,(3,3),data_format="channels_last",activation='relu')) model.add(layers.MaxPooling2D(padding = 'same')) model.add(layers.BatchNormalization()) model.add(layers.SpatialDropout2D(0.2)) model.add(layers.Conv2D(128,(3,3),data_format="channels_last",padding = 'same',activation='relu')) model.add(layers.MaxPooling2D()) model.add(layers.BatchNormalization()) model.add(layers.SpatialDropout2D(0.2)) model.add(layers.GlobalAveragePooling2D()) model.add(layers.Dense(500, activation='relu')) model.add(layers.Dense(84, activation='relu')) model.add(layers.Dense(28)) model.compile(optimizer='Adam', loss='mse', metrics=['accuracy']) if fast_train == True: model.fit(dataa, labells, batch_size=1000, epochs=1) model.save('facepoints_model.hdf5') else: model.fit(dataa, labells, batch_size=128, epochs=800,validation_split = 0.2, callbacks = ([check]))
def FashionCapsNet(input_shape, n_class, args): x = layers.Input(shape=input_shape) def residual_block(y, nb_channels, _strides=(2, 2), _project_shortcut=False): shortcut = y # down-sampling is performed with a stride of 2 y = layers.Conv2D(nb_channels, kernel_size=(3, 3), strides=_strides, padding='same')(y) y = layers.BatchNormalization()(y) y = layers.LeakyReLU()(y) y = layers.Conv2D(nb_channels, kernel_size=(3, 3), strides=(1, 1), padding='same')(y) y = layers.BatchNormalization()(y) # identity shortcuts used directly when the input and output are of the same dimensions if _project_shortcut or _strides != (1, 1): # when the dimensions increase projection shortcut is used to match dimensions (done by 1×1 convolutions) # when the shortcuts go across feature maps of two sizes, they are performed with a stride of 2 shortcut = layers.Conv2D(nb_channels, kernel_size=(1, 1), strides=_strides, padding='same')(shortcut) shortcut = layers.BatchNormalization()(shortcut) y = layers.add([shortcut, y]) y = layers.LeakyReLU()(y) return y # Stacked-convolutional layer 1 out = layers.Conv2D(filters=32, kernel_size=7, strides=1, padding='same', name='conv1_1')(x) out = layers.BatchNormalization()(out) out = layers.LeakyReLU()(out) out = layers.SpatialDropout2D(rate=0.3)(out) out = residual_block(out, nb_channels=64, _project_shortcut=True) out = layers.SpatialDropout2D(rate=0.3)(out) out = residual_block(out, nb_channels=128, _project_shortcut=True) out = layers.SpatialDropout2D(rate=0.3)(out) out = residual_block(out, nb_channels=256, _project_shortcut=True) out = layers.SpatialDropout2D(rate=0.3)(out) # PrimaryCaps out = PrimaryCaps(out, dim_capsule=args.dim_capsule) # FashionCaps out = FashionCaps(num_capsule=n_class, dim_capsule=args.dim_capsule, routings=args.routings, name='fashioncaps')(out) # Length of each capsule represents the probability of the existence of the entity out_caps = Length(name='capsnet')(out) # Mask the output of FashionCapsNet y = layers.Input(shape=(n_class,)) masked_by_y = Mask()([out, y]) # The true label is used to mask the output of capsule layer. For training masked = Mask()(out) # Mask using the capsule with maximal length. For prediction # Transpose-convolutional decoder network for reconstruction decoder = models.Sequential(name='decoder') decoder.add(layers.Dense(7*7*args.conv_filters, activation='relu', input_dim=args.dim_capsule*n_class)) decoder.add(layers.Reshape((7, 7, args.conv_filters))) decoder.add(layers.Conv2DTranspose(args.conv_filters, kernel_size=4, strides=2, padding='same')) decoder.add(layers.BatchNormalization(axis=-1)) decoder.add(layers.LeakyReLU()) decoder.add(layers.Conv2DTranspose(int(args.conv_filters/2), kernel_size=4, strides=2, padding='same')) decoder.add(layers.BatchNormalization(axis=-1)) decoder.add(layers.LeakyReLU()) decoder.add(layers.Conv2DTranspose(int(args.conv_filters / 4), kernel_size=4, strides=2, padding='same')) decoder.add(layers.BatchNormalization(axis=-1)) decoder.add(layers.LeakyReLU()) decoder.add(layers.Conv2DTranspose(int(args.conv_filters / 8), kernel_size=4, strides=2, padding='same')) decoder.add(layers.BatchNormalization(axis=-1)) decoder.add(layers.LeakyReLU()) decoder.add(layers.Conv2DTranspose(3, kernel_size=4, strides=2, padding='same', activation='sigmoid')) # Model for training train_model = models.Model([x, y], [out_caps, decoder(masked_by_y)]) # Model for evaluation eval_model = models.Model(x, [out_caps, decoder(masked)]) return train_model, eval_model
return layers.Activation('elu')(y) in_layer = layers.Input(t_x.shape[1:], name = 'RGB_Input') pp_in_layer = layers.GaussianNoise(GAUSSIAN_NOISE)(in_layer) pp_in_layer = layers.BatchNormalization()(pp_in_layer) c = conv_bn(pp_in_layer, BASE_DEPTH//2) c = conv_bn(c, BASE_DEPTH//2) c = conv_bn(c, BASE_DEPTH) skip_layers = [pp_in_layer] for j in range(BLOCK_COUNT): depth_steps = int(np.log2(t_x.shape[1])-2) d = layers.concatenate(skip_layers+[conv_bn(c, BASE_DEPTH*2**j, (2**i, 2**i), preblock=True) for i in range(depth_steps)]) d = layers.SpatialDropout2D(SPATIAL_DROPOUT)(d) d = layers.BatchNormalization()(d) d = layers.Activation('elu')(d) # bottleneck d = conv_bn(d, BASE_DEPTH*2**(j+1)) skip_layers += [c] c = d d = layers.Convolution2D(1, (1, 1), activation='sigmoid', padding='same')(d) d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d) d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d) seg_model = models.Model(inputs = [in_layer], outputs = [d]) seg_model.summary() # %% [code] import keras.backend as K
def UNetCapsuleNetClippedModel(self, n_class=4, number_of_channel=3): shape_default = (self.input_shape[0], self.input_shape[1], number_of_channel) x = layers.Input(shape=shape_default) # 56x56 Level 3 n_filter = 512 conv_level_3 = utils.Conv2DBNSLU(x=x, filters=32, kernel_size=1, strides=1, padding='valid', activation='selu', name='conv_level_3_0') print(conv_level_3.shape) # 28x28 Level 2 conv_level_2 = layers.Conv2D(filters=64, kernel_size=2, strides=2, padding='same', activation='selu', name='conv_level_2')(conv_level_3) conv_level_2 = layers.SpatialDropout2D(0.2)(conv_level_2) # 14x14 conv_level_1 = layers.Conv2D(filters=128, kernel_size=2, strides=1, padding='same', activation='selu', name='conv_level_1')(conv_level_2) conv_level_1 = layers.SpatialDropout2D(0.2)(conv_level_1) conv_level_1 = layers.MaxPooling2D(pool_size=(2, 2), name='pool_level_1')(conv_level_1) # subgroups conv_level_1_7 = layers.Conv2D(filters=128, kernel_size=7, strides=1, padding='same', activation='selu', name='conv_level_1_7')(conv_level_1) conv_level_1_7 = layers.SpatialDropout2D(0.2)(conv_level_1_7) conv_level_1_5 = layers.Conv2D(filters=128, kernel_size=5, strides=1, padding='same', activation='selu', name='conv_level_1_5')(conv_level_1) conv_level_1_5 = layers.SpatialDropout2D(0.2)(conv_level_1_5) conv_level_1_3 = layers.Conv2D(filters=128, kernel_size=(3, 5), strides=1, padding='same', activation='selu', name='conv_level_1_3')(conv_level_1) conv_level_1_3 = layers.SpatialDropout2D(0.2)(conv_level_1_3) # Concatenate conv_level_1 = concatenate([conv_level_1, conv_level_1_5, conv_level_1_3, conv_level_1_7]) # 7x7 conv_level_0 = layers.Conv2D(filters=256, kernel_size=2, strides=2, padding='valid', activation='selu', name='conv_level_0')(conv_level_1) # Contour detection conv_level_0_31 = layers.Conv2D(filters=64, kernel_size=(3, 1), strides=1, padding='same', activation='selu', name='conv_level_0_13')(conv_level_0) conv_level_0_31 = layers.SpatialDropout2D(0.2)(conv_level_0_31) conv_level_0_3 = layers.Conv2D(filters=64, kernel_size=3, strides=1, padding='same', activation='selu', name='conv_level_0_3')(conv_level_0) conv_level_0_3 = layers.SpatialDropout2D(0.2)(conv_level_0_3) conv_level_0_5 = layers.Conv2D(filters=64, kernel_size=5, strides=1, padding='same', activation='selu', name='conv_level_0_5')(conv_level_0) conv_level_0_5 = layers.SpatialDropout2D(0.2)(conv_level_0_5) conv_level_0 = concatenate([conv_level_0, conv_level_0_3, conv_level_0_31, conv_level_0_5]) # Upsampling from level 0 to level 1; 7 --> 14 upsample_level_0_to_1 = keras.layers.UpSampling2D(size=(2, 2), data_format=None)(conv_level_0) conv_level_0_to_1 = concatenate([upsample_level_0_to_1, conv_level_1]) # Upsampling from level 1 to level 2; 14 --> 28 upsample_level_1_to_2 = keras.layers.UpSampling2D(size=(2, 2), data_format=None)(conv_level_0_to_1) conv_level_0_to_2 = concatenate([upsample_level_1_to_2, conv_level_2]) # Reduce the number of filter by half # filter_size = int(conv_level_0_to_2.shape[3]) # filter_size = int(round(filter_size * 0.8)) # filter_size = filter_size - int(conv_level_3.shape[3]) # reduction_level = layers.Conv2D(filter_size, kernel_size=1, strides=1, padding='same', activation='relu', name='reduction_level')(conv_level_0_to_2) # Upsampling from level 2 to level 3; 28 --> 56 upsample_level_2_to_3 = keras.layers.UpSampling2D(size=(2, 2), data_format=None)(conv_level_0_to_2) conv_level_0_to_2_to_3 = concatenate([upsample_level_2_to_3, conv_level_3]) filter_layers = layers.Conv2D(filters=n_filter, kernel_size=3, strides=1, padding='same', activation='selu', name='filter_layer')(conv_level_0_to_2_to_3) one_hot_layer = layers.Conv2D(filters=n_class, kernel_size=1, strides=1, padding='same', activation='softmax', name='ucnet')(filter_layers) y = layers.Input(shape=(self.input_shape[0], self.input_shape[1], n_class)) reshaped_filter_layers = layers.Reshape((n_filter, self.input_shape[0] * self.input_shape[1]), input_shape=(self.input_shape[0], self.input_shape[1], n_filter))( filter_layers) # train condition mask_with_y = custom_layers.MaskFilter(num_classes=n_class, train_mode=True)([reshaped_filter_layers, y]) mask_without_y = custom_layers.MaskFilter(num_classes=n_class, train_mode=False)( [filter_layers, reshaped_filter_layers, one_hot_layer]) reshaped_y_train = layers.Reshape((self.input_shape[0] * self.input_shape[1], n_class), input_shape=(self.input_shape[0], self.input_shape[1], n_class))(y) masked_filters_train = K.batch_dot(reshaped_filter_layers, reshaped_y_train) masked_filters_train = layers.Flatten()(masked_filters_train) # test/prediction condition one_hot_layer_reshaped = layers.Reshape((n_class, self.input_shape[0] * self.input_shape[1]), input_shape=(self.input_shape[0], self.input_shape[1], n_class))( one_hot_layer) reshaped_y_test = K.one_hot(indices=K.argmax(one_hot_layer_reshaped, 1), num_classes=n_class) masked_filters_test = K.batch_dot(reshaped_filter_layers, reshaped_y_test) masked_filters_test = layers.Flatten()(masked_filters_test) print('masked_filters_test', masked_filters_test) print('masked_filters_train', masked_filters_train) # Shared Decoder model in training and prediction shape_default_mask = (shape_default[0], shape_default[1], n_class) decoder = models.Sequential(name='decoder') decoder.add(layers.Dense(512, activation='selu', input_dim=(n_filter * n_class))) # 1024 decoder.add(layers.Dense(1024, activation='selu')) # 2048 decoder.add(layers.Dense(np.prod(shape_default_mask), activation='sigmoid')) decoder.add(layers.Reshape(target_shape=shape_default_mask, name='out_recon')) train_model = models.Model([x, y], [one_hot_layer, decoder(mask_with_y)]) eval_model = models.Model(x, one_hot_layer) # eval_model = models.Model(x, [one_hot_layer, decoder(mask_without_y)]) ''' train_model = models.Model(x,one_hot_layer) eval_model = models.Model(x, one_hot_layer) ''' return train_model, eval_model
def UNet(input_shape=(None, None, 1), conv_layers_dimensions=(16, 32, 64, 128), base_conv_layers_dimensions=(128, 128), output_conv_layers_dimensions=(16, 16), dropout=(), steps_per_pooling=1, number_of_outputs=1, output_activation=None, loss=nd_mean_absolute_error, layer_function=None, **kwargs): """Creates and compiles a U-Net. Parameters ---------- input_shape : tuple of ints Size of the images to be analyzed. conv_layers_dimensions : tuple of ints Number of convolutions in each convolutional layer during down- and upsampling. base_conv_layers_dimensions : tuple of ints Number of convolutions in each convolutional layer at the base of the unet, where the image is the most downsampled. output_conv_layers_dimensions : tuple of ints Number of convolutions in each convolutional layer after the upsampling. steps_per_pooling : int Number of convolutional layers between each pooling and upsampling step. number_of_outputs : int Number of convolutions in output layer. output_activation : str or keras activation The activation function of the output. loss : str or keras loss function The loss function of the network. layer_function : Callable[int] -> keras layer Function that returns a convolutional layer with convolutions determined by the input argument. Can be use to futher customize the network. Returns ------- keras.models.Model Deep learning network. """ if layer_function is None: layer_function = lambda dimensions: layers.Conv2D( dimensions, kernel_size=3, activation="relu", padding="same") unet_input = layers.Input(input_shape) concat_layers = [] layer = unet_input # Downsampling step for conv_layer_dimension in conv_layers_dimensions: for _ in range(steps_per_pooling): layer = layer_function(conv_layer_dimension)(layer) concat_layers.append(layer) if dropout: layer = layers.SpatialDropout2D(dropout[0])(layer) dropout = dropout[1:] layer = layers.MaxPooling2D(2)(layer) # Base steps for conv_layer_dimension in base_conv_layers_dimensions: layer = layer_function(conv_layer_dimension)(layer) # Upsampling step for conv_layer_dimension, concat_layer in zip( reversed(conv_layers_dimensions), reversed(concat_layers)): layer = layers.Conv2DTranspose(conv_layer_dimension, kernel_size=2, strides=2)(layer) layer = layers.Concatenate(axis=-1)([layer, concat_layer]) for _ in range(steps_per_pooling): layer = layer_function(conv_layer_dimension)(layer) # Output step for conv_layer_dimension in output_conv_layers_dimensions: layer = layer_function(conv_layer_dimension)(layer) layer = layers.Conv2D(number_of_outputs, kernel_size=3, activation=output_activation, padding="same")(layer) model = models.Model(unet_input, layer) return KerasModel(model, loss=loss, **kwargs)
def finger_field_injection(dropout_rate=0.0, activation=kl.activations.relu, train_mobilenet=False): # net_in = kl.Input(shape=[224, 224, 3], name=IN('img')) # print(net_in._op.__dict__) mobile_net = MobileNet(include_top=False, weights='imagenet', dropout=dropout_rate, # input_tensor=net_in._op, input_shape=[224, 224, 3]) layers = mobile_net.layers[:26] for layer in layers: layer.trainable = train_mobilenet layers[0].name = IN('img') transferred_net = km.Sequential(layers=layers) # alternative path from input c_alt = kl.Conv2D(filters=128, kernel_size=[7, 7], padding='same', activation=activation)(transferred_net.input) c_alt = kl.Conv2D(filters=256, kernel_size=[5, 5], padding='same', activation=activation)(c_alt) c_alt = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(c_alt) c_alt = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(c_alt) c_alt = kl.MaxPool2D(padding='same', pool_size=(2, 2))(c_alt) c_alt = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_alt) c_alt = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_alt) c_alt = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_alt) c_alt = kl.Conv2D(filters=transferred_net.output_shape[-1], kernel_size=[3, 3], padding='same', activation=activation)(c_alt) c_alt = kl.MaxPool2D(padding='same', pool_size=(2, 2))(c_alt) base_in = kl.concatenate([transferred_net.output, c_alt], axis=-1) c1 = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(base_in) c1 = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(c1) c1 = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c1) c_vec = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(base_in) c_vec = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_vec) c_vec = kl.Lambda(lambda x: x[:, 5:-5, 5:-5, :])(c_vec) c_vec_out_a = kl.Conv2D(filters=10, kernel_size=[3, 3], padding='same', activation='sigmoid')(c_vec) c_vec_out_b = kl.Conv2D(filters=10, kernel_size=[3, 3], padding='same', activation='sigmoid')(c_vec) c_vec_out = kl.subtract([c_vec_out_a, c_vec_out_b], name=OUT('field')) c_vec = kl.ZeroPadding2D(padding=(5, 5))(c_vec_out) c_vec = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_vec) c2_in = kl.concatenate([c1, c_vec], axis=-1) c2 = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c2_in) c2 = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c2) d2 = kl.SpatialDropout2D(rate=dropout_rate)(c2) c3 = kl.Conv2D(filters=64, kernel_size=[3, 3], padding='valid', activation=activation)(d2) c3 = kl.Lambda(lambda x: x[:, 5:-5, 5:-5, :])(c3) c3 = kl.Conv2D(filters=21, kernel_size=[3, 3], padding='valid', activation='sigmoid', name=OUT('heat'))(c3) # before the fully connected is built, cut down the dimensionality of the data bfc1 = kl.MaxPool2D(padding='valid', pool_size=(2, 2))(d2) bfc2 = kl.Conv2D(filters=32, kernel_size=[3, 3], padding='valid', activation=activation)(bfc1) base_fc = kl.Flatten()(bfc2) fc1 = kl.Dense(units=32, activation=activation)(base_fc) fc2 = kl.Dense(units=21, activation='sigmoid', name=OUT('vis'))(fc1) model = km.Model(inputs=(transferred_net.input,), outputs=(c3, fc2, c_vec_out)) return model
shuffle=False, class_mode=None, target_size=(300, 300)) input_1 = Input(shape=(300, 300, 3), dtype='float32', name='egal') # This is module with image preprocessing utilities z = layers.Dense(32, activation='tanh', input_shape=(300, 300, 3))(input_1) z = layers.MaxPooling2D((3, 3))(z) a_1 = layers.SeparableConv2D(64, (3, 3), activation='tanh', padding='same')(z) b_1 = layers.SeparableConv2D(64, (7, 7), activation='tanh', padding='same')(z) c_1 = layers.SeparableConv2D(64, (5, 5), activation='tanh', padding='same')(z) z = layers.concatenate([a_1, b_1, c_1]) z = layers.Conv2D(64, (1, 1))(z) z = layers.SpatialDropout2D(0.2)(z) z = layers.MaxPooling2D((3, 3))(z) a_2 = layers.SeparableConv2D(128, (5, 5), activation='tanh', padding='same')(z) d_2 = layers.GlobalMaxPooling2D()(a_2) b_2 = layers.SeparableConv2D(128, (7, 7), activation='tanh', padding='same')(z) e_2 = layers.GlobalMaxPooling2D()(b_2) c_2 = layers.SeparableConv2D(128, (9, 9), activation='tanh', padding='same')(z) f_2 = layers.GlobalMaxPooling2D()(c_2) z = layers.concatenate([a_2, b_2, c_2]) x = layers.concatenate([d_2, e_2, f_2]) z = layers.multiply([z, x]) z = layers.Conv2D(128, (1, 1))(z) z = layers.MaxPooling2D((3, 3))(z) a_3 = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z) z = layers.SpatialDropout2D(0.2)(a_3) z = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z)
def mb_conv_block(inputs, block_args, activation, drop_rate=None, prefix='', spatial_dropout=False): """Mobile Inverted Residual Bottleneck.""" has_se = (block_args.se_ratio is not None) and (0 < block_args.se_ratio <= 1) bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 # workaround over non working dropout with None in noise_shape in tf.keras Dropout = get_dropout(backend=backend, layers=layers, models=models, utils=keras_utils) # Expansion phase filters = block_args.input_filters * block_args.expand_ratio if block_args.expand_ratio != 1: x = layers.Conv2D(filters, 1, padding='same', use_bias=False, kernel_initializer=CONV_KERNEL_INITIALIZER, name=prefix + 'expand_conv')(inputs) x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'expand_bn')(x) x = layers.Activation(activation, name=prefix + 'expand_activation')(x) else: x = inputs # Depthwise Convolution x = layers.DepthwiseConv2D(block_args.kernel_size, strides=block_args.strides, padding='same', use_bias=False, depthwise_initializer=CONV_KERNEL_INITIALIZER, name=prefix + 'dwconv')(x) if spatial_dropout: x = layers.SpatialDropout2D(0.5)(x) x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'bn')(x) x = layers.Activation(activation, name=prefix + 'activation')(x) # Squeeze and Excitation phase if has_se: num_reduced_filters = max( 1, int(block_args.input_filters * block_args.se_ratio)) se_tensor = layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')(x) target_shape = ( 1, 1, filters) if backend.image_data_format() == 'channels_last' else ( filters, 1, 1) se_tensor = layers.Reshape(target_shape, name=prefix + 'se_reshape')(se_tensor) se_tensor = layers.Conv2D(num_reduced_filters, 1, activation=activation, padding='same', use_bias=True, kernel_initializer=CONV_KERNEL_INITIALIZER, name=prefix + 'se_reduce')(se_tensor) se_tensor = layers.Conv2D(filters, 1, activation='sigmoid', padding='same', use_bias=True, kernel_initializer=CONV_KERNEL_INITIALIZER, name=prefix + 'se_expand')(se_tensor) if backend.backend() == 'theano': # For the Theano backend, we have to explicitly make # the excitation weights broadcastable. pattern = ([True, True, True, False] if backend.image_data_format() == 'channels_last' else [True, False, True, True]) se_tensor = layers.Lambda( lambda x: backend.pattern_broadcast(x, pattern), name=prefix + 'se_broadcast')(se_tensor) x = layers.multiply([x, se_tensor], name=prefix + 'se_excite') # Output phase x = layers.Conv2D(block_args.output_filters, 1, padding='same', use_bias=False, kernel_initializer=CONV_KERNEL_INITIALIZER, name=prefix + 'project_conv')(x) x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'project_bn')(x) if block_args.id_skip and all( s == 1 for s in block_args.strides ) and block_args.input_filters == block_args.output_filters: if drop_rate and (drop_rate > 0): x = Dropout(drop_rate, noise_shape=(None, 1, 1, 1), name=prefix + 'drop')(x) x = layers.add([x, inputs], name=prefix + 'add') return x
def run(seg1_path, seg2_path, batch_size, lr, dropout_rate, data_path, artifacts_folder, img_size, seed, _run): artifacts_folder = Path(artifacts_folder) artifacts_folder.mkdir(parents=True, exist_ok=True) data_path = Path(data_path) data_df = pd.read_csv(data_path / 'train.csv') data_df = prepare_data_df(data_df) print(data_df.info()) print(data_df.head(10)) train_df, val_df = train_test_split(data_df, test_size=0.2, random_state=seed) train_df = train_df.sample(frac=1).reset_index(drop=True) ckpt_path = artifacts_folder / 'ckpts' ckpt_path.mkdir(exist_ok=True, parents=True) seg1_model = models.load_model(seg1_path, compile=False) for layer in seg1_model.layers: layer.name = f'seg1_{layer.name}' layer.trainable = False seg2_model = models.load_model(seg2_path, compile=False) for layer in seg2_model.layers: layer.name = f'seg2_{layer.name}' layer.trainable = False x = layers.concatenate([seg1_model.output, seg2_model.output]) x = layers.SpatialDropout2D(dropout_rate)(x) x = conv(x, 16, 3) x = layers.Conv2D(4, (1, 1))(x) o = layers.Activation('sigmoid', name='output_layer')(x) segmentation_model = models.Model([seg1_model.input, seg2_model.input], o) segmentation_model.compile( optimizers.Adam(lr), sm.losses.bce_dice_loss, metrics=[sm.metrics.iou_score, sm.metrics.f1_score]) utils.plot_model(segmentation_model, str(artifacts_folder / 'seg_model.png'), show_shapes=True) training_callbacks = [ callbacks.ReduceLROnPlateau(patience=3, verbose=1, min_lr=1e-7), callbacks.EarlyStopping(patience=5, verbose=1, restore_best_weights=True), callbacks.ModelCheckpoint(str( ckpt_path / 'seg_model-{epoch:04d}-{val_loss:.4f}.hdf5'), verbose=1, save_best_only=True), callbacks.TensorBoard(log_dir=str(artifacts_folder / 'tb_logs')), callbacks.TerminateOnNaN(), ObserveMetrics(_run, 'seg') ] train_seq = DataSequence(seed, train_df, batch_size, img_size, 'data/train_images', mode='train', shuffle=True, augment=True, for_stacker=True) val_seq = DataSequence(seed, val_df, batch_size, img_size, 'data/train_images', mode='val', shuffle=False, augment=False, for_stacker=True) history = train_model(segmentation_model, train_seq, val_seq, training_callbacks) models.save_model(segmentation_model, str(artifacts_folder / 'seg_model_best.h5')) segmentation_model.save_weights( str(artifacts_folder / 'weights_seg_model_best.h5')) print('loading model back') del segmentation_model segmentation_model = models.load_model(str(artifacts_folder / 'seg_model_best.h5'), compile=False) segmentation_model.predict_generator(val_seq, verbose=1) return history.history['val_loss'][-1]
def _separable_conv_block(ip, filters, kernel_size=(3, 3), strides=(1, 1), block_id=None): '''Adds 2 blocks of [relu-separable conv-batchnorm]. # Arguments ip: Input tensor filters: Number of output filters per layer kernel_size: Kernel size of separable convolutions strides: Strided convolution for downsampling block_id: String block_id # Returns A Keras tensor ''' channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1 with backend.name_scope('separable_conv_block_%s' % block_id): x = layers.Activation('relu')(ip) if strides == (2, 2): x = layers.ZeroPadding2D( padding=correct_pad(backend, x, kernel_size), name='separable_conv_1_pad_%s' % block_id)(x) conv_pad = 'valid' else: conv_pad = 'same' x = layers.SeparableConv2D(filters, kernel_size, strides=strides, name='separable_conv_1_%s' % block_id, padding=conv_pad, use_bias=False, depthwise_regularizer=l2(weight_decay), pointwise_regularizer=l2(weight_decay), kernel_initializer='he_normal')(x) if use_bn: x = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='separable_conv_1_bn_%s' % (block_id))(x) x = layers.SpatialDropout2D(drop_p)(x) x = layers.Activation('relu')(x) x = layers.SeparableConv2D(filters, kernel_size, name='separable_conv_2_%s' % block_id, padding='same', use_bias=False, depthwise_regularizer=l2(weight_decay), pointwise_regularizer=l2(weight_decay), kernel_initializer='he_normal')(x) if use_bn: x = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='separable_conv_2_bn_%s' % (block_id))(x) x = layers.SpatialDropout2D(drop_p)(x) return x
base_pretrained_model = PTModel(input_shape=t_x.shape[1:], include_top=False, weights='imagenet') base_pretrained_model.trainable = False # In[ ]: from keras import models, layers from keras.optimizers import Adam img_in = layers.Input(t_x.shape[1:], name='Image_RGB_In') img_noise = layers.GaussianNoise(GAUSSIAN_NOISE)(img_in) pt_features = base_pretrained_model(img_noise) pt_depth = base_pretrained_model.get_output_shape_at(0)[-1] bn_features = layers.BatchNormalization()(pt_features) feature_dropout = layers.SpatialDropout2D(DROPOUT)(bn_features) gmp_dr = layers.GlobalMaxPooling2D()(feature_dropout) dr_steps = layers.Dropout(DROPOUT)(layers.Dense(DENSE_COUNT, activation='relu')(gmp_dr)) out_layer = layers.Dense(1, activation='sigmoid')(dr_steps) ship_model = models.Model(inputs=[img_in], outputs=[out_layer], name='full_model') ship_model.compile(optimizer=Adam(lr=LEARN_RATE), loss='binary_crossentropy', metrics=['binary_accuracy']) # In[ ]:
def _adjust_block(p, ip, filters, block_id=None): '''Adjusts the input `previous path` to match the shape of the `input`. Used in situations where the output number of filters needs to be changed. # Arguments p: Input tensor which needs to be modified ip: Input tensor whose shape needs to be matched filters: Number of output filters to be matched block_id: String block_id # Returns Adjusted Keras tensor ''' channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1 img_dim = 2 if backend.image_data_format() == 'channels_first' else -2 ip_shape = backend.int_shape(ip) if p is not None: p_shape = backend.int_shape(p) with backend.name_scope('adjust_block'): if p is None: p = ip elif p_shape[img_dim] != ip_shape[img_dim]: with backend.name_scope('adjust_reduction_block_%s' % block_id): p = layers.Activation('relu', name='adjust_relu_1_%s' % block_id)(p) p1 = layers.AveragePooling2D( (1, 1), strides=(2, 2), padding='valid', name='adjust_avg_pool_1_%s' % block_id)(p) p1 = layers.Conv2D(filters // 2, (1, 1), padding='same', kernel_regularizer=l2(weight_decay), use_bias=False, name='adjust_conv_1_%s' % block_id, kernel_initializer='he_normal')(p1) p2 = layers.ZeroPadding2D(padding=((0, 1), (0, 1)))(p) p2 = layers.Cropping2D(cropping=((1, 0), (1, 0)))(p2) p2 = layers.AveragePooling2D( (1, 1), strides=(2, 2), padding='valid', name='adjust_avg_pool_2_%s' % block_id)(p2) p2 = layers.Conv2D(filters // 2, (1, 1), padding='same', kernel_regularizer=l2(weight_decay), use_bias=False, name='adjust_conv_2_%s' % block_id, kernel_initializer='he_normal')(p2) p = layers.concatenate([p1, p2], axis=channel_dim) if use_bn: p = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='adjust_bn_%s' % block_id)(p) p = layers.SpatialDropout2D(drop_p)(p) elif p_shape[channel_dim] != filters: with backend.name_scope('adjust_projection_block_%s' % block_id): p = layers.Activation('relu')(p) p = layers.Conv2D(filters, (1, 1), strides=(1, 1), kernel_regularizer=l2(weight_decay), padding='same', name='adjust_conv_projection_%s' % block_id, use_bias=False, kernel_initializer='he_normal')(p) if use_bn: p = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='adjust_bn_%s' % block_id)(p) p = layers.SpatialDropout2D(drop_p)(p) return p
def D3GenerateModel(n_filter=16, number_of_class=1, input_shape=(16, 144, 144, 1), activation_last='softmax', metrics=[ 'mse', 'acc', dice_coef, recall_at_thresholds, precision_at_thresholds ], loss='kullback_leibler_divergence', dropout=0.05, init='glorot_uniform', two_output=False): #init = initializers.VarianceScaling(scale=1.0, mode='fan_in', distribution='normal', seed=None) filter_size = n_filter input_x = layers.Input(shape=input_shape, name='Input_layer', dtype='float32') #1 level x = layers.Conv3D(filters=filter_size, kernel_size=(3, 3, 3), strides=(1, 1, 1), kernel_initializer=init, padding='same')(input_x) x = cyclical_learning_rate.SineReLU()(x) x = layers.Conv3D(filters=filter_size, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=init)(x) x = cyclical_learning_rate.SineReLU()(x) x = layers.MaxPooling3D(pool_size=(2, 2, 2), padding='same')(x) #2 level conv_list = [] counter = 0 x = layers.Conv3D(filters=filter_size * 2, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=init)(x) x = cyclical_learning_rate.SineReLU()(x) x = layers.MaxPooling3D(pool_size=(1, 2, 2), padding='same')(x) x = layers.UpSampling3D(size=(1, 2, 2))(x) for index, kernel_sizes in enumerate([ [(1, 3, 3), (3, 3, 1)], #Changed [(1,3,3), (1,1,3)] [(3, 3, 3), (3, 1, 3)], #Changed [(3,3,3), (3,1,3)] [(3, 3, 1), (3, 3, 3), (1, 3, 3)] #Changed [(3,3,1), (1,3,1)] ]): for kernel_size in (kernel_sizes): x = layers.Conv3D(filters=(filter_size * 4), kernel_size=kernel_size, kernel_initializer=init, strides=(1, 1, 1), padding='same', name='Conv3D_%s' % (counter))(x) x = layers.BatchNormalization()(x) x = cyclical_learning_rate.SineReLU()(x) counter = counter + 1 conv_list.append(x) x = layers.add(conv_list) x = layers.Conv3D(filters=filter_size * 4, kernel_size=(3, 3, 3), strides=(2, 2, 2), kernel_initializer=init, padding='same')(x) x = layers.Reshape(target_shape=[4, -1, filter_size * 4])(x) x = layers.Conv2D(filters=filter_size * 4, kernel_size=(1, 1296), kernel_initializer=init, strides=(1, 1296))(x) x = layers.SpatialDropout2D(0.01)(x) x = cyclical_learning_rate.SineReLU()(x) x = layers.Reshape(target_shape=[filter_size * 4, -1])(x) x = layers.Conv1D(filters=2, kernel_size=filter_size * 4, strides=filter_size * 4, kernel_initializer=init, kernel_regularizer=l2(0.001))(x) x = layers.Softmax()(x) y = layers.Flatten()(x) #Classification model = Model(inputs=input_x, outputs=y) #optimizer = tf.contrib.opt.AdamWOptimizer(weight_decay=0.000001,lr=lr) #keras.optimizers.SGD(lr=lr, momentum=0.90, decay=decay, nesterov=False) #opt_noise = add_gradient_noise(optimizers.Adam) #optimizer = 'Adam'#opt_noise(lr, amsgrad=True)#, nesterov=True)#opt_noise(lr, amsgrad=True) import yogi optimizer = yogi.Yogi(lr=lr) #optimizer=optimizers.adam(lr, amsgrad=True) model.compile(optimizer=optimizer, loss=loss, metrics=metrics) #categorical_crossentropy return model
def NASNet(input_shape=None, penultimate_filters=4032, num_blocks=6, stem_block_filters=96, skip_reduction=True, filter_multiplier=2, include_top=True, weights=None, input_tensor=None, pooling=None, classes=1000, default_size=None, **kwargs): '''Instantiates a NASNet model. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments input_shape: Optional shape tuple, the input shape is by default `(331, 331, 3)` for NASNetLarge and `(224, 224, 3)` for NASNetMobile. It should have exactly 3 input channels, and width and height should be no smaller than 32. E.g. `(224, 224, 3)` would be one valid value. penultimate_filters: Number of filters in the penultimate layer. NASNet models use the notation `NASNet (N @ P)`, where: - N is the number of blocks - P is the number of penultimate filters num_blocks: Number of repeated blocks of the NASNet model. NASNet models use the notation `NASNet (N @ P)`, where: - N is the number of blocks - P is the number of penultimate filters stem_block_filters: Number of filters in the initial stem block skip_reduction: Whether to skip the reduction step at the tail end of the network. filter_multiplier: Controls the width of the network. - If `filter_multiplier` < 1.0, proportionally decreases the number of filters in each layer. - If `filter_multiplier` > 1.0, proportionally increases the number of filters in each layer. - If `filter_multiplier` = 1, default number of filters from the paper are used at each layer. include_top: Whether to include the fully-connected layer at the top of the network. weights: `None` (random initialization) or `imagenet` (ImageNet weights) input_tensor: Optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. 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. classes: Optional number of classes to classify images into, only to be specified if `include_top` is True, and if no `weights` argument is specified. default_size: Specifies the default image size of the model # Returns A Keras model instance. # Raises ValueError: In case of invalid argument for `weights`, invalid input shape or invalid `penultimate_filters` value. ''' # global backend, layers, models, keras_utils # backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) if not (weights in {'imagenet', None} or os.path.exists(weights)): raise ValueError('The `weights` argument should be either ' '`None` (random initialization), `imagenet` ' '(pre-training on ImageNet), ' 'or the path to the weights file to be loaded.') if weights == 'imagenet' and include_top and classes != 1000: raise ValueError( 'If using `weights` as `"imagenet"` with `include_top` ' 'as true, `classes` should be 1000') if (isinstance(input_shape, tuple) and None in input_shape and weights == 'imagenet'): raise ValueError('When specifying the input shape of a NASNet' ' and loading `ImageNet` weights, ' 'the input_shape argument must be static ' '(no None entries). Got: `input_shape=' + str(input_shape) + '`.') if default_size is None: default_size = 331 # Determine proper input shape and default size. input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if backend.image_data_format() != 'channels_last': warnings.warn('The NASNet family of models is only available ' 'for the input data format "channels_last" ' '(width, height, channels). ' 'However your settings specify the default ' 'data format "channels_first" (channels, width, height).' ' You should set `image_data_format="channels_last"` ' 'in your Keras config located at ~/.keras/keras.json. ' 'The model being returned right now will expect inputs ' 'to follow the "channels_last" data format.') backend.set_image_data_format('channels_last') old_data_format = 'channels_first' else: old_data_format = None if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if penultimate_filters % 24 != 0: raise ValueError( 'For NASNet-A models, the value of `penultimate_filters` ' 'needs to be divisible by 24. Current value: %d' % penultimate_filters) channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1 filters = penultimate_filters // 24 x = layers.Conv2D(stem_block_filters, (3, 3), strides=(2, 2), padding='same', use_bias=False, kernel_regularizer=l2(weight_decay), name='stem_conv1', kernel_initializer='he_normal')(img_input) if use_bn: x = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='stem_bn1')(x) x = layers.SpatialDropout2D(drop_p)(x) x = csSE_block(x, 'res_2x') p = None x, p = _reduction_a_cell(x, p, filters // (filter_multiplier**2), block_id='stem_1') x = csSE_block(x, 'res_4x') x, p = _reduction_a_cell(x, p, filters // filter_multiplier, block_id='stem_2') for i in range(num_blocks): x, p = _normal_a_cell(x, p, filters, block_id='%d' % (i)) x = csSE_block(x, 'res_8x') x, p0 = _reduction_a_cell(x, p, filters * filter_multiplier, block_id='reduce_%d' % (num_blocks)) p = p0 if not skip_reduction else p for i in range(num_blocks): x, p = _normal_a_cell(x, p, filters * filter_multiplier, block_id='%d' % (num_blocks + i + 1)) x = csSE_block(x, 'res_16x') x, p0 = _reduction_a_cell(x, p, filters * filter_multiplier**2, block_id='reduce_%d' % (2 * num_blocks)) p = p0 if not skip_reduction else p for i in range(num_blocks): x, p = _normal_a_cell(x, p, filters * filter_multiplier**2, block_id='%d' % (2 * num_blocks + i + 1)) x = csSE_block(x, 'res_32x') x = layers.Activation('relu')(x) if include_top: x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input model = models.Model(inputs, x, name='NASNet') # Load weights. if weights == 'imagenet': if default_size == 224: # mobile version if include_top: weights_path = keras_utils.get_file( 'nasnet_mobile.h5', NASNET_MOBILE_WEIGHT_PATH, cache_subdir='models', file_hash='020fb642bf7360b370c678b08e0adf61') else: weights_path = keras_utils.get_file( 'nasnet_mobile_no_top.h5', NASNET_MOBILE_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='1ed92395b5b598bdda52abe5c0dbfd63') model.load_weights(weights_path, by_name=True, skip_mismatch=True) elif default_size == 331: # large version if include_top: weights_path = keras_utils.get_file( 'nasnet_large.h5', NASNET_LARGE_WEIGHT_PATH, cache_subdir='models', file_hash='11577c9a518f0070763c2b964a382f17') else: weights_path = keras_utils.get_file( 'nasnet_large_no_top.h5', NASNET_LARGE_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='d81d89dc07e6e56530c4e77faddd61b5') model.load_weights(weights_path, by_name=True, skip_mismatch=True) else: raise ValueError( 'ImageNet weights can only be loaded with NASNetLarge' ' or NASNetMobile') elif weights is not None: model.load_weights(weights, by_name=True, skip_mismatch=True) if old_data_format: backend.set_image_data_format(old_data_format) return model
def D3GenerateModel(n_filter=16, number_of_class=1, input_shape=(16, 144, 144, 1), activation_last='sigmoid', metrics=[ 'mse', 'acc', dice_coef, recall_at_thresholds, precision_at_thresholds, auc_roc ], loss='binary_crossentropy', dropout=0.05, init='glorot_uniform', two_output=False): filter_size = n_filter input_x = layers.Input(shape=input_shape, name='Input_layer', dtype='float32') #1 level x = layers.Conv3D(filters=filter_size * 2, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same')(input_x) x = layers.LeakyReLU()(x) x = layers.Conv3D(filters=filter_size * 4, kernel_size=(3, 3, 3), strides=(1, 1, 1), padding='same')(x) x = layers.LeakyReLU()(x) x = layers.MaxPooling3D(pool_size=(2, 2, 2), padding='same')(x) #2 level conv_list = [] counter = 0 for index, kernel_sizes in enumerate([[(1, 3, 3), (1, 1, 3)], [(3, 3, 3), (3, 1, 3)], [(3, 3, 1), (1, 3, 1)]]): for kernel_size in (kernel_sizes): x = layers.Conv3D(filters=(filter_size * 8), kernel_size=kernel_size, strides=(1, 1, 1), padding='same', name='Conv3D_%s' % (counter))(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU()(x) x = layers.SpatialDropout3D(dropout)(x) counter = counter + 1 conv_list.append(x) x = layers.add(conv_list) x = layers.Conv3D(filters=filter_size * 8, kernel_size=(3, 3, 3), strides=(2, 2, 2), padding='same')(x) x = layers.Reshape(target_shape=[4, -1, filter_size * 8])(x) x = layers.Conv2D(filters=128, kernel_size=(1, 1296), strides=(1, 1296))(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) x = layers.SpatialDropout2D(dropout)(x) #x = layers.Lambda(squash)(x) #x = layers.Softmax()(x) x = layers.Reshape(target_shape=[128, -1])(x) x = layers.Conv1D(filters=2, kernel_size=128, strides=128, activation='sigmoid')(x) y = layers.Flatten()(x) #Classification model = Model(inputs=input_x, outputs=y) #keras.optimizers.SGD(lr=lr, momentum=0.90, decay=decay, nesterov=False) opt_noise = add_gradient_noise(optimizers.Adam) optimizer = opt_noise( lr, amsgrad=True) #, nesterov=True)#opt_noise(lr, amsgrad=True) model.compile(optimizer=optimizer, loss=loss, metrics=metrics) #categorical_crossentropy return model
def __init__(self, filters_size, dropout_rate): self._convo_block = ConvoBlock(filters_size) self._max_pool = layers.MaxPooling2D((2, 2)) self._dropout = layers.SpatialDropout2D(rate=dropout_rate)