def MCNN(trainX1,trainX2,trainY1,valX1,valX2,valY1,input_1,input_2, i,class_weights):
onehot_secstr = conv.Conv1D(5, 10, kernel_initializer='glorot_normal',kernel_regularizer=l2(0.04), padding='valid', name='0_secstr')(input_1)
onehot_secstr = Dropout(0.6)(onehot_secstr)
onehot_secstr = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_secstr)
onehot_secstr = core.Flatten()(onehot_secstr)
onehot_secstr2 = conv.Conv1D(9, 4, kernel_initializer='glorot_normal',kernel_regularizer=l2(0.02), padding='valid', name='1_secstr')(input_1)
onehot_secstr2 = Dropout(0.4)(onehot_secstr2)
onehot_secstr2 = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_secstr2)
onehot_secstr2 = core.Flatten()(onehot_secstr2)
output_onehot_sec = concatenate([onehot_secstr, onehot_secstr2], axis=-1)
onehot_x = conv.Conv1D(5, 10, kernel_initializer='glorot_normal',kernel_regularizer=l2(0.04), padding='valid', name='0')(input_2)
onehot_x = Dropout(0.6)(onehot_x)
onehot_x = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_x)
onehot_x = core.Flatten()(onehot_x)
onehot_x2 = conv.Conv1D(9, 4, kernel_initializer='glorot_normal',kernel_regularizer=l2(0.02), padding='valid', name='1')(input_2)
onehot_x2 = Dropout(0.4)(onehot_x2)
onehot_x2 = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_x2)
onehot_x2 = core.Flatten()(onehot_x2)
output_onehot_seq = concatenate([onehot_x, onehot_x2], axis=-1)
final_output = concatenate([output_onehot_sec, output_onehot_seq])
dense_out = Dense(100, kernel_initializer='glorot_normal', activation='softplus', name='dense_concat')(final_output)
out = Dense(2, activation="softmax", kernel_initializer='glorot_normal', name='6')(dense_out)
########## Set Net ##########
cnn = Model(inputs=[input_1,input_2], outputs=out)
cnn.summary()
nadam = Nadam(lr=0.001)
#early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=1, mode='auto')
cnn.compile(loss='binary_crossentropy', optimizer=nadam, metrics=[keras.metrics.binary_accuracy]) # Nadam
early_stopping = EarlyStopping(monitor='val_loss', patience=20)
checkpointer = ModelCheckpoint(filepath='%d-secstr_seq_denseconcat_60perc.h5' % i, verbose=1,save_best_only=True, monitor='val_loss', mode='min')
fitHistory = cnn.fit([trainX1,trainX2], trainY1, batch_size=256, nb_epoch=500,validation_data=([valX1,valX2], valY1),class_weight=class_weights,callbacks=[checkpointer,early_stopping])
history_dict = fitHistory.history
myjson_file = "myhist_" +"dict_" + "secstr_seq_denseconcat_60perc_" +str(i)
json.dump(history_dict, open(myjson_file, 'w'))
return cnn, fitHistory
def model(input):
x = conv.Conv1D(100,
3,
activation=config.get('first layer', 'activation'),
kernel_initializer=config.get('first layer',
'kernel_initializer'),
kernel_regularizer=l2(
config.getfloat('first layer', 'kernel_regularizer')),
padding=config.get('first layer', 'padding'),
name='Conv1')(input)
x = Dropout(config.getfloat('first layer', 'dropout'), name='drop1')(x)
x = BatchNormalization()(x)
x = MaxPooling1D(pool_size=2, strides=None, padding='valid')(x)
x = conv.Conv1D(200,
7,
activation=config.get('second layer', 'activation'),
kernel_initializer=config.get('second layer',
'kernel_initializer'),
kernel_regularizer=l2(
config.getfloat('second layer', 'kernel_regularizer')),
padding=config.get('second layer', 'padding'),
name='Conv2')(x)
x = Dropout(config.getfloat('second layer', 'dropout'), name='drop2')(x)
x = BatchNormalization()(x)
x = MaxPooling1D(pool_size=2, strides=None, padding='valid')(x)
x = GRU(units=64, return_sequences=True)(x)
x = Dropout(0.2)(x)
x = GRU(units=64, return_sequences=True)(x)
x = Dropout(0.2)(x)
output = core.Flatten()(x)
output = BatchNormalization()(output)
output = Dropout(config.getint('flatten layer', 'dropout'),
name='dropo3')(output)
output = Dense(config.getint('first dense layer', 'units'),
kernel_initializer=config.get('first dense layer',
'kernel_initializer'),
activation=config.get('first dense layer', 'activation'),
name='Denseo1')(output)
output = Dropout(config.getfloat('first dense layer', 'dropout'),
name='dropo4')(output)
output = BatchNormalization()(output)
out = Dense(2,
activation="softmax",
kernel_initializer='glorot_normal',
name='Denseo2')(output)
# ########## Set Cnn ##########
cnn = Model(inputs=input, outputs=out)
cnn.summary()
adam = Adam(lr=0.0005)
cnn.compile(loss='binary_crossentropy',
optimizer=adam,
metrics=[keras.metrics.binary_accuracy]) # Nadam
return cnn
def test_conv_1d():
batch_size = 2
steps = 8
input_dim = 2
kernel_size = 3
filters = 3
for padding in _convolution_paddings:
for strides in [1, 2]:
if padding == 'same' and strides != 1:
continue
layer_test(convolutional.Conv1D,
kwargs={
'filters': filters,
'kernel_size': kernel_size,
'padding': padding,
'strides': strides
},
input_shape=(batch_size, steps, input_dim))
layer_test(convolutional.Conv1D,
kwargs={
'filters': filters,
'kernel_size': kernel_size,
'padding': padding,
'kernel_regularizer': 'l2',
'bias_regularizer': 'l2',
'activity_regularizer': 'l2',
'kernel_constraint': 'max_norm',
'bias_constraint': 'max_norm',
'strides': strides
},
input_shape=(batch_size, steps, input_dim))
# Test dilation
layer_test(convolutional.Conv1D,
kwargs={
'filters': filters,
'kernel_size': kernel_size,
'padding': padding,
'dilation_rate': 2,
'activation': None
},
input_shape=(batch_size, steps, input_dim))
convolutional.Conv1D(filters=filters,
kernel_size=kernel_size,
padding=padding,
input_shape=(input_dim, ))
def build1():
#1维卷积
inputshape= (40,100)
active='elu'
print('#添加层++++++++++++++++++++++++++++++++++++++++')
model=Sequential()
model.add(conv.Conv1D(filters=20,kernel_size=(10),input_shape=inputshape,activation=active))
model.add(Dropout(0.2) )
#model.add(conv.Conv1D(filters=20,kernel_size=(5),activation=active))
#model.add(Dropout(0.2) )
model.add(Flatten() )
model.add(Dense(4) )
model.add(Activation('softmax') )
return model
class LayerCorrectnessTest(test_combinations.TestCase):
def setUp(self):
super(LayerCorrectnessTest, self).setUp()
# Set two virtual CPUs to test MirroredStrategy with multiple devices
cpus = tf.config.list_physical_devices('CPU')
tf.config.set_logical_device_configuration(cpus[0], [
tf.config.LogicalDeviceConfiguration(),
tf.config.LogicalDeviceConfiguration(),
])
def _create_model_from_layer(self, layer, input_shapes):
inputs = [layers.Input(batch_input_shape=s) for s in input_shapes]
if len(inputs) == 1:
inputs = inputs[0]
y = layer(inputs)
model = models.Model(inputs, y)
model.compile('sgd', 'mse')
return model
@parameterized.named_parameters(
('LeakyReLU', activation.LeakyReLU, (2, 2)),
('PReLU', activation.PReLU, (2, 2)), ('ELU', activation.ELU, (2, 2)),
('ThresholdedReLU', activation.ThresholdedReLU,
(2, 2)), ('Softmax', activation.Softmax,
(2, 2)), ('ReLU', activation.ReLU, (2, 2)),
('Conv1D', lambda: convolutional.Conv1D(2, 2), (2, 2, 1)),
('Conv2D', lambda: convolutional.Conv2D(2, 2), (2, 2, 2, 1)),
('Conv3D', lambda: convolutional.Conv3D(2, 2), (2, 2, 2, 2, 1)),
('Conv2DTranspose', lambda: convolutional.Conv2DTranspose(2, 2),
(2, 2, 2, 2)),
('SeparableConv2D', lambda: convolutional.SeparableConv2D(2, 2),
(2, 2, 2, 1)),
('DepthwiseConv2D', lambda: convolutional.DepthwiseConv2D(2, 2),
(2, 2, 2, 1)), ('UpSampling2D', reshaping.UpSampling2D, (2, 2, 2, 1)),
('ZeroPadding2D', reshaping.ZeroPadding2D,
(2, 2, 2, 1)), ('Cropping2D', reshaping.Cropping2D, (2, 3, 3, 1)),
('ConvLSTM2D', lambda: conv_lstm2d.ConvLSTM2D(4, kernel_size=(2, 2)),
(4, 4, 4, 4, 4)), ('Dense', lambda: core.Dense(2), (2, 2)),
('Dropout', lambda: regularization.Dropout(0.5), (2, 2)),
('SpatialDropout2D', lambda: regularization.SpatialDropout2D(0.5),
(2, 2, 2, 2)), ('Activation', lambda: core.Activation('sigmoid'),
(2, 2)), ('Reshape', lambda: reshaping.Reshape(
(1, 4, 1)), (2, 2, 2)),
('Permute', lambda: reshaping.Permute(
(2, 1)), (2, 2, 2)), ('Attention', attention.Attention, [
(2, 2, 3), (2, 3, 3), (2, 3, 3)
]), ('AdditiveAttention', attention.AdditiveAttention, [
(2, 2, 3), (2, 3, 3), (2, 3, 3)
]), ('Embedding', lambda: core.Embedding(4, 4),
(2, 4), 2e-3, 2e-3, np.random.randint(4, size=(2, 4))),
('LocallyConnected1D',
lambda: locally_connected.LocallyConnected1D(2, 2),
(2, 2, 1)), ('LocallyConnected2D',
lambda: locally_connected.LocallyConnected2D(2, 2),
(2, 2, 2, 1)), ('Add', merging.Add, [(2, 2), (2, 2)]),
('Subtract', merging.Subtract, [(2, 2), (2, 2)]),
('Multiply', merging.Multiply, [
(2, 2), (2, 2)
]), ('Average', merging.Average, [(2, 2), (2, 2)]),
('Maximum', merging.Maximum, [
(2, 2), (2, 2)
]), ('Minimum', merging.Minimum, [
(2, 2), (2, 2)
]), ('Concatenate', merging.Concatenate, [
(2, 2), (2, 2)
]), ('Dot', lambda: merging.Dot(1), [(2, 2), (2, 2)]),
('GaussianNoise', lambda: regularization.GaussianNoise(0.5), (2, 2)),
('GaussianDropout', lambda: regularization.GaussianDropout(0.5),
(2, 2)), ('AlphaDropout', lambda: regularization.AlphaDropout(0.5),
(2, 2)),
('BatchNormalization', batch_normalization.BatchNormalization,
(2, 2), 1e-2, 1e-2),
('LayerNormalization', layer_normalization.LayerNormalization,
(2, 2)), ('LayerNormalizationUnfused',
lambda: layer_normalization.LayerNormalization(axis=1),
(2, 2, 2)), ('MaxPooling2D', pooling.MaxPooling2D,
(2, 2, 2, 1)),
('AveragePooling2D', pooling.AveragePooling2D,
(2, 2, 2, 1)), ('GlobalMaxPooling2D', pooling.GlobalMaxPooling2D,
(2, 2, 2, 1)),
('GlobalAveragePooling2D', pooling.GlobalAveragePooling2D,
(2, 2, 2, 1)), ('SimpleRNN', lambda: simple_rnn.SimpleRNN(units=4),
(4, 4, 4), 1e-2, 1e-2),
('SimpleRNN_stateful',
lambda: simple_rnn.SimpleRNN(units=4, stateful=True), (4, 4, 4), 1e-2,
1e-2), ('GRU', lambda: gru_v1.GRU(units=4),
(4, 4, 4)), ('LSTM', lambda: lstm_v1.LSTM(units=4),
(4, 4, 4)), ('GRUV2', lambda: gru.GRU(units=4),
(4, 4, 4)),
('GRUV2_stateful', lambda: gru.GRU(units=4, stateful=True),
(4, 4, 4)), ('LSTMV2', lambda: lstm.LSTM(units=4), (4, 4, 4)),
('LSTMV2_stateful', lambda: lstm.LSTM(units=4, stateful=True),
(4, 4, 4)), ('TimeDistributed',
lambda: time_distributed.TimeDistributed(core.Dense(2)),
(2, 2, 2)),
('Bidirectional',
lambda: bidirectional.Bidirectional(simple_rnn.SimpleRNN(units=4)),
(2, 2, 2)),
('AttentionLayerCausal', lambda: attention.Attention(causal=True), [
(2, 2, 3), (2, 3, 3), (2, 3, 3)
]), ('AdditiveAttentionLayerCausal',
lambda: attention.AdditiveAttention(causal=True), [
(2, 3, 4), (2, 3, 4), (2, 3, 4)
]), ('NormalizationAdapt', _create_normalization_layer_with_adapt,
(4, 4)),
('NormalizationNoAdapt', _create_normalization_layer_without_adapt,
(4, 4)), ('Resizing', lambda: image_preprocessing.Resizing(3, 3),
(2, 5, 5, 1)),
('Rescaling', lambda: image_preprocessing.Rescaling(2., 1.),
(6, 6)), ('CenterCrop', lambda: image_preprocessing.CenterCrop(3, 3),
(2, 5, 5, 1)))
def test_layer(self,
f32_layer_fn,
input_shape,
rtol=2e-3,
atol=2e-3,
input_data=None):
"""Tests a layer by comparing the float32 and mixed precision weights.
A float32 layer, a mixed precision layer, and a distributed mixed precision
layer are run. The three layers are identical other than their dtypes and
distribution strategies. The outputs after predict() and weights after fit()
are asserted to be close.
Args:
f32_layer_fn: A function returning a float32 layer. The other two layers
will automatically be created from this
input_shape: The shape of the input to the layer, including the batch
dimension. Or a list of shapes if the layer takes multiple inputs.
rtol: The relative tolerance to be asserted.
atol: The absolute tolerance to be asserted.
input_data: A Numpy array with the data of the input. If None, input data
will be randomly generated
"""
if f32_layer_fn == reshaping.ZeroPadding2D and tf.test.is_built_with_rocm(
):
return
if isinstance(input_shape[0], int):
input_shapes = [input_shape]
else:
input_shapes = input_shape
strategy = create_mirrored_strategy()
f32_layer = f32_layer_fn()
# Create the layers
assert f32_layer.dtype == f32_layer._compute_dtype == 'float32'
config = f32_layer.get_config()
config['dtype'] = policy.Policy('mixed_float16')
mp_layer = f32_layer.__class__.from_config(config)
distributed_mp_layer = f32_layer.__class__.from_config(config)
# Compute per_replica_input_shapes for the distributed model
global_batch_size = input_shapes[0][0]
assert global_batch_size % strategy.num_replicas_in_sync == 0, (
'The number of replicas, %d, does not divide the global batch size of '
'%d' % (strategy.num_replicas_in_sync, global_batch_size))
per_replica_batch_size = (global_batch_size //
strategy.num_replicas_in_sync)
per_replica_input_shapes = [(per_replica_batch_size, ) + s[1:]
for s in input_shapes]
# Create the models
f32_model = self._create_model_from_layer(f32_layer, input_shapes)
mp_model = self._create_model_from_layer(mp_layer, input_shapes)
with strategy.scope():
distributed_mp_model = self._create_model_from_layer(
distributed_mp_layer, per_replica_input_shapes)
# Set all model weights to the same values
f32_weights = f32_model.get_weights()
mp_model.set_weights(f32_weights)
distributed_mp_model.set_weights(f32_weights)
# Generate input data
if input_data is None:
# Cast inputs to float16 to avoid measuring error from having f16 layers
# cast to float16.
input_data = [
np.random.normal(size=s).astype('float16')
for s in input_shapes
]
if len(input_data) == 1:
input_data = input_data[0]
# Assert all models have close outputs.
f32_output = f32_model.predict(input_data)
mp_output = mp_model.predict(input_data)
self.assertAllClose(mp_output, f32_output, rtol=rtol, atol=atol)
self.assertAllClose(distributed_mp_model.predict(input_data),
f32_output,
rtol=rtol,
atol=atol)
# Run fit() on models
output = np.random.normal(
size=f32_model.outputs[0].shape).astype('float16')
for model in f32_model, mp_model, distributed_mp_model:
model.fit(input_data, output, batch_size=global_batch_size)
# Assert all models have close weights
f32_weights = f32_model.get_weights()
self.assertAllClose(mp_model.get_weights(),
f32_weights,
rtol=rtol,
atol=atol)
self.assertAllClose(distributed_mp_model.get_weights(),
f32_weights,
rtol=rtol,
atol=atol)
def OOKCNN(trainX,
trainY,
nb_epoch,
earlystop=None,
compiletimes=0,
compilemodels=None,
batch_size=2048,
class_weights={
0: 1,
1: 1
},
predict=False):
#Set Oneofkey Network Size and Data
input_row = trainX.shape[2]
input_col = trainX.shape[3]
trainX_t = trainX
# Early_stop
if (earlystop is not None):
early_stopping = EarlyStopping(monitor='val_loss',
mode='min',
patience=earlystop)
# set to a very big value since earlystop used
nb_epoch = nb_epoch
# TrainX_t For Shape
trainX_t.shape = (trainX_t.shape[0], input_row, input_col)
input = Input(shape=(input_row, input_col))
# params = {'dropout1': 0.09055921027754717, 'dropout2': 0.6391239298866936, 'dropout3': 0.4494981811340072,
# 'dropout4': 0.13858850326177857, 'dropout5': 0.37168935754516325, 'layer1_node': 21.380001953812567,
# 'layer1_size': 1, 'layer2_node': 42.3937544103545, 'layer2_size': 16, 'layer3_node': 184.87943202539697,
# 'layer4_node': 61.85302597240724, 'layer5_node': 415.9952475249118, 'nb_epoch': 178, 'windowSize': 16}
# layer1_node = int(params["layer1_node"])
# layer2_node = int(params["layer2_node"])
# layer3_node = int(params["layer3_node"])
# layer4_node = int(params["layer4_node"])
# layer5_node = int(params["layer5_node"])
# layer1_size = params["layer1_size"]
# layer2_size = params["layer2_size"]
# dropout1 = params["dropout1"]
# dropout2 = params["dropout2"]
# dropout3 = params["dropout3"]
# dropout4 = params["dropout4"]
# dropout5 = params["dropout5"]
if compiletimes == 0:
# Total Set Classes
nb_classes = 2
# Total Set Batch_size
batch_size = 8192
# Total Set Optimizer
# optimizer = SGD(lr=0.0001, momentum=0.9, nesterov= True)
optimization = 'Nadam'
#begin of Oneofkey Network
# x = conv.Conv1D(layer1_node, layer1_size, name="layer1", kernel_initializer="glorot_normal",
# kernel_regularizer=l2(0), padding="same")(input)
# x = Dropout(dropout1)(input)
# x = Activation('softsign')(x)
#
# x = conv.Conv1D(layer2_node, layer2_size, name="layer2", kernel_initializer="glorot_normal",
# kernel_regularizer=l2(0), padding="same")(x)
# x = Dropout(dropout2)(x)
# x = Activation('softsign')(x)
#
# output_x = core.Flatten()(x)
# output = BatchNormalization()(output_x)
# output = Dropout(dropout3)(output)
#
# # attention_probs = Dense(1155, activation='softmax', name='attention_probs')(output)
# # attention_mul = Multiply()([output, attention_probs])
#
# output = Dense(layer3_node, kernel_initializer='glorot_normal', activation='relu', name='layer3')(output)
# output = Dropout(dropout4)(output)
# output = Dense(layer4_node, kernel_initializer='glorot_normal', activation="relu", name='layer4')(output)
# output = Dropout(dropout5)(output)
# output = Dense(layer5_node, kernel_initializer='glorot_normal', activation="relu", name='layer5')(output)
# End of Oneofkey Network
# out = Dense(nb_classes, kernel_initializer='glorot_normal', activation='softmax', kernel_regularizer=l2(0.001),
# name='7')(output)
#
# cnn = Model(input, out)
# cnn.compile(loss=keras.losses.binary_crossentropy, optimizer=optimization, metrics=[keras.metrics.binary_accuracy])
x = conv.Conv1D(51,
2,
name="0",
kernel_initializer="glorot_normal",
kernel_regularizer=l2(0),
padding="same")(input)
x = Dropout(0.3)(x)
x = Activation('softsign')(x)
x = conv.Conv1D(21,
3,
name="1",
kernel_initializer="glorot_normal",
kernel_regularizer=l2(0),
padding="same")(x)
x = Dropout(0.4)(x)
x = Activation('softsign')(x)
# x = conv.Conv1D(21, 5, name="2", kernel_initializer="glorot_normal", kernel_regularizer=l2(0), padding="same")(x)
# x = Dropout(0.4)(x)
# x = Activation('softsign')(x)
#
# x = conv.Conv1D(101, 7, name="3", kernel_initializer="glorot_normal", kernel_regularizer=l2(0), padding="same")(x)
# x = Activation('softsign')(x)
# # x_reshape = core.Reshape((x._keras_shape[2], x._keras_shape[1]))(x)
# x = Dropout(0.4)(x)
output_x = core.Flatten()(x)
output = BatchNormalization()(output_x)
output = Dropout(0.3)(output)
# attention_probs = Dense(1155, activation='softmax', name='attention_probs')(output)
# attention_mul = Multiply()([output, attention_probs])
output = Dense(128,
kernel_initializer='glorot_normal',
activation='relu',
name='4')(output)
output = Dropout(0.2)(output)
output = Dense(64,
kernel_initializer='glorot_normal',
activation="relu",
name='5')(output)
output = Dropout(0.2)(output)
output = Dense(415,
kernel_initializer='glorot_normal',
activation="relu",
name='6')(output)
# End of Oneofkey Network
out = Dense(nb_classes,
kernel_initializer='glorot_normal',
activation='softmax',
kernel_regularizer=l2(0.001),
name='7')(output)
cnn = Model(input, out)
cnn.compile(loss=keras.losses.binary_crossentropy,
optimizer=optimization,
metrics=[keras.metrics.binary_accuracy])
else:
cnn = compilemodels
oneofkclass_weights = class_weights
if (predict is False):
if (trainY is not None):
if (earlystop is None):
fitHistory = cnn.fit(trainX_t,
trainY,
batch_size=batch_size,
nb_epoch=nb_epoch)
else:
# checkpointer = ModelCheckpoint(filepath='oneofk.h5', verbose=1, save_best_only=True)
weight_checkpointer = ModelCheckpoint(
filepath='oneofkweight9.h5',
verbose=0,
save_best_only=True,
monitor='val_binary_accuracy',
mode='max',
save_weights_only=True)
fitHistory = cnn.fit(
trainX_t,
trainY,
batch_size=batch_size,
epochs=nb_epoch,
shuffle=True,
validation_split=0.2,
callbacks=[early_stopping, weight_checkpointer],
class_weight=oneofkclass_weights,
verbose=0)
else:
fitHistory = cnn.fit(trainX_t,
trainY,
batch_size=batch_size,
nb_epoch=nb_epoch)
return cnn
def MCNN_best(trainX1, trainX2, trainY1, valX1, valX2, valY1, input_1, input_2,
i, class_weights, t):
if (t == 0):
print("####################################bootstrap iteration ", t,
"#############fold iteration ", i, "\n")
onehot_secstr = conv.Conv1D(
5,
10,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.0010949235793883667),
padding='valid',
name='0_secstr')(input_1)
onehot_secstr = Dropout(0.745150134528914)(onehot_secstr)
onehot_secstr = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_secstr)
onehot_secstr = core.Flatten()(onehot_secstr)
onehot_secstr2 = conv.Conv1D(
9,
4,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.03405758144816304),
padding='valid',
name='1_secstr')(input_1)
onehot_secstr2 = Dropout(0.36965944352568686)(onehot_secstr2)
onehot_secstr2 = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_secstr2)
onehot_secstr2 = core.Flatten()(onehot_secstr2)
output_onehot_sec = concatenate([onehot_secstr, onehot_secstr2],
axis=-1)
onehot_x = conv.Conv1D(5,
10,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.03217477728270726),
padding='valid',
name='0')(input_2)
onehot_x = Dropout(0.6653716368558287)(onehot_x)
onehot_x = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_x)
onehot_x = core.Flatten()(onehot_x)
onehot_x2 = conv.Conv1D(9,
4,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.01608962762003551),
padding='valid',
name='1')(input_2)
onehot_x2 = Dropout(0.038045356303735206)(onehot_x2)
onehot_x2 = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_x2)
onehot_x2 = core.Flatten()(onehot_x2)
output_onehot_seq = concatenate([onehot_x, onehot_x2], axis=-1)
final_output = concatenate([output_onehot_sec, output_onehot_seq])
dense_out = Dense(512,
kernel_initializer='glorot_normal',
activation='softplus',
name='dense_concat')(final_output)
out = Dense(2,
activation="softmax",
kernel_initializer='glorot_normal',
name='6')(dense_out)
########## Set Net ##########
cnn = Model(inputs=[input_1, input_2], outputs=out)
cnn.load_weights('weightsfile_hyperasbest.h5')
cnn.summary()
adam = Adam(lr=0.08582474007227135)
nadam = Nadam(lr=0.0014045290291504406)
rmsprop = RMSprop(lr=0.037289952982092284)
sgd = SGD(lr=0.01373965388919854)
optim = sgd
## choiceval = {{choice(['adam', 'sgd', 'rmsprop','nadam'])}}
## if choiceval == 'adam':
## optim = adam
## elif choiceval == 'rmsprop':
## optim = rmsprop
## elif choiceval=='nadam':
## optim = nadam
## else:
## optim = sgd
cnn.compile(loss='binary_crossentropy',
optimizer=optim,
metrics=[keras.metrics.binary_accuracy]) # Nadam
early_stopping = EarlyStopping(monitor='val_loss', patience=20)
checkpointer = ModelCheckpoint(
filepath='%d-secstr_seq_denseconcat_60perc_best.h5' % i,
verbose=1,
save_best_only=True,
monitor='val_loss',
mode='min')
fitHistory = cnn.fit([trainX1, trainX2],
trainY1,
batch_size=32,
nb_epoch=500,
validation_data=([valX1, valX2], valY1),
callbacks=[checkpointer, early_stopping],
class_weight=class_weights)
myjson_file = "myhist_" + "dict_" + "secstr_seq_denseconcat_60perc_best_" + str(
i)
json.dump(fitHistory.history, open(myjson_file, 'w'))
return cnn, fitHistory
else:
print("####################################bootstrap iteration ", t,
"#############fold iteration ", i, "\n")
cnn = models.load_model('%d-secstr_seq_denseconcat_60perc_best.h5' % i)
early_stopping = EarlyStopping(monitor='val_loss', patience=20)
checkpointer = ModelCheckpoint(
filepath='%d-secstr_seq_denseconcat_60perc_best.h5' % i,
verbose=1,
save_best_only=True,
monitor='val_loss',
mode='min')
fitHistory = cnn.fit([trainX1, trainX2],
trainY1,
batch_size=32,
nb_epoch=500,
validation_data=([valX1, valX2], valY1),
class_weight=class_weights,
callbacks=[checkpointer, early_stopping])
myjson_file = "myhist_" + "dict_" + "secstr_seq_denseconcat_60perc_best_" + str(
i)
json.dump(fitHistory.history, open(myjson_file, 'a'))
return cnn, fitHistory
def MCNN_26(trainX1, trainX2, trainY1, valX1, valX2, valY1, input_1, input_2,
i, class_weights, t):
if (t == 0):
print("####################################bootstrap iteration ", t,
"#############fold iteration ", i, "\n")
onehot_secstr = conv.Conv1D(
5,
10,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.011206678796947282),
padding='valid',
name='0_secstr')(input_1)
onehot_secstr = Dropout(0.9942741825824339)(onehot_secstr)
onehot_secstr = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_secstr)
onehot_secstr = core.Flatten()(onehot_secstr)
onehot_secstr2 = conv.Conv1D(
9,
4,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.04663753230167181),
padding='valid',
name='1_secstr')(input_1)
onehot_secstr2 = Dropout(0.4084429796653032)(onehot_secstr2)
onehot_secstr2 = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_secstr2)
onehot_secstr2 = core.Flatten()(onehot_secstr2)
output_onehot_sec = concatenate([onehot_secstr, onehot_secstr2],
axis=-1)
onehot_x = conv.Conv1D(5,
10,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.032491576988669696),
padding='valid',
name='0')(input_2)
onehot_x = Dropout(0.5471399358933519)(onehot_x)
onehot_x = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_x)
onehot_x = core.Flatten()(onehot_x)
onehot_x2 = conv.Conv1D(9,
4,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(0.021775346680719416),
padding='valid',
name='1')(input_2)
onehot_x2 = Dropout(0.10926522237224338)(onehot_x2)
onehot_x2 = keras.layers.advanced_activations.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None)(onehot_x2)
onehot_x2 = core.Flatten()(onehot_x2)
output_onehot_seq = concatenate([onehot_x, onehot_x2], axis=-1)
final_output = concatenate([output_onehot_sec, output_onehot_seq])
dense_out = Dense(30,
kernel_initializer='glorot_normal',
activation='softplus',
name='dense_concat')(final_output)
out = Dense(2,
activation="softmax",
kernel_initializer='glorot_normal',
name='6')(dense_out)
########## Set Net ##########
cnn = Model(inputs=[input_1, input_2], outputs=out)
cnn.load_weights('weightsfile_hyperas26.h5')
cnn.summary()
adam = Adam(lr=0.06971582946481189)
nadam = Nadam(lr=0.010482932560304255)
rmsprop = RMSprop(lr=0.031598749327261345)
sgd = SGD(lr=0.008615890670714792)
optim = sgd
## choiceval = {{choice(['adam', 'sgd', 'rmsprop','nadam'])}}
## if choiceval == 'adam':
## optim = adam
## elif choiceval == 'rmsprop':
## optim = rmsprop
## elif choiceval=='nadam':
## optim = nadam
## else:
## optim = sgd
cnn.compile(loss='binary_crossentropy',
optimizer=optim,
metrics=[keras.metrics.binary_accuracy]) # Nadam
early_stopping = EarlyStopping(monitor='val_loss', patience=20)
checkpointer = ModelCheckpoint(
filepath='%d-secstr_seq_denseconcat_60perc_trial26.h5' % i,
verbose=1,
save_best_only=True,
monitor='val_loss',
mode='min')
fitHistory = cnn.fit([trainX1, trainX2],
trainY1,
batch_size=32,
nb_epoch=500,
validation_data=([valX1, valX2], valY1),
callbacks=[checkpointer, early_stopping],
class_weight=class_weights)
myjson_file = "myhist_" + "dict_" + "secstr_seq_denseconcat_60perc_trial26_" + str(
i)
json.dump(fitHistory.history, open(myjson_file, 'w'))
return cnn, fitHistory
else:
print("####################################bootstrap iteration ", t,
"#############fold iteration ", i, "\n")
cnn = models.load_model('%d-secstr_seq_denseconcat_60perc_trial26.h5' %
i)
early_stopping = EarlyStopping(monitor='val_loss', patience=20)
checkpointer = ModelCheckpoint(
filepath='%d-secstr_seq_denseconcat_60perc_trial26.h5' % i,
verbose=1,
save_best_only=True,
monitor='val_loss',
mode='min')
fitHistory = cnn.fit([trainX1, trainX2],
trainY1,
batch_size=32,
nb_epoch=500,
validation_data=([valX1, valX2], valY1),
class_weight=class_weights,
callbacks=[checkpointer, early_stopping])
myjson_file = "myhist_" + "dict_" + "secstr_seq_denseconcat_60perc_trial26_" + str(
i)
json.dump(fitHistory.history, open(myjson_file, 'a'))
return cnn, fitHistory
def MCNN(trainX1,trainX2,trainY1,valX1,valX2,valY1,testX1,testX2,testY):
import pickle
from sklearn.metrics import precision_score, recall_score, f1_score
import pandas as pd
#import pirna_kmer as pk
from pandas import DataFrame
from sklearn.model_selection import train_test_split
import numpy as np
#import phy_net as pn
from keras.layers import Input
import keras.utils.np_utils as kutils
#import threading
import time
from keras.utils import np_utils
from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, BatchNormalization, Activation, Flatten
from keras.optimizers import Adam
from keras.wrappers.scikit_learn import KerasClassifier
from keras.models import load_model
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.utils.class_weight import compute_class_weight
from keras.layers import Convolution2D as Conv2D
from keras.layers import MaxPooling2D
from keras.callbacks import EarlyStopping
import json
#from sklearn.metrics import matthews_corrcoef
from keras.models import Model
import tensorflow as tf
## from tensorflow.keras.callbacks import TensorBoard
import os
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from sklearn.metrics import precision_recall_curve, roc_curve, auc, average_precision_score, matthews_corrcoef
from sklearn.metrics import precision_score, recall_score, f1_score
#from sklearn.metrics import accuracy_score, recall_score
remark = '' # The mark written in the result file.
import time
import numpy as np
import matplotlib
import pickle
matplotlib.use('Agg')
import keras.layers.core as core
import keras.layers.convolutional as conv
import keras.models as models
from keras.models import Model
from keras.layers.merge import concatenate
from keras.callbacks import EarlyStopping, ModelCheckpoint, Callback, LearningRateScheduler, History
from keras.layers import Dense, Dropout, Activation, Flatten, Input
from keras.layers.normalization import BatchNormalization
from keras.regularizers import l1, l2, l1_l2
import keras.metrics
import matplotlib.pyplot as plt
from keras.optimizers import Nadam,Adam,RMSprop,SGD
from sklearn.metrics import precision_recall_curve, roc_curve, auc, average_precision_score, matthews_corrcoef
import os
from sklearn import svm
from sklearn.manifold import TSNE
from matplotlib import offsetbox
from sklearn.metrics import accuracy_score, recall_score
import random
## from tensorflow.keras.callbacks import TensorBoard
row1,col1 = trainX1[0].shape
input_1 = Input(shape=(row1,col1))
row2,col2 = trainX2[0].shape
input_2 = Input(shape=(row2,col2))
NAME = "combined_secstr_seq_CNN_model_emboss-{}".format(int(time.time()))
tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))
onehot_secstr = conv.Conv1D(5, 10, kernel_initializer='glorot_normal',kernel_regularizer=l2({{uniform(0.0001, 0.1)}}), padding='valid', name='0_secstr')(input_1)
onehot_secstr = Dropout({{uniform(0, 1)}})(onehot_secstr)
onehot_secstr = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_secstr)
onehot_secstr = core.Flatten()(onehot_secstr)
onehot_secstr2 = conv.Conv1D(9, 4, kernel_initializer='glorot_normal',kernel_regularizer=l2({{uniform(0.0001, 0.1)}}), padding='valid', name='1_secstr')(input_1)
onehot_secstr2 = Dropout({{uniform(0, 1)}})(onehot_secstr2)
onehot_secstr2 = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_secstr2)
onehot_secstr2 = core.Flatten()(onehot_secstr2)
output_onehot_sec = concatenate([onehot_secstr, onehot_secstr2], axis=-1)
onehot_x = conv.Conv1D(5, 10, kernel_initializer='glorot_normal',kernel_regularizer=l2({{uniform(0.0001, 0.1)}}), padding='valid', name='0')(input_2)
onehot_x = Dropout({{uniform(0, 1)}})(onehot_x)
onehot_x = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_x)
onehot_x = core.Flatten()(onehot_x)
onehot_x2 = conv.Conv1D(9, 4, kernel_initializer='glorot_normal',kernel_regularizer=l2({{uniform(0.0001, 0.1)}}), padding='valid', name='1')(input_2)
onehot_x2 = Dropout({{uniform(0, 1)}})(onehot_x2)
onehot_x2 = keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None,alpha_constraint=None, shared_axes=None)(onehot_x2)
onehot_x2 = core.Flatten()(onehot_x2)
output_onehot_seq = concatenate([onehot_x, onehot_x2], axis=-1)
final_output = concatenate([output_onehot_sec, output_onehot_seq])
dense_out = Dense({{choice([20,30,50,60,64,70,80,90,100, 128, 256, 512, 1024])}}, kernel_initializer='glorot_normal', activation='softplus', name='dense_concat')(final_output)
out = Dense(2, activation="softmax", kernel_initializer='glorot_normal', name='6')(dense_out)
########## Set Net ##########
cnn = Model(inputs=[input_1,input_2], outputs=out)
cnn.summary()
adam = Adam(lr={{uniform(0.0001, 0.1)}})
nadam = Nadam(lr={{uniform(0.0001, 0.1)}})
rmsprop = RMSprop(lr={{uniform(0.0001, 0.1)}})
sgd = SGD(lr={{uniform(0.0001, 0.1)}})
choiceval = {{choice(['adam', 'sgd', 'rmsprop','nadam'])}}
if choiceval == 'adam':
optim = adam
elif choiceval == 'rmsprop':
optim = rmsprop
elif choiceval=='nadam':
optim = nadam
else:
optim = sgd
globalvars.globalVar += 1
#early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=1, mode='auto')
cnn.compile(loss='binary_crossentropy', optimizer=optim, metrics=[keras.metrics.binary_accuracy]) # Nadam
early_stopping = EarlyStopping(monitor='val_loss', patience=20)
checkpointer = ModelCheckpoint(filepath='%d-secstr_seq_denseconcat.h5' % globalvars.globalVar, verbose=1,save_best_only=True, monitor='val_loss', mode='min')
fitHistory = cnn.fit([trainX1,trainX2], trainY1, batch_size={{choice([32,64,128,256,512])}}, nb_epoch=500,validation_data=([valX1,valX2], valY1),callbacks=[checkpointer,early_stopping,tensorboard],class_weight=cwt.class_weights)
myjson_file = "myhist_" +"_dict" + "_hyperas_model_trial_" +str(globalvars.globalVar)
json.dump(fitHistory.history, open(myjson_file, 'w'))
score, acc = cnn.evaluate([valX1, valX2], valY1, batch_size=32)
pred_proba = cnn.predict([valX1,valX2], batch_size=32)
pred_score = pred_proba[:, 1]
true_class = valY1[:, 1]
f1_sc = f1_score(true_class,pred_score)
print('F1 score:', f1_sc)
print('Test score:', score)
print('accuracy:', acc)
return {'loss': -f1_sc, 'status': STATUS_OK, 'model': cnn}
def MultiCNN(train_ook_X,
trainAAIndexX,
train_ook_Y,
nb_epoch,
earlystop=None,
compiletimes=0,
batch_size=2048,
predict=False,
compileModel=None,
class_weight={
0: 0.5,
1: 0.5
},
verbose=1,
model_id=0):
# Set Oneofkey Data
ook_row = train_ook_X.shape[2]
ook_col = train_ook_X.shape[3]
ook_x_t = train_ook_X
ook_x_t.shape = (ook_x_t.shape[0], ook_row, ook_col)
ook_input = Input(shape=(ook_row, ook_col))
# AAindex
aaindex_x_t = trainAAIndexX
aaindex_row = trainAAIndexX.shape[2]
aaindex_col = trainAAIndexX.shape[3]
aaindex_x_t.shape = (trainAAIndexX.shape[0], aaindex_row, aaindex_col)
aaindex_input = Input(shape=(aaindex_row, aaindex_col))
if (earlystop is not None):
early_stopping = EarlyStopping(monitor='val_loss',
mode='min',
patience=earlystop)
nb_epoch = nb_epoch
# TrainX_t For Shape
if compiletimes == 0:
# Total Set Classes
nb_classes = 2
# Total Set Batch_size
batch_size = 8192
# Total Set Optimizer
# optimizer = SGD(lr=0.0001, momentum=0.9, nesterov= True)
optimization = 'Nadam'
# begin of Oneofkey Network
ook_x = conv.Conv1D(51,
2,
name="0",
kernel_initializer="glorot_normal",
kernel_regularizer=l2(0),
padding="same")(ook_input)
ook_x = Dropout(0.3)(ook_x)
ook_x = Activation('softsign')(ook_x)
ook_x = conv.Conv1D(21,
3,
name="1",
kernel_initializer="glorot_normal",
kernel_regularizer=l2(0),
padding="same")(ook_x)
ook_x = Dropout(0.4)(ook_x)
ook_x = Activation('softsign')(ook_x)
output_ook_x = core.Flatten()(ook_x)
output_ook_x = BatchNormalization()(output_ook_x)
output_ook_x = Dropout(0.3)(output_ook_x)
output_ook_x = Dense(128,
kernel_initializer='glorot_normal',
activation='relu',
name='2')(output_ook_x)
output_ook_x = Dropout(0.2)(output_ook_x)
output_ook_x = Dense(64,
kernel_initializer='glorot_normal',
activation="relu",
name='3')(output_ook_x)
output_ook_x = Dropout(0.2)(output_ook_x)
# below modified
output_ook_x = Dense(415,
kernel_initializer='glorot_normal',
activation="relu",
name='4')(output_ook_x)
# output_ook_x = Dense(nb_classes, kernel_initializer='glorot_normal', activation='softmax', kernel_regularizer=l2(0.001),
# name='7')(output_ook_x)
# End of Oneofkey Network
# start with AAindex Dnn
aaindex_x = core.Flatten()(aaindex_input)
attention_probs = Dense(aaindex_row * aaindex_col,
activation='softmax',
name='5')(aaindex_x)
aaindex_x = Multiply()([aaindex_x, attention_probs])
aaindex_x = BatchNormalization()(aaindex_x)
aaindex_x = Dense(256,
kernel_initializer='he_uniform',
activation='relu',
name='6')(aaindex_x)
aaindex_x = Dropout(0.6)(aaindex_x)
aaindex_x = Dense(128,
kernel_initializer='he_uniform',
activation='softplus',
name='7')(aaindex_x)
# aaindex_x = BatchNormalization()(aaindex_x)
aaindex_x = Dropout(0.55)(aaindex_x)
aaindex_x = GaussianNoise(10)(aaindex_x)
output_aaindex_x = Dense(64,
kernel_initializer='glorot_normal',
activation='relu',
name='8')(aaindex_x)
# output_aaindex_x = Dense(nb_classes, kernel_initializer='glorot_normal', activation='softmax',
# kernel_regularizer=l2(0.001), name='19')(output_aaindex_x)
# output = Maximum()([output_ook_x, output_aaindex_x])
output = Concatenate()([output_ook_x, output_aaindex_x])
output = BatchNormalization()(output)
# output = Dense(64, activation="relu", kernel_initializer="he_normal", kernel_regularizer=l2(0.001), name="21")(output)
# output = BatchNormalization()(output)
output = Dense(128,
activation="relu",
kernel_initializer="he_normal",
kernel_regularizer=l2(0.001),
name="9")(output)
output = Dropout(0.6)(output)
output = Dense(64,
activation="relu",
kernel_initializer="he_normal",
kernel_regularizer=l2(0.001),
name="10")(output)
output = Dropout(0.5)(output)
output = Dense(16,
activation="relu",
kernel_initializer="he_normal",
kernel_regularizer=l2(0.001),
name="11")(output)
out = Dense(nb_classes,
kernel_initializer='glorot_normal',
activation='softmax',
kernel_regularizer=l2(0.001),
name='12')(output)
multinn = Model([ook_input, aaindex_input], out)
multinn.compile(loss=keras.losses.binary_crossentropy,
optimizer=optimization,
metrics=[keras.metrics.binary_accuracy])
else:
multinn = compileModel
oneofkclass_weights = class_weight
if (earlystop is None):
fitHistory = multinn.fit([ook_x_t, aaindex_x_t],
train_ook_Y,
batch_size=batch_size,
nb_epoch=nb_epoch)
else:
weight_checkpointer = ModelCheckpoint(filepath='temp/temp.h5',
verbose=verbose,
save_best_only=True,
monitor='val_binary_accuracy',
mode='auto',
save_weights_only=True)
fitHistory = multinn.fit(
[ook_x_t, aaindex_x_t],
train_ook_Y,
batch_size=batch_size,
epochs=nb_epoch,
shuffle=True,
validation_split=0.2,
callbacks=[early_stopping, weight_checkpointer],
class_weight=oneofkclass_weights,
verbose=verbose)
return multinn
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
self.testing_x_path = "./data/PCA16_test.npy"
self.batch_size = 16
self.input_dim = (4, 4)
self.max_epochs = 20
self.lr = 1e-3
self.cnn_model_weights_path = "./model/cnn_model_weights.h5"
self.cnn_model_structure_path = "./model/cnn_model_structure.json"
cnn_config = Config()
inputs = Input(shape=cnn_config.input_dim)
x = convolutional.Conv1D(32,
kernel_size=3,
strides=1,
padding='same',
activation='relu')(inputs)
x = pooling.MaxPool1D(2)(x)
x = convolutional.Conv1D(64,
kernel_size=3,
strides=1,
padding='same',
activation='relu')(x)
x = pooling.MaxPool1D(2)(x)
# model.add(convolutional.Conv1D(32, kernel_size=3,
# strides=1, padding='same',
# activation='relu',
# input_shape=cnn_config.input_dim))
# model.add(pooling.MaxPool1D(2))
