def creat_model(self):
from keras.layers import Input, Conv1D, Flatten, Dense
from keras.layers import normalization, Activation, pooling
from keras.models import Model
from keras.callbacks import ReduceLROnPlateau, ModelCheckpoint, TensorBoard
from keras.layers.core import Dropout
import os
# Input layer
input_layer = Input(self.input_shape, name="main_input")
# CNN layers
conv_layer = Conv1D(filters=16*1, kernel_size=5, strides=1, padding="valid")(input_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(activation="relu")(conv_layer)
conv_layer = Conv1D(filters=16*1, kernel_size=3, strides=1, padding="valid")(conv_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(activation="relu")(conv_layer)
# Max pooling layer
conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
# conv_layer = input_layer
#############################
# ResNet Units
n_filters = 16 * 1
n_layers = 3 # Keep it as it is
#kernel_sizes = [7, 5, 3] # #elements has to be eqaul to n_layers
kernel_sizes = [3, 3, 3] # #elements has to be eqaul to n_layers
#kernel_sizes = [7, 7, 7] # #elements has to be eqaul to n_layers
resnet_unit_input = conv_layer
for i in range(self.n_resnet_units):
if i == 0:
first_resnet_unit=True
else:
first_resnet_unit=False
resnet_unit_output = self.__create_resnet_unit(resnet_unit_input, n_filters=n_filters,
n_layers=n_layers, kernel_sizes=kernel_sizes,
first_resnet_unit=first_resnet_unit)
resnet_unit_input = resnet_unit_output
# #############################
# # Max pooling layer
# conv_layer = pooling.MaxPooling1D(pool_size=2)(resnet_unit_output)
# #############################
# # ResNet Units
# n_filters = 16
# n_layers = 3
# #kernel_sizes = [7, 5, 3] # #elements has to be eqaul to n_layers
# kernel_sizes = [3, 3, 3] # #elements has to be eqaul to n_layers
# resnet_unit_input = conv_layer
# for i in range(self.n_resnet_units):
# if i == 0:
# first_resnet_unit=True
# else:
# first_resnet_unit=False
# resnet_unit_output = self.__create_resnet_unit(resnet_unit_input, n_filters=n_filters,
# n_layers=n_layers, kernel_sizes=kernel_sizes,
# first_resnet_unit=first_resnet_unit)
# resnet_unit_input = resnet_unit_output
# #############################
# # Max pooling layer
# conv_layer = pooling.MaxPooling1D(pool_size=2)(resnet_unit_output)
# #############################
# # ResNet Units
# n_filters = 32
# n_layers = 3
# #kernel_sizes = [7, 5, 3] # #elements has to be eqaul to n_layers
# kernel_sizes = [3, 3, 3] # #elements has to be eqaul to n_layers
# resnet_unit_input = conv_layer
# for i in range(self.n_resnet_units):
# if i == 0:
# first_resnet_unit=True
# else:
# first_resnet_unit=False
# resnet_unit_output = self.__create_resnet_unit(resnet_unit_input, n_filters=n_filters,
# n_layers=n_layers, kernel_sizes=kernel_sizes,
# first_resnet_unit=first_resnet_unit)
# resnet_unit_input = resnet_unit_output
# #############################
# Max pooling layer
conv_layer = pooling.MaxPooling1D(pool_size=2)(resnet_unit_output)
# Global pooling layer
#fc_layer = pooling.GlobalAveragePooling1D()(resnet_unit_output)
# Flatten 2D data into 1D
fc_layer = Flatten()(conv_layer)
fc_layer = Dropout(0.2, seed=100)(fc_layer)
# # Add Dense layer
# fc_layer = Dense(100, activation="relu")(fc_layer)
# fc_layer = Dropout(0.1, seed=100)(fc_layer)
# Output layer
# Use softmax
output_layer = Dense(self.n_classes, activation="softmax")(fc_layer)
# Put all the model components together
model = Model(inputs=input_layer, outputs=output_layer)
# configure the model
model.compile(loss=self.loss, optimizer=self.optimizer,
metrics=self.metrics)
# Reduce the learning rate if plateau occurs on the loss curve
reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.5, patience=10,
min_lr=0.00001)
# Save the model at certain checkpoints
fname = "weights.epoch_{epoch:02d}.val_loss_{val_loss:.2f}.val_acc_{val_acc:.2f}.hdf5"
file_path = os.path.join(self.out_dir, fname)
model_checkpoint = ModelCheckpoint(file_path, monitor='val_acc', save_best_only=False, period=5)
self.callbacks = [reduce_lr,model_checkpoint]
return model
def creat_model(self):
from keras.layers import Input, Conv1D, Dense, Flatten
from keras.layers import normalization, Activation, pooling
from keras.models import Model
from keras.callbacks import ReduceLROnPlateau, ModelCheckpoint, TensorBoard
from keras.layers.core import Dropout
import os
# Input layer
input_layer = Input(self.input_shape)
conv_layer = Conv1D(filters=16, kernel_size=3, strides=2, padding="valid")(input_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(activation="relu")(conv_layer)
# Max pooling layer
#conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
#Dropout
#conv_layer = Dropout(0.2, seed=100)(conv_layer)
conv_layer = Conv1D(filters=32, kernel_size=3, strides=2, padding="valid")(conv_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(activation="relu")(conv_layer)
# Max pooling layer
conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
# #Dropout
# #conv_layer = Dropout(0.2, seed=100)(conv_layer)
conv_layer = Conv1D(filters=32, kernel_size=3, strides=1, padding="valid")(conv_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(activation="relu")(conv_layer)
# Max pooling layer
#conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
conv_layer = Conv1D(filters=32, kernel_size=3, strides=1, padding="valid")(conv_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(activation="relu")(conv_layer)
#
# conv_layer = Conv1D(filters=32, kernel_size=3, strides=1, padding="same")(conv_layer)
# conv_layer = normalization.BatchNormalization()(conv_layer)
# conv_layer = Activation(activation="relu")(conv_layer)
# #Dropout
# #conv_layer = Dropout(0.2, seed=100)(conv_layer)
#
# conv_layer = Conv1D(filters=32, kernel_size=3, strides=1, padding="same")(conv_layer)
# conv_layer = normalization.BatchNormalization()(conv_layer)
# conv_layer = Activation(activation="relu")(conv_layer)
## Global pooling layer
#gap_layer = pooling.GlobalAveragePooling1D()(conv_layer)
# Max pooling layer
# conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
# Flatten 2D data into 1D
fc_layer = Flatten()(conv_layer)
fc_layer = Dropout(0.5, seed=100)(fc_layer)
# Add Dense layer
fc_layer = Dense(50, activation="relu")(fc_layer)
fc_layer = Dropout(0.2, seed=100)(fc_layer)
# Add Dense layer
fc_layer = Dense(10, activation="relu")(fc_layer)
# Output layer
# Use softmax
output_layer = Dense(self.n_classes, activation="softmax")(fc_layer)
# Put all the model components together
model = Model(inputs=input_layer, outputs=output_layer)
# configure the model
model.compile(loss=self.loss, optimizer=self.optimizer, metrics=self.metrics)
# Reduce the learning rate if plateau occurs on the loss curve
reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.5, patience=10,
min_lr=0.00001)
# Save the model at certain checkpoints
fname = "weights.epoch_{epoch:02d}.val_loss_{val_loss:.2f}.val_acc_{val_acc:.2f}.hdf5"
file_path = os.path.join(self.out_dir, fname)
model_checkpoint = ModelCheckpoint(file_path, monitor='val_loss', save_best_only=False, period=5)
# # For TensorBoard visualization
# log_dir = os.path(out_dir, "logs")
# TensorBoard(log_dir=log_dir, batch_size=self.batch_size, update_freq='epoch')
self.callbacks = [reduce_lr,model_checkpoint]
return model
def creat_model(self):
# Input layer
input_layer = Input(self.input_shape)
conv_layer = Conv1D(filters=32,
kernel_size=3,
strides=2,
padding="valid")(input_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(
activation=self.hidden_layer_activation)(conv_layer)
# Max pooling layer
#conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
conv_layer = Conv1D(filters=32,
kernel_size=3,
strides=2,
padding="valid")(conv_layer)
conv_layer = normalization.BatchNormalization()(conv_layer)
conv_layer = Activation(
activation=self.hidden_layer_activation)(conv_layer)
# Max pooling layer
conv_layer = pooling.MaxPooling1D(pool_size=2)(conv_layer)
# Flatten 2D data into 1D
fc_layer = Flatten()(conv_layer)
#fc_layer = Dropout(0.5, seed=100)(fc_layer)
# Add Dense layer
fc_layer = Dense(1000,
activation=self.hidden_layer_activation)(fc_layer)
#fc_layer = Dropout(0.2, seed=100)(fc_layer)
# ####################
# # Add Dense layer
# fc_layer = Dense(200, activation=self.hidden_layer_activation)(fc_layer)
# #fc_layer = Dropout(0.2, seed=100)(fc_layer)
#
# fc_layer = Dense(200, activation=self.hidden_layer_activation)(fc_layer)
# #fc_layer = Dropout(0.2, seed=100)(fc_layer)
####################
## Add Dense layer
fc_layer = Dense(300,
activation=self.hidden_layer_activation)(fc_layer)
# Output layer
num_output_nodes = self.output_shape[0]
output_layer = Dense(num_output_nodes, activation="linear")(fc_layer)
# Put all the model components together
model = Model(inputs=input_layer, outputs=output_layer)
# configure the model
model.compile(loss=self.loss,
optimizer=self.optimizer,
metrics=self.metrics)
# Reduce the learning rate if plateau occurs on the loss curve
reduce_lr = ReduceLROnPlateau(monitor='loss',
factor=0.5,
patience=10,
min_lr=0.00001)
# Save the model at certain checkpoints
fname = "weights.epoch_{epoch:02d}.val_loss_{val_loss:.2f}.hdf5"
file_path = os.path.join(self.out_dir, fname)
model_checkpoint = ModelCheckpoint(file_path,
monitor='val_loss',
save_best_only=False,
period=5)
# # For TensorBoard visualization
# log_dir = os.path(out_dir, "logs")
# TensorBoard(log_dir=log_dir, batch_size=self.batch_size, update_freq='epoch')
self.callbacks = [reduce_lr, model_checkpoint]
return model
def run_model(self, data, targets, batch_size, epochs):
# double the sample - disabled
#data = double_inverse_samples(data)
#targets = double_inverse_samples(targets)
test_size_1 = 0.25
test_size_2 = 0.15
drop_out = 0.5
# split the data up into multiple sets: training, testing validation
train_data, data_set_2, train_target, target_set_2 = train_test_split(
data, targets, test_size=test_size_1, random_state=42)
test_data, val_data, test_target, val_target = train_test_split(
data_set_2, target_set_2, test_size=test_size_2, random_state=24)
# pre-processing
X_train = train_data.reshape(train_data.shape[0], train_data.shape[1],
1)
X_test = test_data.reshape(test_data.shape[0], test_data.shape[1], 1)
y_train = np_utils.to_categorical(train_target, 2)
y_test = np_utils.to_categorical(test_target, 2)
val_data = val_data.reshape(val_data.shape[0], -1, 1)
val_target = np_utils.to_categorical(val_target, 2)
# create a linear model
model = Sequential()
# add a convolutional layer
model.add(
convolutional.Conv1D(filters=16,
kernel_size=1,
padding='same',
strides=1,
activation='relu',
input_shape=X_train.shape[1:]))
# add a max pooling layer
model.add(pooling.MaxPooling1D(
pool_size=1,
padding='same',
))
# add a convolutional layer
model.add(
convolutional.Conv1D(
filters=32,
kernel_size=2,
padding='same',
strides=1,
activation='relu',
))
# add a max pooling layer
model.add(pooling.MaxPooling1D(
pool_size=1,
padding='same',
))
# flatten the activation maps into a 1d vector
model.add(Flatten())
# add a dense layer with 128 neurons
model.add(Dense(128))
# set activation layer
model.add(Activation('relu'))
# set drop out rate
model.add(Dropout(drop_out))
# add a dense layer with 2 neurons
model.add(Dense(2))
# set softmax function to make the categories
model.add(Activation('softmax'))
# define adam optimizer
adam = Adam(lr=0.001,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0)
# compile mode to use cross entropy
model.compile(optimizer=adam,
loss='categorical_crossentropy',
metrics=['accuracy'])
# fit the model and use cross validation
model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=2,
validation_data=(val_data, val_target))
# get the test loss and accuracy of our model
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=2)
# get the validation loss and accuracy of our model
val_loss, val_accuracy = model.evaluate(val_data,
val_target,
verbose=2)
# collect metrics for output
metrics = {
"test_loss": test_loss,
"test_accuracy": test_accuracy,
"val_loss": val_loss,
"val_accuracy": val_accuracy,
"batch_size": batch_size,
"epochs": epochs,
"test_size_1": test_size_1,
"test_size_2": test_size_2,
"drop_out": drop_out
}
return metrics, model
def build(self, nb_genes, nb_classes):
# params
dropout_f = 0.25 # prevent overfitting
dropout_c = 0.25
dropout_d = 0.25
# feature extration
nb_filters = 500
kernel_size = 10
L1CNN = 0
actfun = 'relu'
pool_size = 11 # window size for features
# hidden layers
units1 = 200 # number of nodes in hidden layer
units2 = 150
units3 = 120
units4 = 100
# compilation
INIT_LR = 0.01 # initial learning rate
lamb = 1.0
# build the model
input1 = Input(shape=(nb_genes, 1))
feature1 = conv.Conv1D(nb_filters,
kernel_size,
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=reg.l1(L1CNN))(input1)
feature1 = Dropout(dropout_f)(feature1)
feature1 = Activation(actfun)(feature1)
feature1 = pool.MaxPooling1D(pool_size)(feature1)
feature1 = Flatten()(feature1)
input2 = Input(shape=(nb_genes, 1))
feature2 = conv.Conv1D(nb_filters,
kernel_size,
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=reg.l1(L1CNN))(input2)
feature2 = Dropout(dropout_f)(feature2)
feature2 = Activation(actfun)(feature2)
feature2 = pool.MaxPooling1D(pool_size)(feature2)
feature2 = Flatten()(feature2)
hidden1_1 = Dense(units1, activation='relu')(feature1)
target = Dense(units3, activation='relu')(hidden1_1) # z1 -> z3
hidden1_2 = Dense(units1, activation='relu')(feature2)
context = Dense(units3, activation='relu')(hidden1_2)
hidden2 = Dense(units2, activation='relu')(hidden1_1) # z1 -> z2
hidden4 = Dense(units4, activation='relu')(target) # z3 -> z4
concatenated = Concatenate(axis=1)([hidden2,
hidden4]) # concatenate z2, z4
concatenated = Dropout(dropout_c)(concatenated)
similarity = Dot(axes=1,
normalize=True)([target, context
]) # setup for the validation model
dot_product = Dot(axes=1)([target, context])
dot_product = Reshape((1, ))(dot_product)
dot_product = Dropout(dropout_d)(dot_product)
output1 = Dense(nb_classes, activation='softmax',
name='output1')(concatenated)
output2 = Dense(1, activation='sigmoid', name='output2')(dot_product)
model = Model(inputs=[input1, input2],
outputs=[output1, output2],
name='graphSemiCNN')
val_model = Model(inputs=[input1, input2],
outputs=similarity) # similarity callback
# compile the model
losses = {
'output1': 'categorical_crossentropy',
'output2': 'binary_crossentropy',
}
lossWeights = {'output1': 1.0, 'output2': lamb}
opt = SGD(lr=INIT_LR)
model.compile(loss=losses,
loss_weights=lossWeights,
optimizer=opt,
metrics=['accuracy']) # loss function: cross entropy
return model, val_model
dropout_layer_5 = Dropout(0.5)(cnn_layer_5) dropout_layer_6 = Dropout(0.5)(cnn_layer_6) dense_layer_1 = Dense(1, name='dense_layer_1')(dropout_layer_1) dense_layer_2 = Dense(1, name='dense_layer_2')(dropout_layer_2) dense_layer_3 = Dense(1, name='dense_layer_3')(dropout_layer_3) dense_layer_4 = Dense(1, name='dense_layer_4')(dropout_layer_4) dense_layer_5 = Dense(1, name='dense_layer_5')(dropout_layer_5) dense_layer_6 = Dense(1, name='dense_layer_6')(dropout_layer_6) ''' dense_layer_4 = Dense(1)(dropout_layer_4) dense_layer_5 = Dense(1)(dropout_layer_5) dense_layer_6 = Dense(1)(dropout_layer_6) ''' pool_layer_1 = pooling.MaxPooling1D(pool_length=seqlen - 2)(dense_layer_1) pool_layer_2 = pooling.MaxPooling1D(pool_length=seqlen - 3)(dense_layer_2) pool_layer_3 = pooling.MaxPooling1D(pool_length=seqlen - 4)(dense_layer_3) pool_layer_4 = pooling.MaxPooling1D(pool_length=seqlen - 2)(dense_layer_4) pool_layer_5 = pooling.MaxPooling1D(pool_length=seqlen - 3)(dense_layer_5) pool_layer_6 = pooling.MaxPooling1D(pool_length=seqlen - 4)(dense_layer_6) ''' pool_layer_1 = pooling.MaxPooling1D(pool_length = seqlen - 2)(dropout_layer_1) pool_layer_2 = pooling.MaxPooling1D(pool_length = seqlen - 3)(dropout_layer_2) pool_layer_3 = pooling.MaxPooling1D(pool_length = seqlen - 4)(dropout_layer_3) pool_layer_4 = pooling.MaxPooling1D(pool_length = seqlen - 2)(dropout_layer_4) pool_layer_5 = pooling.MaxPooling1D(pool_length = seqlen - 3)(dropout_layer_5) pool_layer_6 = pooling.MaxPooling1D(pool_length = seqlen - 4)(dropout_layer_6) ''' ''' pool_layer_1 = pooling.MaxPooling1D(pool_length = 2, border_mode = 'valid')(cnn_layer_1)
