def DetectNet(lr,input_shape,filter_num,lstm_units,kernel_size,drop_ratio,lstm_drop_ratio,dense_units):
'''
Network architecture of DetectNet
'''
ConvInput = Input(input_shape)
x1 = Convolution1D(filter_num,kernel_size,padding='same',data_format='channels_first',activation='relu')(ConvInput)
x1 = Dropout(rate=drop_ratio)(x1)
x2 = Convolution1D(filter_num,kernel_size,padding='same',data_format='channels_first',activation='relu')(x1)
x2 = Dropout(rate=drop_ratio)(x2)
x3 = Flatten()(x2)
# dimension reduction
x4 = Dense(input_shape[-1],activation='linear')(x3)
x4 = Reshape(target_shape=(1,input_shape[-1]))(x4)
LSTMInput = concatenate([x4,ConvInput],axis=1)
y1 = LSTM(units=lstm_units,return_sequences=True,recurrent_dropout=lstm_drop_ratio,input_shape=(input_shape[-1],3))(LSTMInput)
y2 = LSTM(units=lstm_units,dropout=lstm_drop_ratio)(y1)
y2 = Flatten()(y2)
y3 = Dense(dense_units,activation='relu')(y2)
predictions = Dense(2, activation='softmax')(y3)
model = Model(inputs=ConvInput,outputs=predictions)
model.compile(loss='categorical_crossentropy',optimizer=Adam(lr=lr), metrics=['accuracy'])
model.summary()
return model
def get_model():
nclass = 1
inp = Input(shape=(187, 1))
img_1 = Convolution1D(32,
kernel_size=5,
activation=activations.relu,
padding="valid")(inp)
for i in range(5):
img_1 = res_block(img_1, 32, dropout=0.2)
img_1 = Convolution1D(32,
kernel_size=3,
activation=activations.relu,
padding="same")(img_1)
img_1 = Convolution1D(32,
kernel_size=3,
activation=activations.relu,
padding="same",
name="final_conv")(img_1)
img_1 = GlobalMaxPool1D()(img_1)
img_1 = Dropout(rate=0.2)(img_1)
dense_1 = Dense(32, activation=activations.relu, name="dense_1")(img_1)
dense_1 = Dense(32, activation=activations.relu, name="dense_2")(dense_1)
dense_1 = Dense(nclass,
activation=activations.sigmoid,
name="dense_3_mitbih")(dense_1)
model = models.Model(inputs=inp, outputs=dense_1)
opt = optimizers.Adam(0.001)
model.compile(optimizer=opt,
loss=losses.binary_crossentropy,
metrics=['acc'])
model.summary()
return model
def CNN(lr, input_shape, filter_num, kernel_size, drop_ratio, dense_units):
ConvInput = Input(input_shape)
x1 = Convolution1D(filter_num,
kernel_size,
padding='same',
data_format='channels_first',
input_shape=input_shape,
activation='relu')(ConvInput)
x1 = Dropout(rate=drop_ratio)(x1)
x2 = Convolution1D(filter_num,
kernel_size,
padding='same',
data_format='channels_first',
activation='relu')(x1)
x2 = Dropout(rate=drop_ratio)(x2)
x2 = Flatten()(x2)
x3 = Dense(dense_units, activation='relu')(x2)
x3 = Dropout(rate=drop_ratio)(x3)
predictions = Dense(2, activation='softmax')(x3)
model = Model(inputs=ConvInput, outputs=predictions)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=lr),
metrics=['accuracy'])
model.summary()
return model
def train_cnn(X_train, y_train, X_test, y_test, X_val, y_val):
model = keras.Sequential()
model.add(
Convolution1D(filters=1500,
kernel_size=2,
strides=2,
activation='relu',
input_shape=(48, 272)))
model.add(MaxPooling1D(2))
model.add(Dropout(0.2))
model = keras.Sequential()
model.add(
Convolution1D(filters=500, kernel_size=2, strides=2,
activation='relu'))
model.add(MaxPooling1D(2))
model.add(Dropout(0.2))
model = keras.Sequential()
model.add(
Convolution1D(filters=500, kernel_size=2, strides=2,
activation='relu'))
model.add(MaxPooling1D(2))
model.add(Dropout(0.2))
model = keras.Sequential()
model.add(
Convolution1D(filters=500, kernel_size=2, strides=2,
activation='relu'))
model.add(MaxPooling1D(2))
model.add(Dropout(0.2))
model.add(Flatten())
for i in range(0, 1):
model.add(Dense(256, activation="relu"))
model.add(Dropout(0.2))
model.add(Dense(2, activation="softmax"))
model.compile(loss=['categorical_crossentropy'],
optimizer=adam,
metrics=['accuracy', mil_squared_error])
print("Fit model on training data")
history = model.fit(X_train,
y_train,
batch_size=64,
epochs=150,
validation_data=(X_val, y_val),
verbose=1)
#from sklearn.metrics import f1_score
y_preds = [np.argmax(val) for val in model.predict(X_test)]
y_trues = [np.argmax(val) for val in y_test]
print(accuracy_score(y_trues, y_preds))
model.save('..//models//cnn.hdf5')
return model
def maxpool_block(X, filters, kernel_size=5, dropout=0.1, pool_size=2):
img_1 = Convolution1D(filters, kernel_size=kernel_size, activation='relu', padding='same')(X)
img_1 = Convolution1D(filters, kernel_size=kernel_size, activation='relu', padding='same')(img_1)
img_1 = Add()([X, img_1])
img_1 = Activation('relu')(img_1)
img_1 = MaxPool1D(pool_size=2)(img_1)
return img_1
def create_model(self):
# 使用model模式
main_input = Input(shape=(maxlen, ), dtype='float64')
embedder = Embedding(max_words + 1, 300, input_length=maxlen)
embed = embedder(main_input)
# 3,4,5 windows
cnn1 = Convolution1D(256,
3,
padding='same',
strides=1,
activation='relu')(embed)
cnn1 = MaxPool1D(pool_size=4)(cnn1)
cnn2 = Convolution1D(256,
4,
padding='same',
strides=1,
activation='relu')(embed)
cnn2 = MaxPool1D(pool_size=4)(cnn2)
cnn3 = Convolution1D(256,
5,
padding='same',
strides=1,
activation='relu')(embed)
cnn3 = MaxPool1D(pool_size=4)(cnn3)
# concat
cnn = concatenate([cnn1, cnn2, cnn3], axis=-1)
flat = Flatten()(cnn)
drop = Dropout(0.5)(flat)
main_output = Dense(1, activation='sigmoid')(drop)
model = Model(inputs=main_input, outputs=main_output)
model.compile(loss='binary_crossentropy',
optimizer=Adam(lr=1e-3),
metrics=['accuracy'])
return model
def create_encoder_network(self, batch_norm=True, encoding_dropout=0.2, lstm_units=320, encoding_d=256):
input_seqs = Input(shape=(None,), name="input_seqs") # (batch_number, sequence_length)
x = Embedding(input_dim=self.vocabulary_size,
output_dim=self.vocabulary_size - 1,
input_length=None, mask_zero=True, trainable=True)(
input_seqs) # (batch_number, sequence_length, 5)
x = Convolution1D(filters=320, kernel_size=26, activation='relu',
data_format="channels_last", name="lstm_conv_1")(
x) # (batch_number, sequence_length-5, 1, 192)
if batch_norm:
x = BatchNormalization(center=True, scale=True, name="conv1_batch_norm")(x)
x = MaxPooling1D(pool_size=13, padding="same")(x)
x = Dropout(encoding_dropout)(x)
x = Convolution1D(filters=192, kernel_size=6, activation='relu', name="lstm_conv_2")(x)
if batch_norm:
x = BatchNormalization(center=True, scale=True, name="conv2_batch_norm")(x)
x = MaxPooling1D(pool_size=3, padding="same")(x)
x = Dropout(encoding_dropout)(x)
x = Bidirectional(LSTM(lstm_units, return_sequences=False, return_state=False),
merge_mode='concat')(x) # (batch_number, 320+320)
x = Dropout(encoding_dropout)(x)
x = Dense(encoding_d, activation='linear', name="encoder_output")(x)
if batch_norm:
x = BatchNormalization(center=True, scale=True, name="encoder_output_normalized")(x)
return Model(input_seqs, x, name="encoder_model")
def compile(self):
self.model = Sequential()
self.model.add(
Embedding(self.max_words,
self.embedding_dims,
input_length=self.sequence_length,
weights=[self.embedding_weight_matrix],
trainable=False))
self.model.add(Dropout(0.5))
self.model.add(
Convolution1D(self.n_filters,
self.filter_size,
padding='valid',
activation='relu'))
self.model.add(MaxPooling1D())
self.model.add(
Convolution1D(self.n_filters,
self.filter_size,
padding='valid',
activation='relu'))
self.model.add(MaxPooling1D())
self.model.add(Flatten())
self.model.add(Dense(self.hidden_dims, activation='relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(self.n_classes, activation='softmax'))
self.model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
def create_cnn(num_classes: int = 2) -> tf.keras.Model:
x = Input(shape=(256, ), dtype="int64")
h = Embedding(en2vec.corpus_size + 1, 128, input_length=256)(x)
conv1 = Convolution1D(filters=256, kernel_size=10, activation="tanh")(h)
conv2 = Convolution1D(filters=256, kernel_size=7, activation="tanh")(h)
conv3 = Convolution1D(filters=256, kernel_size=5, activation="tanh")(h)
conv4 = Convolution1D(filters=256, kernel_size=3, activation="tanh")(h)
h = Concatenate()([
GlobalMaxPooling1D()(conv1),
GlobalMaxPooling1D()(conv2),
GlobalMaxPooling1D()(conv3),
GlobalMaxPooling1D()(conv4),
])
h = Dense(1024, activation="selu", kernel_initializer="lecun_normal")(h)
h = AlphaDropout(0.1)(h)
h = Dense(1024, activation="selu", kernel_initializer="lecun_normal")(h)
h = AlphaDropout(0.1)(h)
y = Dense(num_classes, activation="softmax")(h)
model = Model(x, y)
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy", AUC()])
return model
def __init__(self,
output_channels: int,
input_channels: Optional[int] = None,
kernel_size: int = 3,
pooling_size: int = 1,
batch_normalization: bool = True,
dropout_rate: float = 0.0,
l2_regularization: float = 0.0):
super().__init__()
leaky_relu = LeakyReLU(alpha=0.01)
dimension_decrease_factor = 4
if batch_normalization:
self.batch_normalization = BatchNormalization(scale=False)
self.batch_normalization1 = BatchNormalization(scale=False)
self.batch_normalization2 = BatchNormalization(scale=False)
else:
self.batch_normalization = None
if l2_regularization > 0:
l2_regularizer = L2(l2_regularization)
else:
l2_regularizer = None
self.dimension_decrease_layer = Convolution1D(
output_channels // dimension_decrease_factor,
kernel_size=1,
activation=leaky_relu,
kernel_regularizer=l2_regularizer)
self.convolutional_layer = Convolution1D(
output_channels // dimension_decrease_factor,
kernel_size=kernel_size,
activation=leaky_relu,
padding='same',
kernel_regularizer=l2_regularizer)
self.dimension_increase_layer = Convolution1D(
output_channels,
kernel_size=1,
activation=leaky_relu,
kernel_regularizer=l2_regularizer)
if pooling_size > 1:
self.pooling_layer = MaxPooling1D(pool_size=pooling_size,
padding='same')
else:
self.pooling_layer = None
if input_channels is not None and output_channels != input_channels:
if output_channels < input_channels:
raise NotImplementedError(
f'Residual blocks with less output channels than input channels is not'
f'implemented. Output channels was {output_channels} and input was'
f'{input_channels}')
self.dimension_change_permute0 = Permute((2, 1))
self.dimension_change_layer = ZeroPadding1D(
padding=(0, output_channels - input_channels))
self.dimension_change_permute1 = Permute((2, 1))
else:
self.dimension_change_layer = None
if dropout_rate > 0:
self.dropout_layer = SpatialDropout1D(rate=dropout_rate)
else:
self.dropout_layer = None
def __init__(self, num_points):
super(Conv2048, self).__init__()
self.num_points = num_points
self.conv1 = Convolution1D(64, 1, activation='relu')
self.conv2 = Convolution1D(128, 1, activation='relu')
self.conv3 = Convolution1D(1024, 1, activation='relu')
self.conv4 = Convolution1D(2048, 1, activation='relu')
self.max_pooling = MaxPooling1D(pool_size=self.num_points)
self.flatten = Flatten()
def cnn_features_model(n_timesteps, n_features, n_outputs, nb_features):
input = Input(shape=(n_timesteps, n_features))
conv_1 = Convolution1D(12,
5,
input_shape=(n_timesteps, n_features),
padding='same',
activation='relu')(input)
bat_1 = BatchNormalization()(conv_1)
# drop_1 = Dropout(0.3)(bat_1)
maxp_1 = MaxPooling1D(pool_size=2, padding='same', strides=2)(bat_1)
conv_2 = Convolution1D(12,
5,
input_shape=(n_timesteps, n_features),
padding='same',
activation='relu')(maxp_1)
bat_2 = BatchNormalization()(conv_2)
# drop_2 = Dropout(0.3)(conv_2)
maxp_2 = MaxPooling1D(pool_size=2, padding='same', strides=2)(bat_2)
conv_3 = Convolution1D(20,
5,
input_shape=(n_timesteps, n_features),
padding='same',
activation='relu')(maxp_2)
bat_3 = BatchNormalization()(conv_3)
drop_3 = Dropout(0.3)(bat_3)
maxp_3 = MaxPooling1D(pool_size=2, padding='same', strides=2)(drop_3)
conv_4 = Convolution1D(16,
5,
input_shape=(n_timesteps, n_features),
padding='same',
activation='relu')(maxp_3)
bat_4 = BatchNormalization()(conv_4)
# drop_4 = Dropout(0.3)(conv_4)
maxp_4 = MaxPooling1D(pool_size=2, padding='same', strides=2)(bat_4)
# drop = Dropout(0.3)(maxp_4)
seq_features = GlobalAveragePooling1D()(maxp_4)
other_features = Input(shape=(nb_features, ))
model = Concatenate()([seq_features, other_features])
# model.add(Flatten())
model = Dense(n_outputs,
activation='softmax',
kernel_regularizer=regularizers.l2(0.2))(model)
model = Model([input, other_features], model)
model.compile(
optimizer=Adam(lr=0.0003),
# loss='categorical_crossentropy',
# loss=focal_loss(gamma=2,alpha=1),
loss=ghm.ghm_class_loss,
metrics=['categorical_accuracy'])
return model
def __init__(self, num_points):
super(Conv64, self).__init__()
self.num_points = num_points
self.conv1 = Convolution1D(64,
1,
input_shape=(self.num_points, 3),
activation='relu')
self.conv2 = Convolution1D(64,
1,
input_shape=(self.num_points, 3),
activation='relu')
def conv_bn_relu_3_sandwich(x, filters, kernel_size):
first_x = x
for _ in range(3):
x = Convolution1D(filters, kernel_size, padding='same',
kernel_initializer=weightinit,
kernel_regularizer=l2(regularization))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
first_x = Convolution1D(filters, kernel_size=1, padding='same',
kernel_initializer=weightinit,
kernel_regularizer=l2(regularization))(x)
x = Add()([x, first_x])
return x
def get_model():
nclass = 5
inp = Input(shape=(187, 1))
img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding="valid")(inp)
img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding="valid")(img_1)
img_1 = MaxPool1D(pool_size=2)(img_1)
img_1 = Dropout(rate=0.1)(img_1)
img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")(img_1)
img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")(img_1)
img_1 = MaxPool1D(pool_size=2)(img_1)
img_1 = Dropout(rate=0.1)(img_1)
img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")(img_1)
img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")(img_1)
img_1 = MaxPool1D(pool_size=2)(img_1)
img_1 = Dropout(rate=0.1)(img_1)
img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding="valid")(img_1)
img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding="valid")(img_1)
img_1 = GlobalMaxPool1D()(img_1)
img_1 = Dropout(rate=0.2)(img_1)
dense_1 = Dense(64, activation=activations.relu, name="dense_1")(img_1)
dense_1 = Dense(64, activation=activations.relu, name="dense_2")(dense_1)
dense_1 = Dense(nclass, activation=activations.softmax, name="dense_3_mitbih")(dense_1)
model = models.Model(inputs=inp, outputs=dense_1)
opt = optimizers.Adam(0.001)
model.compile(optimizer=opt, loss=losses.sparse_categorical_crossentropy, metrics=['acc'])
#model.summary()
return model
def __init__(self, num_points):
super(FeatureTransNet, self).__init__()
self.num_points = num_points
self.conv1 = Convolution1D(64, 1, activation='relu')
self.conv2 = Convolution1D(128, 1, activation='relu')
self.conv3 = Convolution1D(1024, 1, activation='relu')
self.max_pooling = MaxPooling1D(pool_size=self.num_points)
self.dense1 = Dense(512, activation='relu')
self.dense2 = Dense(256, activation='relu')
self.dense3 = Dense(64 * 64,
weights=[
np.zeros([256, 64 * 64]),
np.eye(64).flatten().astype(np.float32)
])
def __init__(self,
output_channels: int,
input_channels: Optional[int] = None,
kernel_size: int = 3,
pooling_size: int = 1,
dropout_rate: float = 0.0):
super().__init__()
dimension_decrease_factor = 4
kernel_initializer = LecunNormal()
self.dimension_decrease_layer = Convolution1D(
output_channels // dimension_decrease_factor,
kernel_size=1,
activation=selu,
kernel_initializer=kernel_initializer)
self.convolutional_layer = Convolution1D(
output_channels // dimension_decrease_factor,
kernel_size=kernel_size,
activation=selu,
padding='same',
kernel_initializer=kernel_initializer)
self.dimension_increase_layer = Convolution1D(
output_channels,
kernel_size=1,
activation=selu,
kernel_initializer=kernel_initializer)
if pooling_size > 1:
self.pooling_layer = AveragePooling1D(pool_size=pooling_size,
padding='same')
else:
self.pooling_layer = None
if input_channels is not None and output_channels != input_channels:
if output_channels < input_channels:
raise NotImplementedError(
f'Residual blocks with less output channels than input channels is not'
f'implemented. Output channels was {output_channels} and input was'
f'{input_channels}')
self.dimension_change_permute0 = Permute((2, 1))
self.dimension_change_layer = ZeroPadding1D(
padding=(0, output_channels - input_channels))
self.dimension_change_permute1 = Permute((2, 1))
else:
self.dimension_change_layer = None
if dropout_rate > 0:
self.dropout_layer = AlphaDropout(rate=dropout_rate,
noise_shape=(50, 1,
output_channels))
else:
self.dropout_layer = None
def cnn_rnn_1_conv_1_lstm(win_len, regression=False):
forward_lstm = LSTM(units=320, return_sequences=True)
brnn = Bidirectional(forward_lstm)
# CNN
model = Sequential()
model.add(
Convolution1D(activation="relu",
input_shape=(win_len, 4),
padding="valid",
strides=1,
filters=16,
kernel_size=30))
model.add(MaxPooling1D(strides=15, pool_size=15))
model.add(Dropout(0.2))
# RNN
model.add(brnn)
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
if regression:
model.add(Dense(1, kernel_initializer='normal', activation='linear'))
else:
model.add(Dense(2, activation='softmax'))
return model
def train_model(data, model_path):
x = data['x']
y = data['y']
(x_train, x_val, y_train, y_val) = train_test_split(x, y, test_size=0.3,
random_state=SEED)
print('Building model...')
n_features = x_train.shape[2]
model = models.Sequential()
model.add(Convolution1D(64, FILTER_LENGTH, activation='relu',
input_shape=(150, 150, 3)))
model.add(MaxPooling1D(2))
model.add(layers.Convolution1D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling1D((2, 2)))
model.add(layers.Convolution1D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling1D((2, 2)))
model.add(layers.Convolution1D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling1D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dropout(0.3))
model.add(layers.Dense(1, activation='sigmoid'))
return model
def __call__(self, inputs):
if self.dilations is None:
self.dilations = [1, 2, 4, 8, 16, 32]
x = inputs
x = Convolution1D(self.nb_filters,
1,
padding=self.padding,
name=self.name + '_initial_conv')(x)
skip_connections = []
for s in range(self.nb_stacks):
for i in self.dilations:
x, skip_out = residual_block(x,
s,
i,
self.activation,
self.nb_filters,
self.kernel_size,
self.padding,
self.dropout_rate,
name=self.name)
skip_connections.append(skip_out)
if self.use_skip_connections:
x = tensorflow.keras.layers.add(skip_connections)
x = Activation('relu')(x)
if not self.return_sequences:
output_slice_index = -1
x = Lambda(lambda tt: tt[:, output_slice_index, :])(x)
return x
def dilated_tcn(num_feat, num_classes, nb_filters,
kernel_size, dilations, nb_stacks, max_len,
activation='norm_relu', use_skip_connections=True,
return_param_str=False, output_slice_index=None,
regression=False, lr=0.00007):
"""
dilation_depth : number of layers per stack
nb_stacks : number of stacks.
"""
input_layer = Input(name='input_layer', shape=(max_len, num_feat))
x = input_layer
x = Convolution1D(nb_filters, kernel_size, padding='causal', name='initial_conv')(x)
skip_connections = []
for s in range(nb_stacks):
for i in dilations:
x, skip_out = residual_block(x, s, i, activation, nb_filters, kernel_size)
skip_connections.append(skip_out)
if use_skip_connections:
x = keras.layers.add(skip_connections)
x = Activation('relu')(x)
if output_slice_index is not None: # can test with 0 or -1.
if output_slice_index == 'last':
output_slice_index = -1
if output_slice_index == 'first':
output_slice_index = 0
x = Lambda(lambda tt: tt[:, output_slice_index, :])(x)
print('x.shape=', x.shape)
if not regression:
# classification
x = Dense(num_classes)(x)
x = Activation('softmax', name='output_softmax')(x)
output_layer = x
print(f'model.x = {input_layer.shape}')
print(f'model.y = {output_layer.shape}')
model = Model(input_layer, output_layer)
adam = optimizers.Adam(lr=lr, clipnorm=1.)
model.compile(adam, loss='sparse_categorical_crossentropy', metrics=['accuracy'])
print('Adam with norm clipping.')
else:
# regression
x = Dense(1)(x)
x = Activation('linear', name='output_dense')(x)
output_layer = x
print(f'model.x = {input_layer.shape}')
print(f'model.y = {output_layer.shape}')
model = Model(input_layer, output_layer)
adam = optimizers.Adam(lr=lr, clipnorm=1.)
model.compile(adam, loss='mean_squared_error', metrics=['mae','acc'])
if return_param_str:
param_str = 'D-TCN_C{}_B{}_L{}'.format(2, nb_stacks, dilations)
return model, param_str
else:
return model
def build_simple_model(x_train):
print('Building simple model...')
n_features = x_train.shape[2]
input_shape = (None, n_features)
model_input = Input(input_shape, name='input')
layer = model_input
layer = Convolution1D(filters=CONV_FILTER_COUNT, kernel_size=FILTER_LENGTH, name='convolution_1')(layer)
layer = Dense(256, activation='relu')(layer)
layer = Dropout(0.5)(layer)
layer = Dense(len(GENRES))(layer)
merge_layer = Lambda(function=lambda x: K.mean(x, axis=1), output_shape=lambda shape: (shape[0],) + shape[2:],
name='output_merged')
layer = merge_layer(layer)
layer = Activation('softmax', name='output_realtime')(layer)
model_output = layer
model = Model(model_input, model_output)
opt = Adam(lr=0.001)
model.compile(
loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy']
)
print(model.summary())
return model
def build_model(x_train):
print('Building model...')
n_features = x_train.shape[2]
input_shape = (None, n_features)
model_input = Input(input_shape, name='input')
layer = model_input
for i in range(N_LAYERS):
layer = Convolution1D(filters=CONV_FILTER_COUNT, kernel_size=FILTER_LENGTH,
name='convolution_' + str(i + 1))(layer)
layer = BatchNormalization(momentum=0.9)(layer)
layer = Activation('relu')(layer)
layer = MaxPooling1D(2)(layer)
layer = Dropout(0.5)(layer)
layer = Dense(len(GENRES))(layer)
time_distributed_merge_layer = Lambda(
function=lambda x: K.mean(x, axis=1),
output_shape=lambda shape: (shape[0],) + shape[2:],
name='output_merged'
)
layer = time_distributed_merge_layer(layer)
layer = Activation('softmax', name='output_realtime')(layer)
model_output = layer
model = Model(model_input, model_output)
opt = Adam(lr=0.001)
model.compile(
loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy']
)
print(model.summary())
return model
def build_model(cls, n_features):
n_labels = len(cls.label_names)
print('Building model...')
input_shape = (None, n_features)
model_input = Input(input_shape, name='input')
layer = model_input
for i in range(N_LAYERS):
layer = Convolution1D(filters=CONV_FILTER_COUNT,
kernel_size=FILTER_LENGTH,
name='convolution_' + str(i + 1))(layer)
layer = BatchNormalization(momentum=0.9)(layer)
layer = Activation('relu')(layer)
layer = MaxPooling1D(2)(layer)
layer = Dropout(0.5)(layer)
layer = TimeDistributed(Dense(n_labels))(layer)
time_distributed_merge_layer = Lambda(
function=lambda x: K.mean(x, axis=1),
output_shape=lambda shape: (shape[0], ) + shape[2:],
name='output_merged')
layer = time_distributed_merge_layer(layer)
layer = Activation('softmax', name='output_realtime')(layer)
model_output = layer
model = Model(model_input, model_output)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(learning_rate=0.001),
metrics=[
'accuracy',
TopKCategoricalAccuracy(3, name='top3-accuracy')
])
model.summary()
return model
def build(self):
conv_layers = [[256, 10], [256, 7], [256, 5], [256, 3]]
fully_connected_layers = [1024, 1024]
input = Input(shape=(self.max_sequence_len, ),
dtype='int32',
name='input')
embedded_sequence = self.embedding_layer(input)
convolution_output = []
for num_filters, filter_width in conv_layers:
conv = Convolution1D(filters=num_filters,
kernel_size=filter_width,
activation='tanh',
name='Conv1D_{}_{}'.format(
num_filters,
filter_width))(embedded_sequence)
pool = GlobalMaxPooling1D(name='MaxPoolingOverTime_{}_{}'.format(
num_filters, filter_width))(conv)
convolution_output.append(pool)
x = Concatenate()(convolution_output)
for fl in fully_connected_layers:
x = Dense(fl, activation='selu',
kernel_initializer='lecun_normal')(x)
x = AlphaDropout(0.5)(x)
output = Dense(self.class_len, activation='sigmoid')(x)
model = Model(inputs=input, outputs=output)
return model
def testOutput(self):
with self.assertRaises(ValueError) as cm:
self.classifier.add(Convolution1D(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(Convolution2D(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(Convolution3D(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(Conv2DTranspose(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(Conv3DTranspose(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(SeparableConv1D(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(SeparableConv2D(64,0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
with self.assertRaises(ValueError) as cm:
self.classifier.add(DepthwiseConv2D(0,padding="same",input_shape=(32,32,1),activation='relu'))
print(cm.expected)
def fit(self, train_x, train_y):
# It seems hard to pass the tokenizer to the model here to calculate the vocab_size
# Therefore directly build the vectorization inside model
max_features = 20000
maxlen = 50
self.tokenizer = tokenizer = Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(train_x))
list_tokenized_train = tokenizer.texts_to_sequences(train_x)
vectorized_train_x = pad_sequences(list_tokenized_train,
maxlen=maxlen,
padding='post')
vocab_size = len(tokenizer.word_index)
for idx, cls in enumerate(self.classes):
print("Building Model")
model = tf.keras.models.Sequential()
model.add(Embedding(vocab_size + 1, 100, input_length=50))
model.add(Convolution1D(256, 5, padding='same'))
model.add(MaxPooling1D(3, 3, padding='same'))
model.add(Convolution1D(128, 5, padding='same'))
model.add(MaxPooling1D(3, 3, padding='same'))
model.add(Convolution1D(64, 3, padding='same'))
model.add(Flatten())
model.add(Dropout(0.1))
model.add(BatchNormalization())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(2, activation='softmax'))
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
self.models[cls] = model
class_labels = train_y[:, idx]
# This is recommended by one of the error returned.
class_labels_binarized_the_way_keras_wants = to_categorical(
class_labels)
print("fitting model")
self.models[cls].fit(vectorized_train_x,
class_labels_binarized_the_way_keras_wants,
epochs=5,
batch_size=800)
print("done fitting")
def cnn_1_conv_2_fcc(win_len, regression=False):
# ================= Heuristic-based efficient architectures (win_len=3000) =================
# - conv: Conv1D
# - mp: MaxPooling1D
# - dp: Dropout
# >>> conv[32@50]_mp[5@15]_fcc[128]
# CNN
model = Sequential()
model.add(
Convolution1D(activation="relu",
input_shape=(win_len, 4),
padding="valid",
strides=1,
filters=32,
kernel_size=50)) #starting default: 30, 60 (ok)
model.add(MaxPooling1D(strides=5, pool_size=50))
model.add(
Convolution1D(activation="relu",
input_shape=(win_len, 4),
padding="valid",
strides=1,
filters=64,
kernel_size=50)) #starting default: 30, 60 (ok)
model.add(MaxPooling1D(strides=5, pool_size=50))
#model.add(Convolution1D(activation="relu",
# input_shape=(win_len, 4),
# padding="valid", strides=1,
# filters=32, kernel_size=40)) #starting default: 30, 60 (ok)
#model.add(MaxPooling1D(strides=5, pool_size=40))
# FCC
model.add(Flatten())
model.add(Dense(256, activation='relu'))
#model.add(Dense(128, activation='relu'))
#model.add(Dropout(0.2))
if regression:
model.add(Dense(1, kernel_initializer='normal', activation='linear'))
else:
model.add(Dense(2, activation='softmax'))
return model
def f(input_):
residual = input_
tanh_out = Convolution1D(n_atrous_filters,
atrous_filter_size,
dilation_rate=atrous_rate,
padding='same',
activation='tanh')(input_)
sigmoid_out = Convolution1D(n_atrous_filters,
atrous_filter_size,
dilation_rate=atrous_rate,
padding='same',
activation='sigmoid')(input_)
merged = Multiply()([tanh_out, sigmoid_out])
skip_out = Convolution1D(1, 1, activation='relu',
padding='same')(merged)
out = Add()([skip_out, residual])
return out, skip_out
def identity_block(X, filters, kernel_size=5, dropout=0.1, pool_size=2):
img_1 = Convolution1D(filters,
kernel_size=kernel_size,
activation='relu',
padding='same')(X)
img_1 = Convolution1D(filters,
kernel_size=kernel_size,
activation='relu',
padding='same')(img_1)
img_1 = Convolution1D(filters,
kernel_size=kernel_size,
activation='relu',
padding='same')(img_1)
img_1 = Add()([X, img_1])
img_1 = Activation('relu')(img_1)
img_1 = Dropout(rate=dropout)(img_1)
return img_1