def _create_model(self, input_shape, dropout=0, last_activation='sigmoid'): resnet_base = ResNet50(input_shape=input_shape, include_top=False) for l in resnet_base.layers: l.trainable = True conv1 = resnet_base.get_layer("activation_1").output conv2 = resnet_base.get_layer("activation_10").output conv3 = resnet_base.get_layer("activation_22").output conv4 = resnet_base.get_layer("activation_40").output conv5 = resnet_base.get_layer("activation_49").output up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1) conv6 = conv_block_simple(up6, 256, "conv6_1") conv6 = conv_block_simple(conv6, 256, "conv6_2") up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1) conv7 = conv_block_simple(up7, 192, "conv7_1") conv7 = conv_block_simple(conv7, 192, "conv7_2") up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1) conv8 = conv_block_simple(up8, 128, "conv8_1") conv8 = conv_block_simple(conv8, 128, "conv8_2") up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1) conv9 = conv_block_simple(up9, 64, "conv9_1") conv9 = conv_block_simple(conv9, 64, "conv9_2") vgg = VGG16(input_shape=input_shape, input_tensor=resnet_base.input, include_top=False) for l in vgg.layers: l.trainable = False vgg_first_conv = vgg.get_layer("block1_conv2").output up10 = concatenate( [UpSampling2D()(conv9), resnet_base.input, vgg_first_conv], axis=-1) conv10 = conv_block_simple(up10, 32, "conv10_1") conv10 = conv_block_simple(conv10, 32, "conv10_2") conv10 = SpatialDropout2D(0.2)(conv10) x = Conv2D(1, (1, 1), activation=last_activation, name="prediction")(conv10) model = Model(resnet_base.input, x) return model
def dsv(x, size, scale_factor, dropout=0.0, batch_norm=True): if K.image_dim_ordering() == 'th': axis = 1 else: axis = 3 conv = Conv2D(size, (3, 3), padding='same')(x) if batch_norm is True: conv = BatchNormalization(axis=axis)(conv) conv = Activation('relu')(conv) conv = Conv2D(size, (3, 3), padding='same')(conv) if batch_norm is True: conv = BatchNormalization(axis=axis)(conv) conv = Activation('relu')(conv) if dropout > 0: conv = SpatialDropout2D(dropout)(conv) upsampler = UpSampling2DBilinear(stride=scale_factor)(conv) return upsampler
def double_conv_layer(x, size, dropout=0.0, batch_norm=True): if K.image_dim_ordering() == 'th': axis = 1 else: axis = 3 conv = Conv2D( size, (3, 3), padding='same', )(x) if batch_norm is True: conv = BatchNormalization(axis=axis)(conv) conv = Activation('relu')(conv) conv = Conv2D(size, (3, 3), padding='same')(conv) if batch_norm is True: conv = BatchNormalization(axis=axis)(conv) conv = Activation('relu')(conv) if dropout > 0: conv = SpatialDropout2D(dropout)(conv) return conv
def get_unet_resnet(input_shape): resnet_base = ResNet50(input_shape=input_shape, include_top=False) # for idx,l in enumerate(resnet_base.layers): # if idx <= 78 : # l.trainable = False # else: # l.trainable = True for l in resnet_base.layers: l.trainable = True conv1 = resnet_base.get_layer("activation_1").output conv2 = resnet_base.get_layer("activation_10").output conv3 = resnet_base.get_layer("activation_22").output conv4 = resnet_base.get_layer("activation_40").output conv5 = resnet_base.get_layer("activation_49").output up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1) conv6 = conv_block_simple(up6, 256, "conv6_1") conv6 = conv_block_simple(conv6, 256, "conv6_2") up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1) conv7 = conv_block_simple(up7, 192, "conv7_1") conv7 = conv_block_simple(conv7, 192, "conv7_2") up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1) conv8 = conv_block_simple(up8, 128, "conv8_1") conv8 = conv_block_simple(conv8, 128, "conv8_2") up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1) conv9 = conv_block_simple(up9, 64, "conv9_1") conv9 = conv_block_simple(conv9, 64, "conv9_2") up10 = UpSampling2D()(conv9) conv10 = conv_block_simple(up10, 32, "conv10_1") conv10 = conv_block_simple(conv10, 32, "conv10_2") conv10 = SpatialDropout2D(0.2)(conv10) x = Conv2D(1, (1, 1), activation="sigmoid", name="prediction")(conv10) model = Model(resnet_base.input, x) return model
def bottleneck(inputData, output, internal_scale=4, asymmetric=0, dilated=0, downsample=False, dropout_rate=0.1): internal = output // internal_scale encodeData = inputData if downsample: input_stride = 2 else: input_stride=1 encodeData = Conv2D(internal, (input_stride, input_stride), strides=(input_stride, input_stride), use_bias=False)(encoder) encodeData = BatchNormalization(momentum=0.1)(encodeData) encodeData = PReLU(shared_axes=[1, 2])(encodeData) if not asymmetric and not dilated: encodeData = Conv2D(internal, (3, 3), padding='same')(encodeData) elif asymmetric: encodeData = Conv2D(internal, (1, asymmetric), padding='same', use_bias=False)(encodeData) encodeData = Conv2D(internal, (asymmetric, 1), padding='same')(encodeData) else : encodeData = Conv2D(internal, (3, 3), dilation_rate=(dilated, dilated), padding='same')(encodeData) encodeData = BatchNormalization(momentum=0.1)(encodeData) encodeData = PReLU(shared_axes=[1, 2])(encodeData) encodeData = Conv2D(output, (1, 1), use_bias=False)(encodeData) encodeData = BatchNormalization(momentum=0.1)(encodeData) encodeData = SpatialDropout2D(dropout_rate)(encodeData) prevData = inputData if downsample: prevData = MaxPooling2D()(prevData) prevData = Permute((1, 3, 2))(prevData) pad_feature_maps = prevData - inputData.get_shape().as_list()[3] tb_pad = (0, 0) lr_pad = (0, pad_feature_maps) prevData = ZeroPadding2D(padding=(tb_pad, lr_pad))(other) prevData = Permute((1, 3, 2))(other) encodeData = add([encodeData, prevData]) encodeData = PReLU(shared_axes=[1, 2])(encodeData) return encodeData
def get_unet_inception_resnet_v2(input_shape, numberOfMaskChannels): if numberOfMaskChannels == 1: base_model = GetOrBuildModel("./encoder_models/inception_resnet_v2_model_untrained_1_channel_masks_notop.h5", input_shape) elif numberOfMaskChannels == 2: base_model = GetOrBuildModel("./encoder_models/inception_resnet_v2_model_untrained_2_channel_masks_notop.h5", input_shape) else: raise ValueError('numberOfMaskChannels must be 1 or 2') conv1 = base_model.get_layer('activation_3').output conv2 = base_model.get_layer('activation_5').output conv3 = base_model.get_layer('block35_10_ac').output conv4 = base_model.get_layer('block17_20_ac').output conv5 = base_model.get_layer('conv_7b_ac').output up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1) conv6 = conv_block_simple(up6, 256, "conv6_1") conv6 = conv_block_simple(conv6, 256, "conv6_2") up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1) conv7 = conv_block_simple(up7, 256, "conv7_1") conv7 = conv_block_simple(conv7, 256, "conv7_2") up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1) conv8 = conv_block_simple(up8, 128, "conv8_1") conv8 = conv_block_simple(conv8, 128, "conv8_2") up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1) conv9 = conv_block_simple(up9, 64, "conv9_1") conv9 = conv_block_simple(conv9, 64, "conv9_2") up10 = concatenate([UpSampling2D()(conv9), base_model.input], axis=-1) conv10 = conv_block_simple(up10, 48, "conv10_1") conv10 = conv_block_simple(conv10, 32, "conv10_2") conv10 = SpatialDropout2D(0.4)(conv10) if numberOfMaskChannels == 1: x = Conv2D(1, (1, 1), activation="sigmoid", name="prediction")(conv10) elif numberOfMaskChannels == 2: x = Conv2D(2, (1, 1), activation="sigmoid", name="prediction")(conv10) model = Model(base_model.input, x) return model
def get_simple_unet(input_shape): img_input = Input(input_shape) conv1 = conv_block_simple(img_input, 32, "conv1_1") conv1 = conv_block_simple(conv1, 32, "conv1_2") pool1 = MaxPooling2D((2, 2), strides=(2, 2), padding="same", name="pool1")(conv1) conv2 = conv_block_simple(pool1, 64, "conv2_1") conv2 = conv_block_simple(conv2, 64, "conv2_2") pool2 = MaxPooling2D((2, 2), strides=(2, 2), padding="same", name="pool2")(conv2) conv3 = conv_block_simple(pool2, 128, "conv3_1") conv3 = conv_block_simple(conv3, 128, "conv3_2") pool3 = MaxPooling2D((2, 2), strides=(2, 2), padding="same", name="pool3")(conv3) conv4 = conv_block_simple(pool3, 256, "conv4_1") conv4 = conv_block_simple(conv4, 256, "conv4_2") conv4 = conv_block_simple(conv4, 256, "conv4_3") up5 = concatenate([UpSampling2D()(conv4), conv3], axis=-1) conv5 = conv_block_simple(up5, 128, "conv5_1") conv5 = conv_block_simple(conv5, 128, "conv5_2") up6 = concatenate([UpSampling2D()(conv5), conv2], axis=-1) conv6 = conv_block_simple(up6, 64, "conv6_1") conv6 = conv_block_simple(conv6, 64, "conv6_2") up7 = concatenate([UpSampling2D()(conv6), conv1], axis=-1) conv7 = conv_block_simple(up7, 32, "conv7_1") conv7 = conv_block_simple(conv7, 32, "conv7_2") conv7 = SpatialDropout2D(0.2)(conv7) prediction = Conv2D(1, (1, 1), activation="sigmoid", name="prediction")(conv7) model = Model(img_input, prediction) return model
def conv2d_basic(x, filters, kernel_size=(3, 3), strides=(1, 1), dilation_rate=(1, 1), padding='same', activation='selu', dropout=0.2, weight_decay=1e-4, name=None): """Utility function to apply conv + BN. # Arguments x: input tensor. filters: filters in `Conv2D`. kernel_size: kernel size as in `Conv2D`. strides: strides in `Conv2D`. padding: padding mode in `Conv2D`. activation: activation in `Conv2D`. use_bias: whether to use a bias in `Conv2D`. name: name of the ops; will become `name + '_ac'` for the activation and `name + '_bn'` for the batch norm layer. # Returns Output tensor after applying `Conv2D` and `BatchNormalization`. """ x = Conv2D(filters, kernel_size, strides=strides, dilation_rate=dilation_rate, padding=padding, kernel_initializer='he_normal', kernel_regularizer=l2(weight_decay), name=name)(x) if activation is not None: ac_name = None if name is None else name + '_ac' x = Activation(activation, name=ac_name)(x) x = SpatialDropout2D(dropout)(x) return x
def double_conv_layer(inputs: tf_tensor, filter: int) -> tf_tensor: """Create a double convolution layer with mentioned inputs and filters. Parameters ---------- inputs: tf_tensor input keras layer filter: int filter size/ kernal size for the tf_tensor Returns ------- tf_tensor tensor with mentioned number of filters Example ------- robin.unet.double_conv_layer(Input, 32) """ conv = Conv2D( filter, (3, 3), padding="same", kernel_initializer="he_normal")(inputs) conv = BatchNormalization(axis=3)(conv) conv = Activation("relu")(conv) conv = Conv2D( filter, (3, 3), padding="same", kernel_initializer="he_normal")(conv) conv = BatchNormalization(axis=3)(conv) conv = Activation("relu")(conv) conv = SpatialDropout2D(0.1)(conv) return conv
def build_model(input_shape): input_tensor = Input(shape=input_shape) resnet_base = ResNet50(input_tensor=input_tensor, weights='imagenet', include_top=False) #resnet_base.summary() for l in resnet_base.layers: l.trainable = True conv1 = resnet_base.get_layer("activation_1").output conv2 = resnet_base.get_layer("activation_10").output conv3 = resnet_base.get_layer("activation_22").output conv4 = resnet_base.get_layer("activation_40").output conv5 = resnet_base.get_layer("activation_49").output up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1) conv6 = conv_block_simple(up6, 256, "conv6_1") conv6 = conv_block_simple(conv6, 256, "conv6_2") up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1) conv7 = conv_block_simple(up7, 192, "conv7_1") conv7 = conv_block_simple(conv7, 192, "conv7_2") up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1) conv8 = conv_block_simple(up8, 128, "conv8_1") conv8 = conv_block_simple(conv8, 128, "conv8_2") up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1) conv9 = conv_block_simple(up9, 64, "conv9_1") conv9 = conv_block_simple(conv9, 64, "conv9_2") up10 = UpSampling2D()(conv9) conv10 = conv_block_simple(up10, 32, "conv10_1") conv10 = conv_block_simple(conv10, 32, "conv10_2") conv10 = SpatialDropout2D(0.2)(conv10) x = Conv2D(4, (1, 1), activation="sigmoid", name="prediction")(conv10) model = Model(inputs=[resnet_base.input], outputs=[x]) return model
def build_discriminator(size): model = Sequential(name='discriminator') f = 64 s = size while s > 7: if s == size: model.add( Conv2D(filters=f, kernel_size=7, strides=1, padding='same', input_shape=(size, size, 10))) else: model.add( Conv2D(filters=f, kernel_size=7, strides=1, padding='same')) model.add(BatchNormalization(momentum=0.8, axis=3)) model.add(Activation('relu')) model.add(Conv2D(filters=f, kernel_size=3, strides=1, padding='same')) model.add(BatchNormalization(momentum=0.8, axis=3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.2)) f = f * 2 s = s // 2 model.add(GlobalAveragePooling2D()) model.add(Dense(1, activation='sigmoid')) model.trainable = True return model
def get_model(shape, dropout=0.5, path=None): print('building neural network') model=Sequential() model.add(Convolution2D(512, 3, 3, border_mode='same', input_shape=shape)) model.add(Activation('relu')) model.add(Convolution2D(512, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(dropout)) model.add(Flatten())#input_shape=shape)) # model.add(Dense(4096)) # model.add(Activation('relu')) # model.add(Dropout(0.5)) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1)) #model.add(Activation('linear')) return model
def model_init(input_shape, **kwargs): from keras.models import Sequential from keras.layers.core import Dense, Activation, Flatten, Dropout from keras.layers.convolutional import Convolution2D, MaxPooling2D from keras.layers.normalization import BatchNormalization from keras.layers import GlobalAveragePooling2D assert (len(input_shape) == 3) try: from keras.layers.core import SpatialDropout2D except: from keras import __version__ as __kv__ from warnings import warn warn('no SpatialDropout2D layer in keras version: %s' % __kv__) SpatialDropout2D = Dropout # need to set the input_shape to first layer for a new model model = Sequential() model.add( Convolution2D(64, (3, 3), padding='same', input_shape=input_shape)) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(64, (3, 3))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(64, (2, 2), padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(64, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(72, (2, 2), padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(72, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.3)) model.add(Convolution2D(96, (2, 2), padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(96, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.4)) model.add(GlobalAveragePooling2D()) model.add(Dense(2048)) model.add(Activation('relu')) model.add(Dropout(0.5)) return dict(model=model, lr_mult=1.0)
train_generator = generate(train_samples) validation_generator = generate(validation_samples, train=False) import keras from keras.models import Sequential from keras.layers import Flatten, Dense, Lambda, Cropping2D, Dropout from keras.layers.convolutional import Convolution2D from keras.layers.core import SpatialDropout2D from keras.callbacks import ModelCheckpoint, EarlyStopping model = Sequential() model.add(Lambda(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))) model.add(Cropping2D(cropping=((70, 25), (0, 0)))) model.add(Convolution2D(24, 5, 5, subsample=(2, 2), activation='relu')) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(36, 5, 5, subsample=(2, 2), activation='relu')) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(48, 5, 5, subsample=(2, 2), activation='relu')) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(64, 3, 3, activation='relu')) model.add(Convolution2D(64, 3, 3, activation='relu')) model.add(Flatten()) model.add(Dense(100)) model.add(Dropout(0.1)) model.add(Dense(50)) model.add(Dropout(0.1)) model.add(Dense(1)) print('training') ''' callbacks are to make useful check points and to make the training stop as optimum as possible
model.add(Cropping2D(cropping=((75, 20), (0, 0)), input_shape=(180, 320, 3))) # Preprocess incoming data, centered around zero with small standard deviation #model.add(Lambda(lambda x: (x / 255.0) - 0.5)) #Nvidia model model.add( Convolution2D(24, (5, 5), activation="relu", name="conv_1", strides=(2, 2))) model.add( Convolution2D(36, (5, 5), activation="relu", name="conv_2", strides=(2, 2))) model.add( Convolution2D(48, (5, 5), activation="relu", name="conv_3", strides=(2, 2))) model.add(SpatialDropout2D(.5, dim_ordering='default')) model.add( Convolution2D(64, (3, 3), activation="relu", name="conv_4", strides=(1, 1))) model.add( Convolution2D(64, (3, 3), activation="relu", name="conv_5", strides=(1, 1))) model.add(Flatten()) model.add(Dense(1164)) model.add(Dropout(.5)) model.add(Dense(100, activation='relu')) model.add(Dropout(.5)) model.add(Dense(50, activation='relu'))
def run(): driving_log = pd.read_csv(data_path, names=('Center Image', 'Left Image', 'Right Image', 'Steering Angle', 'Throttle', 'Break', 'Speed')) image_names_full = [] y_data_full = [] for index, row in driving_log.iterrows(): center_img = row['Center Image'] left_img = row['Left Image'].strip() right_img = row['Right Image'].strip() steering_angle = row['Steering Angle'] image_names_full.append(center_img) y_data_full.append(steering_angle) left = steering_angle + angle_correction right = steering_angle - angle_correction image_names_full.append(left_img) y_data_full.append(left) image_names_full.append(right_img) y_data_full.append(right) image_names_full, y_data_full = np.array(image_names_full), np.array( y_data_full) print('CSV loaded') #split data X_train, X_val, y_train, y_val = train_test_split(image_names_full, y_data_full, test_size=0.2) #model model = Sequential() model.add( Cropping2D(cropping=((60, 20), (0, 0)), input_shape=(160, 320, 3))) model.add(Lambda(resize)) model.add(BatchNormalization(axis=1)) model.add(Convolution2D(24, 5, 5, border_mode='same', activation='elu')) model.add(MaxPooling2D(border_mode='same')) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(36, 5, 5, border_mode='same', activation='elu')) model.add(MaxPooling2D(border_mode='same')) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(48, 5, 5, border_mode='same', activation='elu')) model.add(MaxPooling2D(border_mode='same')) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(64, 3, 3, border_mode='same', activation='elu')) model.add(MaxPooling2D(border_mode='same')) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(64, 3, 3, border_mode='same', activation='elu')) model.add(MaxPooling2D(border_mode='same')) model.add(SpatialDropout2D(0.2)) model.add(Flatten()) # Fully connected layers model.add(Dense(100, activation='elu', W_regularizer=l2(1e-6))) model.add(Dense(50, activation='elu', W_regularizer=l2(1e-6))) model.add(Dense(10, activation='elu', W_regularizer=l2(1e-6))) model.add(Dense(1)) #summary model.summary() #training print('Start training') model.compile(optimizer='adam', loss='mse') datagen = MyDataGenerator() history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size, shuffle=True, flip_prob=flip_prob), samples_per_epoch=len(y_train), nb_epoch=nb_epoch, validation_data=datagen.flow( X_val, y_val, batch_size=batch_size, shuffle=True), nb_val_samples=len(y_val)) #save model print('Save model') with open('model.json', 'w') as f: json.dump(model.to_json(), f) model.save_weights('model.h5')
def build_model(img_width, img_height, img_channels, num_classes): # Set the input shape if K.image_data_format() == "channels_first": input_shape = (img_channels, img_height, img_width) else: input_shape = (img_height, img_width, img_channels) # Create the model model = Sequential() # Create the model pipeline, including image preprocessing (avoids having to change drive_train.py) model = Sequential([ # Resize and normalize the image Lambda(NVIDIA_NN.resize), Lambda(NVIDIA_NN.normalize), # Conv1 Conv2D(24, 5, 5, border_mode='valid', activation='elu', subsample=(2, 2), init="he_normal"), SpatialDropout2D(0.2), # Conv2 Conv2D(36, 5, 5, border_mode='valid', activation='elu', subsample=(2, 2), init="he_normal"), SpatialDropout2D(0.2), # Conv3 Conv2D(48, 5, 5, border_mode='valid', activation='elu', subsample=(2, 2), init="he_normal"), SpatialDropout2D(0.2), # Conv4 Conv2D(64, 3, 3, border_mode='valid', activation='elu', init="he_normal"), SpatialDropout2D(0.2), # Conv5 Conv2D(64, 3, 3, border_mode='valid', activation='elu', init="he_normal"), SpatialDropout2D(0.2), # FC1 Flatten(), Dense(100, activation='elu', init="he_normal"), Dropout(0.5), # FC2 Dense(50, activation='elu', init="he_normal"), # FC3 Dense(10, activation='elu', init="he_normal"), Dropout(0.5), # Final layer Dense(1) ]) return model
def unet_model(trainable=True, embedding=False): print "creating model trainable=", trainable, " embedding", embedding inputs = Input((512, 512, 1)) conv1 = Convolution2D(64, 3, 3, activation='relu', border_mode='same', trainable=trainable)(inputs) #conv1 = Dropout(0.2)(conv1) conv1 = Convolution2D(64, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Convolution2D(128, 3, 3, activation='relu', border_mode='same', trainable=trainable)(pool1) #conv2 = Dropout(0.2)(conv2) conv2 = Convolution2D(128, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Convolution2D(256, 3, 3, activation='relu', border_mode='same', trainable=trainable)(pool2) #conv3 = Dropout(0.2)(conv3) conv3 = Convolution2D(256, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Convolution2D(512, 3, 3, activation='relu', border_mode='same', trainable=trainable)(pool3) #conv4 = Dropout(0.2)(conv4) conv4 = Convolution2D(512, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(conv4) conv5 = Convolution2D(1024, 3, 3, activation='relu', border_mode='same', trainable=trainable)(pool4) #conv5 = Dropout(0.2)(conv5) if embedding: conv5 = Convolution2D(64, 1, 1, name="embedding_64d", activation='relu', border_mode='same')(conv5) conv5 = Convolution2D(1024, 1, 1, name="embedding_1024u", activation='relu', border_mode='same')(conv5) conv5 = Convolution2D(1024, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv5) bridge4 = SpatialDropout2D(0.2)(conv4) up6 = merge([UpSampling2D(size=(2, 2))(conv5), bridge4], mode='concat') conv6 = Convolution2D(512, 3, 3, activation='relu', border_mode='same', trainable=trainable)(up6) conv6 = Dropout(0.2)(conv6) conv6 = Convolution2D(512, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv6) bridge3 = SpatialDropout2D(0.2)(conv3) up7 = merge([UpSampling2D(size=(2, 2))(conv6), bridge3], mode='concat') conv7 = Convolution2D(256, 3, 3, activation='relu', border_mode='same', trainable=trainable)(up7) conv7 = Dropout(0.2)(conv7) conv7 = Convolution2D(256, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv7) bridge2 = SpatialDropout2D(0.2)(conv2) up8 = merge([UpSampling2D(size=(2, 2))(conv7), bridge2], mode='concat') conv8 = Convolution2D(128, 3, 3, activation='relu', border_mode='same', trainable=trainable)(up8) conv8 = Dropout(0.2)(conv8) conv8 = Convolution2D(128, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv8) bridge1 = SpatialDropout2D(0.2)(conv1) up9 = merge([UpSampling2D(size=(2, 2))(conv8), bridge1], mode='concat') conv9 = Convolution2D(64, 3, 3, activation='relu', border_mode='same', trainable=trainable)(up9) conv9 = Dropout(0.2)(conv9) conv9 = Convolution2D(64, 3, 3, activation='relu', border_mode='same', trainable=trainable)(conv9) conv10 = Convolution2D(1, 1, 1, activation='sigmoid')(conv9) predictions = Reshape(target_shape=(262144, 1))(conv10) model = Model(input=inputs, output=predictions) model.summary() #optimizer = SGD(lr=0.00001, momentum=0.985, decay=0.0, nesterov=True) optimizer = Adam(lr=1e-5) model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=[ dice_coef, 'binary_accuracy', 'precision', 'recall', 'mean_squared_error' ], sample_weight_mode='temporal') return model
assert(len(input_shape)==3) try: from keras.layers.core import SpatialDropout2D except: from keras import __version__ as __kv__ from warnings import warn warn('no SpatialDropout2D layer in keras version: %s'%__kv__) SpatialDropout2D = Dropout # need to set the input_shape to first layer for a new model model = Sequential() model.add(Convolution2D(16,(3,3),padding='same',input_shape=input_shape)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(24,(2,2))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(30,(2,2))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(36,(2,2))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.2))
def bottleneck(inp, output, internal_scale=4, asymmetric=0, dilated=0, downsample=False, dropout_rate=0.1): internal = output // internal_scale encoder = inp # 1x1 # the 1st 1x1 projection is replaced with a 2x2 convolution when downsampling input_stride = 2 if downsample else 1 encoder = Conv2D( internal, (input_stride, input_stride), # padding='same', strides=(input_stride, input_stride), use_bias=False, kernel_initializer='he_normal')(encoder) # Batch normalization + PReLU # enet uses momentum of 0.1, keras default is 0.99 encoder = BatchNormalization(momentum=0.1)(encoder) encoder = PReLU(shared_axes=[1, 2])(encoder) # conv if not asymmetric and not dilated: encoder = Conv2D(internal, (3, 3), padding='same', kernel_initializer='he_normal')(encoder) elif asymmetric: encoder = Conv2D(internal, (1, asymmetric), padding='same', use_bias=False, kernel_initializer='he_normal')(encoder) encoder = Conv2D(internal, (asymmetric, 1), padding='same', kernel_initializer='he_normal')(encoder) elif dilated: encoder = Conv2D(internal, (3, 3), dilation_rate=(dilated, dilated), padding='same', kernel_initializer='he_normal')(encoder) else: raise (Exception('You shouldn\'t be here')) # enet uses momentum of 0.1, keras default is 0.99 encoder = BatchNormalization(momentum=0.1)(encoder) encoder = PReLU(shared_axes=[1, 2])(encoder) # 1x1 encoder = Conv2D(output, (1, 1), use_bias=False, kernel_initializer='he_normal')(encoder) # enet uses momentum of 0.1, keras default is 0.99 encoder = BatchNormalization(momentum=0.1)(encoder) encoder = SpatialDropout2D(dropout_rate)(encoder) other = inp # other branch if downsample: other = MaxPooling2D()(other) other = Permute((1, 3, 2))(other) pad_feature_maps = output - inp.get_shape().as_list()[3] tb_pad = (0, 0) lr_pad = (0, pad_feature_maps) other = ZeroPadding2D(padding=(tb_pad, lr_pad))(other) other = Permute((1, 3, 2))(other) encoder = add([encoder, other]) encoder = PReLU(shared_axes=[1, 2])(encoder) return encoder
def UNET(channels, classes, initial_features=32, num_layers=5, loss="binary_crossentropy", optimizer=Adam(), metrics=[jaccard_coef, dice_coef], batch_normalization=False, dropout_type=0, dropout_p=1.0): """ This UNET implements the standard model :param classes: Number of classes used :param initial_features: Number of features used initially for the convolutions :param num_layers: Number of down and up sampling blocks :param loss: The type of loss used :param optimizer: The optimizer used for the gradient descent :param metrics: The metrics used to assess the performance :param channels: Number of channels of the input image :return: Returns a UNET model """ # Initialize a list which will store some of the layers in the model layers = [] layers.append(Input((None, None, channels))) # DOWNDSAMPLING for i in range(num_layers): # LAYER BLOCK if i != (num_layers - 1): # Define two convolutions and a max pooling layers.append( Conv2D(initial_features * (2**i), (3, 3), activation='relu', padding='same')(layers[-1])) # Add batch normalization after convolution if batch_normalization: layers[-1] = BatchNormalization(axis=-1)(layers[-1]) layers[-1] = Conv2D(initial_features * (2**i), (3, 3), activation='relu', padding='same')(layers[-1]) # BATCH NORMALIZATION if batch_normalization: layers[-1] = BatchNormalization(axis=-1)(layers[-1]) layers.append(MaxPooling2D(pool_size=(2, 2))(layers[-1])) # FINAL LAYER else: # Define just two convolutions for the final layer layers.append( Conv2D(initial_features * (2**i), (3, 3), activation='relu', padding='same')(layers[-1])) # BATCH NORMALIZATION if batch_normalization: layers[-1] = BatchNormalization(axis=-1)(layers[-1]) layers[-1] = Conv2D(initial_features * (2**i), (3, 3), activation='relu', padding='same')(layers[-1]) # BATCH NORMALIZATION if batch_normalization: layers[-1] = BatchNormalization(axis=-1)(layers[-1]) # DROPOUT TYPE 1 if dropout_type == 1: layers[-1] = SpatialDropout2D(dropout_p)(layers[-1]) # UPSAMPLING for j in range(num_layers - 1): # Concatenate with the appropriate output of a previous layer and the upsample layers.append( concatenate([ UpSampling2D(size=(2, 2))(layers[-1]), layers[2 * num_layers - (2 * j) - 3] ], axis=-1)) # DROPOUT TYPE 2 if dropout_type == 2: layers[-1] = SpatialDropout2D(dropout_p)(layers[-1]) # Add two extra convolutions layers.append( Conv2D(initial_features * 2**(num_layers - 2 - j), (3, 3), activation='relu', padding='same')(layers[-1])) # BATCH NORMALIZATION if batch_normalization: layers[-1] = BatchNormalization(axis=-1)(layers[-1]) layers[-1] = Conv2D(initial_features * 2**(num_layers - 2 - j), (3, 3), activation='relu', padding='same')(layers[-1]) # BATCH NORMALIZATION if batch_normalization: layers[-1] = BatchNormalization(axis=-1)(layers[-1]) # Add the final sigmoid output layers.append( Conv2D(classes - 1, (1, 1), activation='sigmoid')(layers[-1])) # Compile the model print(layers) model = Model(inputs=layers[0], outputs=layers[-1]) model.compile(optimizer=optimizer, loss=loss, metrics=metrics) return model
def nvidia_model(): # Create the Sequential model model = Sequential() # No. of units to reduce at the top / bottom of the image - (width, height) model.add(Cropping2D(cropping=((13, 0), (9, 0)), input_shape=(3, 160, 320))) model.add(Lambda(resize)) #model.add(Lambda(normalize), input_shape=(3, img_width, img_height)) model.add(Lambda(normalize)) model.add( Convolution2D(24, 5, 5, activation='elu', border_mode='valid', subsample=(2, 2))) model.add(SpatialDropout2D(0.2)) model.add( Convolution2D(36, 5, 5, activation='elu', border_mode='valid', subsample=(2, 2))) model.add(SpatialDropout2D(0.2)) model.add( Convolution2D(48, 5, 5, activation='elu', border_mode='valid', subsample=(2, 2))) model.add(SpatialDropout2D(0.2)) model.add( Convolution2D(64, 3, 3, activation='elu', border_mode='valid', subsample=(1, 1))) model.add(SpatialDropout2D(0.2)) model.add( Convolution2D(64, 3, 3, activation='elu', border_mode='valid', subsample=(1, 1))) model.add(Flatten()) model.add(Dropout(0.2)) model.add(Activation('elu')) model.add(Dense(100, activation='elu')) model.add(Dropout(0.5)) model.add(Dense(50, activation='elu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='elu')) model.add(Dropout(0.5)) model.add(Dense(1, name='y_pred')) model.compile('adam', 'mean_squared_error') return model
def model_init(input_shape,**kwargs): from keras import backend as _backend from keras.models import Sequential from keras.layers.core import Dense, Activation, Flatten, Dropout from keras.layers import SeparableConv2D as Convolution2D from keras.layers import MaxPooling2D, GlobalAveragePooling2D from keras.layers.normalization import BatchNormalization try: from keras.layers.core import SpatialDropout2D except: from keras import __version__ as __kv__ from warnings import warn warn('no SpatialDropout2D layer in keras version: %s'%__kv__) SpatialDropout2D = Dropout assert(len(input_shape)==3) model = Sequential() model.add(Convolution2D(64,(3,3),padding='same',input_shape=input_shape)) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.1)) model.add(Convolution2D(128,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(128,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(256,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(256,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.3)) model.add(Convolution2D(384,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(384,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.4)) model.add(Convolution2D(512,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Convolution2D(512,(2,2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(SpatialDropout2D(0.5)) model.add(GlobalAveragePooling2D()) model.add(Dense(2048)) model.add(Activation('relu')) model.add(Dropout(0.5)) return dict(model=model,lr_mult=1.0)
###################### # Layer-2 convolution ###################### model.add(Convolution2D(12, 5, 5, border_mode='valid', activation=None)) model.add(LeakyReLU(alpha=0.15)) model.add(MaxPooling2D(pool_size=(2, 2), strides=None, border_mode='valid')) ###################### # Layer-3 convolution ###################### model.add(Convolution2D(16, 3, 3, border_mode='valid', activation=None)) model.add(LeakyReLU(alpha=0.15)) # Add spatial dropout layer instead of max pooling to prevent overfitting model.add(SpatialDropout2D(p=0.2)) #model.add(MaxPooling2D(pool_size=(2, 2), strides=None, border_mode='valid')) ################################################# # Use either globalpooling layer or flatten layer #model.add(GlobalAveragePooling2D()) model.add(Flatten()) ######################### # Fully connected layers ######################### model.add(Dense(1500)) model.add(Dense(300))
def LinkNet(input_shape=(256, 256, 3), classes=1, dropout=0.5, feature_scale=4, pretrained_weights=None, skipConnectionConv1=False): """ Architecture is similar to linknet, but there are a lot of enhancements - initial block is changed to strides 1, 2*32 convs to better handle borders. - additional encoder block with filter size=512 and corresponding decoder block. - ability to use subpixel deconvolution ( not optimized may lead to artifacts) - ability to have skip connection from conv1 - ability to use pretrained RGB weights for network with more channels, additional channels are initialised with zeros the same way as in Deep Image Matting paper Overall this approach helps to better deal with very small objects and boundaries between them. The network has around 20m parameters in default configuration, for a small dataset like Urban3D it is better to use dropout rate = 0.5 As SpatialDropout2D (aka feature map dropout) is used instead of ordinary Dropout it improves semantic segmetation performance and helps to reduce overfitting See: LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentation (https://arxiv.org/abs/1707.03718) Understanding Convolution for Semantic Segmentation https://arxiv.org/abs/1702.08502 Deep Image Matting https://arxiv.org/abs/1703.03872 """ layers = [2, 2, 2, 2, 2] filters = [64, 128, 256, 512, 512] inputs = Input(shape=input_shape) if pretrained_weights: print("Using pretrained weights {}".format(pretrained_weights)) if pretrained_weights and input_shape[-1] > 3: x = conv_bn_relu(inputs, 32, 3, stride=1, name="block1_conv1_changed") else: x = conv_bn_relu(inputs, 32, 3, stride=1, name="block1_conv1") x = conv_bn_relu(x, 32, 3, stride=1, name="block1_conv2") conv1 = x x = MaxPooling2D((2, 2), strides=(2, 2), padding="same", name="block1_pool")(x) enc1 = encoder(x, m=32, n=filters[0], blocks=layers[0], stride=1, name='encoder1') enc2 = encoder(enc1, m=filters[0], n=filters[1], blocks=layers[1], stride=2, name='encoder2') enc3 = encoder(enc2, m=filters[1], n=filters[2], blocks=layers[2], stride=2, name='encoder3') enc4 = encoder(enc3, m=filters[2], n=filters[3], blocks=layers[3], stride=2, name='encoder4') enc5 = encoder(enc4, m=filters[3], n=filters[4], blocks=layers[4], stride=2, name='encoder5') x = linknet_decoder(conv1, enc1, enc2, enc3, enc4, enc5, filters, feature_scale) x = SpatialDropout2D(dropout)(x) x = Conv2D(filters=classes, kernel_size=(1, 1), padding="same", name="prediction")(x) x = Activation("sigmoid", name="mask")(x) model = Model(inputs=inputs, outputs=x) if pretrained_weights: print("Loading pretrained weights {}".format(pretrained_weights)) model.load_weights(pretrained_weights, by_name=True) if pretrained_weights and input_shape[-1] > 3: conv1_weights = np.zeros((3, 3, input_shape[-1], 32), dtype="float32") three_channels_net = LinkNet(input_shape=(224, 224, 3)) three_channels_net.load_weights(pretrained_weights, by_name=True) conv1_weights[:, :, :3, :] = three_channels_net.get_layer( "block1_conv1_conv").get_weights()[0][:, :, :, :] bias = three_channels_net.get_layer( "block1_conv1_conv").get_weights()[1] model.get_layer('block1_conv1_changed_conv').set_weights( (conv1_weights, bias)) model.get_layer('block1_conv1_changed_conv').name = 'block1_conv1_conv' return model
def create_convnet_nvidia(): ''' Create a convnet using the network architecture documented in NVIDIA's paper ''' # Create the model pipeline, including image preprocessing (avoids having to change drive.py) model = Sequential([ # Crop the area above the horizon, resize and normalize the image Cropping2D(cropping=((22, 0), (0, 0)), input_shape=(160, 320, 3)), Lambda(resize), Lambda(normalize), # Conv1 Convolution2D(24, 5, 5, border_mode='valid', activation='elu', subsample=(2, 2), init="he_normal"), SpatialDropout2D(0.2), # Conv2 Convolution2D(36, 5, 5, border_mode='valid', activation='elu', subsample=(2, 2), init="he_normal"), SpatialDropout2D(0.2), # Conv3 Convolution2D(48, 5, 5, border_mode='valid', activation='elu', subsample=(2, 2), init="he_normal"), SpatialDropout2D(0.2), # Conv4 Convolution2D(64, 3, 3, border_mode='valid', activation='elu', init="he_normal"), SpatialDropout2D(0.2), # Conv5 Convolution2D(64, 3, 3, border_mode='valid', activation='elu', init="he_normal"), SpatialDropout2D(0.2), # FC1 Flatten(), Dense(100, activation='elu', init="he_normal"), Dropout(0.5), # FC2 Dense(50, activation='elu', init="he_normal"), # FC3 Dense(10, activation='elu', init="he_normal"), Dropout(0.5), # Final layer Dense(1) ]) model.summary() model.compile(optimizer=Adam(lr=INITIAL_LR), loss="mse") return model
def WideResidualNetwork(depth=28, width=8, dropout_rate=0.0, include_top=True, weights='cifar10', input_tensor=None, input_shape=None, classes=10, activation='softmax', weight_decay=0.0): """Instantiate the Wide Residual Network architecture, optionally loading weights pre-trained on CIFAR-10. Note that when using TensorFlow, for best performance you should set `image_dim_ordering="tf"` in your Keras config at ~/.keras/keras.json. The model and the weights are compatible with both TensorFlow and Theano. The dimension ordering convention used by the model is the one specified in your Keras config file. # Arguments depth: number or layers in the DenseNet width: multiplier to the ResNet width (number of filters) dropout_rate: dropout rate include_top: whether to include the fully-connected layer at the top of the network. weights: one of `None` (random initialization) or "cifar10" (pre-training on CIFAR-10).. input_tensor: optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. input_shape: optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(32, 32, 3)` (with `tf` dim ordering) or `(3, 32, 32)` (with `th` dim ordering). It should have exactly 3 inputs channels, and width and height should be no smaller than 8. E.g. `(200, 200, 3)` would be one valid value. 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. # Returns A Keras model instance. """ if weights not in {'cifar10', None}: raise ValueError('The `weights` argument should be either ' '`None` (random initialization) or `cifar10` ' '(pre-training on CIFAR-10).') if weights == 'cifar10' and include_top and classes != 10: raise ValueError('If using `weights` as CIFAR 10 with `include_top`' ' as true, `classes` should be 10') if (depth - 4) % 6 != 0: raise ValueError('Depth of the network must be such that (depth - 4)' 'should be divisible by 6.') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=32, min_size=8, data_format=K.image_dim_ordering(), require_flatten=include_top) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor img_input2 = SpatialDropout2D(rate=0.05)(img_input) x = __create_wide_residual_network(classes, img_input2, include_top, depth, width, dropout_rate, activation, weight_decay) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='wide-resnet') # load weights if weights == 'cifar10': if (depth == 28) and (width == 8) and (dropout_rate == 0.0): # Default parameters match. Weights for this model exist: if K.image_dim_ordering() == 'th': if include_top: h5_file = 'wide_resnet_28_8_th_dim_ordering_th_kernels.h5' weights_path = get_file(h5_file, TH_WEIGHTS_PATH, cache_subdir='models') else: h5_file = 'wide_resnet_28_8_th_dim_ordering_th_kernels_no_top.h5' weights_path = get_file(h5_file, TH_WEIGHTS_PATH_NO_TOP, cache_subdir='models') model.load_weights(weights_path) if K.backend() == 'tensorflow': warnings.warn( 'You are using the TensorFlow backend, yet you ' 'are using the Theano ' 'image dimension ordering convention ' '(`image_dim_ordering="th"`). ' 'For best performance, set ' '`image_dim_ordering="tf"` in ' 'your Keras config ' 'at ~/.keras/keras.json.') convert_all_kernels_in_model(model) else: if include_top: h5_file = 'wide_resnet_28_8_tf_dim_ordering_tf_kernels.h5' weights_path = get_file(h5_file, TF_WEIGHTS_PATH, cache_subdir='models') else: h5_file = 'wide_resnet_28_8_tf_dim_ordering_tf_kernels_no_top.h5' weights_path = get_file(h5_file, TF_WEIGHTS_PATH_NO_TOP, cache_subdir='models') model.load_weights(weights_path) if K.backend() == 'theano': convert_all_kernels_in_model(model) return model
def model_init(input_shape, **kwargs): from keras.models import Sequential from keras.layers.core import Dense, Activation, Flatten, Dropout from keras.layers.convolutional import Convolution2D, MaxPooling2D from keras.layers.normalization import BatchNormalization from keras.backend import set_image_data_format assert (len(input_shape) == 3 and input_shape[2] == 3) set_image_data_format('channels_last') try: from keras.layers.core import SpatialDropout2D except: from keras import __version__ as __kv__ from warnings import warn warn('no SpatialDropout2D layer in keras version: %s' % __kv__) SpatialDropout2D = Dropout # need to set the input_shape to first layer for a new model model = Sequential() model.add( Convolution2D(32, (3, 3), padding='same', input_shape=input_shape)) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.1)) # 2 model.add(Convolution2D(48, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.1)) # 3 model.add(Convolution2D(64, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.2)) # 4 model.add(Convolution2D(128, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.2)) # 5 model.add(Convolution2D(164, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.3)) # 6 model.add(Convolution2D(172, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.3)) # 7 model.add(Convolution2D(196, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.4)) # 8 model.add(Convolution2D(224, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.4)) # 9 model.add(Convolution2D(248, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.5)) # 10 model.add(Convolution2D(296, (2, 2))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(SpatialDropout2D(0.5)) model.add(Flatten()) model.add(Dense(2048)) model.add(Activation('relu')) model.add(Dropout(0.5)) return dict(model=model, lr_mult=1.0)