def create_model_bn_5_dropout():
#Max Accuracy: 0.78884
#Max Validation Accuracy: 0.8482999801635742
model = Sequential()
# Convolutional layers
model.add(
Conv2D(filters=20,
kernel_size=(3, 3),
activation='relu',
input_shape=x_train.shape[1:],
padding="same"))
model.add(BatchNormalization())
model.add(
Conv2D(filters=20,
kernel_size=(3, 3),
activation='relu',
input_shape=x_train.shape[1:],
padding="same"))
model.add(BatchNormalization())
model.add(MaxPooling2D())
model.add(SpatialDropout2D(0.25))
model.add(
Conv2D(filters=40,
kernel_size=(3, 3),
activation='relu',
padding="same"))
model.add(
Conv2D(filters=40,
kernel_size=(3, 3),
activation='relu',
padding="same"))
model.add(BatchNormalization())
model.add(MaxPooling2D())
model.add(SpatialDropout2D(0.2))
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
activation='relu',
padding="same"))
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
activation='relu',
padding="same"))
model.add(BatchNormalization())
model.add(MaxPooling2D())
model.add(Dropout(0.15))
# Fully Connected layers
model.add(Flatten())
model.add(Dense(units=384, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(units=192, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=num_classes, activation='softmax'))
return model
def build_model():
"""
NVIDIA model
http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
"""
model = Sequential()
model.add(Lambda(lambda x: x / 127.5 - 1., input_shape=INPUT_SHAPE))
model.add(Cropping2D(cropping=((60, 20), (0, 0))))
model.add(Convolution2D(24, 5, 5, border_mode="same", subsample=(2,2), activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(36, 5, 5, border_mode="same", subsample=(2,2), activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(48, 5, 5, border_mode="valid", subsample=(2,2), activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(100, activation="elu"))
model.add(Dense(50, activation="elu"))
model.add(Dense(10, activation="elu"))
model.add(Dropout(0.5))
model.add(Dense(1))
return model
def main():
samples = []
# with open(FLAGS.csv_path) as csvfile:
# reader = csv.reader(csvfile)
# for line in reader:
# samples.append(line)
# samples.pop(0)
with open(FLAGS.csv_path_augmented) as csvfile:
reader = csv.reader(csvfile)
for line in reader:
samples.append(line)
from sklearn.model_selection import train_test_split
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=FLAGS.batch_size)
validation_generator = generator(validation_samples,
batch_size=FLAGS.batch_size)
def resize(img):
import tensorflow as tf
img = tf.image.resize_images(img, (66, 200))
return img
model = Sequential([
Cropping2D(cropping=((22, 22), (0, 0)), input_shape=(160, 320, 3)),
Lambda(lambda x: (x / 255.0) - 0.5),
Lambda(resize),
Conv2D(24, (5, 5), padding='same', strides=(2, 2), activation='relu'),
SpatialDropout2D(0.2),
Conv2D(36, (5, 5), padding='same', strides=(2, 2), activation='elu'),
SpatialDropout2D(0.2),
Conv2D(48, (5, 5), padding='same', strides=(2, 2), activation='elu'),
SpatialDropout2D(0.2),
Conv2D(64, (3, 3), padding='valid', activation='elu'),
SpatialDropout2D(0.2),
Conv2D(64, (3, 3), padding='same', activation='elu'),
SpatialDropout2D(0.2),
Flatten(),
Dropout(0.5),
Dense(100, activation='elu'),
Dense(50, activation='elu'),
Dense(10, activation='elu'),
Dropout(0.5),
Dense(1)
])
model.compile(loss='mse', optimizer=Adam(lr=FLAGS.lrate))
model.fit_generator(generator=train_generator,\
steps_per_epoch=len(train_samples)//FLAGS.batch_size,\
epochs=FLAGS.num_epochs,\
validation_data=validation_generator,\
validation_steps=len(validation_samples)//FLAGS.batch_size\
)
model.summary()
model.save('model.h5')
def def_model_(self):
model = Sequential()
model.add(Conv2D(self.n_channels, 3, padding='same',input_shape=self.input_size,
kernel_regularizer=regularizers.l2(self.weight_decay)))
model.add(Activation('relu'))
model.add(BatchNormalization(momentum=0.9))
model.add(MaxPooling2D(pool_size=3, strides=2))
model.add(SpatialDropout2D(rate=self.drop))
# model.add(Dropout(drop))
for _ in range(self.blocks - 1):
self.n_channels *= 2
model.add(Conv2D(self.n_channels, (3, 3), padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay)))
model.add(Activation('relu'))
model.add(BatchNormalization(momentum=0.9))
model.add(MaxPooling2D(pool_size=3, strides=2))
model.add(SpatialDropout2D(rate=self.drop))
# model.add(Dropout(drop))
model.add(Flatten())
model.add(Dense(self.embedding_dim, kernel_regularizer=regularizers.l2(self.weight_decay)))
model.add(Lambda(lambda x: K.l2_normalize(x, axis=-1)))
model.summary()
return model
def lenet_model(input_shape=(160, 320, 3), drop_out=0.5, drop_out_sp=0.2):
"""
LeNet Architecture
"""
print('\n\n ')
print('>> Building the model (LeNet Architecture)...')
# Pre-processing layer
model = pre_processing_model(input_shape=input_shape)
# Other layers
model.add(
Convolution2D(6, (5, 5),
strides=(1, 1),
padding='valid',
activation='relu'))
model.add(SpatialDropout2D(drop_out_sp))
model.add(MaxPooling2D(pool_size=(2, 2), padding='valid'))
model.add(
Convolution2D(6, (5, 5),
strides=(1, 1),
padding='valid',
activation='relu'))
model.add(SpatialDropout2D(drop_out_sp))
model.add(MaxPooling2D(pool_size=(2, 2), padding='valid'))
model.add(Flatten())
model.add(Dropout(drop_out))
model.add(Dense(120))
model.add(Dropout(drop_out))
model.add(Dense(84))
model.add(Dropout(drop_out))
model.add(Dense(1))
model.summary()
return model
def model_generator(latent_dim,
nch=512,
dropout=0.5,
reg=lambda: l1l2(l1=1e-7, l2=1e-7)):
model = Sequential(name="decoder")
h = 5
model.add(
Dense(input_dim=latent_dim,
output_dim=nch * 4 * 4,
W_regularizer=reg()))
model.add(Reshape(dim_ordering_shape((nch, 4, 4))))
model.add(SpatialDropout2D(dropout))
model.add(LeakyReLU(0.2))
model.add(
Convolution2D(nch / 2, h, h, border_mode='same', W_regularizer=reg()))
model.add(SpatialDropout2D(dropout))
model.add(LeakyReLU(0.2))
model.add(UpSampling2D(size=(2, 2)))
model.add(
Convolution2D(nch / 2, h, h, border_mode='same', W_regularizer=reg()))
model.add(SpatialDropout2D(dropout))
model.add(LeakyReLU(0.2))
model.add(UpSampling2D(size=(2, 2)))
model.add(
Convolution2D(nch / 4, h, h, border_mode='same', W_regularizer=reg()))
model.add(SpatialDropout2D(dropout))
model.add(LeakyReLU(0.2))
model.add(UpSampling2D(size=(2, 2)))
model.add(Convolution2D(3, h, h, border_mode='same', W_regularizer=reg()))
model.add(Activation('sigmoid'))
return model
def make_model(activation='relu',
loss='categorical_crossentropy',
optimizer='sgd',
sp_dropout=0.1,
dropout=0.1):
"""
This creates a new CNN model evey time is called.
"""
conv_model_gaus_dr = Sequential()
conv_model_gaus_dr.add(
Conv2D(32, (3, 3), input_shape=(64, 64, 1), activation=activation))
conv_model_gaus_dr.add(BatchNormalization())
conv_model_gaus_dr.add(Conv2D(64, (3, 3), activation=activation))
conv_model_gaus_dr.add(MaxPool2D((2, 2)))
conv_model_gaus_dr.add(SpatialDropout2D(sp_dropout))
conv_model_gaus_dr.add(Conv2D(128, (3, 3), activation=activation))
conv_model_gaus_dr.add(MaxPool2D((2, 2)))
conv_model_gaus_dr.add(SpatialDropout2D(sp_dropout))
conv_model_gaus_dr.add(Conv2D(256, (3, 3), activation=activation))
conv_model_gaus_dr.add(MaxPool2D((2, 2)))
conv_model_gaus_dr.add(Flatten())
conv_model_gaus_dr.add(Dropout(dropout))
conv_model_gaus_dr.add(Dense(512, activation='relu'))
conv_model_gaus_dr.add(Dense(4, activation='softmax'))
conv_model_gaus_dr.compile(loss=loss,
optimizer=optimizer,
metrics=['accuracy'])
return conv_model_gaus_dr
def model_encoder(latent_dim,
input_shape,
nch=512,
reg=lambda: l1l2(l1=1e-7, l2=1e-7),
dropout=0.5):
k = 5
x = Input(input_shape)
h = Convolution2D(nch / 4, k, k, border_mode='same',
W_regularizer=reg())(x)
h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h)
h = LeakyReLU(0.2)(h)
h = Convolution2D(nch / 2, k, k, border_mode='same',
W_regularizer=reg())(h)
h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h)
h = LeakyReLU(0.2)(h)
h = Convolution2D(nch / 2, k, k, border_mode='same',
W_regularizer=reg())(h)
h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h)
h = LeakyReLU(0.2)(h)
h = Convolution2D(nch, k, k, border_mode='same', W_regularizer=reg())(h)
h = SpatialDropout2D(dropout)(h)
h = LeakyReLU(0.2)(h)
h = Flatten()(h)
mu = Dense(latent_dim, name="encoder_mu", W_regularizer=reg())(h)
log_sigma_sq = Dense(latent_dim,
name="encoder_log_sigma_sq",
W_regularizer=reg())(h)
z = merge(
[mu, log_sigma_sq],
mode=lambda p: p[0] + K.random_normal(K.shape(p[0])) * K.exp(p[1] / 2),
output_shape=lambda p: p[0])
return Model(x, z, name="encoder")
def model_nvidia(img_shape):
"""Model based on the following paper by Nvidia
http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
"""
model = Sequential()
model.add(Lambda(lambda x: x / 127.5 - 1.0, input_shape=img_shape, output_shape=img_shape))
# model.add(Cropping2D(cropping=((70, 25),(0, 0))))
model.add(Convolution2D(24, 5, 5, border_mode="same", subsample=(2,2), activation="relu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(36, 5, 5, border_mode="same", subsample=(2,2), activation="relu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(48, 5, 5, border_mode="valid", subsample=(2,2), activation="relu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="relu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="relu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(100, activation="relu"))
model.add(Dense(50, activation="relu"))
model.add(Dense(10, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(1))
return model
def make_model_tinycnn():
model = Sequential()
model.add(ZeroPadding2D((1, 1), input_shape=input_shape))
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu'))
model.add(SpatialDropout2D(0.3))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(SpatialDropout2D(0.4))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(256, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
optim = Adam(lr=0.0001)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=optim,
metrics=['accuracy'])
return model
def create_multi_res_model():
'''Create a PPT text detector model using multi-resolution responses
'''
base_model = create_single_res_model()
# create a multi-resolution model
inputs = Input(shape=(3, None, None))
a2 = AveragePooling2D((2, 2))(inputs)
a3 = AveragePooling2D((3, 3))(inputs)
a4 = AveragePooling2D((4, 4))(inputs)
# decode at each resolution
p1 = base_model(inputs)
p2 = base_model(a2)
p3 = base_model(a3)
p4 = base_model(a4)
# dropout
d1 = SpatialDropout2D(0.25)(p1)
d2 = SpatialDropout2D(0.25)(p2)
d3 = SpatialDropout2D(0.25)(p3)
d4 = SpatialDropout2D(0.25)(p4)
# map to original resolution
o2 = UpSampling2D((2, 2))(d2)
o3 = UpSampling2D((3, 3))(d3)
o4 = UpSampling2D((4, 4))(d4)
# merge all response
f = merge([d1, o2, o3, o4], mode='concat', concat_axis=1)
f_pad = ZeroPadding2D((5, 5))(f)
bottle = Convolution2D(8, 11, 11, activation='relu', name='bottle')(f_pad)
output = Convolution2D(3, 1, 1, activation=softmax4)(bottle)
model = Model(input=inputs, output=output)
return model
def regression_model(input_shape=(image_height, image_width, 3), use_adadelta=True, learning_rate=0.01, W_l2=0.0001, ):
"""
"""
model = Sequential()
model.add(Conv2D(16, (5, 5), input_shape=input_shape, kernel_initializer="he_normal", activation='relu', padding='same'))
model.add(SpatialDropout2D(0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(20, (5, 5), kernel_initializer="he_normal", activation='relu', padding='same'))
model.add(SpatialDropout2D(0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(40, (3, 3), kernel_initializer="he_normal", activation='relu', padding='same'))
model.add(SpatialDropout2D(0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(60, (3, 3), kernel_initializer="he_normal", activation='relu', padding='same'))
model.add(SpatialDropout2D(0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(80, (2, 2), kernel_initializer="he_normal", activation='relu', padding='same'))
model.add(SpatialDropout2D(0.1))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, (2, 2), kernel_initializer="he_normal", activation='relu', padding='same'))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(output_dim=1, kernel_initializer='he_normal', W_regularizer=l2(W_l2)))
optimizer = SGD(lr=learning_rate, momentum=0.9)
model.compile(loss=rmse, optimizer=optimizer)
return model
def keras_model(input_image):
model = Sequential()
model.add(Lambda(resize_images, input_image=input_image))
model.add(Lambda(lambda x: x / 255. - 0.5))
model.add(Convolution2D(24, 5, 5, border_mode="same", subsample=(2, 2), activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(36, 5, 5, border_mode="same", subsample=(2, 2), activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(48, 5, 5, border_mode="valid", subsample=(2, 2), activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(100, activation="elu"))
model.add(Dense(50, activation="elu"))
model.add(Dense(10, activation="elu"))
model.add(Dropout(0.5))
model.add(Dense(1))
model.compile(optimizer=Adam(lr=0.001), loss='mse')
return model
def decoder_a(self):
""" Decoder for side A """
kwargs = dict(kernel_size=5, kernel_initializer=self.kernel_initializer)
decoder_complexity = 320 if self.low_mem else self.config["complexity_decoder_a"]
dense_dim = 384 if self.low_mem else 512
decoder_shape = self.input_shape[0] // 16
input_ = Input(shape=(decoder_shape, decoder_shape, dense_dim))
var_x = input_
var_x = UpscaleBlock(decoder_complexity, activation="leakyrelu", **kwargs)(var_x)
var_x = SpatialDropout2D(0.25)(var_x)
var_x = UpscaleBlock(decoder_complexity, activation="leakyrelu", **kwargs)(var_x)
if self.low_mem:
var_x = SpatialDropout2D(0.15)(var_x)
else:
var_x = SpatialDropout2D(0.25)(var_x)
var_x = UpscaleBlock(decoder_complexity // 2, activation="leakyrelu", **kwargs)(var_x)
var_x = UpscaleBlock(decoder_complexity // 4, activation="leakyrelu", **kwargs)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_a")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(decoder_complexity, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(decoder_complexity, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(decoder_complexity // 2, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(decoder_complexity // 4, activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_a")(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name="decoder_a")
def nvidia_model(): row, col, depth = 66,200,3 model = Sequential() model.add(Lambda(process,input_shape = (160,320,3) )) model.add(Lambda(lambda x: x/255.-0.5)) model.add(Convolution2D(24, 5, 5, border_mode="same", subsample=(2,2), activation="relu")) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(36, 5, 5, border_mode="same", subsample=(2,2), activation="relu")) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(48, 5, 5, border_mode="valid", subsample=(2,2), activation="relu")) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="relu")) model.add(SpatialDropout2D(0.2)) model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="relu")) model.add(SpatialDropout2D(0.2)) model.add(Flatten()) model.add(Dropout(0.5)) model.add(Dense(100, activation="relu")) model.add(Dense(50, activation="relu")) model.add(Dense(10, activation="relu")) model.add(Dropout(0.5)) model.add(Dense(1)) model.summary() # Adam loss optimizer to reduce error model.compile(loss = 'mse' , optimizer = 'adam') return model
def layer1(inputmodel):
#model = Model()(inputmodel)
model = Conv2D(50, kernel_size=(5, 5), dilation_rate=2,
activation='relu')(inputmodel)
model = SpatialDropout2D(0.3)(model)
model = Conv2D(50, kernel_size=(5, 5), dilation_rate=2,
activation='relu')(model)
model = MaxPooling2D(pool_size=(2, 2))(model)
# model = SpatialDropout2D(0.3)(model)
model = Conv2D(50, kernel_size=(5, 5), dilation_rate=2,
activation='relu')(model)
model = SpatialDropout2D(0.3)(model)
model = Conv2D(50, kernel_size=(5, 5), dilation_rate=2,
activation='relu')(model)
model = MaxPooling2D(pool_size=(2, 2))(model)
# model = SpatialDropout2D(0.3)(model)
model = Conv2D(50, kernel_size=(5, 5), dilation_rate=2,
activation='relu')(model)
model = SpatialDropout2D(0.3)(model)
model = Conv2D(50, kernel_size=(5, 5), dilation_rate=2,
activation='relu')(model)
model = MaxPooling2D(pool_size=(2, 2))(model)
model = SpatialDropout2D(0.3)(model)
return model
def def_model(self):
base_map_num = 32
inputs = Input(shape=self.input_shape)
x = Conv2D(base_map_num, (3, 3),
padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay),
input_shape=self.input_shape)(inputs)
x = Activation('relu')(x)
x = BatchNormalization()(x)
x = Conv2D(base_map_num, (3, 3),
padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay))(x)
x = Activation('relu')(x)
x = Dropout(0.25)(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = SpatialDropout2D(0.25)(x)
x = Conv2D(2 * base_map_num, (3, 3),
padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay))(x)
x = Activation('relu')(x)
x = BatchNormalization()(x)
x = Conv2D(2 * base_map_num, (3, 3),
padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay))(x)
x = Activation('relu')(x)
x = Dropout(0.35)(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = SpatialDropout2D(0.35)(x)
x = Conv2D(4 * base_map_num, (3, 3),
padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay))(x)
x = Activation('relu')(x)
x = BatchNormalization()(x)
x = Conv2D(4 * base_map_num, (3, 3),
padding='same',
kernel_regularizer=regularizers.l2(self.weight_decay))(x)
x = Activation('relu')(x)
x = Dropout(0.4)(x)
x = BatchNormalization()(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = SpatialDropout2D(0.4)(x)
x = Flatten()(x)
embedding = Dense(self.embedding_dim,
kernel_regularizer=regularizers.l2(
self.weight_decay))(x)
embedding = Lambda(lambda x_: K.l2_normalize(x_, axis=-1),
name="embedding_output")(embedding)
x = BatchNormalization()(embedding)
x = Activation('relu')(x)
classify = Dense(10, activation='softmax', name="class_output")(x)
final = Model(inputs=inputs, outputs=[embedding, classify])
final.summary()
return final
def model_nvidia(input_shape):
def resize_images(img):
import tensorflow as tf
return tf.image.resize_images(img, (66, 200))
model = Sequential()
model.add(Lambda(resize_images, input_shape=input_shape))
model.add(Lambda(lambda x: x / 255. - 0.5))
model.add(
Convolution2D(24,
5,
5,
border_mode=SAME_BORDER_MODE,
subsample=SUB_SAMPLE,
activation=ACTIVATION))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(36,
5,
5,
border_mode=SAME_BORDER_MODE,
subsample=SUB_SAMPLE,
activation=ACTIVATION))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(48,
5,
5,
border_mode=VALID_BORDER_MODE,
subsample=SUB_SAMPLE,
activation=ACTIVATION))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(64,
3,
3,
border_mode=VALID_BORDER_MODE,
activation=ACTIVATION))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(64,
3,
3,
border_mode=VALID_BORDER_MODE,
activation=ACTIVATION))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(100, activation=ACTIVATION))
model.add(Dense(50, activation=ACTIVATION))
model.add(Dense(10, activation=ACTIVATION))
model.add(Dropout(0.5))
model.add(Dense(1))
model.compile(optimizer=Adam(lr=LOSS_RATE), loss=LOSS_FUNCTION)
return model
def conv_block(m, dim, acti, bn, res, do=0):
n = Conv2D(dim, 3, activation=acti, padding='same')(m)
n = BatchNormalization()(n) if bn else n
n = SpatialDropout2D(do/2.0)(n) if do else n
n = Conv2D(dim, 3, activation=acti, padding='same')(n)
n = BatchNormalization()(n) if bn else n
n = Concatenate()([m, n]) if res else n
n = SpatialDropout2D(do)(n) if do else n
return n
def small_2d_conv_net_dynamic(size_y=32,
size_x=32,
n_channels=1,
n_frames=5,
filters=10):
inp = Input(shape=(size_y, size_x, n_channels, n_frames))
x1 = Reshape(target_shape=(size_y, size_x, n_channels * n_frames))(inp)
x1 = DynImage(filters=filters)(x1)
x1 = GaussianNoise(0.05)(x1)
x1 = Conv2D(32, (3, 3), padding='same')(x1)
x1 = SpatialDropout2D(0.3)(x1)
x1 = LeakyReLU(alpha=0.2)(x1)
x1 = MaxPooling2D(pool_size=(2, 2))(x1)
x1 = GaussianNoise(0.02)(x1)
x1 = Conv2D(64, (3, 3), padding='same')(x1)
x1 = SpatialDropout2D(0.3)(x1)
x1 = LeakyReLU(alpha=0.2)(x1)
x1 = MaxPooling2D(pool_size=(2, 2))(x1)
x1 = GaussianNoise(0.01)(x1)
x1 = Conv2D(256, (3, 3), padding='same')(x1)
x1 = SpatialDropout2D(0.3)(x1)
x1 = LeakyReLU(alpha=0.2)(x1)
x1 = MaxPooling2D(pool_size=(2, 2))(x1)
# x1 = Flatten()(x1)
# x1 = Dropout(0.3)(x1)
# x1 = Dense(units=h_units)(x1)
# x1 = LeakyReLU(alpha=0.2)(x1)
#
# x1 = Dense(units=(size_y/4)*(size_x/4)*128)(x1)
# x1 = LeakyReLU(alpha=0.2)(x1)
# x1 = Reshape((size_x/4,size_y/4,128))(x1)
x1 = UpSampling2D(size=(2, 2))(x1)
x1 = Conv2D(256, (3, 3), padding='same')(x1)
x1 = LeakyReLU(alpha=0.2)(x1)
x1 = UpSampling2D(size=(2, 2))(x1)
x1 = Conv2D(128, (3, 3), padding='same')(x1)
x1 = LeakyReLU(alpha=0.2)(x1)
x1 = UpSampling2D(size=(2, 2))(x1)
x1 = Conv2D(64, (3, 3), padding='same')(x1)
x1 = LeakyReLU(alpha=0.2)(x1)
x1 = Conv2D(n_frames, (3, 3), activation='tanh', padding='same')(x1)
x1 = Reshape(target_shape=(size_y, size_x, n_channels, n_frames))(x1)
model = Model(inputs=[inp], outputs=[x1])
rmsprop = RMSprop(lr=0.0001)
model.compile(optimizer=rmsprop, loss='mse')
return model
def nvidia_dropout_model(input_shape=(80, 160, 3)):
ch, row, col = 3, 80, 320 # Trimmed image format
model = Sequential()
model.add(Cropping2D(cropping=((50, 30), (0, 0)), input_shape=input_shape))
# 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)))
model.add(
Convolution2D(24,
5,
5,
subsample=(2, 2),
activation="relu",
border_mode='same'))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(36,
5,
5,
subsample=(2, 2),
activation="relu",
border_mode='same'))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(48,
5,
5,
subsample=(2, 2),
activation="relu",
border_mode='same'))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(64,
3,
3,
subsample=(2, 2),
activation="relu",
border_mode='same'))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(64,
3,
3,
subsample=(2, 2),
activation="relu",
border_mode='same'))
model.add(Flatten())
model.add(Dense(100, activation="elu"))
model.add(Dense(50, activation="elu"))
model.add(Dense(10, activation="elu"))
model.add(Dropout(0.5))
model.add(Dense(1))
return model
def nvidia(img):
"""
Model based on Nvidia paper
http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
"""
shape = (img[0], img[1], 3)
model = Sequential()
def process(img):
import tensorflow as tf
# img = tf.image.rgb_to_grayscale(img)
img = tf.image.resize_images(img, (66, 200))
return img
model.add(Lambda(process, input_shape=shape))
model.add(Lambda(lambda x: x / 255. - 0.5))
model.add(
Convolution2D(24,
5,
5,
border_mode="same",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(36,
5,
5,
border_mode="same",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(48,
5,
5,
border_mode="valid",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(100, activation="elu"))
model.add(Dense(50, activation="elu"))
model.add(Dense(10, activation="elu"))
model.add(Dropout(0.5))
model.add(Dense(1))
return model
def nvidia_model(img):
"""
Model from Nvidia
http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
"""
shape = img.shape
model = Sequential()
model.add(Lambda(lambda x: x / 255.0 - 0.5, input_shape=shape))
model.add(Cropping2D(cropping=((70, 24), (
60, 60)))) # crop off 70px top, 25px bottom and 60px off left/right
model.add(
Convolution2D(24,
5,
5,
border_mode="same",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(36,
5,
5,
border_mode="same",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(48,
5,
5,
border_mode="valid",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
# model.add(Dropout(0.25))
model.add(Dense(100, activation="elu"))
model.add(Dense(50, activation="elu"))
model.add(Dense(10, activation="elu"))
# model.add(Dropout(0.25))
model.add(Dense(1))
print("nvidia model returned successfully\n")
return model
def EEGNet_SSVEP(nb_classes, Chans = 64, Samples = 128, regRate = 0.0001,
dropoutRate = 0.25, kernLength = 64, numFilters = 8):
""" Keras Implementation of the variant of EEGNet that was used to classify
signals from an SSVEP task (https://arxiv.org/abs/1803.04566)
Inputs:
nb_classes : int, number of classes to classify
Chans, Samples : number of channels and time points in the EEG data
regRate : regularization parameter for L1 and L2 penalties
dropoutRate : dropout fraction
kernLength : length of temporal convolution in first layer
numFilters : number of temporal-spatial filter pairs to learn
"""
input1 = Input(shape = (1, Chans, Samples))
##################################################################
layer1 = Conv2D(numFilters, (1, kernLength), padding = 'same',
kernel_regularizer = l1_l2(l1=0.0, l2=0.0),
input_shape = (1, Chans, Samples),
use_bias = False)(input1)
layer1 = BatchNormalization(axis = 1)(layer1)
layer1 = DepthwiseConv2D((Chans, 1),
depthwise_regularizer = l1_l2(l1=regRate, l2=regRate),
use_bias = False)(layer1)
layer1 = BatchNormalization(axis = 1)(layer1)
layer1 = Activation('elu')(layer1)
layer1 = SpatialDropout2D(dropoutRate)(layer1)
layer2 = SeparableConv2D(numFilters, (1, 8),
depthwise_regularizer=l1_l2(l1=0.0, l2=regRate),
use_bias = False, padding = 'same')(layer1)
layer2 = BatchNormalization(axis=1)(layer2)
layer2 = Activation('elu')(layer2)
layer2 = AveragePooling2D((1, 4))(layer2)
layer2 = SpatialDropout2D(dropoutRate)(layer2)
layer3 = SeparableConv2D(numFilters*2, (1, 8), depth_multiplier = 2,
depthwise_regularizer=l1_l2(l1=0.0, l2=regRate),
use_bias = False, padding = 'same')(layer2)
layer3 = BatchNormalization(axis=1)(layer3)
layer3 = Activation('elu')(layer3)
layer3 = AveragePooling2D((1, 4))(layer3)
layer3 = SpatialDropout2D(dropoutRate)(layer3)
flatten = Flatten(name = 'flatten')(layer3)
dense = Dense(nb_classes, name = 'dense')(flatten)
softmax = Activation('softmax', name = 'softmax')(dense)
return Model(inputs=input1, outputs=softmax)
def model_88(input_shape=None,
keep_prob=0.5,
classes=10,
r=1e-2,
name='model88'):
Inpt = Input(shape=input_shape, name='Input_' + name)
x = Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
padding='same')(Inpt)
#x = BatchNormalization()(x)
x = Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
padding='same')(x)
#x = BatchNormalization()(x)
x = MaxPooling2D((2, 2))(x)
# x = Dropout(0.2)(x)
x = SpatialDropout2D(0.2)(x)
x = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
padding='same')(x)
#x = BatchNormalization()(x)
x = Conv2D(64, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
padding='same')(x)
#x = BatchNormalization()(x)
x = MaxPooling2D((2, 2))(x)
x = Dropout(0.3)(x)
# x = SpatialDropout2D(0.3)(x)
x = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
padding='same')(x)
#x = BatchNormalization()(x)
x = Conv2D(128, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
padding='same')(x)
#x = BatchNormalization()(x)
x = MaxPooling2D((2, 2))(x)
# x = Dropout(0.4)(x)
x = SpatialDropout2D(0.2)(x)
x = GlobalAveragePooling2D()(x)
# Orignal network use FC layers with BN and Dropout
#x = Flatten()(x)
#x = Dense(128, activation='relu', kernel_initializer='he_uniform')(x)
#x = BatchNormalization()(x)
#x = Dropout(0.5)(x)
prediction = Dense(classes, activation='softmax')(x)
model = Model(Inpt, prediction, name=name)
model.summary()
return model
def nvidia_model(input_shape):
"""
model referenced from
http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
I modified the model by adding Convolution2D and W_regularizer, and change activation function to elu
"""
_model = Sequential()
_model.add(Cropping2D(cropping=((50, 20), (0, 0)),
input_shape=input_shape))
_model.add(Lambda(lambda x: x / 255. - 0.5))
_model.add(
Convolution2D(24, (5, 5),
padding="same",
strides=(2, 2),
activation="elu"))
_model.add(SpatialDropout2D(0.2))
_model.add(
Convolution2D(36, (5, 5),
padding="same",
strides=(2, 2),
activation="elu"))
_model.add(SpatialDropout2D(0.2))
_model.add(
Convolution2D(48, (5, 5),
padding="valid",
strides=(2, 2),
activation="elu"))
_model.add(SpatialDropout2D(0.2))
_model.add(
Convolution2D(64, (3, 3),
padding="valid",
strides=(2, 2),
activation="elu"))
_model.add(SpatialDropout2D(0.2))
_model.add(
Convolution2D(64, (3, 3),
padding="valid",
strides=(2, 2),
activation="elu"))
_model.add(SpatialDropout2D(0.2))
_model.add(Flatten())
_model.add(Dropout(0.2))
_model.add(Dense(100, activation="elu",
kernel_regularizer=l2(REGULARIZER)))
_model.add(Dropout(0.2))
_model.add(Dense(50, activation="elu", kernel_regularizer=l2(REGULARIZER)))
_model.add(Dropout(0.2))
_model.add(Dense(10, activation="elu", kernel_regularizer=l2(REGULARIZER)))
_model.add(Dropout(0.2))
_model.add(Dense(1))
_model.compile(optimizer=Adam(lr=.001), loss='mse')
return _model
def __init__(self):
self.model = Sequential()
#CONV1
self.model.add(
Convolution2D(N_FILTERS1,
3,
3,
init=INIT,
input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)))
self.model.add(LeakyReLU(alpha=ReLU))
#MAX_POOL1
self.model.add(MaxPooling2D((2, 2), strides=(2, 2)))
self.model.add(BatchNormalization())
#CONV2
self.model.add(Convolution2D(N_FILTERS2, 2, 2, init=INIT))
self.model.add(LeakyReLU(alpha=ReLU))
self.model.add(SpatialDropout2D(0.1))
#MAX_POOL2
self.model.add(MaxPooling2D((2, 2), strides=(2, 2)))
self.model.add(BatchNormalization())
#CONV3
self.model.add(Convolution2D(N_FILTERS3, 2, 2, init=INIT))
self.model.add(LeakyReLU(alpha=ReLU))
self.model.add(SpatialDropout2D(0.2))
#MAX_POOL3
self.model.add(MaxPooling2D((2, 2), strides=(2, 2)))
self.model.add(BatchNormalization())
#FC1
self.model.add(Flatten())
self.model.add(Dense(N_FILTERS4, init=INIT))
self.model.add(LeakyReLU(alpha=ReLU))
self.model.add(Dropout(DROP_OUT))
#FC2
self.model.add(Dense(N_FILTERS4, init=INIT))
self.model.add(LeakyReLU(alpha=ReLU))
self.model.add(Dropout(DROP_OUT))
#FC3
self.model.add(Dense(N_FILTERS4, init=INIT))
self.model.add(LeakyReLU(alpha=ReLU))
#KEY_POINTS
self.model.add(Dense(2 * FACEPOINTS_COUNT, init='he_uniform'))
self.model.add(
Reshape((FACEPOINTS_COUNT, 2),
input_shape=(2 * FACEPOINTS_COUNT, )))
def model_nvidia(input_shape):
"""Model based on the following paper by Nvidia
http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf
"""
def resize_images(img):
"""Returns resized image
Cannot be directly used in lambda function
as tf is not understood by keras
"""
import tensorflow as tf
return tf.image.resize_images(img, (66, 200))
model = Sequential()
model.add(Lambda(resize_images, input_shape=input_shape))
model.add(Lambda(lambda x: x / 255. - 0.5))
model.add(
Convolution2D(24,
5,
5,
border_mode="same",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(36,
5,
5,
border_mode="same",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(
Convolution2D(48,
5,
5,
border_mode="valid",
subsample=(2, 2),
activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Convolution2D(64, 3, 3, border_mode="valid", activation="elu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(100, activation="elu"))
model.add(Dense(50, activation="elu"))
model.add(Dense(10, activation="elu"))
model.add(Dropout(0.5))
model.add(Dense(1))
model.compile(optimizer=Adam(lr=0.001), loss='mse')
return model
def setup_model(self):
drop_out = 0.1
model = Sequential()
model.add(Lambda(lambda x: x/127.5 - 1.,
input_shape=(80, 160, 3),
output_shape=(80, 160, 3)))
model.add(Convolution2D(24, 5, 5, border_mode='valid', subsample=(2,2)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(36, 5, 5, border_mode='valid', subsample=(2,2)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(48, 5, 5, border_mode='valid', subsample=(2,2)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(SpatialDropout2D(drop_out))
model.add(Convolution2D(64, 3, 3, border_mode='valid', subsample=(1,1)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, border_mode='valid', subsample=(1,1)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(SpatialDropout2D(drop_out))
model.add(Flatten())
model.add(Dense(1164))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(drop_out))
model.add(Dense(100))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(drop_out))
model.add(Dense(50))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(drop_out))
model.add(Dense(10,))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(drop_out))
model.add(Dense(1))
optimizer = Adam(lr=1e-2, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(optimizer=optimizer, loss='mse',metrics=['mean_absolute_error'])
self.model = model
return
def build_nvidia(self, input_shape=(HEIGHT, WIDTH, CHANNELS), crop=8):
model = Sequential()
#model.add(img_input)
# Normalize input planes
model.add(Lambda(lambda x: x / 255 - 0.5, input_shape=input_shape))
# Resize image
model.add(
Lambda(lambda image: ktf.image.resize_images(image, (48, 64))))
# Cropping image for focus only on the road
model.add(Cropping2D(cropping=((crop, 0), (0, 0))))
# Conv 1 layer
model.add(
Convolution2D(24, (5, 5),
border_mode="same",
subsample=(1, 1),
activation="relu"))
# Conv 2 layer
model.add(
Convolution2D(36, (5, 5),
border_mode="same",
subsample=(1, 1),
activation="relu"))
model.add(SpatialDropout2D(0.2))
# Conv 3 layer
model.add(
Convolution2D(48, (5, 5),
border_mode="valid",
subsample=(1, 1),
activation="relu"))
model.add(SpatialDropout2D(0.2))
# Conv 4 layer
model.add(
Convolution2D(64, (3, 3), border_mode="valid", activation="relu"))
model.add(SpatialDropout2D(0.2))
# Conv 5 layer
model.add(
Convolution2D(64, (3, 3), border_mode="valid", activation="relu"))
model.add(SpatialDropout2D(0.2))
model.add(Flatten())
# Fully Connect layer 1
model.add(Dense(100, activation='relu'))
# Fully Connect layer 2
model.add(Dense(50, activation='relu'))
# Fully Connect layer 3
model.add(Dense(10, activation='relu'))
model.add(Dropout(.5))
# Output
model.add(Dense(1))
# lr=0.001
#model.compile(optimizer=Adam(lr=0.0001), loss='mse')
return model
