train_samples, validation_samples = train_test_split(samples, test_size=0.2) # compile and train the model using the generator function train_generator = generator(train_samples, batch_size=batch_size) validation_generator = generator(validation_samples, batch_size=batch_size) from keras.models import Sequential from keras.layers import Flatten, Dense, Lambda, Activation, Dropout, Cropping2D from keras.layers.convolutional import Convolution2D from keras.layers.pooling import MaxPooling2D model = Sequential() model.add(Lambda(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))) model.add(Cropping2D(cropping=((60, 25), (0, 0)))) model.add(Convolution2D(24, 5, 5, activation="relu")) model.add(MaxPooling2D()) model.add(Convolution2D(36, 5, 5, activation="relu")) model.add(MaxPooling2D()) model.add(Convolution2D(48, 5, 5, activation="relu")) model.add(MaxPooling2D()) model.add(Convolution2D(64, 3, 3, activation="relu")) model.add(Convolution2D(64, 3, 3, activation="relu")) model.add(Flatten()) model.add(Dropout(0.5)) model.add(Dense(100)) model.add(Dropout(0.5)) model.add(Dense(50)) model.add(Dropout(0.5)) model.add(Dense(10)) model.add(Dense(1))
from keras.models import Sequential from keras.layers.core import Dense, Dropout, Flatten from keras.layers.convolutional import Conv2D from keras.optimizers import Adam from keras.layers.pooling import MaxPooling2D from keras.layers.core import Activation from keras.preprocessing.image import ImageDataGenerator import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # Create the model model = Sequential() model.add(Conv2D(32, (3, 3), input_shape=(96, 96, 1))) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(3, 3))) model.add(Dropout(0.25)) model.add(Conv2D(64, (3, 3))) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Conv2D(128, (3, 3), padding="same")) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(1024, activation="relu")) model.add(Dropout(0.5))
validation_generator = generator(validation_samples, batch_size=8) ch, col, row = 3, 90, 320 # Trimmed image format model = Sequential() # Crop the image, to remove the sky and the hood model.add(Cropping2D(cropping=((50, 20), (0, 0)), input_shape=(160, 320, 3))) # Preprocess incoming data, centered around zero with small standard deviation model.add( Lambda(lambda x: x / 127.5 - 1., input_shape=(row, col, ch), output_shape=(row, col, ch))) # Convnets model.add(Conv2D(16, (3, 3))) model.add(MaxPooling2D((2, 2))) model.add(Dropout(0.25)) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3))) model.add(MaxPooling2D((2, 2))) model.add(Dropout(0.25)) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3))) model.add(MaxPooling2D((2, 2))) model.add(Dropout(0.25)) model.add(Activation('relu')) # Fully connected layers model.add(Flatten())
# Define IoU metric def mean_iou(y_true, y_pred): prec = [] for t in np.arange(0.5, 1.0, 0.05): y_pred_ = tf.to_int32(y_pred > t) score, up_opt = tf.metrics.mean_iou(y_true, y_pred_, 2) K.get_session().run(tf.local_variables_initializer()) with tf.control_dependencies([up_opt]): score = tf.identity(score) prec.append(score) return K.mean(K.stack(prec), axis=0) # Build model inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)) s = Lambda(lambda x: x / 255) (inputs) c1 = Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (s) c1 = Dropout(.3)(c1) c1 = Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same') (c1) p1 = MaxPooling2D((2, 2)) (c1) c4 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (p1) outputs = Conv2D(1, (1, 1), activation='sigmoid') (c4) model = Model(inputs=[inputs], outputs=[outputs]) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=[mean_iou]) model.summary() results = model.fit(X_train, Y_train, validation_split=0.2, batch_size=16, epochs=100)
def build_model(input_layer, start_neurons, DropoutRatio=0.5): # 101 -> 50 conv1 = Conv2D(start_neurons * 1, (3, 3), activation=None, padding='same')(input_layer) conv1 = residual_block(conv1, start_neurons * 1) conv1 = residual_block(conv1, start_neurons * 1, True) pool1 = MaxPooling2D((2, 2))(conv1) pool1 = Dropout(DropoutRatio / 2)(pool1) # 50 -> 25 conv2 = Conv2D(start_neurons * 2, (3, 3), activation=None, padding='same')(pool1) conv2 = residual_block(conv2, start_neurons * 2) conv2 = residual_block(conv2, start_neurons * 2, True) pool2 = MaxPooling2D((2, 2))(conv2) pool2 = Dropout(DropoutRatio)(pool2) # 25 -> 12 conv3 = Conv2D(start_neurons * 4, (3, 3), activation=None, padding='same')(pool2) conv3 = residual_block(conv3, start_neurons * 4) conv3 = residual_block(conv3, start_neurons * 4, True) pool3 = MaxPooling2D((2, 2))(conv3) pool3 = Dropout(DropoutRatio)(pool3) # 12 -> 6 conv4 = Conv2D(start_neurons * 8, (3, 3), activation=None, padding='same')(pool3) conv4 = residual_block(conv4, start_neurons * 8) conv4 = residual_block(conv4, start_neurons * 8, True) pool4 = MaxPooling2D((2, 2))(conv4) pool4 = Dropout(DropoutRatio)(pool4) # Middle convm = Conv2D(start_neurons * 16, (3, 3), activation=None, padding='same')(pool4) convm = residual_block(convm, start_neurons * 16) convm = residual_block(convm, start_neurons * 16, True) # 6 -> 12 deconv4 = Conv2DTranspose(start_neurons * 8, (3, 3), strides=(2, 2), padding='same')(convm) uconv4 = concatenate([deconv4, conv4]) uconv4 = Dropout(DropoutRatio)(uconv4) uconv4 = Conv2D(start_neurons * 8, (3, 3), activation=None, padding='same')(uconv4) uconv4 = residual_block(uconv4, start_neurons * 8) uconv4 = residual_block(uconv4, start_neurons * 8, True) # 12 -> 25 deconv3 = Conv2DTranspose(start_neurons * 4, (3, 3), strides=(2, 2), padding='valid')(uconv4) uconv3 = concatenate([deconv3, conv3]) uconv3 = Dropout(DropoutRatio)(uconv3) uconv3 = Conv2D(start_neurons * 4, (3, 3), activation=None, padding='same')(uconv3) uconv3 = residual_block(uconv3, start_neurons * 4) uconv3 = residual_block(uconv3, start_neurons * 4, True) # 25 -> 50 deconv2 = Conv2DTranspose(start_neurons * 2, (3, 3), strides=(2, 2), padding='same')(uconv3) uconv2 = concatenate([deconv2, conv2]) uconv2 = Dropout(DropoutRatio)(uconv2) uconv2 = Conv2D(start_neurons * 2, (3, 3), activation=None, padding='same')(uconv2) uconv2 = residual_block(uconv2, start_neurons * 2) uconv2 = residual_block(uconv2, start_neurons * 2, True) # 50 -> 101 deconv1 = Conv2DTranspose(start_neurons * 1, (3, 3), strides=(2, 2), padding='valid')(uconv2) uconv1 = concatenate([deconv1, conv1]) uconv1 = Dropout(DropoutRatio)(uconv1) uconv1 = Conv2D(start_neurons * 1, (3, 3), activation=None, padding='same')(uconv1) uconv1 = residual_block(uconv1, start_neurons * 1) uconv1 = residual_block(uconv1, start_neurons * 1, True) output_layer_noActi = Conv2D(1, (1, 1), padding='same', activation=None)(uconv1) output_layer = Activation('sigmoid')(output_layer_noActi) return output_layer
def pooling(x, ks, st): x = MaxPooling2D((ks, ks), strides=(st, st))(x) return x
# convert class vectors to binary class matrices Y_train = keras.utils.to_categorical(Y_train, num_classes) Y_valid = keras.utils.to_categorical(Y_valid, num_classes) # build model model = Sequential() # CNN # block 1 model.add( Conv2D(32, (5, 5), padding='valid', activation='relu', input_shape=input_shape)) model.add(ZeroPadding2D(padding=(1, 1), data_format='channels_last')) model.add(MaxPooling2D(pool_size=(5, 5), strides=(2, 2))) model.add(Dropout(0.3)) # block 2 model.add(Conv2D(64, (3, 3), activation='relu')) model.add(ZeroPadding2D(padding=(1, 1), data_format='channels_last')) model.add(Dropout(0.3)) # block 3 model.add(Conv2D(128, (3, 3), activation='relu')) model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2))) model.add(ZeroPadding2D(padding=(1, 1), data_format='channels_last')) model.add(Dropout(0.3)) # block 4 model.add(Conv2D(256, (3, 3), activation='relu'))
def DenseNet169(nb_dense_block=4, growth_rate=32, nb_filter=64, reduction=0.0, dropout_rate=0.0, weight_decay=1e-4, classes=1000, weights_path=None): '''Instantiate the DenseNet architecture, # Arguments nb_dense_block: number of dense blocks to add to end growth_rate: number of filters to add per dense block nb_filter: initial number of filters reduction: reduction factor of transition blocks. dropout_rate: dropout rate weight_decay: weight decay factor classes: optional number of classes to classify images weights_path: path to pre-trained weights # Returns A Keras model instance. ''' eps = 1.1e-5 # compute compression factor compression = 1.0 - reduction # Handle Dimension Ordering for different backends global concat_axis if K.image_dim_ordering() == 'tf': concat_axis = 3 img_input = Input(shape=(224, 224, 3), name='data') else: concat_axis = 1 img_input = Input(shape=(3, 224, 224), name='data') # From architecture for ImageNet (Table 1 in the paper) nb_filter = 64 nb_layers = [6,12,32,32] # For DenseNet-169 # Initial convolution x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input) x = Convolution2D(nb_filter, 7, 7, subsample=(2, 2), name='conv1', bias=False)(x) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x) x = Scale(axis=concat_axis, name='conv1_scale')(x) x = Activation('relu', name='relu1')(x) x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x) x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): stage = block_idx+2 x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) # Add transition_block x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) final_stage = stage + 1 x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv'+str(final_stage)+'_blk_bn')(x) x = Scale(axis=concat_axis, name='conv'+str(final_stage)+'_blk_scale')(x) x = Activation('relu', name='relu'+str(final_stage)+'_blk')(x) x = GlobalAveragePooling2D(name='pool'+str(final_stage))(x) print(x.shape) out = Dense(classes, name='fc6')(x) out = Activation('softmax', name='prob')(out) model = Model(img_input, out, name='densenet') if weights_path is not None: model.load_weights(weights_path) model2 = Model(img_input, x) return model2
def DenseUNet(nb_dense_block=4, growth_rate=48, nb_filter=96, reduction=0.0, dropout_rate=0.0, weight_decay=1e-4, weights_path=None, args=None): '''Instantiate the DenseNet 161 architecture, # Arguments nb_dense_block: number of dense blocks to add to end growth_rate: number of filters to add per dense block nb_filter: initial number of filters reduction: reduction factor of transition blocks. dropout_rate: dropout rate weight_decay: weight decay factor classes: optional number of classes to classify images weights_path: path to pre-trained weights # Returns A Keras model instance. ''' eps = 1.1e-5 # compute compression factor compression = 1.0 - reduction # Handle Dimension Ordering for different backends global concat_axis if K.image_dim_ordering() == 'tf': concat_axis = 3 img_input = Input(batch_shape=(args.b, args.input_size, args.input_size, 3), name='data') else: concat_axis = 1 img_input = Input(shape=(3, 224, 224), name='data') # From architecture for ImageNet (Table 1 in the paper) nb_filter = 96 nb_layers = [6, 12, 36, 24] # For DenseNet-161 box = [] # Initial convolution x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input) x = Conv2D(nb_filter, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x) x = Scale(axis=concat_axis, name='conv1_scale')(x) x = Activation('relu', name='relu1')(x) box.append(x) x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x) x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): stage = block_idx + 2 x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) box.append(x) # Add transition_block x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) final_stage = stage + 1 x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv' + str(final_stage) + '_blk_bn')(x) x = Scale(axis=concat_axis, name='conv' + str(final_stage) + '_blk_scale')(x) x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x) box.append(x) up0 = UpSampling2D(size=(2, 2))(x) line0 = Conv2D(2208, (1, 1), padding="same", kernel_initializer="normal", name="line0")(box[3]) up0_sum = add([line0, up0]) conv_up0 = Conv2D(768, (3, 3), padding="same", kernel_initializer="normal", name="conv_up0")(up0_sum) bn_up0 = BatchNormalization(name="bn_up0")(conv_up0) ac_up0 = Activation('relu', name='ac_up0')(bn_up0) up1 = UpSampling2D(size=(2, 2))(ac_up0) up1_sum = add([box[2], up1]) conv_up1 = Conv2D(384, (3, 3), padding="same", kernel_initializer="normal", name="conv_up1")(up1_sum) bn_up1 = BatchNormalization(name="bn_up1")(conv_up1) ac_up1 = Activation('relu', name='ac_up1')(bn_up1) up2 = UpSampling2D(size=(2, 2))(ac_up1) up2_sum = add([box[1], up2]) conv_up2 = Conv2D(96, (3, 3), padding="same", kernel_initializer="normal", name="conv_up2")(up2_sum) bn_up2 = BatchNormalization(name="bn_up2")(conv_up2) ac_up2 = Activation('relu', name='ac_up2')(bn_up2) up3 = UpSampling2D(size=(2, 2))(ac_up2) up3_sum = add([box[0], up3]) conv_up3 = Conv2D(96, (3, 3), padding="same", kernel_initializer="normal", name="conv_up3")(up3_sum) bn_up3 = BatchNormalization(name="bn_up3")(conv_up3) ac_up3 = Activation('relu', name='ac_up3')(bn_up3) up4 = UpSampling2D(size=(2, 2))(ac_up3) conv_up4 = Conv2D(64, (3, 3), padding="same", kernel_initializer="normal", name="conv_up4")(up4) conv_up4 = Dropout(rate=0.3)(conv_up4) bn_up4 = BatchNormalization(name="bn_up4")(conv_up4) ac_up4 = Activation('relu', name='ac_up4')(bn_up4) x = Conv2D(3, (1, 1), padding="same", kernel_initializer="normal", name="dense167classifer")(ac_up4) #pdb.set_trace() model = Model(img_input, x, name='denseu161') return model
def __create_dense_net(nb_classes, img_input, include_top, depth=40, nb_dense_block=3, growth_rate=12, nb_filter=-1, nb_layers_per_block=-1, bottleneck=False, reduction=0.0, dropout_rate=None, weight_decay=1e-4, subsample_initial_block=False, activation='softmax'): ''' Build the DenseNet model Args: nb_classes: number of classes img_input: tuple of shape (channels, rows, columns) or (rows, columns, channels) include_top: flag to include the final Dense layer depth: number or layers nb_dense_block: number of dense blocks to add to end (generally = 3) growth_rate: number of filters to add per dense block nb_filter: initial number of filters. Default -1 indicates initial number of filters is 2 * growth_rate nb_layers_per_block: number of layers in each dense block. Can be a -1, positive integer or a list. If -1, calculates nb_layer_per_block from the depth of the network. If positive integer, a set number of layers per dense block. If list, nb_layer is used as provided. Note that list size must be (nb_dense_block + 1) bottleneck: add bottleneck blocks reduction: reduction factor of transition blocks. Note : reduction value is inverted to compute compression dropout_rate: dropout rate weight_decay: weight decay rate subsample_initial_block: Set to True to subsample the initial convolution and add a MaxPool2D before the dense blocks are added. subsample_initial: activation: Type of activation at the top layer. Can be one of 'softmax' or 'sigmoid'. Note that if sigmoid is used, classes must be 1. Returns: keras tensor with nb_layers of conv_block appended ''' concat_axis = 1 if K.image_data_format() == 'channels_first' else -1 if reduction != 0.0: assert reduction <= 1.0 and reduction > 0.0, 'reduction value must lie between 0.0 and 1.0' # layers in each dense block if type(nb_layers_per_block) is list or type(nb_layers_per_block) is tuple: nb_layers = list(nb_layers_per_block) # Convert tuple to list assert len(nb_layers) == (nb_dense_block), 'If list, nb_layer is used as provided. ' \ 'Note that list size must be (nb_dense_block)' final_nb_layer = nb_layers[-1] nb_layers = nb_layers[:-1] else: if nb_layers_per_block == -1: assert (depth - 4) % 3 == 0, 'Depth must be 3 N + 4 if nb_layers_per_block == -1' count = int((depth - 4) / 3) if bottleneck: count = count // 2 nb_layers = [count for _ in range(nb_dense_block)] final_nb_layer = count else: final_nb_layer = nb_layers_per_block nb_layers = [nb_layers_per_block] * nb_dense_block # compute initial nb_filter if -1, else accept users initial nb_filter if nb_filter <= 0: nb_filter = 1 * growth_rate # compute compression factor compression = 1.0 - reduction # Initial convolution if subsample_initial_block: initial_kernel = (7, 7) initial_strides = (2, 2) else: initial_kernel = (3, 3) initial_strides = (1, 1) x = Conv2D(nb_filter, initial_kernel, kernel_initializer='he_normal', padding='same', strides=initial_strides, use_bias=False, kernel_regularizer=l2(weight_decay))(img_input) if subsample_initial_block: x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): x, nb_filter = __dense_block(x, nb_layers[block_idx], nb_filter, growth_rate, bottleneck=bottleneck, dropout_rate=dropout_rate, weight_decay=weight_decay) # add transition_block x = __transition_block(x, nb_filter, compression=compression, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) print(block_idx, '---------------------------------') # The last dense_block does not have a transition_block x, nb_filter = __dense_block(x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck, dropout_rate=dropout_rate, weight_decay=weight_decay) x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(x) x = Activation('relu')(x) x = GlobalAveragePooling2D()(x) if include_top: x = Dense(nb_classes, activation=activation)(x) return x
e = 2.0 c = w - w * K.log(1 + (w/e)) def wingLoss(y_true, y_pred, w=w, e=e, c=c): error = y_true - y_pred cond = K.abs(error) < w true = w * (K.log(1 + (K.abs(error)/e))) otherwise = K.abs(error) - c return tf.where(cond, true, otherwise) input = Input((192, 192, 3), name='Input') conv1 = initial_conv_block1(input) #conv1 = Residual2(32, 64, conv1) pool1 = MaxPooling2D(pool_size=(2, 2), name='MaxPool1')(conv1) conv2 = Residual3(64, 128, pool1) #conv2 = Residual4(128, 128, conv2) pool2 = MaxPooling2D(pool_size=(2, 2), name='MaxPool2')(conv2) conv3 = Residual5(128, 256, pool2) #conv3 = Residual6(256, 256, conv3) pool3 = MaxPooling2D(pool_size=(2, 2), name='MaxPool3')(conv3) #conv4 = Residual7(256, 512, pool3) #conv4 = Residual8(512, 512, conv4) #drop4 = Dropout(0.2, name='Dropout1')(conv4) #pool4 = MaxPooling2D(pool_size=(2, 2), name='MaxPool4')(drop4) conv5 = Residual9(256, 512, pool3)
def make_network(X_DC, X_IC, num_labels, DC_drop_value, IC_drop_value, connected_drop_value): # DEEP CORE # #print("Train Data DC", X_DC.shape) strings = X_DC.shape[1] dom_per_string = X_DC.shape[2] dom_variables = X_DC.shape[3] # Conv DC + batch normalization, later dropout and maxpooling input_DC = Input(shape=(strings, dom_per_string, dom_variables)) conv1_DC = Conv2D(100, kernel_size=(strings, 5), padding='same', activation='tanh')(input_DC) batch1_DC = BatchNormalization()(conv1_DC) pool1_DC = MaxPooling2D(pool_size=(1, 2))(batch1_DC) drop1_DC = Dropout(DC_drop_value)(pool1_DC) conv2_DC = Conv2D(100, kernel_size=(strings, 7), padding='same', activation='relu')(drop1_DC) batch2_DC = BatchNormalization()(conv2_DC) drop2_DC = Dropout(DC_drop_value)(batch2_DC) conv3_DC = Conv2D(100, kernel_size=(strings, 7), padding='same', activation='relu')(drop2_DC) batch3_DC = BatchNormalization()(conv3_DC) drop3_DC = Dropout(DC_drop_value)(batch3_DC) conv4_DC = Conv2D(100, kernel_size=(strings, 3), padding='valid', activation='relu')(drop3_DC) batch4_DC = BatchNormalization()(conv4_DC) pool4_DC = MaxPooling2D(pool_size=(1, 2))(batch4_DC) drop4_DC = Dropout(DC_drop_value)(pool4_DC) conv5_DC = Conv2D(100, kernel_size=(1, 7), padding='same', activation='relu')(drop4_DC) batch5_DC = BatchNormalization()(conv5_DC) drop5_DC = Dropout(DC_drop_value)(batch5_DC) conv6_DC = Conv2D(100, kernel_size=(1, 7), padding='same', activation='relu')(drop5_DC) batch6_DC = BatchNormalization()(conv6_DC) drop6_DC = Dropout(DC_drop_value)(batch6_DC) conv7_DC = Conv2D(100, kernel_size=(1, 1), padding='same', activation='relu')(drop6_DC) batch7_DC = BatchNormalization()(conv7_DC) drop7_DC = Dropout(DC_drop_value)(batch7_DC) conv8_DC = Conv2D(100, kernel_size=(1, 1), padding='same', activation='relu')(drop7_DC) batch8_DC = BatchNormalization()(conv8_DC) drop8_DC = Dropout(DC_drop_value)(batch8_DC) flat_DC = Flatten()(drop8_DC) # ICECUBE NEAR DEEPCORE # #print("Train Data IC", X_IC.shape) strings_IC = X_IC.shape[1] dom_per_string_IC = X_IC.shape[2] dom_variables_IC = X_IC.shape[3] # Conv DC + batch normalization, later dropout and maxpooling input_IC = Input(shape=(strings_IC, dom_per_string_IC, dom_variables_IC)) conv1_IC = Conv2D(100, kernel_size=(strings_IC, 5), padding='same', activation='tanh')(input_IC) batch1_IC = BatchNormalization()(conv1_IC) pool1_IC = MaxPooling2D(pool_size=(1, 2))(batch1_IC) drop1_IC = Dropout(IC_drop_value)(pool1_IC) conv2_IC = Conv2D(100, kernel_size=(strings_IC, 7), padding='same', activation='relu')(drop1_IC) batch2_IC = BatchNormalization()(conv2_IC) drop2_IC = Dropout(IC_drop_value)(batch2_IC) conv3_IC = Conv2D(100, kernel_size=(strings_IC, 7), padding='same', activation='relu')(drop2_IC) batch3_IC = BatchNormalization()(conv3_IC) drop3_IC = Dropout(IC_drop_value)(batch3_IC) conv4_IC = Conv2D(100, kernel_size=(strings_IC, 3), padding='valid', activation='relu')(drop3_IC) batch4_IC = BatchNormalization()(conv4_IC) pool4_IC = MaxPooling2D(pool_size=(1, 2))(batch4_IC) drop4_IC = Dropout(IC_drop_value)(pool4_IC) conv5_IC = Conv2D(100, kernel_size=(1, 7), padding='same', activation='relu')(drop4_IC) batch5_IC = BatchNormalization()(conv5_IC) drop5_IC = Dropout(IC_drop_value)(batch5_IC) conv6_IC = Conv2D(100, kernel_size=(1, 7), padding='same', activation='relu')(drop5_IC) batch6_IC = BatchNormalization()(conv6_IC) drop6_IC = Dropout(IC_drop_value)(batch6_IC) conv7_IC = Conv2D(100, kernel_size=(1, 1), padding='same', activation='relu')(drop6_IC) batch7_IC = BatchNormalization()(conv7_IC) drop7_IC = Dropout(IC_drop_value)(batch7_IC) conv8_IC = Conv2D(100, kernel_size=(1, 1), padding='same', activation='relu')(drop7_IC) batch8_IC = BatchNormalization()(conv8_IC) drop8_IC = Dropout(IC_drop_value)(batch8_IC) flat_IC = Flatten()(drop8_IC) # PUT TOGETHER # concatted = concatenate([flat_DC, flat_IC]) full1 = Dense(300, activation='relu')(concatted) batch1_full = BatchNormalization()(full1) dropf = Dropout(connected_drop_value)(batch1_full) output = Dense(num_labels, activation='linear')(dropf) model_DC = Model(inputs=[input_DC, input_IC], outputs=output) return model_DC
return K.mean(K.categorical_crossentropy(y_pred, y_true), axis=-1) def identity_loss(y_true, y_pred): return y_pred #%% weight_masks = Input((128, 128, 1)) true_masks = Input((128, 128, 2)) inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)) s = Lambda(lambda x: x / 255)(inputs) c1 = Conv2D(8, (3, 3), activation='relu', padding='same')(s) c1 = Conv2D(8, (3, 3), activation='relu', padding='same')(c1) p1 = MaxPooling2D((2, 2))(c1) c2 = Conv2D(16, (3, 3), activation='relu', padding='same')(p1) c2 = Conv2D(16, (3, 3), activation='relu', padding='same')(c2) p2 = MaxPooling2D((2, 2))(c2) c3 = Conv2D(32, (3, 3), activation='relu', padding='same')(p2) c3 = Conv2D(32, (3, 3), activation='relu', padding='same')(c3) p3 = MaxPooling2D((2, 2))(c3) c4 = Conv2D(64, (3, 3), activation='relu', padding='same')(p3) c4 = Conv2D(64, (3, 3), activation='relu', padding='same')(c4) p4 = MaxPooling2D(pool_size=(2, 2))(c4) c5 = Conv2D(128, (3, 3), activation='relu', padding='same')(p4) c5 = Conv2D(128, (3, 3), activation='relu', padding='same')(c5)
def main(__): # TODO: Build the Final Test Neural Network in Keras Here model = Sequential() # Cropping to 90x320x3 that only with the view of roads model.add( Cropping2D(cropping=((50, 20), (0, 0)), input_shape=(160, 320, 3))) #Normalization of the images model.add(Lambda(lambda x: x / 255.0 - 0.5)) # Layer 1: 43x158x24 model.add(Convolution2D(24, 5, 5)) model.add(MaxPooling2D((2, 2))) model.add(Activation('relu')) # Layer 2: 20x77x36 model.add(Convolution2D(36, 5, 5)) model.add(MaxPooling2D((2, 2))) model.add(Activation('relu')) #Layer 3: 8x37x48 model.add(Convolution2D(48, 5, 5)) model.add(MaxPooling2D((2, 2))) model.add(Activation('relu')) #Layer 4: 6x35x64 model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) #Layer 5: 4x33x64 model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(Flatten()) #Layer 6: fully connected layer model.add(Dense(100)) #Layer 7: fully connected layer model.add(Dense(50)) #Layer 8: fully connected layer model.add(Dense(10)) #Layer 9: fully connected layer model.add(Dense(1)) #Reading from the command flag to decide wether transfer learning or not if FLAGS.re_training is True: model.load_weights('my_model_weights.h5') print( 'The weights of the model has been loaded from my_model_weights.h5...' ) #Using adam optimizer model.compile(optimizer='adam', loss='mse') history = model.fit_generator(train_generator, samples_per_epoch=len(train_samples), validation_data=validation_generator, nb_val_samples=len(validation_samples), nb_epoch=2, verbose=1) ### print the keys contained in the history object print(history.history.keys()) ### plot the training and validation loss for each epoch plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model mean squared error loss') plt.ylabel('mean squared error loss') plt.xlabel('epoch') plt.legend(['training set', 'validation set'], loc='upper right') plt.show() #Save the model and its weights model.save('model.h5') model.save_weights('my_model_weights.h5') exit()
def __create_pre_residual_of_residual(nb_classes, img_input, include_top, depth=28, width=1, dropout=0.0): ''' Creates a Residual Network of Residual Network with specified parameters Example : To create a Pre-RoR model, use k = 1 model = ResidualOfResidual(depth=28, width=1) # Pre-RoR-3 To create a RoR-WRN model, use k > 1 model = ResidualOfResidual(depth=28, width=10) # Pre-RoR-3, RoR-3-WRN-28-10 Args: nb_classes: number of classes img_input: tuple of shape (channels, rows, columns) or (rows, columns, channels) include_top: flag to include the final Dense layer depth: depth of the network width: width of the network dropout: Adds dropout if value is greater than 0.0. Note : Generally not used in RoR Returns: a Keras Model ''' N = (depth - 4) // 6 channel_axis = 1 if K.image_dim_ordering() == 'th' else -1 # Initial convolution layer x = Conv2D(16, (3, 3), padding='same', kernel_initializer='he_normal')(img_input) nb_conv = 4 # Dont count 4 long residual connections in WRN models conv0_level1_shortcut = Conv2D(64 * width, (1, 1), padding='same', strides=(4, 4), name='conv0_level1_shortcut')(x) conv1_level2_shortcut = Conv2D(16 * width, (1, 1), padding='same', name='conv1_level2_shortcut')(x) for i in range(N): initial = (i == 0) x = __initial_conv_block(x, k=width, dropout=dropout, initial=initial) nb_conv += 2 # Add Level 2 shortcut x = add([x, conv1_level2_shortcut]) x = MaxPooling2D((2, 2))(x) conv2_level2_shortcut = Conv2D(32 * width, (1, 1), padding='same', name='conv2_level2_shortcut')(x) for i in range(N): x = __conv_block(x, k=width, dropout=dropout) nb_conv += 2 # Add Level 2 shortcut x = add([x, conv2_level2_shortcut]) x = MaxPooling2D((2, 2))(x) conv3_level2_shortcut = Conv2D(64 * width, (1, 1), padding='same', name='conv3_level2_shortcut')(x) for i in range(N): x = __conv_block(x, nb_filters=64, k=width, dropout=dropout) nb_conv += 2 # Add Level 2 shortcut x = add([x, conv3_level2_shortcut]) # Add Level 1 shortcut x = add([x, conv0_level1_shortcut]) x = BatchNormalization(axis=channel_axis)(x) x = Activation('relu')(x) x = AveragePooling2D((8, 8))(x) if include_top: x = Flatten()(x) x = Dense(nb_classes, activation='softmax')(x) return x
def pooling(x, ks, st, name): x = MaxPooling2D((ks, ks), strides=(st, st), name=name)(x) return x
def get_unet(input_img, n_filters=16, dropout=0.5, batchnorm=True): c01 = conv2d_block(input_img, n_filters=n_filters * 1, kernel_size=3, batchnorm=batchnorm) p01 = MaxPooling2D((2, 2))(c01) d01 = Dropout(dropout * 0.05)(p01) c02 = conv2d_block(d01, n_filters=n_filters * 2, kernel_size=3, batchnorm=batchnorm) p02 = MaxPooling2D((2, 2))(c02) d02 = Dropout(dropout)(p02) c1 = conv2d_block(d02, n_filters=n_filters * 4, kernel_size=3, batchnorm=batchnorm) p1 = MaxPooling2D((2, 2))(c1) d1 = Dropout(dropout)(p1) c2 = conv2d_block(d1, n_filters=n_filters * 8, kernel_size=3, batchnorm=batchnorm) p2 = MaxPooling2D((2, 2))(c2) d2 = Dropout(dropout)(p2) c3 = conv2d_block(d2, n_filters=n_filters * 16, kernel_size=3, batchnorm=batchnorm) p3 = MaxPooling2D((2, 2))(c3) d3 = Dropout(dropout)(p3) c4 = conv2d_block(d3, n_filters=n_filters * 32, kernel_size=3, batchnorm=batchnorm) p4 = MaxPooling2D((2, 2))(c4) d4 = Dropout(dropout)(p4) c5 = conv2d_block(p4, n_filters=n_filters * 64, kernel_size=3, batchnorm=batchnorm) u6 = Conv2DTranspose(n_filters * 32, (3, 3), strides=(2, 2), padding='same')(c5) u6 = concatenate([u6, c4]) u6 = Dropout(dropout)(u6) c6 = conv2d_block(u6, n_filters=n_filters * 32, kernel_size=3, batchnorm=batchnorm) u7 = Conv2DTranspose(n_filters * 16, (3, 3), strides=(2, 2), padding='same')(c6) u7 = concatenate([u7, c3]) u7 = Dropout(dropout)(u7) c7 = conv2d_block(u7, n_filters=n_filters * 16, kernel_size=3, batchnorm=batchnorm) u8 = Conv2DTranspose(n_filters * 8, (3, 3), strides=(2, 2), padding='same')(c7) u8 = concatenate([u8, c2]) u8 = Dropout(dropout)(u8) c8 = conv2d_block(u8, n_filters=n_filters * 8, kernel_size=3, batchnorm=batchnorm) u9 = Conv2DTranspose(n_filters * 4, (3, 3), strides=(2, 2), padding='same')(c8) u9 = concatenate([u9, c1], axis=3) u9 = Dropout(dropout)(u9) c9 = conv2d_block(u9, n_filters=n_filters * 4, kernel_size=3, batchnorm=batchnorm) u10 = Conv2DTranspose(n_filters * 2, (3, 3), strides=(2, 2), padding='same')(c9) u10 = concatenate([u10, c02], axis=3) u10 = Dropout(dropout)(u10) c10 = conv2d_block(u10, n_filters=n_filters * 2, kernel_size=3, batchnorm=batchnorm) u11 = Conv2DTranspose(n_filters * 1, (3, 3), strides=(2, 2), padding='same')(c10) u11 = concatenate([u11, c01], axis=3) u11 = Dropout(dropout)(u11) c11 = conv2d_block(u11, n_filters=n_filters * 1, kernel_size=3, batchnorm=batchnorm) outputs = Conv2D(1, (1, 1), activation='linear')(c11) model = Model(inputs=[input_img], outputs=[outputs]) # model.compile(optimizer=Adam(lr=1e-3), loss=dice_coef_loss, metrics=[dice_coef]) return model
def DenseNet(nb_dense_block=4, growth_rate=20, nb_filter=32, reduction=0.0, dropout_rate=0.0, weight_decay=0, classes=1000, weights_path=None): '''Instantiate the DenseNet 121 architecture, # Arguments nb_dense_block: number of dense blocks to add to end growth_rate: number of filters to add per dense block nb_filter: initial number of filters reduction: reduction factor of transition blocks. dropout_rate: dropout rate weight_decay: weight decay factor classes: optional number of classes to classify images weights_path: path to pre-trained weights # Returns A Keras model instance. ''' with tf.device('/gpu:0'): eps = 1.1e-5 # compute compression factor compression = 1.0 - reduction # Handle Dimension Ordering for different backends global concat_axis if K.image_dim_ordering() == 'tf': concat_axis = 3 img_input = Input(shape=(512, 512, 3), name='data') else: concat_axis = 1 img_input = Input(shape=(3, 224, 224), name='data') # From architecture for ImageNet (Table 1 in the paper) nb_filter = 16 ##make this 16 nb_layers = [3, 6, 12, 8] #[6,12,24,16] # For DenseNet-121 # Initial convolution x = ZeroPadding2D((1, 1), name='conv1_zeropadding')(img_input) x = Conv2D(nb_filter * 2, (7, 7), strides=(4, 4), name='conv1', kernel_initializer='he_normal', padding='same')( x) ### Put strides of 2*2 here and padding = valid x = BatchNormalization(axis=concat_axis, name='conv1_bn')(x) x = Scale(axis=concat_axis, name='conv1_scale')(x) x = Activation('relu', name='relu1')(x) #x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x) x = MaxPooling2D( (3, 3), strides=(2, 2), name='pool1')(x) ### Put strides of 2*2 and pooling 3*3 # Add dense blocks for block_idx in range(nb_dense_block - 1): stage = block_idx + 2 x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) # Add transition_block x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) final_stage = stage + 1 x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) #x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv'+str(final_stage)+'_blk_bn')(x) x = Scale(axis=concat_axis, name='conv' + str(final_stage) + '_blk_scale')(x) '''x1 = Conv2D(32,(3,3),dilation_rate = 6, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv1', activation = 'relu',data_format='channels_last')(x) x2 = Conv2D(32,(3,3),dilation_rate = 12, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv2', activation = 'relu',data_format='channels_last')(x) x3 = Conv2D(32,(3,3),dilation_rate = 18, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv3', activation = 'relu',data_format='channels_last')(x) x4 = Conv2D(32,(3,3),dilation_rate = 24, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv4', activation = 'relu',data_format='channels_last')(x) sum_b = add([x1,x2,x3,x4],name = 'sum_b')''' #x = Activation('relu', name='relu'+str(final_stage)+'_blk')(x) x = Conv2D(1, (1, 1), padding='valid', kernel_initializer='he_normal')(x) model = Model(img_input, x, name='densenet') '''xp = model.get_layer(name = 'conv5_blk_scale').output x1 = Conv2D(16,(3,3),dilation_rate = 6, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv1', activation = 'relu',data_format='channels_last')(xp) x2 = Conv2D(16,(3,3),dilation_rate = 12, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv2', activation = 'relu',data_format='channels_last')(xp) x3 = Conv2D(16,(3,3),dilation_rate = 18, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv3', activation = 'relu',data_format='channels_last')(xp) x4 = Conv2D(16,(3,3),dilation_rate = 24, padding = 'same', kernel_initializer = 'he_normal', name = 'dil_conv4', activation = 'relu',data_format='channels_last')(xp) sum_b = add([x1,x2,x3,x4],name = 'sum_b') #sum_b_activation = Activation('relu', name='relu_sum')(sum_b) out = Conv2D(1,(1,1),padding = 'valid',kernel_initializer='he_normal',activation = 'relu')(sum_b) model_2 = Model(inputs = model.input, outputs = out) ''' if weights_path is not None: model.load_weights(weights_path) return model
def vgg_block(x, weight_decay): ''' # Block 1 x = conv(x, 64, 3, "conv1_1", (weight_decay, 0)) x = relu(x) x = conv(x, 64, 3, "conv1_2", (weight_decay, 0)) x = relu(x) x = pooling(x, 2, 2, "pool1_1") # Block 2 x = conv(x, 128, 3, "conv2_1", (weight_decay, 0)) x = relu(x) x = conv(x, 128, 3, "conv2_2", (weight_decay, 0)) x = relu(x) x = pooling(x, 2, 2, "pool2_1") # Block 3 x = conv(x, 256, 3, "conv3_1", (weight_decay, 0)) x = relu(x) x = conv(x, 256, 3, "conv3_2", (weight_decay, 0)) x = relu(x) x = conv(x, 256, 3, "conv3_3", (weight_decay, 0)) x = relu(x) x = conv(x, 256, 3, "conv3_4", (weight_decay, 0)) x = relu(x) x = pooling(x, 2, 2, "pool3_1") # Block 4 x = conv(x, 512, 3, "conv4_1", (weight_decay, 0)) x = relu(x) x = conv(x, 512, 3, "conv4_2", (weight_decay, 0)) x = relu(x) # Additional non vgg layers x = conv(x, 256, 3, "conv4_3_CPM", (weight_decay, 0)) x = relu(x) x = conv(x, 128, 3, "conv4_4_CPM", (weight_decay, 0)) x = relu(x)''' ''' x = conv(x, 64, 3, "conv1_1", (weight_decay, 0),strides=(2,2)) #64 x = BatchNormalization(axis=bn_axis, epsilon=1e-5, momentum=0.9)(x) x = relu(x) x = conv(x, 64, 3, "conv1_2", (weight_decay, 0)) #64 x = BatchNormalization(axis=bn_axis, epsilon=1e-5, momentum=0.9)(x) x = relu(x) # Block 2 x = conv(x, 128, 3, "conv2_1", (weight_decay, 0),strides=(2,2)) #128 x = BatchNormalization(axis=bn_axis, epsilon=1e-5, momentum=0.9)(x) x = relu(x) x = conv(x, 128, 3, "conv2_2", (weight_decay, 0),strides=(2,2)) #256 x = BatchNormalization(axis=bn_axis, epsilon=1e-5, momentum=0.9)(x) x = relu(x) ''' bn_axis = 1 if K.image_data_format() == 'channels_first' else -1 x = ZeroPadding2D((2, 2))(x) # 对图片界面填充0,保证特征图的大小# x = conv(x, 64, 7, strides=(2, 2), name='conv1', weight_decay=(weight_decay, 0)) # 定义卷积层# x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x) # 批标准化# x = Activation('relu')(x) # 激活函数# x = MaxPooling2D((3, 3), strides=(2, 2))(x) # 最大池化层# x = STEM_block(x, [64, 64], 1, (weight_decay, 0)) x = STEM_block(x, [64, 64], 2, (weight_decay, 0)) x = STEM_block(x, [64, 64], 3, (weight_decay, 0)) x = pooling(x, 2, 2) x = STEM_block(x, [128, 128], 4, (weight_decay, 0), change=True) x = STEM_block(x, [128, 128], 5, (weight_decay, 0)) x = STEM_block(x, [128, 128], 6, (weight_decay, 0)) x = STEM_block(x, [128, 128], 7, (weight_decay, 0)) x1=x x = STEM_block(x, [256, 256], 8, (weight_decay, 0), change=True) x = STEM_block(x, [256, 256], 9, (weight_decay, 0)) x = STEM_block(x, [256, 256], 10, (weight_decay, 0)) x = STEM_block(x, [256, 256], 11, (weight_decay, 0)) return x,x1
def conv_block(x, stage, branch, nb_filter, dropout_rate=None, weight_decay=0): '''Apply BatchNorm, Relu, bottleneck 1x1 Conv2D, 3x3 Conv2D, and option dropout # Arguments x: input tensor stage: index for dense block branch: layer index within each dense block nb_filter: number of filters dropout_rate: dropout rate weight_decay: weight decay factor ''' eps = 1.1e-5 conv_name_base = 'conv' + str(stage) + '_' + str(branch) relu_name_base = 'relu' + str(stage) + '_' + str(branch) # 1x1 Convolution (Bottleneck layer) inter_channel = nb_filter * 3 #x = BatchNormalization(epsilon=eps, axis=concat_axis, name=conv_name_base+'_x1_bn')(x) x = Scale(axis=concat_axis, name=conv_name_base + '_x1_scale')(x) #x = Activation('relu', name=relu_name_base+'_x1')(x) x1 = Conv2D(inter_channel, (1, 1), name=conv_name_base + '_x1', kernel_initializer='he_normal', activation='relu')(x) x2_1 = Conv2D(inter_channel / 2, (1, 1), name=conv_name_base + '_x2_1', kernel_initializer='he_normal', activation='relu')(x) x2_2 = Conv2D(inter_channel, (3, 3), name=conv_name_base + '_x2_2', kernel_initializer='he_normal', activation='relu', padding='same')(x2_1) x3_1 = Conv2D(inter_channel / 2, (1, 1), name=conv_name_base + '_x3_1', kernel_initializer='he_normal', activation='relu')(x) x3_2 = Conv2D(inter_channel, (3, 3), name=conv_name_base + '_x3_2', kernel_initializer='he_normal', activation='relu', padding='same')(x3_1) x3_3 = Conv2D(inter_channel, (3, 3), name=conv_name_base + '_x3_3', kernel_initializer='he_normal', activation='relu', padding='same')(x3_2) x4_1 = MaxPooling2D((2, 2), strides=(1, 1), padding='same')(x) x4_2 = Conv2D(inter_channel, (1, 1), name=conv_name_base + '_x4_2', kernel_initializer='he_normal', activation='relu')(x4_1) x5 = add([x1, x2_2, x3_3, x4_2]) if dropout_rate: x5 = Dropout(dropout_rate)(x5) # 3x3 Convolution #x = BatchNormalization(epsilon=eps, axis=concat_axis, name=conv_name_base+'_x2_bn')(x) x = Scale(axis=concat_axis, name=conv_name_base + '_x2_scale')(x5) #x = Activation('relu', name=relu_name_base+'_x2')(x) #x = ZeroPadding2D((1, 1), name=conv_name_base+'_x2_zeropadding')(x) x = Conv2D(nb_filter, (1, 1), name=conv_name_base + '_x2', kernel_initializer='he_normal', activation='relu')(x) if dropout_rate: x = Dropout(dropout_rate)(x) return x
def train_model(itername, train_generator, train_size, valid_generator, valid_size, display_generator, display_size, \ batch_size, yimagerange, ysize, xsize, epochs, modelfilename, modelfileext, modellayoutpicfilename, \ modellayoutpicfileext, sMP, bdisplay = False, bdebug = False): # ... # Train model # ... # Inputs # ... # itername : name of training iteration # train_generator : variable pointing to function that retrieves next values from training generator # train_size : total number of training data sets # valid_generator : variable pointing to function that retrieves next values from validation generator # valid_size : total number of validation data sets # display_generator : variable pointing to function that retrieves next values from display generator # display_size : total number of display data sets # batch_size : batch size # yimagerange : range of pixels used from source images in vertical direction # ysize : source image height in pixels # xsize : source image width in pixels # epochs : number of epochs # modelfilename : file name in which model will be saved # modelfileext : file extension for file in which model will be saved # modellayoutpicfilename : picture file in which model layout will be stored # modellayoutpicfileext : file extension for picture file in which model layout will be stored # sMP : object containing model parameters that define the model layout # bdisplay : boolean for 'display information' # bdebug : boolean for 'debug generator' # display information if bdisplay: # display number of batches print( '= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =' ) print('Configuration:', itername) print( '- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -' ) print('Batch size:', batch_size) # debug generator if bdebug: # loop through all training data for display_dataset in range(0, display_size, batch_size): # get and display training data get_and_display_generator_data(display_generator, display_dataset, display_size, bdisplay) # define Keras model model = Sequential() # define Keras input adjustments model.add( Cropping2D(cropping=((yimagerange[0], (ysize - yimagerange[1])), (0, 0)), input_shape=(ysize, xsize, 3))) model.add(Lambda(lambda x: (x / 255.0) - 0.5, \ input_shape = (3, (ysize - (yimagerange[0] + (ysize - yimagerange[1]))), xsize))) # define Keras convolutional layers for conv_layer in sMP.conv_layers: model.add(Conv2D(conv_layer.features, conv_layer.filter_size[0], conv_layer.filter_size[1], \ subsample = conv_layer.strides, activation = "relu", kernel_regularizer = sMP.regularizer)) if conv_layer.busepooling: model.add(MaxPooling2D()) # define Keras dense layers model.add(Flatten()) for full_layer in sMP.full_layers: if (full_layer.keep_percentage < 1): model.add(Dropout(full_layer.keep_percentage)) model.add(Dense(full_layer.features)) # print the layout of the model plot_model(model, to_file = (modellayoutpicfilename + '_' + itername + modellayoutpicfileext), show_shapes = True, \ show_layer_names = True) model.summary() # generate model model.compile(loss='mse', optimizer='adam') # train model history_object = model.fit_generator(train_generator, samples_per_epoch = np.int(train_size // batch_size), \ validation_data = valid_generator, \ nb_val_samples = np.int(valid_size // batch_size), nb_epoch = epochs, verbose = 1) # display information if bdisplay: # print the keys contained in the history object #print(history_object.history.keys()) # plot the training and validation loss for each epoch plt.plot(history_object.history['loss']) plt.plot(history_object.history['val_loss']) plt.title('model mean squared error loss') plt.ylabel('mean squared error loss') plt.xlabel('epoch') plt.legend(['training set', 'validation set'], loc='upper right') plt.show() # save trained model model.save((modelfilename + '_' + itername + modelfileext))
def densenet161_model(img_rows, img_cols, color_type=1, nb_dense_block=4, growth_rate=48, nb_filter=96, reduction=0.5, dropout_rate=0.0, weight_decay=1e-4, num_classes=None): ''' DenseNet 161 Model for Keras Model Schema is based on https://github.com/flyyufelix/DenseNet-Keras ImageNet Pretrained Weights Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfVnlCMlBGTDR3RGs TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfUDZwVjU2cFNidTA # Arguments nb_dense_block: number of dense blocks to add to end growth_rate: number of filters to add per dense block nb_filter: initial number of filters reduction: reduction factor of transition blocks. dropout_rate: dropout rate weight_decay: weight decay factor classes: optional number of classes to classify images weights_path: path to pre-trained weights # Returns A Keras model instance. ''' eps = 1.1e-5 # compute compression factor compression = 1.0 - reduction # Handle Dimension Ordering for different backends global concat_axis if K.image_dim_ordering() == 'tf': concat_axis = 3 img_input = Input(shape=(224, 224, 3), name='data') else: concat_axis = 1 img_input = Input(shape=(3, 224, 224), name='data') # From architecture for ImageNet (Table 1 in the paper) nb_filter = 96 nb_layers = [6, 12, 36, 24] # For DenseNet-161 # Initial convolution x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input) x = Convolution2D(nb_filter, 7, 7, subsample=(2, 2), name='conv1', bias=False)(x) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x) x = Scale(axis=concat_axis, name='conv1_scale')(x) x = Activation('relu', name='relu1')(x) x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x) x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): stage = block_idx + 2 x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) # Add transition_block x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) final_stage = stage + 1 x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv' + str(final_stage) + '_blk_bn')(x) x = Scale(axis=concat_axis, name='conv' + str(final_stage) + '_blk_scale')(x) x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x) x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x) x_fc = Dense(1000, name='fc6')(x_fc) x_fc = Activation('softmax', name='prob')(x_fc) model = Model(img_input, x_fc, name='densenet') weights_path = densenet161_weights # if K.image_dim_ordering() == 'th': # # Use pre-trained weights for Theano backend # weights_path = 'imagenet_models/densenet161_weights_th.h5' # else: # # Use pre-trained weights for Tensorflow backend # weights_path = 'imagenet_models/densenet161_weights_tf.h5' model.load_weights(weights_path, by_name=True) # Truncate and replace softmax layer for transfer learning # Cannot use model.layers.pop() since model is not of Sequential() type # The method below works since pre-trained weights are stored in layers but not in the model x_newfc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x) x_newfc = Dense(num_classes, name='fc6')(x_newfc) x_newfc = Activation('softmax', name='prob')(x_newfc) model = Model(img_input, x_newfc) # Learning rate is changed to 0.001 # sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True) # model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) return model
s.login(fromaddr, passwd) text = msg.as_string() s.sendmail(fromaddr, toaddr, text) s.quit() ################################################################################################### myInput = Input(shape=(96, 96, 3)) x = ZeroPadding2D(padding=(3, 3), input_shape=(96, 96, 3))(myInput) x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x) x = BatchNormalization(axis=3, epsilon=0.00001, name='bn1')(x) x = Activation('relu')(x) x = ZeroPadding2D(padding=(1, 1))(x) x = MaxPooling2D(pool_size=3, strides=2)(x) x = Lambda(LRN2D, name='lrn_1')(x) x = Conv2D(64, (1, 1), name='conv2')(x) x = BatchNormalization(axis=3, epsilon=0.00001, name='bn2')(x) x = Activation('relu')(x) x = ZeroPadding2D(padding=(1, 1))(x) x = Conv2D(192, (3, 3), name='conv3')(x) x = BatchNormalization(axis=3, epsilon=0.00001, name='bn3')(x) x = Activation('relu')(x) x = Lambda(LRN2D, name='lrn_2')(x) x = ZeroPadding2D(padding=(1, 1))(x) x = MaxPooling2D(pool_size=3, strides=2)(x) # Inception3a inception_3a_3x3 = Conv2D(96, (1, 1), name='inception_3a_3x3_conv1')(x) inception_3a_3x3 = BatchNormalization(
def inception_block_1a(X): """ Implementation of an inception block """ X_3x3 = Conv2D(96, (1, 1), data_format='channels_first', name='inception_3a_3x3_conv1')(X) X_3x3 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_3x3_bn1')(X_3x3) X_3x3 = Activation('relu')(X_3x3) X_3x3 = ZeroPadding2D(padding=(1, 1), data_format='channels_first')(X_3x3) X_3x3 = Conv2D(128, (3, 3), data_format='channels_first', name='inception_3a_3x3_conv2')(X_3x3) X_3x3 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_3x3_bn2')(X_3x3) X_3x3 = Activation('relu')(X_3x3) X_5x5 = Conv2D(16, (1, 1), data_format='channels_first', name='inception_3a_5x5_conv1')(X) X_5x5 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_5x5_bn1')(X_5x5) X_5x5 = Activation('relu')(X_5x5) X_5x5 = ZeroPadding2D(padding=(2, 2), data_format='channels_first')(X_5x5) X_5x5 = Conv2D(32, (5, 5), data_format='channels_first', name='inception_3a_5x5_conv2')(X_5x5) X_5x5 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_5x5_bn2')(X_5x5) X_5x5 = Activation('relu')(X_5x5) X_pool = MaxPooling2D(pool_size=3, strides=2, data_format='channels_first')(X) X_pool = Conv2D(32, (1, 1), data_format='channels_first', name='inception_3a_pool_conv')(X_pool) X_pool = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_pool_bn')(X_pool) X_pool = Activation('relu')(X_pool) X_pool = ZeroPadding2D(padding=((3, 4), (3, 4)), data_format='channels_first')(X_pool) X_1x1 = Conv2D(64, (1, 1), data_format='channels_first', name='inception_3a_1x1_conv')(X) X_1x1 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_1x1_bn')(X_1x1) X_1x1 = Activation('relu')(X_1x1) # CONCAT inception = concatenate([X_3x3, X_5x5, X_pool, X_1x1], axis=1) return inception
def DenseUNet(img_input, nb_dense_block=4, growth_rate=48, nb_filter=96, reduction=0.0, dropout_rate=0.0, weight_decay=1e-4, classes=1000, weights_path=None): '''Instantiate the DenseNet 161 architecture, # Arguments nb_dense_block: number of dense blocks to add to end growth_rate: number of filters to add per dense block nb_filter: initial number of filters reduction: reduction factor of transition blocks. dropout_rate: dropout rate weight_decay: weight decay factor classes: optional number of classes to classify images weights_path: path to pre-trained weights # Returns A Keras model instance. ''' eps = 1.1e-5 # compute compression factor compression = 1.0 - reduction # Handle Dimension Ordering for different backends global concat_axis concat_axis = 3 # From architecture for ImageNet (Table 1 in the paper) nb_filter = 96 nb_layers = [6,12,36,24] # For DenseNet-161 box = [] # Initial convolution x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input) x = Conv2D(nb_filter, (7, 7), strides=(2, 2), name='conv1', use_bias=False, trainable=True)(x) x = BatchNormalization(epsilon=eps, axis=concat_axis, momentum = 1, name='conv1_bn', trainable=False)(x, training=False) x = Scale(axis=concat_axis, name='conv1_scale')(x) x = Activation('relu', name='relu1')(x) box.append(x) x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x) x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x) # Add dense blocks for block_idx in range(nb_dense_block - 1): stage = block_idx+2 x, nb_filter = dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) box.append(x) # Add transition_block x = transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay) nb_filter = int(nb_filter * compression) final_stage = stage + 1 x, nb_filter = dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay) x = BatchNormalization(epsilon=eps, axis=concat_axis, momentum = 1, name='conv'+str(final_stage)+'_blk_bn', trainable=False)(x, training=False) x = Scale(axis=concat_axis, name='conv'+str(final_stage)+'_blk_scale')(x) x = Activation('relu', name='relu'+str(final_stage)+'_blk')(x) box.append(x) up0 = UpSampling2D(size=(2,2))(x) conv_up0 = Conv2D(768, (3, 3), padding="same", name = "conv_up0", trainable=True)(up0) bn_up0 = BatchNormalization(name = "bn_up0", momentum = 1, trainable=False)(conv_up0, training=False) ac_up0 = Activation('relu', name='ac_up0')(bn_up0) up1 = UpSampling2D(size=(2,2))(ac_up0) conv_up1 = Conv2D(384, (3, 3), padding="same", name = "conv_up1", trainable=True)(up1) bn_up1 = BatchNormalization(name = "bn_up1", momentum = 1, trainable=False)(conv_up1, training=False) ac_up1 = Activation('relu', name='ac_up1')(bn_up1) up2 = UpSampling2D(size=(2,2))(ac_up1) conv_up2 = Conv2D(96, (3, 3), padding="same", name = "conv_up2", trainable=True)(up2) bn_up2 = BatchNormalization(name = "bn_up2", momentum = 1, trainable=False)(conv_up2, training=False) ac_up2 = Activation('relu', name='ac_up2')(bn_up2) up3 = UpSampling2D(size=(2,2))(ac_up2) conv_up3 = Conv2D(96, (3, 3), padding="same", name = "conv_up3", trainable=True)(up3) bn_up3 = BatchNormalization(name = "bn_up3", momentum = 1, trainable=False)(conv_up3, training=False) ac_up3 = Activation('relu', name='ac_up3')(bn_up3) up4 = UpSampling2D(size=(2, 2))(ac_up3) conv_up4 = Conv2D(64, (3, 3), padding="same", name="conv_up4", trainable=True)(up4) bn_up4 = BatchNormalization(name="bn_up4", momentum = 1, trainable=False)(conv_up4, training=False) ac_up4 = Activation('relu', name='ac_up4')(bn_up4) x = Conv2D(3, (1,1), padding="same", name='dense167classifer', trainable=True)(ac_up4) return ac_up4, x
def faceRecoModel(input_shape): """ Implementation of the Inception model used for FaceNet Arguments: input_shape -- shape of the images of the dataset Returns: model -- a Model() instance in Keras """ # Define the input as a tensor with shape input_shape X_input = Input(input_shape) # Zero-Padding X = ZeroPadding2D((3, 3))(X_input) # First Block X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(X) X = BatchNormalization(axis=1, name='bn1')(X) X = Activation('relu')(X) # Zero-Padding + MAXPOOL X = ZeroPadding2D((1, 1))(X) X = MaxPooling2D((3, 3), strides=2)(X) # Second Block X = Conv2D(64, (1, 1), strides=(1, 1), name='conv2')(X) X = BatchNormalization(axis=1, epsilon=0.00001, name='bn2')(X) X = Activation('relu')(X) # Zero-Padding + MAXPOOL X = ZeroPadding2D((1, 1))(X) # Second Block X = Conv2D(192, (3, 3), strides=(1, 1), name='conv3')(X) X = BatchNormalization(axis=1, epsilon=0.00001, name='bn3')(X) X = Activation('relu')(X) # Zero-Padding + MAXPOOL X = ZeroPadding2D((1, 1))(X) X = MaxPooling2D(pool_size=3, strides=2)(X) # Inception 1: a/b/c X = inception_block_1a(X) X = inception_block_1b(X) X = inception_block_1c(X) # Inception 2: a/b X = inception_block_2a(X) X = inception_block_2b(X) # Inception 3: a/b X = inception_block_3a(X) X = inception_block_3b(X) # Top layer X = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X) X = Flatten()(X) X = Dense(128, name='dense_layer')(X) # L2 normalization X = Lambda(lambda x: K.l2_normalize(x, axis=1))(X) # Create model instance model = Model(inputs=X_input, outputs=X, name='FaceRecoModel') return model
def get_unet(input_img, n_filters=16, dropout=0.5, batchnorm=True): # contracting path c1 = conv2d_block(input_img, n_filters=n_filters * 1, kernel_size=3, batchnorm=batchnorm) p1 = MaxPooling2D((2, 2))(c1) p1 = Dropout(dropout * 0.5)(p1) c2 = conv2d_block(p1, n_filters=n_filters * 2, kernel_size=3, batchnorm=batchnorm) p2 = MaxPooling2D((2, 2))(c2) p2 = Dropout(dropout)(p2) c3 = conv2d_block(p2, n_filters=n_filters * 4, kernel_size=3, batchnorm=batchnorm) p3 = MaxPooling2D((2, 2))(c3) p3 = Dropout(dropout)(p3) c4 = conv2d_block(p3, n_filters=n_filters * 8, kernel_size=3, batchnorm=batchnorm) p4 = MaxPooling2D(pool_size=(2, 2))(c4) p4 = Dropout(dropout)(p4) c5 = conv2d_block(p4, n_filters=n_filters * 16, kernel_size=3, batchnorm=batchnorm) # expansive path u6 = Conv2DTranspose(n_filters * 8, (3, 3), strides=(2, 2), padding='same')(c5) u6 = concatenate([u6, c4]) u6 = Dropout(dropout)(u6) c6 = conv2d_block(u6, n_filters=n_filters * 8, kernel_size=3, batchnorm=batchnorm) u7 = Conv2DTranspose(n_filters * 4, (3, 3), strides=(2, 2), padding='same')(c6) u7 = concatenate([u7, c3]) u7 = Dropout(dropout)(u7) c7 = conv2d_block(u7, n_filters=n_filters * 4, kernel_size=3, batchnorm=batchnorm) u8 = Conv2DTranspose(n_filters * 2, (3, 3), strides=(2, 2), padding='same')(c7) u8 = concatenate([u8, c2]) u8 = Dropout(dropout)(u8) c8 = conv2d_block(u8, n_filters=n_filters * 2, kernel_size=3, batchnorm=batchnorm) u9 = Conv2DTranspose(n_filters * 1, (3, 3), strides=(2, 2), padding='same')(c8) u9 = concatenate([u9, c1], axis=3) u9 = Dropout(dropout)(u9) c9 = conv2d_block(u9, n_filters=n_filters * 1, kernel_size=3, batchnorm=batchnorm) outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9) model = Model(inputs=[input_img], outputs=[outputs]) return model
def create_model(): myInput = Input(shape=(192, 192, 3)) x = ZeroPadding2D(padding=(3, 3), input_shape=(192, 192, 3))(myInput) x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x) x = BatchNormalization(axis=3, epsilon=0.00001, name='bn1')(x) x = Activation('relu')(x) x = ZeroPadding2D(padding=(1, 1))(x) x = MaxPooling2D(pool_size=3, strides=2)(x) x = Lambda(LRN2D, name='lrn_1')(x) x = Conv2D(64, (1, 1), name='conv2')(x) x = BatchNormalization(axis=3, epsilon=0.00001, name='bn2')(x) x = Activation('relu')(x) x = ZeroPadding2D(padding=(1, 1))(x) x = Conv2D(192, (3, 3), name='conv3')(x) x = BatchNormalization(axis=3, epsilon=0.00001, name='bn3')(x) x = Activation('relu')(x) x = Lambda(LRN2D, name='lrn_2')(x) x = ZeroPadding2D(padding=(1, 1))(x) x = MaxPooling2D(pool_size=3, strides=2)(x) # Inception3a inception_3a_3x3 = Conv2D(96, (1, 1), name='inception_3a_3x3_conv1')(x) inception_3a_3x3 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3a_3x3_bn1')(inception_3a_3x3) inception_3a_3x3 = Activation('relu')(inception_3a_3x3) inception_3a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3a_3x3) inception_3a_3x3 = Conv2D(128, (3, 3), name='inception_3a_3x3_conv2')(inception_3a_3x3) inception_3a_3x3 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3a_3x3_bn2')(inception_3a_3x3) inception_3a_3x3 = Activation('relu')(inception_3a_3x3) inception_3a_5x5 = Conv2D(16, (1, 1), name='inception_3a_5x5_conv1')(x) inception_3a_5x5 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3a_5x5_bn1')(inception_3a_5x5) inception_3a_5x5 = Activation('relu')(inception_3a_5x5) inception_3a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3a_5x5) inception_3a_5x5 = Conv2D(32, (5, 5), name='inception_3a_5x5_conv2')(inception_3a_5x5) inception_3a_5x5 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3a_5x5_bn2')(inception_3a_5x5) inception_3a_5x5 = Activation('relu')(inception_3a_5x5) inception_3a_pool = MaxPooling2D(pool_size=(3, 3), strides=1)(x) inception_3a_pool = Conv2D( 32, (1, 1), name='inception_3a_pool_conv')(inception_3a_pool) inception_3a_pool = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3a_pool_bn')(inception_3a_pool) inception_3a_pool = Activation('relu')(inception_3a_pool) inception_3a_pool = ZeroPadding2D(padding=((1, 1), (1, 1)))(inception_3a_pool) inception_3a_1x1 = Conv2D(64, (1, 1), name='inception_3a_1x1_conv')(x) inception_3a_1x1 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3a_1x1_bn')(inception_3a_1x1) inception_3a_1x1 = Activation('relu')(inception_3a_1x1) inception_3a = concatenate([ inception_3a_3x3, inception_3a_5x5, inception_3a_pool, inception_3a_1x1 ], axis=3) # Inception3b inception_3b_3x3 = Conv2D(96, (1, 1), name='inception_3b_3x3_conv1')(inception_3a) inception_3b_3x3 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3b_3x3_bn1')(inception_3b_3x3) inception_3b_3x3 = Activation('relu')(inception_3b_3x3) inception_3b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3b_3x3) inception_3b_3x3 = Conv2D(128, (3, 3), name='inception_3b_3x3_conv2')(inception_3b_3x3) inception_3b_3x3 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3b_3x3_bn2')(inception_3b_3x3) inception_3b_3x3 = Activation('relu')(inception_3b_3x3) inception_3b_5x5 = Conv2D(32, (1, 1), name='inception_3b_5x5_conv1')(inception_3a) inception_3b_5x5 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3b_5x5_bn1')(inception_3b_5x5) inception_3b_5x5 = Activation('relu')(inception_3b_5x5) inception_3b_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3b_5x5) inception_3b_5x5 = Conv2D(64, (5, 5), name='inception_3b_5x5_conv2')(inception_3b_5x5) inception_3b_5x5 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3b_5x5_bn2')(inception_3b_5x5) inception_3b_5x5 = Activation('relu')(inception_3b_5x5) inception_3b_pool = AveragePooling2D(pool_size=(3, 3), strides=1)(inception_3a) inception_3b_pool = Conv2D( 64, (1, 1), name='inception_3b_pool_conv')(inception_3b_pool) inception_3b_pool = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3b_pool_bn')(inception_3b_pool) inception_3b_pool = Activation('relu')(inception_3b_pool) inception_3b_pool = ZeroPadding2D(padding=((1, 1), (1, 1)))(inception_3b_pool) inception_3b_1x1 = Conv2D(64, (1, 1), name='inception_3b_1x1_conv')(inception_3a) inception_3b_1x1 = BatchNormalization( axis=3, epsilon=0.00001, name='inception_3b_1x1_bn')(inception_3b_1x1) inception_3b_1x1 = Activation('relu')(inception_3b_1x1) inception_3b = concatenate([ inception_3b_3x3, inception_3b_5x5, inception_3b_pool, inception_3b_1x1 ], axis=3) # Inception3c inception_3c_3x3 = utils.conv2d_bn(inception_3b, layer='inception_3c_3x3', cv1_out=128, cv1_filter=(1, 1), cv2_out=256, cv2_filter=(3, 3), cv2_strides=(2, 2), padding=(1, 1)) inception_3c_5x5 = utils.conv2d_bn(inception_3b, layer='inception_3c_5x5', cv1_out=32, cv1_filter=(1, 1), cv2_out=64, cv2_filter=(5, 5), cv2_strides=(2, 2), padding=(2, 2)) inception_3c_pool = MaxPooling2D(pool_size=3, strides=2)(inception_3b) inception_3c_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_3c_pool) inception_3c = concatenate( [inception_3c_3x3, inception_3c_5x5, inception_3c_pool], axis=3) #inception 4a inception_4a_3x3 = utils.conv2d_bn(inception_3c, layer='inception_4a_3x3', cv1_out=96, cv1_filter=(1, 1), cv2_out=192, cv2_filter=(3, 3), cv2_strides=(1, 1), padding=(1, 1)) inception_4a_5x5 = utils.conv2d_bn(inception_3c, layer='inception_4a_5x5', cv1_out=32, cv1_filter=(1, 1), cv2_out=64, cv2_filter=(5, 5), cv2_strides=(1, 1), padding=(2, 2)) inception_4a_pool = AveragePooling2D(pool_size=(3, 3), strides=1)(inception_3c) inception_4a_pool = utils.conv2d_bn(inception_4a_pool, layer='inception_4a_pool', cv1_out=128, cv1_filter=(1, 1), padding=((1, 1), (1, 1))) inception_4a_1x1 = utils.conv2d_bn(inception_3c, layer='inception_4a_1x1', cv1_out=256, cv1_filter=(1, 1)) inception_4a = concatenate([ inception_4a_3x3, inception_4a_5x5, inception_4a_pool, inception_4a_1x1 ], axis=3) #inception4e inception_4e_3x3 = utils.conv2d_bn(inception_4a, layer='inception_4e_3x3', cv1_out=160, cv1_filter=(1, 1), cv2_out=256, cv2_filter=(3, 3), cv2_strides=(2, 2), padding=(1, 1)) inception_4e_5x5 = utils.conv2d_bn(inception_4a, layer='inception_4e_5x5', cv1_out=64, cv1_filter=(1, 1), cv2_out=128, cv2_filter=(5, 5), cv2_strides=(2, 2), padding=(2, 2)) inception_4e_pool = MaxPooling2D(pool_size=3, strides=2)(inception_4a) inception_4e_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_4e_pool) inception_4e = concatenate( [inception_4e_3x3, inception_4e_5x5, inception_4e_pool], axis=3) #inception5a inception_5a_3x3 = utils.conv2d_bn(inception_4e, layer='inception_5a_3x3', cv1_out=96, cv1_filter=(1, 1), cv2_out=384, cv2_filter=(3, 3), cv2_strides=(1, 1), padding=(1, 1)) inception_5a_pool = AveragePooling2D(pool_size=(3, 3), strides=1)(inception_4e) inception_5a_pool = utils.conv2d_bn(inception_5a_pool, layer='inception_5a_pool', cv1_out=96, cv1_filter=(1, 1), padding=((1, 1), (1, 1))) inception_5a_1x1 = utils.conv2d_bn(inception_4e, layer='inception_5a_1x1', cv1_out=256, cv1_filter=(1, 1)) inception_5a = concatenate( [inception_5a_3x3, inception_5a_pool, inception_5a_1x1], axis=3) #inception_5b inception_5b_3x3 = utils.conv2d_bn(inception_5a, layer='inception_5b_3x3', cv1_out=96, cv1_filter=(1, 1), cv2_out=384, cv2_filter=(3, 3), cv2_strides=(1, 1), padding=(1, 1)) inception_5b_pool = MaxPooling2D(pool_size=3, strides=1)(inception_5a) inception_5b_pool = utils.conv2d_bn(inception_5b_pool, layer='inception_5b_pool', cv1_out=96, cv1_filter=(1, 1)) inception_5b_pool = ZeroPadding2D(padding=((1, 1), (1, 1)))(inception_5b_pool) inception_5b_1x1 = utils.conv2d_bn(inception_5a, layer='inception_5b_1x1', cv1_out=256, cv1_filter=(1, 1)) inception_5b = concatenate( [inception_5b_3x3, inception_5b_pool, inception_5b_1x1], axis=3) av_pool = AveragePooling2D(pool_size=(3, 3), strides=(1, 1))(inception_5b) reshape_layer = Flatten()(av_pool) dense_layer = Dense(128, name='dense_layer')(reshape_layer) norm_layer = Lambda(lambda x: K.l2_normalize(x, axis=1), name='norm_layer')(dense_layer) return Model(inputs=[myInput], outputs=norm_layer)
Computes the precision, a metric for multi-label classification of how many selected items are relevant. """ true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) precision = true_positives / (predicted_positives + K.epsilon()) return precision ## build the unet model with keras inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS)) s = Lambda(lambda x: x / 255) (inputs) conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(s) conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool1) conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool2) conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool3) conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv4) drop4 = Dropout(0.5)(conv4) #pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) #conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool4)
def get_siamese_model(input_shape): """ Model architecture based on the one provided in: http://www.cs.utoronto.ca/~gkoch/files/msc-thesis.pdf """ # Define the tensors for the two input images left_input = Input(input_shape) right_input = Input(input_shape) # Convolutional Neural Network model = Sequential() model.add( Conv2D(64, (10, 10), activation='relu', input_shape=input_shape, kernel_initializer=initialize_weights, kernel_regularizer=l2(2e-4))) model.add(MaxPooling2D()) model.add( Conv2D(128, (7, 7), activation='relu', kernel_initializer=initialize_weights, bias_initializer=initialize_bias, kernel_regularizer=l2(2e-4))) model.add(MaxPooling2D()) model.add( Conv2D(128, (4, 4), activation='relu', kernel_initializer=initialize_weights, bias_initializer=initialize_bias, kernel_regularizer=l2(2e-4))) model.add(MaxPooling2D()) model.add( Conv2D(256, (4, 4), activation='relu', kernel_initializer=initialize_weights, bias_initializer=initialize_bias, kernel_regularizer=l2(2e-4))) model.add(Flatten()) model.add( Dense(10, activation='sigmoid', kernel_regularizer=l2(1e-3), kernel_initializer=initialize_weights, bias_initializer=initialize_bias)) # Generate the encodings (feature vectors) for the two images encoded_l = model(left_input) encoded_r = model(right_input) # Add a customized layer to compute the absolute difference between the encodings L1_layer = Lambda(lambda tensors: K.abs(tensors[0] - tensors[1])) L1_distance = L1_layer([encoded_l, encoded_r]) # Add a dense layer with a sigmoid unit to generate the similarity score prediction = Dense(1, activation='sigmoid', bias_initializer=initialize_bias)(L1_distance) # Connect the inputs with the outputs siamese_net = Model(inputs=[left_input, right_input], outputs=prediction) # return the model return siamese_net