def Dave_v3(input_tensor=None, load_weights=False):
model = models.Sequential()
model.add(
convolutional.Convolution2D(16,
3,
3,
input_shape=(32, 128, 3),
activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(convolutional.Convolution2D(32, 3, 3, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(convolutional.Convolution2D(64, 3, 3, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(core.Flatten())
model.add(core.Dense(500, activation='relu'))
#model.add(core.Dropout(.5))
model.add(core.Dense(100, activation='relu'))
#model.add(core.Dropout(.25))
model.add(core.Dense(20, activation='relu'))
model.add(core.Dense(1))
model.add(
Lambda(One_to_radius, output_shape=atan_layer_shape,
name="prediction"))
if load_weights:
model.load_weights('./models/dave3/dave3.h5')
model.compile(optimizer=optimizers.Adam(lr=1e-04),
loss='mean_squared_error')
return model
def _cnn():
train_data, train_target, test_data = load_data() # load data from utility
train_data, validation_data, train_target, validation_target = train_test_split(
train_data, train_target, test_size=0.2, random_state=42
) #r andomly split data into traingin and validation sets
test_data, input_shape = _reshape(test_data) # see docstring
train_data, input_shape = _reshape(train_data) # see docstring
validation_data, input_shape = _reshape(validation_data) # see docstring
model = Sequential() # sequential model
model.add(
convolutional.Conv2D( # first convolitional layer
filters=32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(convolutional.Conv2D(
64, (3, 3),
activation='relu')) # 2nd convo layer, using relu for activation
model.add(pooling.MaxPooling2D(pool_size=(2, 2))) #1st pooling
model.add(Dropout(0.25)) # prevent overfit w/dropout 1
model.add(Flatten()) # flatten for dnn
model.add(Dense(128, activation='relu')) # 1st dnn layer
model.add(Dropout(0.5)) # prevent overfit w/dropout 2
model.add(Dense(3, activation='softmax')) # using softmax for activation
model.compile( # compile using Adadelta for optimizer
loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
model.fit(train_data, train_target, batch_size=128, epochs=12,
verbose=1) # fit using training data
loss, accuracy = model.evaluate(
validation_data, validation_target,
verbose=0) # evaluate using validation data
print "accuracy: {}".format(accuracy)
class_output = model.predict_classes(test_data) # predict on test_data
return class_output
def mnist_model(input_shape):
"""Creates a MNIST model."""
model = sequential_model_lib.Sequential()
# Adding custom pass-through layer to visualize input images.
model.add(LayerForImageSummary())
model.add(
conv_layer_lib.Conv2D(
32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
model.add(conv_layer_lib.Conv2D(64, (3, 3), activation='relu'))
model.add(pool_layer_lib.MaxPooling2D(pool_size=(2, 2)))
model.add(layer_lib.Dropout(0.25))
model.add(layer_lib.Flatten())
model.add(layer_lib.Dense(128, activation='relu'))
model.add(layer_lib.Dropout(0.5))
model.add(layer_lib.Dense(NUM_CLASSES, activation='softmax'))
# Adding custom pass-through layer for summary recording.
model.add(LayerForHistogramSummary())
return model
X_train /= 255
X_test /= 255
# Convert 1-dimensional class arrays to 10-dimensional class matrices
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)
################################################################## BUILD NETWORK
# 7. Define model architecture
model = Sequential()
model.add(convolutional.Conv2D(NB_CONV_1, KERNEL_SIZE_CONV_1, activation='relu', input_shape=(28,28,1)))
model.add(convolutional.Conv2D(NB_CONV_2, KERNEL_SIZE_CONV_2, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=POOL_SIZE))
model.add(Dropout(DROPOUT_1))
model.add(Flatten())
model.add(Dense(DENSE_SIZE_1, activation='relu'))
model.add(Dropout(DROPOUT_2))
model.add(Dense(DENSE_SIZE_2, activation='softmax'))
config = {
'sequential':model.get_config(),
'compilation': {
'loss' : 'categorical_crossentropy',
'optimizer' : 'adam',
'metrics' : ['acc']
},
'training': {
def architecture():
# put the normalization fucntion inside the model ensure preprocess using Lambda layer
# There were many issue depending on using the lambda layer and in this waa it works
def resize_normalize(image):
import cv2
from keras.backend import tf as ktf
"""
Applies preprocessing pipeline to an image: crops `top` and `bottom`
portions of image, resizes to 66*200 px and scales pixel values to [0, 1].
"""
# resize to width 200 and high 66 liek recommended
# in the nvidia paper for the used CNN
# image = cv2.resize(image, (66, 200)) #first try
resized = ktf.image.resize_images(image, (32, 128))
#normalize 0-1
resized = resized / 255.0 - 0.5
return resized
print('I am inside call of architecture')
#initialize model
model = Sequential()
#dropout = 0.5
nonlinear = 'tanh'
print('I am before call of cropping layer')
### Convolution layers and parameters were taken from the "nvidia paper" on end-to-end autonomous steering.
model.add(
Cropping2D(cropping=((60, 20), (1, 1)), input_shape=(160, 320, 3)))
print('I am before call of Lambda')
model.add(
Lambda(resize_normalize,
input_shape=(160, 320, 3),
output_shape=(32, 128, 3)))
# Model architecture
model.add(
Convolution2D(16, 3, 3, input_shape=(32, 128, 3), activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(32, 3, 3, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(64, 3, 3, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(core.Flatten())
model.add(core.Dense(500, activation='relu'))
model.add(core.Dropout(.5))
model.add(core.Dense(100, activation='relu'))
model.add(core.Dropout(.25))
model.add(core.Dense(20, activation='relu'))
model.add(core.Dense(1))
model.compile(optimizer=optimizers.Adam(lr=1e-04),
loss='mean_squared_error')
#model.add(Lambda(lambda x: resize_normalize(x), input_shape=(80,318,3), output_shape=(66, 200, 3)))
# model.add(Convolution2D(24, 5, 5, name='conv1', subsample=(2, 2), activation=nonlinear))
# model.add(Convolution2D(36, 5, 5, name='conv2', subsample=(2, 2), activation=nonlinear))
# model.add(Convolution2D(48, 5, 5, name='conv3', subsample=(2, 2), activation=nonlinear))
# model.add(Convolution2D(64, 3, 3, name='conv4', activation=nonlinear))
# model.add(Convolution2D(64, 3, 3, name='conv5', activation=nonlinear))
# ### Regression
# model.add(Flatten())
# model.add(Dropout(dropout))
# model.add(Dense(1164, name='hidden1', activation=nonlinear))
# model.add(Dropout(dropout))
# model.add(Dense(100, name='hidden2', activation=nonlinear))
# model.add(Dropout(dropout))
# model.add(Dense(50, name='hidden3', activation=nonlinear))
# model.add(Dropout(dropout))
# model.add(Dense(10, name='hidden4', activation=nonlinear))
# model.add(Dropout(dropout))
# model.add(Dense(1, name='output', activation=nonlinear))
# #model.compile(optimizer=optimizers.Adam(lr=1e-04), loss='mean_squared_error')
# model.compile(optimizer='adam', loss='mse')
print('I am finished build the model')
print(model.summary())
return model
nb_validation_samples = 2079
batch_size = 10
epochs = 4
num_classes = 51
inp = Input(shape=(img_width, img_height, 3))
conv_layer1 = convolutional.Conv2D(8, (3, 3),
strides=(1, 1),
padding='same',
activation='relu')(inp)
conv_layer2 = convolutional.Conv2D(8, (3, 3),
strides=(1, 1),
padding='same',
activation='relu')(conv_layer1)
pool_layer1 = pooling.MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None)(conv_layer2)
conv_layer3 = convolutional.Conv2D(16, (3, 3),
strides=(1, 1),
padding='same',
activation='relu')(pool_layer1)
pool_layer2 = pooling.MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None)(conv_layer3)
conv_layer4 = convolutional.Conv2D(32, (3, 3),
strides=(1, 1),
padding='same',
activation='relu')(pool_layer2)
pool_layer3 = pooling.MaxPooling2D(pool_size=(2, 2),
strides=None,
from keras import models, optimizers, backend
from keras.layers import core, convolutional, pooling
from sklearn import model_selection,utils
from dataPreprocessing import generate_samples, preprocess
if __name__ == '__main__':
# Read splitted data
df_train = pd.read_csv('train.csv')
df_valid = pd.read_csv('test.csv')
# CNN Model Architecture
model = models.Sequential()
model.add(convolutional.Convolution2D(16, 3, 3, input_shape=(32, 128, 3), activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(convolutional.Convolution2D(32, 3, 3, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(convolutional.Convolution2D(64, 3, 3, activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2)))
model.add(core.Flatten())
model.add(core.Dense(500, activation='relu'))
model.add(core.Dropout(.5))
model.add(core.Dense(100, activation='relu'))
model.add(core.Dropout(.25))
model.add(core.Dense(20, activation='relu'))
model.add(core.Dense(1))
model.compile(optimizer=optimizers.Adam(lr=1e-04), loss='mean_squared_error')
# load the exist model
model.load_weights("model.h5")
def _cnn():
train_data, train_target, test_data = load_data()
train_data, validation_data, train_target, validation_target = train_test_split(
train_data, train_target, test_size=0.2, random_state=42)
test_data, input_shape = _reshape(test_data)
train_data, input_shape = _reshape(train_data)
validation_data, input_shape = _reshape(validation_data)
model = Sequential()
model.add(
convolutional.Conv2D(filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
input_shape=input_shape,
activation='relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), padding='same'))
model.add(convolutional.Conv2D(64, (5, 5), padding='same'))
model.add(Activation('relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), padding='same'))
model.add(convolutional.Conv2D(64, (5, 5), padding='same'))
model.add(Activation('relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), padding='same'))
model.add(convolutional.Conv2D(64, (5, 5), padding='same'))
model.add(Activation('relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), padding='same'))
model.add(convolutional.Conv2D(64, (5, 5), padding='same'))
model.add(Activation('relu'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), padding='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(3))
model.add(Activation('softmax'))
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(optimizer=adam,
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_data, train_target, epochs=20, batch_size=64, verbose=2)
loss, accuracy = model.evaluate(validation_data,
validation_target,
verbose=2)
print "accuracy: {}".format(accuracy)
output = model.predict_classes(test_data)
return output
train_data_raw = pd.read_csv("./input/train.csv").values
test_data_raw = pd.read_csv("./input/test.csv").values
img_cols = 28
img_rows = 28
train_X = train_data_raw[:, 1:].reshape(train_data_raw.shape[0], 1, img_rows, img_cols)
train_Y = kutils.to_categorical(train_data_raw[:, 0])
num_class = train_Y.shape[1]
num_filters_1 = 64
conv_dim = 3
cnn = kmodels.Sequential()
cnn.add(kconv.ZeroPadding2D((1,1), input_shape=(1, 28, 28),))
cnn.add(kconv.Convolution2D(num_filters_1, conv_dim, conv_dim, activation="relu"))
cnn.add(kpool.MaxPooling2D(strides=(2, 2)))
num_filters_2 = 128
cnn.add(kconv.ZeroPadding2D((1, 1)))
cnn.add(kconv.Convolution2D(num_filters_2, conv_dim, conv_dim, activation="relu"))
cnn.add(kpool.MaxPooling2D(strides=(2, 2)))
conv_dim_2 = 3
cnn.add(kconv.ZeroPadding2D((1, 1)))
cnn.add(kconv.Convolution2D(num_filters_2, conv_dim_2, conv_dim_2, activation="relu"))
cnn.add(kpool.MaxPooling2D(strides=(2, 2)))
cnn.add(kconv.ZeroPadding2D((1, 1)))
cnn.add(kconv.Convolution2D(num_filters_2, conv_dim_2, conv_dim_2, activation="relu"))
cnn.add(kpool.MaxPooling2D(strides=(2, 2)))
def __init__(self,
input_shape=None,
n_epoch=None,
batch_size=None,
encoder_layers=None,
decoder_layers=None,
filters=None,
kernel_size=None,
strides=None,
pool_size=None,
denoising=None):
args, _, _, values = inspect.getargvalues(inspect.currentframe())
values.pop("self")
for arg, val in values.items():
setattr(self, arg, val)
loss_history = LossHistory()
early_stop = keras.callbacks.EarlyStopping(monitor="val_loss",
patience=10)
reduce_learn_rate = keras.callbacks.ReduceLROnPlateau(
monitor="val_loss", factor=0.1, patience=20)
self.callbacks_list = [loss_history, early_stop, reduce_learn_rate]
# INPUTS
self.input_data = Input(shape=self.input_shape)
# ENCODER
self.encoded = BatchNormalization()(self.input_data)
for i in range(self.encoder_layers):
self.encoded = BatchNormalization()(self.encoded)
self.encoded = convolutional.Conv2D(filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.encoded)
self.encoded = Dropout(rate=0.5)(self.encoded)
self.encoded = pooling.MaxPooling2D(strides=self.pool_size,
padding="same")(self.encoded)
# DECODER
self.decoded = BatchNormalization()(self.encoded)
for i in range(self.decoder_layers):
self.decoded = BatchNormalization()(self.decoded)
self.decoded = convolutional.Conv2D(filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.decoded)
self.decoded = Dropout(rate=0.5)(self.decoded)
self.decoded = convolutional.UpSampling2D(size=self.pool_size)(
self.decoded)
# ACTIVATION
self.decoded = convolutional.Conv2D(filters=self.input_shape[2],
kernel_size=self.kernel_size,
strides=self.strides,
activation="sigmoid",
padding="same")(self.decoded)
self.autoencoder = Model(self.input_data, self.decoded)
self.autoencoder.compile(optimizer=keras.optimizers.Adam(),
loss="mean_squared_error")
def _cnn():
train_data, train_target, test_data = load_data() # load data from utility
train_data, validation_data, train_target, validation_target = train_test_split(
train_data, train_target, test_size=0.2,
random_state=42) #randomly split for validation
test_data, input_shape = _reshape(test_data) # see docstring
train_data, input_shape = _reshape(train_data) # see docstring
validation_data, input_shape = _reshape(validation_data) # see docstring
model = Sequential() # sequential model
model.add(
convolutional.Conv2D( # first convolitional layer
filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
input_shape=input_shape,
activation='relu'))
model.add(convolutional.Conv2D(64, (3, 3),
padding='same')) # 2nd convo layer
model.add(Activation('relu')) #using relu
model.add(pooling.MaxPooling2D(pool_size=(2, 2),
padding='same')) # 1st pooling
model.add(convolutional.Conv2D(64, (3, 3),
padding='same')) # 3rd convo layer
model.add(Activation('relu')) # using relu
model.add(pooling.MaxPooling2D(pool_size=(2, 2),
padding='same')) # 2nd pooling
model.add(convolutional.Conv2D(64, (3, 3),
padding='same')) # 4th convo layer
model.add(Activation('relu')) # using relu
model.add(pooling.MaxPooling2D(pool_size=(2, 2),
padding='same')) # 3nd pooling
model.add(Dropout(0.25)) # prevent overfit w/dropout 1
model.add(Flatten()) # flatten for dnn
model.add(Dense(1024)) # 1st dnn layer
model.add(Activation('relu')) # using relu
model.add(Dropout(0.5)) # prevent overfit w/dropout 2
model.add(Dense(3)) # output dnn layer
model.add(Activation('softmax')) # using softmax
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08,
decay=0.0) # adam optimizer
model.compile(optimizer=adam,
loss='categorical_crossentropy',
metrics=['accuracy']) # compile
model.fit(train_data, train_target, epochs=12, batch_size=128,
verbose=1) # fit using training data
loss, accuracy = model.evaluate(
validation_data, validation_target,
verbose=0) # evaluate using validation data
print "accuracy: {}".format(accuracy)
output = model.predict_classes(test_data) # predict on test_data
return output
def learn(self,train_data, train_target, cn_drp_rate=0.2, d_drp_rate=0.5, epochs=150, batch_size=40,
num_class=2):
train_target = np_utils.to_categorical(train_target, num_class)
train_data = train_data.reshape(train_data.shape[0], 1, train_data.shape[1], 1)
self.model = Sequential()
#Adding first convolution layer with dropout and maxpooling with activation relu
self.model.add(
convolutional.Conv2D(filters=32, kernel_size=(3,3),strides=(1, 1),padding='same',activation='relu'
,input_shape=(1,193,1)))
#model.add(Dropout(cn_drp_rate))
self.model.add(pooling.MaxPooling2D(pool_size=(2, 2),padding='same'))
#Adding second convolution layer with activation relu
self.model.add(convolutional.Conv2D(48,(5,5),padding='same'))
self.model.add(Activation('relu'))
#Adding third convolution layer with activation relu and dropout
self.model.add(convolutional.Conv2D(48,(5,5),padding='same'))
self.model.add(Activation('relu'))
#model.add(Dropout(cn_drp_rate))
#Adding fourth convolution layer with activation relu and dropout
self.model.add(convolutional.Conv2D(64,(5,5),padding='same'))
self.model.add(Activation('relu'))
#model.add(Dropout(cn_drp_rate))
#Adding fifth convolution layer with activation relu and dropout
self.model.add(convolutional.Conv2D(64,(5,5),padding='same'))
self.model.add(Activation('relu'))
#model.add(Dropout(cn_drp_rate))
#model.add(pooling.MaxPooling2D(pool_size=(2,2),padding='same'))
#model.add(convolutional.Conv2D(48,(5,5),padding='same'))
#model.add(Activation('relu'))
#model.add(Dropout(cn_drp_rate))
#model.add(pooling.MaxPooling2D(pool_size=(2,2),padding='same'))
# Adding flatten layer and fully connected layer or deep neural network
self.model.add(Flatten())
#Adding first dense layer with acitivation relu and dropout
self.model.add(Dense(150))
self.model.add(Activation('relu'))
self.model.add(Dropout(d_drp_rate))
#Adding second dense layer with acitivation relu and dropout
self.model.add(Dense(150))
self.model.add(Activation('relu'))
self.model.add(Dropout(d_drp_rate))
self.model.add(Dense(150))
self.model.add(Activation('relu'))
self.model.add(Dropout(d_drp_rate))
#Adding final output layer with softmax
self.model.add(Dense(units=num_class))
self.model.add(Activation('softmax'))
self.model.compile(loss='categorical_crossentropy', optimizer=Adamax(), metrics=['accuracy'])
self.model.fit(train_data, train_target, batch_size = batch_size, epochs=epochs)
camcol = int(pathfile.split('/')[-1][-11:-10])
field = int(pathfile.split('/')[-1][-9:-5])
objid = int(pathfile.split('/')[-1].replace("new", "")[0:-26])
d = list(
set(sp.where(GZ2["run"] == run)[0]).intersection(
sp.where(GZ2["camcol"] == camcol)[0],
sp.where(GZ2["field"] == field)[0],
sp.where(GZ2["obj"] == objid)[0]))[0]
y_train.append(prob[d])
x_train = sp.array(x_train) #.transpose()
y_train = sp.asarray(y_train)
model = Sequential()
model.add(
Convolution2D(16, 10, 10, border_mode='same', input_shape=(207, 207, 1)))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), border_mode='same')) #98x98
model.add(Convolution2D(32, 9, 9, border_mode='same'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), border_mode='same')) # 45x45
model.add(Convolution2D(64, 6, 6, border_mode='same'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), border_mode='same')) #20x20
model.add(Convolution2D(128, 5, 5, border_mode='same'))
model.add(pooling.MaxPooling2D(pool_size=(2, 2), border_mode='same')) #8x8
model.add(Convolution2D(256, 3, 3, border_mode='same'))
#6x6
model.add(Convolution2D(256, 3, 3, border_mode='same')) #4x4
model.add(MaxPooling2D(pool_size=(2, 2), border_mode='same')) #2x2
def __init__(self,
input_shape=None,
n_epoch=None,
batch_size=None,
encoder_layers=None,
decoder_layers=None,
filters=None,
kernel_size=None,
strides=None,
pool_size=None,
denoising=None):
args, _, _, values = inspect.getargvalues(inspect.currentframe())
values.pop("self")
for arg, val in values.items():
setattr(self, arg, val)
loss_history = LossHistory()
early_stop = keras.callbacks.EarlyStopping(monitor="val_loss",
patience=10)
reduce_learn_rate = keras.callbacks.ReduceLROnPlateau(
monitor="val_loss", factor=0.1, patience=20)
self.callbacks_list = [loss_history, early_stop, reduce_learn_rate]
for i in range(self.encoder_layers):
if i == 0:
self.input_data = Input(shape=self.input_shape)
self.encoded = BatchNormalization()(self.input_data)
self.encoded = convolutional.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.encoded)
self.encoded = Dropout(rate=0.5)(self.encoded)
elif 0 < i < self.encoder_layers - 1:
self.encoded = BatchNormalization()(self.encoded)
self.encoded = convolutional.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.encoded)
self.encoded = Dropout(rate=0.5)(self.encoded)
elif i == self.encoder_layers - 1:
self.encoded = BatchNormalization()(self.encoded)
self.encoded = convolutional.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.encoded)
self.encoded = pooling.MaxPooling2D(strides=self.pool_size,
padding="same")(self.encoded)
self.decoded = BatchNormalization()(self.encoded)
self.decoded = convolutional.Conv2D(filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.decoded)
self.decoded = convolutional.UpSampling2D(size=self.pool_size)(
self.decoded)
for i in range(self.decoder_layers):
if i < self.decoder_layers - 1:
self.decoded = BatchNormalization()(self.decoded)
self.decoded = convolutional.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.decoded)
self.decoded = Dropout(rate=0.5)(self.decoded)
else:
self.decoded = BatchNormalization()(self.decoded)
self.decoded = convolutional.Conv2D(
filters=self.filters,
kernel_size=self.kernel_size,
strides=self.strides,
activation="elu",
padding="same")(self.decoded)
# 4D tensor with shape: (samples, new_rows, new_cols, filters).
# Remember think of this as a 2D-Lattice across potentially multiple channels per observation.
# Rows represent time and columns represent some quantities of interest that evolve over time.
# Channels might represent different sources of information.
self.decoded = BatchNormalization()(self.decoded)
self.decoded = convolutional.Conv2D(filters=self.input_shape[2],
kernel_size=self.kernel_size,
strides=self.strides,
activation="sigmoid",
padding="same")(self.decoded)
self.autoencoder = Model(self.input_data, self.decoded)
self.autoencoder.compile(optimizer=keras.optimizers.Adam(),
loss="mean_squared_error")
def main():
parser = argparse.ArgumentParser(description="Convolutional Neural Net")
parser.add_argument("mode",
help="Specify whether to train or test the model")
args = parser.parse_args()
#Define CNN architecture
#Load model if it has a savefile, otherwise reinitialize
try:
print("Loading model")
model = keras.models.load_model("./CNN.save")
except:
print("save file not found, reinstantiating...")
#Initialize a model with five convolutional layers and one hidden layer
model = Sequential([
convolutional.Conv2D(16, 15, input_shape=(512, 512, 1)),
pooling.MaxPooling2D(pool_size=(4)),
convolutional.Conv2D(16, 7),
Activation('tanh'),
BatchNormalization(),
convolutional.Conv2D(16, 7),
Activation('tanh'),
BatchNormalization(),
convolutional.Conv2D(16, 7),
Activation('tanh'),
BatchNormalization(),
pooling.MaxPooling2D(pool_size=(4)),
convolutional.Conv2D(16, 3),
Activation('tanh'),
BatchNormalization(),
pooling.MaxPooling2D(pool_size=(4)),
Flatten(),
Dense(16, activation="tanh"),
BatchNormalization(),
Dense(1, activation="tanh")
])
#Compile the model and use stochastic gradient descent to minimize error
model.compile(loss='mean_squared_error',
optimizer=optimizers.SGD(lr=.01),
metrics=['acc'])
#Create a callback function that logs the results of training
log = keras.callbacks.CSVLogger("KerasLog.csv", append=True)
#END OF ARCHITECTURE
if args.mode.lower() == "test":
print("Beginning test")
testImages, testLabels = readTest()
print(model.evaluate(testImages.reshape(40, 512, 512, 1), testLabels))
elif args.mode.lower() == "train":
print("Reading validation images")
batchSize = 16
valImages, valLabels = readValidationImages()
bestLoss = float('inf')
for i in range(1000):
batch, labels = readBatch(batchSize)
history = model.fit(x=batch.reshape(batchSize, 512, 512, 1),
y=labels,
epochs=5,
validation_data=(valImages.reshape(
16, 512, 512, 1), valLabels),
callbacks=[log])
#Check to see whether the most recent round of training led to an
#improved accuracy rate
currLoss = history.history['val_loss'][-1]
if currLoss < bestLoss:
print("Saving model with loss of " + str(currLoss))
model.save("./CNN.save")
activation='relu'))
# create a convolutional layer for 2 dimensions
model.add(
convolutional.Conv2D(filters=32,
kernel_size=(2, 2),
padding='same',
strides=(1, 1),
activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(.1))
# create a max pooling layer for 2 dimensions
model.add(pooling.MaxPooling2D(
pool_size=(2, 2),
padding='same',
))
# create a convolutional layer for 2 dimensions
model.add(
convolutional.Conv2D(filters=64,
kernel_size=(2, 2),
padding='same',
strides=(1, 1),
activation='relu'))
# create a convolutional layer for 2 dimensions
model.add(
convolutional.Conv2D(filters=64,
kernel_size=(2, 2),
padding='same',
strides=(1, 1),
activation='relu'))
