def create_unet_vgg16(C=3):
inputs = Input(shape=(None, None, C))
s = Lambda(lambda x: x / 255.0)(inputs)
# Block 1 down
c1 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv1')(s)
c1 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv2')(c1)
p1 = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(c1)
# Block 2 down
c2 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv1')(p1)
c2 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv2')(c2)
p2 = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(c2)
# Block 3 down
c3 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv1')(p2)
c3 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv2')(c3)
c3 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv3')(c3)
p3 = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(c3)
# Block 4 down
c4 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv1')(p3)
c4 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv2')(c4)
c4 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv3')(c4)
p4 = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(c4)
# Block 5 down
c5 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv1')(p4)
c5 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv2')(c5)
c5 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv3')(c5)
p5 = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(c5)
model_vgg = Model(inputs=[inputs], outputs=[p5])
weights_path = get_file(
'vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model_vgg.load_weights(weights_path)
# Bottom of the U block
c6 = Conv2D(512, (3, 3), activation='relu',
padding='same')(model_vgg.layers[-1].output)
c6 = Conv2D(512, (3, 3), activation='relu', padding='same')(c6)
# Block 5 up
u6 = Conv2DTranspose(512, (3, 3), strides=(2, 2), padding='same')(c6)
u6 = concatenate([u6, model_vgg.layers[-2].output])
c7 = Conv2D(512, (3, 3), activation='relu', padding='same')(u6)
c7 = Conv2D(512, (3, 3), activation='relu', padding='same')(c7)
c7 = Conv2D(512, (3, 3), activation='relu', padding='same')(c7)
# Block 4 up
u7 = Conv2DTranspose(512, (3, 3), strides=(2, 2), padding='same')(c7)
u7 = concatenate([u7, model_vgg.layers[-6].output])
c8 = Conv2D(512, (3, 3), activation='relu', padding='same')(u7)
c8 = Conv2D(512, (3, 3), activation='relu', padding='same')(c8)
c8 = Conv2D(512, (3, 3), activation='relu', padding='same')(c8)
# Block 3 up
u8 = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding='same')(c8)
u8 = concatenate([u8, model_vgg.layers[-10].output])
c9 = Conv2D(256, (3, 3), activation='relu', padding='same')(u8)
c9 = Conv2D(256, (3, 3), activation='relu', padding='same')(c9)
c9 = Conv2D(256, (3, 3), activation='relu', padding='same')(c9)
# Block 2 up
u9 = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding='same')(c9)
u9 = concatenate([u9, model_vgg.layers[-14].output])
c10 = Conv2D(128, (3, 3), activation='relu', padding='same')(u9)
c10 = Conv2D(128, (3, 3), activation='relu', padding='same')(c10)
# Block 1 up
u10 = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding='same')(c10)
u10 = concatenate([u10, model_vgg.layers[-17].output])
c11 = Conv2D(64, (3, 3), activation='relu', padding='same')(u10)
c11 = Conv2D(64, (3, 3), activation='relu', padding='same')(c11)
outputs = Conv2D(1, (1, 1), activation='sigmoid')(c11)
model = Model(inputs=[inputs], outputs=[outputs])
return model
def conv_4_fc_3_more_filters(dropout = []):
"""This network has four convolution layers and three fully connected layers and a lot more
filters than the conv_4_fc_3 model.
Parameters:
dropout - list of dropout values for the 3 fully connected layers
Returns:
A model"""
# ensure the dropout list has enough values in it for the model
# augment the values of some are missing
if dropout == None or len(dropout) == 0:
dropout = [0.0, 0.0]
elif len(dropout) == 1:
dropout = dropout * 2
# this hack gets the current function name and sets it to the name of the model
model = Sequential(name=traceback.extract_stack(None, 2)[-1][2])
# crop top 56 rows and bottom 24 rows from the images
model.add(Cropping2D(cropping=((56, 24), (0, 0)), input_shape=(160, 320, 3), name='pp_crop'))
# mean center the pixels
model.add(Lambda(lambda x: (x / 255.0) - 0.5, name='pp_center'))
# layer 1: convolution + max pooling. Input 80x320x3. Output 40x160x32
model.add(Convolution2D(32, 5, 5, border_mode='same', name='conv1'))
model.add(MaxPooling2D((2, 2), name='pool1'))
model.add(Activation('relu', name='act1'))
# layer 2: convolution = max pooling. Input 40x160x32. Output 20x80x64
model.add(Convolution2D(64, 5, 5, border_mode='same', name='conv2'))
model.add(MaxPooling2D((2, 2), name='pool2'))
model.add(Activation('relu', name='act2'))
# layer 3: convolution = max pooling. Input 20x80x64. Output 10x40x128
model.add(Convolution2D(128, 3, 3, border_mode='same', name='conv3'))
model.add(MaxPooling2D((2, 2), name='pool3'))
model.add(Activation('relu', name='act3'))
# layer 4: convolution = max pooling. Input 10x40x128. Output 5x20x128
model.add(Convolution2D(128, 3, 3, border_mode='same', name='conv4'))
model.add(MaxPooling2D((2, 2), name='pool4'))
model.add(Activation('relu', name='act4'))
# flatten: Input 5x20x128. Output 12800
model.add(Flatten(name='flat'))
# layer 5: fully connected + dropout. Input 12800. Output 556
model.add(Dense(556, name='fc5'))
model.add(Dropout(dropout[0], name='drop5'))
model.add(Activation('relu', name='act5'))
# layer 6: fully connected + dropout. Input 556. Output 24
model.add(Dense(24, name='fc6'))
model.add(Dropout(dropout[1], name='drop6'))
model.add(Activation('relu', name='act6'))
# layer 7: fully connected. Input 24. Output 1.
model.add(Dense(1, name='out'))
return model
# Build U-Net model
inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))
s = Lambda(lambda x: x / 255)(inputs)
c1 = Conv2D(16, (3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(s)
c1 = Dropout(0.1)(c1)
c1 = Conv2D(16, (3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c1)
p1 = MaxPooling2D((2, 2))(c1)
c2 = Conv2D(32, (3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p1)
c2 = Dropout(0.1)(c2)
c2 = Conv2D(32, (3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c2)
p2 = MaxPooling2D((2, 2))(c2)
c3 = Conv2D(64, (3, 3),
activation='elu',
kernel_initializer='he_normal',
### 1 CNN part
model.add(Lambda(lambda x: x / 127.5 - 1, input_shape=imshape))
def converter(im):
import tensorflow as tf
return tf.image.rgb_to_grayscale(im)
model.add(Lambda(converter, output_shape=imshape2))
model.add(Cropping2D(cropping=((70, 25), (0, 0))))
model.add(
Conv2D(filters=16, kernel_size=(5, 5), activation='relu', padding='same'))
#model.add(Conv2D(filters=16,kernel_size=(3,3),activation='relu',padding='same'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), padding='valid'))
model.add(Dropout(0.5))
model.add(
Conv2D(filters=32, kernel_size=(5, 5), activation='relu', padding='same'))
#model.add(Conv2D(filters=32,kernel_size=(3,3),activation='relu',padding='same'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), padding='valid'))
model.add(Dropout(0.5))
model.add(
Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), padding='valid'))
model.add(Dropout(0.5))
model.add(
Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same'))
model.add(BatchNormalization())
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('sigmoid', 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
def fcn_8s(num_classes, init_lr, input_shape, vgg_weight_path=None):
img_input = Input(input_shape)
# Block 1
x = Conv2D(64, (3, 3), padding='same', name='block1_conv1')(img_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, (3, 3), padding='same', name='block1_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D()(x)
# Block 2
x = Conv2D(128, (3, 3), padding='same', name='block2_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(128, (3, 3), padding='same', name='block2_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D()(x)
# Block 3
x = Conv2D(256, (3, 3), padding='same', name='block3_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same', name='block3_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same', name='block3_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
block_3_out = MaxPooling2D()(x)
# Block 4
x = Conv2D(512, (3, 3), padding='same', name='block4_conv1')(block_3_out)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block4_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block4_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
block_4_out = MaxPooling2D()(x)
# Block 5
x = Conv2D(512, (3, 3), padding='same', name='block5_conv1')(block_4_out)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block5_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block5_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D()(x)
# Load pretrained weights.
if vgg_weight_path is not None:
vgg16 = Model(img_input, x)
vgg16.load_weights(vgg_weight_path, by_name=True)
# Convolutinalized fully connected layer.
x = Conv2D(4096, (7, 7), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(4096, (1, 1), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# Classifying layers.
x = Conv2D(num_classes, (1, 1), strides=(1, 1), activation='linear')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
block_3_out = Conv2D(num_classes, (1, 1), strides=(1, 1), activation='linear')(block_3_out)
block_3_out = BatchNormalization()(block_3_out)
block_3_out = Activation('relu')(block_3_out)
block_4_out = Conv2D(num_classes, (1, 1), strides=(1, 1), activation='linear')(block_4_out)
block_4_out = BatchNormalization()(block_4_out)
block_4_out = Activation('relu')(block_4_out)
x = Lambda(lambda x: tf.image.resize_images(x, (x.shape[1] * 2, x.shape[2] * 2)))(x)
x = Add()([x, block_4_out])
x = Lambda(lambda x: tf.image.resize_images(x, (x.shape[1] * 2, x.shape[2] * 2)))(x)
x = Add()([x, block_3_out])
x = Lambda(lambda x: tf.image.resize_images(x, (x.shape[1] * 8, x.shape[2] * 8)))(x)
x = Activation('softmax')(x)
model = Model(img_input, x)
model.compile(optimizer=Adam(lr=init_lr, decay=5e-4),
loss='categorical_crossentropy',
metrics=[dice_coef])
return model
def resnet_v2_stem(input):
'''The stem of the pure Inception-v4 and Inception-ResNet-v2 networks. This is input part of those networks.'''
# Input shape is 299 * 299 * 3 (Tensorflow dimension ordering)
x = Conv2D(32, (3, 3),
kernel_regularizer=l2(0.0002),
activation="relu",
strides=(2, 2))(input) # 149 * 149 * 32
x = Conv2D(32, (3, 3), kernel_regularizer=l2(0.0002),
activation="relu")(x) # 147 * 147 * 32
x = Conv2D(64, (3, 3),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(x) # 147 * 147 * 64
x1 = MaxPooling2D((3, 3), strides=(2, 2))(x)
x2 = Conv2D(96, (3, 3),
kernel_regularizer=l2(0.0002),
activation="relu",
strides=(2, 2))(x)
x = concatenate([x1, x2], axis=3) # 73 * 73 * 160
x1 = Conv2D(64, (1, 1),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(x)
x1 = Conv2D(96, (3, 3), kernel_regularizer=l2(0.0002),
activation="relu")(x1)
x2 = Conv2D(64, (1, 1),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(x)
x2 = Conv2D(64, (7, 1),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(x2)
x2 = Conv2D(64, (1, 7),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(x2)
x2 = Conv2D(96, (3, 3),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="valid")(x2)
x = concatenate([x1, x2], axis=3) # 71 * 71 * 192
x1 = Conv2D(192, (3, 3),
kernel_regularizer=l2(0.0002),
activation="relu",
strides=(2, 2))(x)
x2 = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = concatenate([x1, x2], axis=3) # 35 * 35 * 384
x = BatchNormalization(axis=3)(x)
x = Activation("relu")(x)
return x
def get_2stack_unet_nonorm(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS):
# Creates the 2-stack U-net model.
inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))
# --------------------------------------------------------------------
# U-Net 1:
c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (inputs)
c1 = Dropout(0.1) (c1)
c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c1)
p1 = MaxPooling2D((2, 2)) (c1)
c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p1)
c2 = Dropout(0.1) (c2)
c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c2)
p2 = MaxPooling2D((2, 2)) (c2)
c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p2)
c3 = Dropout(0.2) (c3)
c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c3)
p3 = MaxPooling2D((2, 2)) (c3)
c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p3)
c4 = Dropout(0.2) (c4)
c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c4)
p4 = MaxPooling2D(pool_size=(2, 2)) (c4)
c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p4)
c5 = Dropout(0.3) (c5)
c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c5)
u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same') (c5)
u6 = concatenate([u6, c4])
c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u6)
c6 = Dropout(0.2) (c6)
c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c6)
u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c6)
u7 = concatenate([u7, c3])
c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u7)
c7 = Dropout(0.2) (c7)
c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c7)
u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c7)
u8 = concatenate([u8, c2])
c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u8)
c8 = Dropout(0.1) (c8)
c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c8)
u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c8)
u9 = concatenate([u9, c1], axis=3)
c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u9)
c9 = Dropout(0.1) (c9)
c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c9)
# --------------------------------------------------------------------
# U-Net 2:
c12 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c9)
c12 = Dropout(0.1) (c12)
c12 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c12)
p12 = MaxPooling2D((2, 2)) (c12)
c22 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p12)
c22 = Dropout(0.1) (c22)
c22 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c22)
p22 = MaxPooling2D((2, 2)) (c22)
c32 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p22)
c32 = Dropout(0.2) (c32)
c32 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c32)
p32 = MaxPooling2D((2, 2)) (c32)
c42 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p32)
c42 = Dropout(0.2) (c42)
c42 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c42)
p42 = MaxPooling2D(pool_size=(2, 2)) (c42)
c52 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p42)
c52 = Dropout(0.3) (c52)
c52 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c52)
u62 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same') (c52)
u62 = concatenate([u62, c42])
c62 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u62)
c62 = Dropout(0.2) (c62)
c62 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c62)
u72 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c62)
u72 = concatenate([u72, c32])
c72 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u72)
c72 = Dropout(0.2) (c72)
c72 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c72)
u82 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c72)
u82 = concatenate([u82, c22])
c82 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u82)
c82 = Dropout(0.1) (c82)
c82 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c82)
u92 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c82)
u92 = concatenate([u92, c12], axis=3)
c92 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u92)
c92 = Dropout(0.1) (c92)
c92 = Conv2D(1, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c92)
# --------------------------------------------------------------------
outputs = c92
model = Model(inputs=[inputs], outputs=[outputs])
return model
model = Sequential() # Imitating the network of NVidia :-D # Preprocess incoming data, centered around zero with small standard deviation model.add(Lambda(lambda x: (x / 255.0) - 0.5, input_shape=(160, 320, 3))) # Crop image to only see section with road model.add(Cropping2D(cropping=((70, 25), (0, 0)))) # sizes from tutorial video # Convolution 5x5 Layers model.add(Conv2D(24, 5, 5, subsample=(2, 2), activation='relu')) model.add(Conv2D(36, 5, 5, subsample=(2, 2), activation='relu')) model.add(Conv2D(48, 5, 5, subsample=(2, 2), activation='relu')) # Convolution 3x3 Layers model.add(Conv2D(64, 3, 3, activation='relu')) model.add(Conv2D(64, 3, 3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering="th")) model.add(Dropout(keep_prob)) model.add(Flatten()) # Full-Connected Layers model.add(Dense(100)) model.add(Dense(50)) model.add(Dense(10)) model.add(Dense(1)) model.compile(loss='mse', optimizer='adam') ################################################### ############# Get Data and Start Computing ######## ################################################### # compile and train the model using the generator function
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
# 이미지 데이터를 불러오기 --- (※1)
X_train, X_test, y_train, y_test = np.load('newobj.npy')
# 읽어온 데이터 정규화하기
X_train = X_train.astype('float') / 256
X_test = X_test.astype('float') / 256
print('X_train shape:', X_train.shape)
# CNN 모델 구축하기
model = Sequential()
model.add(
Convolution2D(32, 3, 3, border_mode='same', input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Convolution2D(64, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten()) # --- (※3)
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes)) # 4개의 클래스
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 get_unet_mod(input_img, n_filters = 16, dropout = 0.1, batchnorm = True):
"""Function to define the UNET Model"""
# Contracting Path
skip = Conv2D(filters = n_filters * 1, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(input_img)
c1 = conv2d_block(skip, n_filters * 1, kernel_size = 3, batchnorm = batchnorm)
c1 = layers.add([c1, skip])
p1 = MaxPooling2D((2, 2))(c1)
p1 = Dropout(dropout)(p1)
skip = Conv2D(filters = n_filters * 2, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(p1)
c2 = conv2d_block(skip, n_filters * 2, kernel_size = 3, batchnorm = batchnorm)
c2 = layers.add([c2, skip])
p2 = MaxPooling2D((2, 2))(c2)
p2 = Dropout(dropout)(p2)
skip = Conv2D(filters = n_filters * 4, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(p2)
c3 = conv2d_block(skip, n_filters * 4, kernel_size = 3, batchnorm = batchnorm)
c3 = layers.add([c3, skip])
p3 = MaxPooling2D((2, 2))(c3)
p3 = Dropout(dropout)(p3)
skip = Conv2D(filters = n_filters * 8, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(p3)
c4 = conv2d_block(skip, n_filters * 8, kernel_size = 3, batchnorm = batchnorm)
c4 = layers.add([c4, skip])
p4 = MaxPooling2D((2, 2))(c4)
p4 = Dropout(dropout)(p4)
skip = Conv2D(filters = n_filters * 16, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(p4)
c5 = conv2d_block(skip, n_filters = n_filters * 16, kernel_size = 3, batchnorm = batchnorm)
c5 = aspp_block(c5,num_filters=256,rate_scale=1,output_stride=16,input_shape=(256,256,3))
# Expansive Path
u6 = Conv2DTranspose(n_filters * 8, (3, 3), strides = (2, 2), padding = 'same')(c5)
u6 = concatenate([u6, c4])
u6 = Dropout(dropout)(u6)
skip = Conv2D(filters = n_filters * 8, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(u6)
c6 = conv2d_block(skip, n_filters * 8, kernel_size = 3, batchnorm = batchnorm)
c6 = layers.add([c6, skip])
u7 = Conv2DTranspose(n_filters * 4, (3, 3), strides = (2, 2), padding = 'same')(c6)
u7 = concatenate([u7, c3])
u7 = Dropout(dropout)(u7)
skip = Conv2D(filters = n_filters * 4, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(u7)
c7 = conv2d_block(skip, n_filters * 4, kernel_size = 3, batchnorm = batchnorm)
c6 = layers.add([c7, skip])
u8 = Conv2DTranspose(n_filters * 2, (3, 3), strides = (2, 2), padding = 'same')(c7)
u8 = concatenate([u8, c2])
u8 = Dropout(dropout)(u8)
skip = Conv2D(filters = n_filters * 2, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(u8)
c8 = conv2d_block(skip, n_filters * 2, kernel_size = 3, batchnorm = batchnorm)
c6 = layers.add([c8, skip])
u9 = Conv2DTranspose(n_filters * 1, (3, 3), strides = (2, 2), padding = 'same')(c8)
u9 = concatenate([u9, c1])
u9 = Dropout(dropout)(u9)
skip = Conv2D(filters = n_filters * 1, kernel_size = (3, 3),\
kernel_initializer = 'he_normal', padding = 'same')(u9)
c9 = conv2d_block(skip, n_filters * 1, kernel_size = 3, batchnorm = batchnorm)
c6 = layers.add([c9, skip])
#outputs = Conv2D(1, (1, 1), activation='sigmoid')(c5)
#c9 = aspp_block(c5,num_filters=256,rate_scale=1,output_stride=16,input_shape=(256,256,3))
outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9)
model = Model(inputs=[input_img], outputs=[outputs])
return model
def train(features_dir, top_model_filename, labels, test_indexes, batch_size, sample_size,
learning_rate, momentum, epochs, kfolds, training_indexes_filename,
verbose=False, num_classes=3):
if verbose:
print("Creating block 5 of VGG16..", end="")
# Replication of block 5 of VGG16. This is the layer that we're going
# to retrain to become more attuned to daytime imagery.
model = Sequential()
model.add(Conv2D(
filters=512,
kernel_size=(3, 3),
activation='relu',
padding='same',
name='block5_conv1',
# Hard-coded input size. This is the output size of `block4_pool` when
# the input images are 400x400.
input_shape=(25, 25, 512)
))
model.add(Conv2D(
filters=512,
kernel_size=(3, 3),
activation='relu',
padding='same',
name='block5_conv2'
))
model.add(Conv2D(
filters=512,
kernel_size=(3, 3),
activation='relu',
padding='same',
name='block5_conv3'
))
model.add(MaxPooling2D(
pool_size=(2, 2),
strides=(2, 2),
name='block5_pool'
))
if verbose:
print("done.")
# Initialize the layers of block 5 with the VGG16 ImageNet weights.
# Note: we should load weights *before* adding the top of the model,
# as we might clobber some of the previously trained weights in the
# top if we load weights after the top has been added.
if verbose:
print("Loading ImageNet weights into block 5...", end="")
weights_path = get_file('vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
BLOCK5_WEIGHTS, cache_subdir='models')
model.load_weights(weights_path, by_name=True)
if verbose:
print("done.")
# Load the previously trained top model, and add it to the top of the net.
if verbose:
print("Loading the top of the model from %s..." % (top_model_filename,), end="")
top_model = load_model(top_model_filename)
model.add(top_model)
if verbose:
print("done.")
if verbose:
print("Compiling model...", end="")
model.compile(
loss=keras.losses.categorical_crossentropy,
# Note: this learning rate should be pretty low (e.g., 1e-4, as
# recommended in the referenced blog post, to keep previously-
# learned features in tact. Reference:
# https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
optimizer=SGD(lr=learning_rate, momentum=momentum),
metrics=['accuracy'],
)
if verbose:
print("done.")
# Sample for training indexes, or load from file
if training_indexes_filename is not None:
sampled_examples = []
with open(training_indexes_filename) as training_indexes_file:
for line in training_indexes_file:
sampled_examples.append(int(line.strip()))
else:
sampled_examples = get_training_examples(
features_dir, labels, test_indexes, sample_size)
# Divide the sampled training data into folds
folds = get_folds(sampled_examples, kfolds)
# Convert labels to one-hot array for use in training.
label_array = keras.utils.to_categorical(labels, num_classes)
# Here, we fit the neural network for each fold
for i, fold in enumerate(folds, start=1):
training_examples = fold["training"]
validation_examples = fold["validation"]
if verbose:
print("Training on fold %d of %d" % (i, len(folds)))
print("Training set size: %d" % (len(training_examples)))
print("Validation set size: %d" % (len(validation_examples)))
# Do the actual fitting here
model.fit_generator(
FeatureExampleGenerator(training_examples, features_dir, label_array, batch_size),
steps_per_epoch=math.ceil(float(len(training_examples)) / batch_size),
epochs=epochs,
verbose=(1 if verbose else 0),
validation_data=FeatureExampleGenerator(validation_examples, features_dir, label_array, batch_size),
validation_steps=math.ceil(float(len(validation_examples)) / batch_size),
)
if not os.path.exists("models"):
os.makedirs("models")
model.save(os.path.join(
"models", "tuned-" + strftime("%Y%m%d-%H%M%S", gmtime()) + ".h5"))
def create_unet_twoOutputs(C=3):
inputs = Input(shape=(None, None, C))
s = Lambda(lambda x: x / 255.0)(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)
u6c = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding='same')(c5)
u6c = concatenate([u6c, c4])
c6c = Conv2D(64, (3, 3), activation='relu', padding='same')(u6c)
c6c = Conv2D(64, (3, 3), activation='relu', padding='same')(c6c)
u7c = Conv2DTranspose(32, (3, 3), strides=(2, 2), padding='same')(c6c)
u7c = concatenate([u7c, c3])
c7c = Conv2D(32, (3, 3), activation='relu', padding='same')(u7c)
c7c = Conv2D(32, (3, 3), activation='relu', padding='same')(c7c)
u8c = Conv2DTranspose(16, (3, 3), strides=(2, 2), padding='same')(c7c)
u8c = concatenate([u8c, c2])
c8c = Conv2D(16, (3, 3), activation='relu', padding='same')(u8c)
c8c = Conv2D(16, (3, 3), activation='relu', padding='same')(c8c)
u9c = Conv2DTranspose(8, (3, 3), strides=(2, 2), padding='same')(c8c)
u9c = concatenate([u9c, c1], axis=3)
c9c = Conv2D(8, (3, 3), activation='relu', padding='same')(u9c)
c9c = Conv2D(8, (3, 3), activation='relu', padding='same')(c9c)
contours = Conv2D(1, (1, 1), activation='sigmoid', name='contours')(c9c)
u6l = Conv2DTranspose(64, (3, 3), strides=(2, 2), padding='same')(c5)
u6l = concatenate([u6l, c4])
c6l = Conv2D(64, (3, 3), activation='relu', padding='same')(u6l)
c6l = Conv2D(64, (3, 3), activation='relu', padding='same')(c6l)
u7l = Conv2DTranspose(32, (3, 3), strides=(2, 2), padding='same')(c6l)
u7l = concatenate([u7l, c3])
c7l = Conv2D(32, (3, 3), activation='relu', padding='same')(u7l)
c7l = Conv2D(32, (3, 3), activation='relu', padding='same')(c7l)
u8l = Conv2DTranspose(16, (3, 3), strides=(2, 2), padding='same')(c7l)
u8l = concatenate([u8l, c2])
c8l = Conv2D(16, (3, 3), activation='relu', padding='same')(u8l)
c8l = Conv2D(16, (3, 3), activation='relu', padding='same')(c8l)
u9l = Conv2DTranspose(8, (3, 3), strides=(2, 2), padding='same')(c8l)
u9l = concatenate([u9l, c1], axis=3)
c9l = Conv2D(8, (3, 3), activation='relu', padding='same')(u9l)
c9l = Conv2D(8, (3, 3), activation='relu', padding='same')(c9l)
labels = Conv2D(1, (1, 1), activation='sigmoid', name='labels')(c9l)
model = Model(inputs=[inputs], outputs=[labels, contours])
return model
def build_UNet(unit_size=None, final_max_pooling=None):
s = Lambda(lambda x: x / 255)(inputs)
c1 = Conv2D(unit_size, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(s)
c1 = Dropout(dropout)(c1)
c1 = Conv2D(unit_size, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c1)
p1 = MaxPooling2D((2, 2))(c1)
c2 = Conv2D(unit_size * 2, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(p1)
c2 = Dropout(dropout)(c2)
c2 = Conv2D(unit_size * 2, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c2)
p2 = MaxPooling2D((2, 2))(c2)
c3 = Conv2D(unit_size * 4, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(p2)
c3 = Dropout(dropout)(c3)
c3 = Conv2D(unit_size * 4, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c3)
p3 = MaxPooling2D((2, 2))(c3)
c4 = Conv2D(unit_size * 8, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(p3)
c4 = Dropout(dropout)(c4)
c4 = Conv2D(unit_size * 8, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c4)
p4 = MaxPooling2D((2, 2))(c4)
c5 = Conv2D(unit_size * 16, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(p4)
c5 = Dropout(dropout)(c5)
c5 = Conv2D(unit_size * 16, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c5)
c5 = Dropout(dropout)(c5)
c5 = Conv2D(unit_size * 16, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c5)
u6 = Conv2DTranspose(unit_size * 8, (2, 2), strides=(2, 2),
padding='same')(c5)
u6 = concatenate([u6, c4])
c6 = Conv2D(unit_size * 8, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(u6)
c6 = Dropout(dropout)(c6)
c6 = Conv2D(unit_size * 8, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c6)
u7 = Conv2DTranspose(unit_size * 4, (2, 2), strides=(2, 2),
padding='same')(c6)
u7 = concatenate([u7, c3])
c7 = Conv2D(unit_size * 4, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(u7)
c7 = Dropout(dropout)(c7)
c7 = Conv2D(unit_size * 4, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c7)
u8 = Conv2DTranspose(unit_size * 2, (2, 2), strides=(2, 2),
padding='same')(c7)
u8 = concatenate([u8, c2])
c8 = Conv2D(unit_size * 2, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(u8)
c8 = Dropout(dropout)(c8)
c8 = Conv2D(unit_size * 2, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c8)
u9 = Conv2DTranspose(unit_size, (2, 2), strides=(2, 2), padding='same')(c8)
u9 = concatenate([u9, c1], axis=3)
c9 = Conv2D(unit_size, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(u9)
c9 = Dropout(dropout)(c9)
c9 = Conv2D(unit_size, (3, 3),
activation=DEFAULT_ACTIVATION,
kernel_initializer='he_normal',
padding='same')(c9)
outputs = Conv2D(1, (1, 1), activation='sigmoid')(c9)
model = Model(inputs=[inputs], outputs=[outputs])
return model
image = np.fliplr(image)
measurement = -measurement
images.append(image)
measurements.append(measurement)
X_train = np.array(images)
Y_train = np.array(measurements)
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))))
# Five Convolutional Layer
model.add(Convolution2D(24, 5, 5, border_mode='same'))
model.add(MaxPooling2D())
model.add(Activation('relu'))
model.add(Convolution2D(36, 5, 5, border_mode='same'))
model.add(MaxPooling2D())
model.add(Activation('relu'))
model.add(Convolution2D(48, 5, 5, border_mode='same'))
model.add(MaxPooling2D())
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, border_mode='same'))
model.add(MaxPooling2D())
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, border_mode='same'))
model.add(MaxPooling2D())
model.add(Activation('relu'))
# Five Fully-Connected Layer
def DenseNet(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)
x = Dense(classes, name='fc6')(x)
x = Activation('softmax', name='prob')(x)
model = Model(img_input, x, name='densenet')
if weights_path is not None:
model.load_weights(weights_path)
x = model.output
x = Dense(6, name='fc61')(x)
x = Activation('softmax', name='prob1')(x)
model = Model(img_input, x, name='densenet1')
return model
# imgs.append(image_flipped)
# measurements.append(measurement_flipped)
#
#print(len(imgs))
#print(len(measurements))
#
#X_train = np.array(imgs)
#y_train = np.array(measurements)
model = Sequential()
model.add(Cropping2D(cropping=((70, 25), (0, 0)), input_shape=[160, 320, 3]))
model.add(Lambda(lambda x: x / 255. - 0.5))
model.add(Conv2D(filters=6, kernel_size=(5, 5)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Conv2D(filters=16, kernel_size=(5, 5)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Dropout(0.5))
model.add(Conv2D(filters=32, kernel_size=(3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Flatten())
model.add(Dense(120))
model.add(Activation('relu'))
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="same")(uconv4)
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="same")(uconv2)
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)
#uconv1 = Dropout(DropoutRatio/2)(uconv1)
#output_layer = Conv2D(1, (1,1), padding="same", activation="sigmoid")(uconv1)
output_layer_noActi = Conv2D(1, (1, 1), padding="same",
activation=None)(uconv1)
output_layer = Activation('sigmoid')(output_layer_noActi)
return output_layer
X_train = np.array(images)
y_train = np.array(angles)
y_train = to_categorical(y_train, num_classes=NUM_CLASSES)
# define model here
# input -> crop image -> normalize -> 2 Conv layers ->
# -> 2 fully connected layers -> output softmax to 3 classes
model = Sequential()
model.add(
Cropping2D(cropping=((70, 50), (0, 0)), input_shape=(160, 320, 1)))
model.add(Lambda(lambda x: x / 255. - 0.5)) #normalize
model.add(Conv2D(32, (3, 3),
activation='relu')) #input shape here is (40,320,1)
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.5))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(NUM_CLASSES, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
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)
nb_layers = [count for _ in range(nb_dense_block)]
final_nb_layer = count
else:
final_nb_layer = nb_layers_per_block
nb_layers = [nb_layers_per_block] * nb_dense_block
# compute initial nb_filter if -1, else accept users initial nb_filter
if nb_filter <= 0:
nb_filter = 2 * growth_rate
# compute compression factor
compression = 1.0 - reduction
# Initial convolution
if subsample_initial_block:
initial_kernel = (7, 7)
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)
# 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
import os
import numpy as np
from numpy import genfromtxt
import pandas as pd
import tensorflow as tf
from utils import LRN2D
import utils
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 loadModel(
url='https://drive.google.com/uc?id=1LSe1YCV1x-BfNnfb7DFZTNpv_Q9jITxn'
):
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(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), 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(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75),
name='lrn_2')(x) #x is equal added
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, strides=2)(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=((3, 4), (3,
4)))(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 = Lambda(lambda x: x**2, name='power2_3b')(inception_3a)
inception_3b_pool = AveragePooling2D(pool_size=(3, 3),
strides=(3, 3))(inception_3b_pool)
inception_3b_pool = Lambda(lambda x: x * 9,
name='mult9_3b')(inception_3b_pool)
inception_3b_pool = Lambda(lambda x: K.sqrt(x),
name='sqrt_3b')(inception_3b_pool)
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=(4, 4))(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 = Conv2D(128, (1, 1),
strides=(1, 1),
name='inception_3c_3x3_conv1')(inception_3b)
inception_3c_3x3 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3c_3x3_bn1')(inception_3c_3x3)
inception_3c_3x3 = Activation('relu')(inception_3c_3x3)
inception_3c_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3c_3x3)
inception_3c_3x3 = Conv2D(256, (3, 3),
strides=(2, 2),
name='inception_3c_3x3_conv' +
'2')(inception_3c_3x3)
inception_3c_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_3c_3x3_bn' +
'2')(inception_3c_3x3)
inception_3c_3x3 = Activation('relu')(inception_3c_3x3)
inception_3c_5x5 = Conv2D(32, (1, 1),
strides=(1, 1),
name='inception_3c_5x5_conv1')(inception_3b)
inception_3c_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_3c_5x5_bn1')(inception_3c_5x5)
inception_3c_5x5 = Activation('relu')(inception_3c_5x5)
inception_3c_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3c_5x5)
inception_3c_5x5 = Conv2D(64, (5, 5),
strides=(2, 2),
name='inception_3c_5x5_conv' +
'2')(inception_3c_5x5)
inception_3c_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_3c_5x5_bn' +
'2')(inception_3c_5x5)
inception_3c_5x5 = Activation('relu')(inception_3c_5x5)
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 = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_4a_3x3_conv' + '1')(inception_3c)
inception_4a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_3x3_bn' +
'1')(inception_4a_3x3)
inception_4a_3x3 = Activation('relu')(inception_4a_3x3)
inception_4a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4a_3x3)
inception_4a_3x3 = Conv2D(192, (3, 3),
strides=(1, 1),
name='inception_4a_3x3_conv' +
'2')(inception_4a_3x3)
inception_4a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_3x3_bn' +
'2')(inception_4a_3x3)
inception_4a_3x3 = Activation('relu')(inception_4a_3x3)
inception_4a_5x5 = Conv2D(32, (1, 1),
strides=(1, 1),
name='inception_4a_5x5_conv1')(inception_3c)
inception_4a_5x5 = BatchNormalization(
axis=3, epsilon=0.00001, name='inception_4a_5x5_bn1')(inception_4a_5x5)
inception_4a_5x5 = Activation('relu')(inception_4a_5x5)
inception_4a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4a_5x5)
inception_4a_5x5 = Conv2D(64, (5, 5),
strides=(1, 1),
name='inception_4a_5x5_conv' +
'2')(inception_4a_5x5)
inception_4a_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_5x5_bn' +
'2')(inception_4a_5x5)
inception_4a_5x5 = Activation('relu')(inception_4a_5x5)
inception_4a_pool = Lambda(lambda x: x**2, name='power2_4a')(inception_3c)
inception_4a_pool = AveragePooling2D(pool_size=(3, 3),
strides=(3, 3))(inception_4a_pool)
inception_4a_pool = Lambda(lambda x: x * 9,
name='mult9_4a')(inception_4a_pool)
inception_4a_pool = Lambda(lambda x: K.sqrt(x),
name='sqrt_4a')(inception_4a_pool)
inception_4a_pool = Conv2D(128, (1, 1),
strides=(1, 1),
name='inception_4a_pool_conv' +
'')(inception_4a_pool)
inception_4a_pool = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_pool_bn' +
'')(inception_4a_pool)
inception_4a_pool = Activation('relu')(inception_4a_pool)
inception_4a_pool = ZeroPadding2D(padding=(2, 2))(inception_4a_pool)
inception_4a_1x1 = Conv2D(256, (1, 1),
strides=(1, 1),
name='inception_4a_1x1_conv' + '')(inception_3c)
inception_4a_1x1 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4a_1x1_bn' +
'')(inception_4a_1x1)
inception_4a_1x1 = Activation('relu')(inception_4a_1x1)
inception_4a = concatenate([
inception_4a_3x3, inception_4a_5x5, inception_4a_pool, inception_4a_1x1
],
axis=3)
#inception4e
inception_4e_3x3 = Conv2D(160, (1, 1),
strides=(1, 1),
name='inception_4e_3x3_conv' + '1')(inception_4a)
inception_4e_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_3x3_bn' +
'1')(inception_4e_3x3)
inception_4e_3x3 = Activation('relu')(inception_4e_3x3)
inception_4e_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4e_3x3)
inception_4e_3x3 = Conv2D(256, (3, 3),
strides=(2, 2),
name='inception_4e_3x3_conv' +
'2')(inception_4e_3x3)
inception_4e_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_3x3_bn' +
'2')(inception_4e_3x3)
inception_4e_3x3 = Activation('relu')(inception_4e_3x3)
inception_4e_5x5 = Conv2D(64, (1, 1),
strides=(1, 1),
name='inception_4e_5x5_conv' + '1')(inception_4a)
inception_4e_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_5x5_bn' +
'1')(inception_4e_5x5)
inception_4e_5x5 = Activation('relu')(inception_4e_5x5)
inception_4e_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4e_5x5)
inception_4e_5x5 = Conv2D(128, (5, 5),
strides=(2, 2),
name='inception_4e_5x5_conv' +
'2')(inception_4e_5x5)
inception_4e_5x5 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_4e_5x5_bn' +
'2')(inception_4e_5x5)
inception_4e_5x5 = Activation('relu')(inception_4e_5x5)
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 = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5a_3x3_conv' + '1')(inception_4e)
inception_5a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_3x3_bn' +
'1')(inception_5a_3x3)
inception_5a_3x3 = Activation('relu')(inception_5a_3x3)
inception_5a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5a_3x3)
inception_5a_3x3 = Conv2D(384, (3, 3),
strides=(1, 1),
name='inception_5a_3x3_conv' +
'2')(inception_5a_3x3)
inception_5a_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_3x3_bn' +
'2')(inception_5a_3x3)
inception_5a_3x3 = Activation('relu')(inception_5a_3x3)
inception_5a_pool = Lambda(lambda x: x**2, name='power2_5a')(inception_4e)
inception_5a_pool = AveragePooling2D(pool_size=(3, 3),
strides=(3, 3))(inception_5a_pool)
inception_5a_pool = Lambda(lambda x: x * 9,
name='mult9_5a')(inception_5a_pool)
inception_5a_pool = Lambda(lambda x: K.sqrt(x),
name='sqrt_5a')(inception_5a_pool)
inception_5a_pool = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5a_pool_conv' +
'')(inception_5a_pool)
inception_5a_pool = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_pool_bn' +
'')(inception_5a_pool)
inception_5a_pool = Activation('relu')(inception_5a_pool)
inception_5a_pool = ZeroPadding2D(padding=(1, 1))(inception_5a_pool)
inception_5a_1x1 = Conv2D(256, (1, 1),
strides=(1, 1),
name='inception_5a_1x1_conv' + '')(inception_4e)
inception_5a_1x1 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5a_1x1_bn' +
'')(inception_5a_1x1)
inception_5a_1x1 = Activation('relu')(inception_5a_1x1)
inception_5a = concatenate(
[inception_5a_3x3, inception_5a_pool, inception_5a_1x1], axis=3)
#inception_5b
inception_5b_3x3 = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5b_3x3_conv' + '1')(inception_5a)
inception_5b_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_3x3_bn' +
'1')(inception_5b_3x3)
inception_5b_3x3 = Activation('relu')(inception_5b_3x3)
inception_5b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5b_3x3)
inception_5b_3x3 = Conv2D(384, (3, 3),
strides=(1, 1),
name='inception_5b_3x3_conv' +
'2')(inception_5b_3x3)
inception_5b_3x3 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_3x3_bn' +
'2')(inception_5b_3x3)
inception_5b_3x3 = Activation('relu')(inception_5b_3x3)
inception_5b_pool = MaxPooling2D(pool_size=3, strides=2)(inception_5a)
inception_5b_pool = Conv2D(96, (1, 1),
strides=(1, 1),
name='inception_5b_pool_conv' +
'')(inception_5b_pool)
inception_5b_pool = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_pool_bn' +
'')(inception_5b_pool)
inception_5b_pool = Activation('relu')(inception_5b_pool)
inception_5b_pool = ZeroPadding2D(padding=(1, 1))(inception_5b_pool)
inception_5b_1x1 = Conv2D(256, (1, 1),
strides=(1, 1),
name='inception_5b_1x1_conv' + '')(inception_5a)
inception_5b_1x1 = BatchNormalization(axis=3,
epsilon=0.00001,
name='inception_5b_1x1_bn' +
'')(inception_5b_1x1)
inception_5b_1x1 = Activation('relu')(inception_5b_1x1)
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)
# Final Model
model = Model(inputs=[myInput], outputs=norm_layer)
#-----------------------------------
# home = str(Path.home())
home = 'D:/newlandface'
if os.path.isfile(home + '/weights/openface_weights.h5') != True:
print("openface_weights.h5 will be downloaded...")
output = home + '/weights/openface_weights.h5'
gdown.download(url, output, quiet=False)
#-----------------------------------
model.load_weights(home + '/weights/openface_weights.h5')
#-----------------------------------
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='sigmoid'):
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 = 2 * 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)
# 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
def end_to_end_nvidia(dropout = []):
"""This model attempts to mimic the model by NVIDIA in their paper End to End Learning for Self-Driving
Cars:
https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
Parameters:
dropout - list of dropout values for the 3 fully connected layers
Returns:
A model based on the End to End NVIDIA model"""
# ensure the dropout list has enough values in it for the model
# augment the values of some are missing
if dropout == None or len(dropout) == 0:
dropout = [0.0, 0.0, 0.0]
elif len(dropout) == 1:
dropout = dropout * 3
elif len(dropout) == 2:
dropout.append(dropout[1])
# this hack gets the current function name and sets it to the name of the model
model = Sequential(name=traceback.extract_stack(None, 2)[-1][2])
# crop top 56 rows and bottom 24 rows from the images
model.add(Cropping2D(cropping=((56, 24), (0, 0)), input_shape=(160, 320, 3), name='pp_crop'))
# mean center the pixels
model.add(Lambda(lambda x: (x / 255.0) - 0.5, name='pp_center'))
# layer 1: convolution. Input 40x160x3. Output 36x156x24
model.add(Convolution2D(24, 5, 5, border_mode='valid', name='conv1'))
model.add(MaxPooling2D((2, 2), border_mode='valid', name='pool1'))
model.add(Activation('relu', name='act1'))
# layer 2: convolution + max pooling. Input 36x156x24. Output 16x76x36
model.add(Convolution2D(36, 5, 5, border_mode='valid', name='conv2'))
model.add(MaxPooling2D((2, 2), border_mode='valid', name='pool2'))
model.add(Activation('relu', name='act2'))
# layer 3: convolution + max pooling. Input 16x76x36. Output 6x36x48
model.add(Convolution2D(48, 5, 5, border_mode='valid', name='conv3'))
model.add(MaxPooling2D((2, 2), border_mode='valid', name='pool3'))
model.add(Activation('relu', name='act3'))
# layer 4: convolution. Input 6x36x48. Output 4x34x64
model.add(Convolution2D(64, 3, 3, border_mode='valid', name='conv4'))
model.add(Activation('relu', name='act4'))
# layer 5: convolution. Input 4x34x64. Output 1x16x64
model.add(Convolution2D(64, 3, 3, border_mode='valid', name='conv5'))
model.add(MaxPooling2D((2, 2), border_mode='valid', name='pool5'))
model.add(Activation('relu', name='act5'))
# flatten: Input 1x16x64. Output 1024
model.add(Flatten(name='flat'))
# layer 6: fully connected + dropout. Input 1024. Output 100
model.add(Dense(100, name='fc6'))
model.add(Dropout(dropout[0], name='drop6'))
model.add(Activation('relu', name='act6'))
# layer 7: fully connected + dropout. Input 100. Output 50
model.add(Dense(50, name='fc7'))
model.add(Dropout(dropout[1], name='drop7'))
model.add(Activation('relu', name='act7'))
# layer 8: fully connected + dropout. Input 50. Output 10
model.add(Dense(10, name='fc8'))
model.add(Dropout(dropout[2], name='drop8'))
model.add(Activation('relu', name='act8'))
# layer 9: fully connected. Input 10. Output 1.
model.add(Dense(1, name='out'))
return model
