def basic_lstm_l1_act(batch_size=8, n_features=1, n_stations=21, seq_len_train=7 * 24,
seq_len_pred=6, n_features_pred=1):
"""
Creates a training with lstm. Inspired by the network of meijer. We input the hourly temperature for
7 days and we predict the mean temperature at day and at night for the following 7 days.
:param batch_size: Size of one batch
:param n_features: Number of features per station
:param n_stations: Number of stations
:param seq_len_pred: Sequence length to predict
:return: training
"""
seq_len_train = 7 * 24
seq_len_pred = 6
input = Input(shape=(seq_len_train, n_features * n_stations),
batch_shape=(batch_size, seq_len_train, n_features * n_stations))
# We have two dense units to preprocess the input. We use 7 units as the idea is that the network abstracts
# from the high resolution to a per day representation.
dense1 = Dense(units=14, activation="elu", activity_regularizer=regularizers.l1(0.01))(input)
dense2 = Dense(units=14, activation="elu", activity_regularizer=regularizers.l1(0.01))(dense1)
# Lstm keeps track of time dependencies
lstm = LSTM(units=1, batch_input_shape=(batch_size, seq_len_train, n_stations * n_features))(dense2)
dense3 = Dense(units=6, activation="tanh", activity_regularizer=regularizers.l1(0.01))(lstm)
out = Dense(units=seq_len_pred, activation="linear")(dense3)
model = Model(input, out)
return model
def encoder(self, data, encoding_dim=2):
inputs = Input(shape=(data[0].shape))
encoded = Dense(30,
activation='sigmoid',
activity_regularizer=regularizers.l1(10e-5))(inputs)
encoded = Dense(10,
activation='sigmoid',
activity_regularizer=regularizers.l1(10e-5))(encoded)
encoded = Dense(encoding_dim,
activation='sigmoid',
activity_regularizer=regularizers.l1(10e-5))(encoded)
model = Model(inputs, encoded)
return model
def train(self, sentences_vector: SentencesVector):
inputer = sentences_vector.inputer
config = inputer.config
sequence_input = Input(shape=(config.MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name="sequence_input") # 100*1最多100个词组成输入
embedded_sequences = inputer.getWordEmbedding()(
sequence_input) # 句子转为向量矩阵 训练集大小*100*64维
# model test2
posi_input = Input(shape=(config.MAX_SEQUENCE_LENGTH,
sentences_vector.position_vec.shape[2]),
name="posi_input")
pos_input = Input(shape=(config.MAX_SEQUENCE_LENGTH,
sentences_vector.pos_vec.shape[2]),
name="pos_input")
embedded_sequences = keras.layers.concatenate(
[embedded_sequences, posi_input, pos_input])
c1 = LSTM(100, input_dtype=[100, 182])(embedded_sequences)
preds = Dense(len(inputer.types),
activation='softmax',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.001))(
c1) # softmax分类
model = Model(inputs=[sequence_input, posi_input, pos_input],
outputs=preds)
print(model.summary())
adam = optimizers.Adam(lr=0.001, decay=0.0001)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=["categorical_accuracy"])
# 如果希望短一些时间可以，epochs调小
# ModelCheckpoint回调函数将在每个epoch后保存模型到filepath，当save_best_only=True保存验证集误差最小的参数
checkpoint = ModelCheckpoint(config.model_file_path,
monitor='val_loss',
verbose=1,
mode='min')
# 当监测值不再改善时，该回调函数将中止训练
early = EarlyStopping(monitor="categorical_accuracy",
mode="min",
patience=50)
metrics = Metrics(sentences_vector)
# 开始训练
callbacks_list = [checkpoint, early, metrics] # early
# And trained it via:
model.fit(
{
'sequence_input': sentences_vector.sentence_vec,
'posi_input': sentences_vector.position_vec,
'pos_input': sentences_vector.pos_vec
},
sentences_vector.classifications_vec,
batch_size=sentences_vector.sentence_vec.shape[1],
epochs=100,
# validation_split=0.2,
# validation_data=({'sequence_input': x_test, 'posi_input': x_test_posi}, y_test),
callbacks=callbacks_list)
return model
def fit(self, X):
model = Sequential()
if self.constraint == 'L1':
model.add(
Dense(self.n_hidden,
input_shape=(X.shape[1], ),
activation='sigmoid',
name='encode',
activity_regularizer=regularizers.l1(1e-6)))
elif self.constraint == 'L2':
model.add(
Dense(self.n_hidden,
input_shape=(X.shape[1], ),
activation='sigmoid',
name='encode',
activity_regularizer=regularizers.l2(1e-6)))
else:
model.add(
Dense(self.n_hidden,
input_shape=(X.shape[1], ),
activation='sigmoid',
name='encode'))
model.add(Dense(X.shape[1], activation='sigmoid'))
sgd = SGD(lr=self.learn_rate)
model.compile(optimizer=sgd, loss='mse', metrics=['accuracy'])
model.fit(X, X, batch_size=32, epochs=self.max_iter, verbose=0)
self.model = model
return self
def get_model(self):
model = Sequential()
#input layer
model.add(
CuDNNGRU(
input_shape=(int(cfg.DEMAND_SEQUENCE_LENGTH /
cfg.DEMAND_SAMPLING_RATE),
cfg.DEMAND_DATAPOINTS_PER_TS),
units=cfg.DEMAND_DATAPOINTS_PER_TS,
kernel_regularizer=regularizers.l1(0.01),
return_sequences=True,
))
model.add(CuDNNGRU(units=200, return_sequences=True))
model.add(Dropout(0.2))
model.add(CuDNNGRU(units=100))
model.add(Dropout(0.2))
model.add(Dense(units=100))
model.add(Dense(units=1))
model.add(Activation('linear'))
start = time.time()
optimizr = rmsprop(lr=0.01)
model.compile(loss='mae', optimizer=optimizr)
log.info('compilation time : {}'.format(time.time() - start))
return model
def tr_net_b3(input_shape_speed,
word_to_vec_map_speed,
word_to_index_speed,
input_shape_bearing,
word_to_vec_map_bearing,
word_to_index_bearing,
no_classes=11):
speed = Input(shape=input_shape_speed, dtype=np.int32)
embedding_layer = pre_trained_embedding_layer(word_to_vec_map_speed,
word_to_index_speed)
embeddings = embedding_layer(speed)
X = Bidirectional(LSTM(128, return_sequences=True))(embeddings)
X = Dropout(0.5)(X)
X = Bidirectional(LSTM(128))(X)
X = Dropout(0.5)(X)
X = Dense(32,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(X)
X = Dropout(0.5)(X)
X = Dense(16,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(X)
bearing = Input(shape=input_shape_bearing, dtype=np.int32)
embedding_layer_bearing = pre_trained_embedding_layer(
word_to_vec_map_bearing, word_to_index_bearing)
embeddings_bearing = embedding_layer_bearing(bearing)
B = Bidirectional(LSTM(128, return_sequences=True))(embeddings_bearing)
B = Dropout(0.5)(B)
B = Bidirectional(LSTM(128))(B)
B = Dropout(0.5)(B)
B = Dense(32,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(B)
B = Dropout(0.5)(B)
B = Dense(16,
kernel_regularizer=regularizers.l2(0.001),
activity_regularizer=regularizers.l1(0.001))(B)
X = Concatenate()([X, B])
X = Dense(no_classes)(X)
X = Activation('softmax')(X)
model = Model(inputs=[speed, bearing], outputs=X)
return model
def train(sentences_vector: SentencesVector):
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name="sequence_input") # 100*1最多100个词组成输入
embedded_sequences = embedding_layer(
sequence_input) # 句子转为向量矩阵 训练集大小*100*64维
# model test2
posi_input = Input(shape=(MAX_SEQUENCE_LENGTH, 40), name="posi_input")
pos_input = Input(shape=(MAX_SEQUENCE_LENGTH, len(all_pos_list)),
name="pos_input")
embedded_sequences = keras.layers.concatenate(
[embedded_sequences, posi_input, pos_input])
# conv1d_1s = MultiConv1D(filters=[90, 80, 70, 50, 30, 10], kernel_size=[3, 4, 5], activation='relu')
c1 = LSTM(100, input_dtype=[100, 182])(embedded_sequences)
# c1 = MaxPooling1D(pool_size=3)(c1)
# c1 = Dropout(rate=0.7)(c1)
# c1 = Flatten()(c1)
# c1 = Dense(128, activation='relu')(c1) # 128全连接
# c1 = Dense(64, activation='relu')(c1) # 64全连接
preds = Dense(len(types),
activation='softmax',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.001))(c1) # softmax分类
model = Model(inputs=[sequence_input, posi_input, pos_input],
outputs=preds)
print(model.summary())
adam = optimizers.Adam(lr=0.001, decay=0.0001)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=["accuracy"])
# 如果希望短一些时间可以，epochs调小
# ModelCheckpoint回调函数将在每个epoch后保存模型到filepath，当save_best_only=True保存验证集误差最小的参数
checkpoint = ModelCheckpoint(model_path,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
# 当监测值不再改善时，该回调函数将中止训练
early = EarlyStopping(monitor="val_loss", mode="min", patience=50)
# 开始训练
callbacks_list = [checkpoint, early] # early
# And trained it via:
model.fit(
{
'sequence_input': sentences_vector.sentence_vec,
'posi_input': sentences_vector.position_vec,
'pos_input': sentences_vector.pos_vec
},
sentences_vector.classifications_vec,
batch_size=128,
epochs=500,
# validation_split=0.2,
# validation_data=({'sequence_input': x_test, 'posi_input': x_test_posi}, y_test),
callbacks=callbacks_list)
return model
def reg_model():
model = Sequential()
model.add(
Dense(64,
kernel_initializer='normal',
kernel_regularizer=regularizers.l1(0.001),
input_shape=STATE_SHAPE,
activation="relu"))
model.add(
Dense(256,
kernel_initializer='normal',
kernel_regularizer=regularizers.l1(0.001),
input_shape=STATE_SHAPE,
activation="relu"))
model.add(Dense(1))
model.compile(loss='mean_absolute_error',
optimizer=Adam(lr=LEARNING_RATE),
metrics=['mae'])
return model
def __autoencoder(size, encoded_size, l1, activation, dropout_rate,
use_batch_norm, coefficients):
# TODO activation fns: relu, elu, selu (AlphaDropout instead of dropout for selu)
# TODO dropout rate: 0 (no dropout), 0.1, 0.2, 0.3
# TODO batch norm: YES/NO
# TODO l1: 0 (no regularization), 1e-7, 1e-6
# TODO optimizers: rmsprop, adam, nadam
# TODO coefficients: [4, 8, 12], [4, 8], [2, 4] etc.
input_layer = Input(shape=(size, ), name='input_conformation')
x = input_layer
for i, c in enumerate(coefficients):
idx = i + 1
x = Dense(size // c, activation=activation, name="enc_%d" % idx)(x)
if use_batch_norm:
x = BatchNormalization(name="enc_%d_batch_norm" % idx)(x)
if dropout_rate > 0:
if activation == 'selu':
x = AlphaDropout(dropout_rate,
name="enc_%d_dropout" % idx)(x)
else:
x = Dropout(dropout_rate, name="enc_%d_dropout" % idx)(x)
x = Dense(encoded_size,
activation="linear",
name="encoded",
activity_regularizer=regularizers.l1(l1))(x)
for i, c in enumerate(reversed(coefficients)):
idx = len(coefficients) - i
x = Dense(size // c, activation=activation, name="dec_%d" % idx)(x)
if use_batch_norm:
x = BatchNormalization(name="dec_%d_batch_norm" % idx)(x)
if dropout_rate > 0:
if activation == 'selu':
x = AlphaDropout(dropout_rate,
name="dec_%d_dropout" % idx)(x)
else:
x = Dropout(dropout_rate, name="dec_%d_dropout" % idx)(x)
decoded = Dense(size, activation="linear",
name="decoded_conformation")(x)
autoencoder = Model(input_layer, decoded)
autoencoder.compile(optimizer=Adam(lr=0.001),
loss='mse',
metrics=['mae'])
autoencoder.summary()
return autoencoder
def buildModel(self,
seqLength=100,
embeddingDim=300,
postionShape2=20,
types=19,
filters=150,
kernel_size=3):
sequence_input = Input(shape=(seqLength, embeddingDim),
dtype='float32',
name="sequence_input") # 100*1最多100个词组成输入
# embedded_sequences = inputer.getWordEmbedding()(sequence_input) # 句子转为向量矩阵 训练集大小*100*300维
# model test2
posi_input = Input(shape=(seqLength, postionShape2), name="posi_input")
typeInput = Input(shape=(types, ), name="typeInput")
# 假设输入embedded_sequeces中一个单词的向量长度为d，假设句长为s，关系种类的向量长度为r
embedded_sequences = keras.layers.concatenate(
[sequence_input, posi_input])
embedded_sequences = Dropout(0.5)(embedded_sequences)
# 下面的部分就是输入部分应用attention,这里不清楚三个矩阵相乘怎么写，主要是bias的问题
# 在这里加bias应该是一样的，因为后面乘R的时候，R都是one-hot的，所以bias只不过多训练了几个参数，关键位置应该是一样的
# 这是probs输出的维度应该是s * r
probs = Dense(types, use_bias=True)(embedded_sequences)
# 这里是probs的每一项与当前句子的关系做点积，输出维度是 s * 1
probsWithRela = Dot(axes=[2, 1])([probs, typeInput])
# 对输出的probs归一化，此时输出的维度仍然是s * 1
probs_softmax = Activation(activation="softmax")(probsWithRela)
input_permute = Permute((2, 1))(embedded_sequences)
# 将probs拷贝d份，每一份与维度倒置的输入相乘，相当于倒置的输入乘了一个对角矩阵，输出维度是d*s
probs_repeated = RepeatVector(embeddingDim +
postionShape2)(probs_softmax)
realInput = keras.layers.Multiply()([input_permute, probs_repeated])
# 将上面的输出倒置过来，维度变成s * d,再传入卷积层
realInput = Permute((2, 1))(realInput)
input_attention = Dropout(0.5)(realInput)
# 这时输出应该是(s - kernel_size) * filters，这时候每个kernal中w的维度是 kernal_size * d
c1 = Conv1D(filters, kernel_size, use_bias=True,
activation='tanh')(input_attention)
# 这时输出的维度应该只是一个一维的filters
c1 = MaxPooling1D(pool_size=seqLength - kernel_size)(c1)
c1 = Permute((2, 1))(c1)
c1 = Reshape((filters, ))(c1)
preds = Dense(types,
activation='softmax',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.001))(
c1) # softmax分类
model = Model(inputs=[sequence_input, posi_input, typeInput],
outputs=preds)
print(model.summary())
return model
def leNet_cnn_l1reg(l1reg, type):
model = Sequential()
if type == 'cifar10':
model.add(
Conv2D(6, (5, 5),
activation='relu',
input_shape=(32, 32, 3),
kernel_regularizer=regularizers.l1(l1reg)))
else:
model.add(
Conv2D(6, (5, 5),
activation='relu',
input_shape=(32, 32, 1),
kernel_regularizer=regularizers.l1(l1reg)))
model.add(AveragePooling2D())
model.add(
Conv2D(16, (5, 5),
activation='relu',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(AveragePooling2D())
model.add(Flatten())
model.add(
Dense(units=120,
activation='relu',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(
Dense(units=84,
activation='relu',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(Dense(units=10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def create_base_network(input_shape):
'''Base network to be shared (eq. to feature extraction).
'''
input = Input(shape=input_shape)
#
x = LSTM(64,
activation='softsign',
dropout=0.001,
recurrent_dropout=0.001,
stateful=False,
return_sequences=True)(
input) #stateful=True,可以使得帧组之间产生关联。 记得要在fit时候，shuffle=True。
x = LSTM(64,
activation='softsign',
dropout=0.001,
recurrent_dropout=0.001,
stateful=False,
return_sequences=False)(
x) #stateful=True,可以使得帧组之间产生关联。 记得要在fit时候，shuffle=True。
x = Dense(64,
activation='relu',
activity_regularizer=regularizers.l1(1e-7))(x)
x = Dropout(0.4)(x)
x = Dense(64,
activation='relu',
activity_regularizer=regularizers.l1(1e-7))(x)
x = Dropout(0.4)(x)
x = Dense(64,
activation='relu',
activity_regularizer=regularizers.l1(1e-7))(x)
x = Dropout(0.4)(x)
#x = Flatten()(x)
return Model(input, x)
def tr_net_r(input_shape, word_to_vec_map, word_to_index, no_classes=11):
sentence_indices = Input(shape=input_shape, dtype=np.int32)
embedding_layer = pre_trained_embedding_layer(word_to_vec_map,
word_to_index)
embeddings = embedding_layer(sentence_indices)
X = Bidirectional(LSTM(128, return_sequences=True))(embeddings)
X = Dropout(0.5)(X)
X = Bidirectional(LSTM(256))(X)
X = Dropout(0.5)(X)
X = Dense(no_classes,
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.01))(X)
X = Activation('softmax')(X)
model = Model(sentence_indices, X)
return model
def train(x_train):
# input placeholder
input_image = Input(shape=(ENCODING_DIM_INPUT, ))
# encoding layer
# *****this code is changed compared with Autoencoder, adding the activity_regularizer to make the input sparse.
encode_layer1 = Dense(
ENCODING_DIM_LAYER1,
activation='relu',
activity_regularizer=regularizers.l1(10e-6))(input_image)
# ******************************
encode_layer2 = Dense(ENCODING_DIM_LAYER2,
activation='relu')(encode_layer1)
encode_layer3 = Dense(ENCODING_DIM_LAYER3,
activation='relu')(encode_layer2)
encode_output = Dense(ENCODING_DIM_OUTPUT)(encode_layer3)
# decoding layer
decode_layer1 = Dense(ENCODING_DIM_LAYER3,
activation='relu')(encode_output)
decode_layer2 = Dense(ENCODING_DIM_LAYER2,
activation='relu')(decode_layer1)
decode_layer3 = Dense(ENCODING_DIM_LAYER1,
activation='relu')(decode_layer2)
decode_output = Dense(ENCODING_DIM_INPUT, activation='tanh')(decode_layer3)
# build autoencoder, encoder
autoencoder = Model(inputs=input_image, outputs=decode_output)
encoder = Model(inputs=input_image, outputs=encode_output)
# compile autoencoder
autoencoder.compile(optimizer='adam', loss='mse')
# training
autoencoder.fit(x_train,
x_train,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
shuffle=True)
return encoder, autoencoder
def mini_VGG_l1reg(l1reg, type):
model = Sequential()
if type == 'cifar10':
model.add(
Conv2D(32, (3, 3),
activation='relu',
padding='same',
input_shape=(32, 32, 3),
kernel_regularizer=regularizers.l1(l1reg)))
else: # MNIST
model.add(
Conv2D(32, (3, 3),
activation='relu',
padding='same',
input_shape=(32, 32, 1),
kernel_regularizer=regularizers.l1(l1reg)))
model.add(
Conv2D(32, (3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(MaxPooling2D((2, 2)))
model.add(
Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(
Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(MaxPooling2D((2, 2)))
model.add(
Conv2D(128, (3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(
Conv2D(128, (3, 3),
activation='relu',
padding='same',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(
Dense(512,
activation='relu',
kernel_initializer='he_uniform',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(
Dense(200,
activation='relu',
kernel_initializer='he_uniform',
kernel_regularizer=regularizers.l1(l1reg)))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def main():
sequence_count = 10
image_count = 5
input_count = 4 # 4 input image; 0: Grey, 1: GT, 2: MOG, 3: Optical flow
height = 160
width = 240
kernelshape = 7 # 5x5 kernel size
teach_size = 30000
test_size = 8000
training_data_kernels = get_kernel_data(sequence_count, image_count,
kernelshape, input_count, height,
width)
network_input = training_data_kernels[:, (0, 2, 3), :, :]
network_label = training_data_kernels[:, 1,
int(kernelshape / 2) + 1,
int(kernelshape / 2) + 1]
#------------------
# keras
#------------------
input_img = Input(shape=(3, kernelshape, kernelshape))
input1 = Reshape((kernelshape, kernelshape, 3))(input_img)
layer1 = keras.layers.Conv2D(20, 3)(input1)
layer2 = keras.layers.Conv2D(20, 3)(layer1)
layer3 = Flatten()(layer2)
layer4 = Dense(10,
activation="relu",
activity_regularizer=regularizers.l2(10e-5))(layer3)
layer5 = Dense(1,
activation="sigmoid",
activity_regularizer=regularizers.l1(10e-5))(layer4)
autoencoder = Model(input_img, layer5)
#build
autoencoder.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
x_train = network_input[:teach_size].astype('float32') / 255.
x_label = network_label[:teach_size].astype('float32') / 255.
x_test = network_input[teach_size:teach_size +
test_size].astype('float32') / 255.
x_test_label = network_label[teach_size:teach_size +
test_size].astype('float32') / 255.
history = autoencoder.fit(x_train,
x_label,
epochs=5,
batch_size=500,
shuffle=True,
validation_data=(x_test, x_test_label))
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()), 1])
plt.title('Training and Validation Accuracy')
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([0, max(plt.ylim())])
plt.title('Training and Validation Loss')
plt.show()
# ------------------
# keras - end
# ------------------
check_result_data = np.zeros(
(10, 10, input_count, height, width)).astype(np.uint8)
check_result_data[:, :, :2, :, :] = get_data(10, 10, height, width)
for seqi in check_result_data:
fn_mog = cv.bgsegm.createBackgroundSubtractorMOG()
i = 0
for imi in seqi:
if i < 2:
imi[2] = imi[0]
imi[3] = imi[0]
# flow = cv.calcOpticalFlowFarneback(im[0], im[0], None, 0.5, 3, 15, 3, 5, 1.2, 0)
else:
imi[2] = seqi[(i - 1), 0]
imi[3] = seqi[(i - 2), 0]
i = i + 1
result_im = np.zeros((height, width))
kernel_i = int(kernelshape / 2)
for k in range(kernel_i, height - kernel_i):
for j in range(kernel_i, width - kernel_i):
pred_im = np.array([
imi[(0, 2, 3), (k - kernel_i):(k + kernel_i + 1),
(j - kernel_i):(j + kernel_i + 1)]
])
result_im[k, j] = autoencoder.predict(pred_im)
print(np.max(result_im))
print(np.sum(result_im))
res_im = cv.normalize(result_im, None, 0, 255, cv.NORM_MINMAX)
cv.imshow("NN 0", res_im.astype(np.uint8))
cv.imshow("im1", imi[0])
cv.imshow("im2", imi[2])
cv.imshow("im3", imi[3])
cv.imshow("gt", imi[1])
cv.waitKey()
def train():
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH, ),
dtype='int32',
name="sequence_input") # 100*1最多100个词组成输入
embedded_sequences = embedding_layer(
sequence_input) # 句子转为向量矩阵 训练集大小*100*300维
# model test2
posi_input = Input(shape=(MAX_SEQUENCE_LENGTH, 40), name="posi_input")
embedded_sequences = keras.layers.concatenate(
[embedded_sequences, posi_input])
conv1d_1s = MultiConv1D(filters=[90, 80, 70, 50, 30, 10],
kernel_size=[3, 4, 5],
activation='relu')
best_model = None
count = 0
for conv1d in conv1d_1s:
c1 = conv1d(embedded_sequences)
c1 = MaxPooling1D(pool_size=3)(c1)
c1 = Dropout(rate=0.7)(c1)
c1 = Flatten()(c1)
# c1 = Dense(128, activation='relu')(c1) # 128全连接
# c1 = Dense(64, activation='relu')(c1) # 64全连接
preds = Dense(len(types),
activation='softmax',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.001))(
c1) # softmax分类
model = Model(inputs=[sequence_input, posi_input], outputs=preds)
print(model.summary())
adam = optimizers.Adam(lr=0.001, decay=0.0001)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=["categorical_accuracy"])
# 如果希望短一些时间可以，epochs调小
# ModelCheckpoint回调函数将在每个epoch后保存模型到filepath，当save_best_only=True保存验证集误差最小的参数
file_path = "../data/model/weights_base.temp" + str(count) + ".hdf5"
checkpoint = ModelCheckpoint(file_path,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
# 当监测值不再改善时，该回调函数将中止训练
early = EarlyStopping(monitor="val_loss", mode="min", patience=50)
# 开始训练
callbacks_list = [checkpoint, early] # early
x_train, x_train_posi, y_train = get_xy("../data/train.txt")
# And trained it via:
model.fit(
{
'sequence_input': x_train,
'posi_input': x_train_posi
},
y_train,
batch_size=128,
epochs=500,
validation_split=0.2,
# validation_data=({'sequence_input': x_test, 'posi_input': x_test_posi}, y_test),
callbacks=callbacks_list)
print(model)
count += 1
best_model = model
return best_model
def action(): #此函数是控制整个采样，训练， 匹配测试的过程。
global filename, total_EEG_number_for_test
global step, directly_load_model_flag, openfile_name, directly_load_filename, time_steps, directly_load_EEG_flag
filename = ui.lineEdit.text() #写入文件名
time_steps = 1
if step == 3: # 匹配测试
disable_Gui()
ui.lcdNumber.display('---')
QApplication.processEvents()
ui.label.setText("匹配测试中...")
ui.pushButton.setText("匹配测试中...")
if directly_load_model_flag == False:
#autoencoder=load_model(filename+'_key.h5')
encoder = load_model(filename + '_key.h5')
print("使用的是刚才训练好的模型:", filename)
if directly_load_model_flag == True:
directly_load_EEG_flag = False
#autoencoder=load_model(directly_load_filename)
encoder = load_model(directly_load_filename)
print("使用的是直接读取的已经训练好的模型:", directly_load_filename)
#############################设置初始偏差值 开始##############################################
if directly_load_EEG_flag == True:
f = open(directly_load_filename, 'r') #读取代训练的EEG数据
print("使用的是预先录取好的EEG文件:", directly_load_filename)
if directly_load_EEG_flag == False:
f = open(filename + 'EEG.txt', 'r') #读取代训练的EEG数据
print("使用的是刚才录取的EEG文件:", filename)
All_EEG_data_lines = f.readlines(
) #################BUG##############################
EEG_data_original = np.zeros(
[total_EEG_number_for_test, total_EEG_Features])
final_score = 0
max_score = 0
original_test_result = np.zeros(
int(total_EEG_data_number / total_EEG_number_for_test))
original_test_result_array = np.zeros(
[total_EEG_number_for_test, encoding_dim])
for times in range(
int(total_EEG_data_number /
total_EEG_number_for_test)): #0,1,2,3....
for k in range(total_EEG_number_for_test):
EEG_data_one_line = (
All_EEG_data_lines[k + times *
total_EEG_number_for_test].split('A')
) ####按照字符"A"来截断每一条EEG数据，分割成24小份
for i in range(total_EEG_Features):
if len(
EEG_data_one_line
) == total_EEG_Features + 1: #这个判断是为了避免有时候读取EEG时候，遇到换行符丢失的现象。
EEG_data_original[k][i] = float(EEG_data_one_line[i])
else:
EEG_data_original[k][i] = EEG_data_original[k - 1][i]
print("发现一处错行！！")
f.close()
EEG_data_original = EEG_data_original.astype(
'float32') / normal_number # minmax_normalized
# EEG_data_original -=EEG_data_original.mean(axis=0)
# EEG_data_original/=EEG_data_original.std(axis=0)
EEG_data_original = EEG_data_original.reshape(
int(total_EEG_number_for_test / time_steps),
int(time_steps * total_EEG_Features))
x = encoder.predict(EEG_data_original)
original_test_result[times] = sum(abs(sum(abs((x)))))
original_test_result_array += x ##################
final_score += sum(abs(sum(abs((x)))))
max_score = max(max_score, sum(abs(sum(abs((x))))))
matched_average_score = (sum(original_test_result)) / (int(
total_EEG_data_number / total_EEG_number_for_test))
matched_median_score = np.median(original_test_result)
print('==================设置的Median Score================',
matched_median_score)
print('==================设置的Average Score================',
matched_average_score)
original_test_result_array = original_test_result_array / (int(
total_EEG_data_number / total_EEG_number_for_test))
# print('Original_test_result_array.shape==',original_test_result_array.shape)
# print('Original_test_result_array==',original_test_result_array)
#############################设置初始偏差值 结束##############################################
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((server_address, 5204)) #5204 为 OPENBCI GUI的缺省服务器段的发送端口
EEG_data_for_test = np.zeros(
[total_EEG_number_for_test,
total_EEG_Features]) # EEG_data_for_test为采样的测试EEG帧。
match_counter = 0 # 用于计数EEG通过测试的个数。
max_score = 0
final_score = 0
test_times = 10
test_result = np.zeros(test_times)
test_result_array = np.zeros([total_EEG_number_for_test, encoding_dim])
QApplication.processEvents()
for times in range(test_times): #测试十次
for k in range(total_EEG_number_for_test): #明天写注释！！！！
EEG_data_one_line = (s.recv(1024).decode('utf-8')).split(
'A') ####按照字符"A"来截断每一条EEG数据，分割成24小份
for i in range(total_EEG_Features):
if len(
EEG_data_one_line
) == total_EEG_Features + 1: #这个判断是为了避免有时候读取EEG时候，遇到换行符丢失的现象。
EEG_data_for_test[k][i] = float(EEG_data_one_line[i])
else:
EEG_data_for_test[k][i] = EEG_data_for_test[k - 1][i]
print("发现一处错行！！")
EEG_data_for_test = EEG_data_for_test.astype(
'float32') / normal_number # 归一化
# EEG_data_for_test -=EEG_data_for_test.mean(axis=0)
# EEG_data_for_test/=EEG_data_for_test.std(axis=0)
test = encoder.predict(EEG_data_for_test, verbose=1)
test_result_array += test
test_result[times] = sum(abs(sum(abs((test)))))
final_score += test_result[times]
max_score = max(max_score, test_result[times])
ui.progressBar.setProperty("value", (times + 1) * 10)
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
test_median = np.median(test_result)
test_average = (final_score) / (test_times)
print('==================现在测试出来的Median Score================',
test_median)
print('==================现在测试出来的Average Score=================',
test_average)
print('test_result_array.shape==', test_result_array.shape)
test_score_for_display = (
1 - abs((test_median + test_average) -
(matched_median_score + matched_average_score)) /
(matched_median_score + matched_average_score)) * 100
if test_score_for_display < 89:
test_score_for_display -= 20
test_result_array = test_result_array / (test_times)
# print('test_result_array.shape==',test_result_array.shape)
# print('test_result_array==',test_result_array)
# print('标准欧几里得距离为:', moreBZOSdis(original_test_result_array,test_result_array))
# print('标准欧几里得距离之和为:', sum(moreBZOSdis(original_test_result_array,test_result_array)))
original_average_zip_features = sum(
original_test_result_array) / total_EEG_number_for_test
tester_average_zip_features = sum(
test_result_array) / total_EEG_number_for_test
print('看一下原始加密者的压缩层的平均值:', original_average_zip_features)
print('看一下测试者的压缩层的平均值:', tester_average_zip_features)
print(
'看一下原始人VS测试者的压缩层的平均值的标准欧几里得距离为:',
moreBZOSdis(original_average_zip_features,
tester_average_zip_features))
test_score_for_display_2 = 0
progressBar_dim_value = np.zeros(encoding_dim)
for i in range(encoding_dim):
test_score_for_display_2 += (
1 - abs(original_average_zip_features[i] -
tester_average_zip_features[i]) /
abs(original_average_zip_features[i])) / encoding_dim * 100
progressBar_dim_value[i] = (
1 - abs(original_average_zip_features[i] -
tester_average_zip_features[i]) /
abs(original_average_zip_features[i])) * 100
# if progressBar_dim_value[i]<=0:
# progressBar_dim_value[i]=0
print("每一个维度的分数", progressBar_dim_value[i])
########################绘制每个维度的匹配度################################
ui.progressBar_dim_0.setProperty("value",
max(int(progressBar_dim_value[0]), 0))
ui.progressBar_dim_1.setProperty("value",
max(int(progressBar_dim_value[1]), 0))
ui.progressBar_dim_2.setProperty("value",
max(int(progressBar_dim_value[2]), 0))
if encoding_dim >= 4:
ui.progressBar_dim_3.setProperty(
"value", max(int(progressBar_dim_value[3]), 0))
if encoding_dim >= 5:
ui.progressBar_dim_4.setProperty(
"value", max(int(progressBar_dim_value[4]), 0))
if encoding_dim >= 6:
ui.progressBar_dim_5.setProperty(
"value", max(int(progressBar_dim_value[5]), 0))
if encoding_dim >= 7:
ui.progressBar_dim_6.setProperty(
"value", max(int(progressBar_dim_value[6]), 0))
if encoding_dim >= 8:
ui.progressBar_dim_7.setProperty(
"value", max(int(progressBar_dim_value[7]), 0))
if encoding_dim >= 9:
ui.progressBar_dim_8.setProperty(
"value", max(int(progressBar_dim_value[8]), 0))
# for i in range(total_EEG_number_for_test):
# print('每一帧的标准欧几里得距离为:',moreBZOSdis(test_result_array[i],sum(original_test_result_array)/total_EEG_number_for_test))
print('test_score_for_display=', test_score_for_display_2)
ui.lcdNumber.display(test_score_for_display_2)
result_text = "测试结束。最终匹配结果为" + str(test_score_for_display_2) + "%"
ui.label.setText(result_text)
ui.label.repaint()
QApplication.processEvents()
ui.pushButton.setText("重新开始匹配测试")
ui.pushButton.repaint()
enable_Gui()
if step == 2: #机器学习
disable_Gui()
rest_process_bar()
ui.lcdNumber.display('---')
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
ui.label.setText("开始机器学习你的脑纹。")
ui.label.repaint()
ui.pushButton.setText("2-机器学习中...")
ui.pushButton.repaint()
######################################### 开始训练 ######################################
####################### 读取代训练的EEG数据############################
if directly_load_EEG_flag == True:
f = open(directly_load_filename, 'r') #读取代训练的EEG数据
print("step-2:使用的是预先录取好的EEG文件:", directly_load_filename)
if directly_load_EEG_flag == False:
f = open(filename + 'EEG.txt', 'r') #读取代训练的EEG数据
print("使用的是刚才录取的EEG文件:", filename)
print(2)
All_EEG_data_lines = f.readlines()
EEG_data = np.zeros([total_EEG_data_number, total_EEG_Features])
time_steps = 1 #强制设定time_steps=1
for k in range(total_EEG_data_number):
EEG_data_one_line = (All_EEG_data_lines[k].split('A')
) ####按照字符"A"来截断每一条EEG数据，分割成24小份
for i in range(total_EEG_Features):
if len(
EEG_data_one_line
) == total_EEG_Features + 1: #这个判断是为了避免有时候读取EEG时候，遇到换行符丢失的现象。
EEG_data[k][i] = float(EEG_data_one_line[i])
else:
EEG_data[k][i] = EEG_data[k - 1][i]
print("发现一处错行！！")
f.close()
EEG_data = EEG_data.astype(
'float32') / normal_number # minmax_normalized
# EEG_data -=EEG_data.mean(axis=0)
# EEG_data/=EEG_data.std(axis=0)
EEG_data = EEG_data.reshape(int(total_EEG_data_number / time_steps),
int(time_steps * total_EEG_Features))
x_train = EEG_data
########################开始搭建神经网络#############################
#120-60-30-15-6-3 似乎不错
# this is our input placeholder
input_img = Input(shape=(int(time_steps * total_EEG_Features), ))
# 编码层
encoded = Dense(96,
activation='relu',
activity_regularizer=regularizers.l1(0))(
input_img) #10e-7
encoded = Dense(48,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(24,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(12,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(6,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
encoder_output = Dense(encoding_dim)(encoded)
# 解码层
decoded = Dense(
6, activation='relu',
activity_regularizer=regularizers.l1(0))(encoder_output)
decoded = Dense(12,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(24,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(48,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(96,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(int(time_steps * total_EEG_Features),
activation='softsign')(decoded)
# 构建自编码模型
autoencoder = Model(inputs=input_img, outputs=decoded)
autoencoder.summary()
# 构建编码模型
encoder = Model(inputs=input_img, outputs=encoder_output)
# compile autoencoder
#adam=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
autoencoder.compile(optimizer='adam', loss='mse')
encoder.compile(optimizer='adam', loss='mse')
# compile autoencoder
#adam=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
autoencoder.compile(optimizer='adam', loss='mse')
encoder.compile(optimizer='adam', loss='mse')
# training
print(x_train.shape)
########################神经网络搭建完毕#############################
#手动 打乱 x,y 次序。
# p = np.random.permutation(range(len(x_train)))
# x_train = x_train[p]
np.random.shuffle(x_train)
################这个tb，是为了使用TensorBoard########################
tensorBoard = TensorBoard(
log_dir='./logs', # log 目录
histogram_freq=
1, # 按照何等频率（epoch）来计算直方图，0为不计算. 必须在fit的时候设定好 validation_split或者validation数据，否则程序死机（此时只能设置为0）。
batch_size=32, # 用多大量的数据计算直方图
write_graph=True, # 是否存储网络结构图
write_grads=False, # 是否可视化梯度直方图
write_images=False, # 是否可视化参数
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None)
# 在命令行，先conda activate envs，然后进入本代码所在的目录，然后用 tensorboard --logdir=logs/ 来看log
# 然后打开chrome浏览器，输入http://localhost:6006/ 来查看
########################开始训练#############################
early_stopping = EarlyStopping(monitor='val_loss',
patience=int(training_times * 0.1),
verbose=1,
mode='min')
training_process_bar = Training_process_bar()
lossHistory = LossHistory()
#############有一个特别的bug，请注意，就是在一个程序中，如果要训练两次，那么请在fit中拿掉tensorBoard！！！！
autoencoder.fit(x_train,
x_train,
validation_split=0.33,
epochs=training_times,
batch_size=training_batch_size,
shuffle=True,
callbacks=[early_stopping, training_process_bar])
#history.loss_plot('epoch') #matplotlib绘制训练过程，似乎有问题。
encoder.save(filename + '_key.h5')
print("把训练好的神经网络保存在:", filename, '_key.h5')
directly_load_model_flag = False
x = encoder.predict(
EEG_data.reshape(int(total_EEG_data_number / time_steps),
int(time_steps * total_EEG_Features)))
print('encoder (x)=', x)
print('shape (x)=', x.shape)
########################训练完毕，并保存训练好的神经网络#############################
ui.label.setText("你的脑纹锁设置成功！")
#ui.label.setText("你的脑纹锁设置成功！最终的损失率为"+final_result_loss+" 最终的准确率为"+final_result_acc)
ui.label.repaint()
ui.pushButton.setText("开始匹配测试")
ui.pushButton.repaint()
ui.progressBar.setProperty("value", 0)
step = 3
ui.label_2.setText("目前载入的是" + filename + "的已经训练好的脑纹")
ui.label_2.repaint()
enable_Gui()
if step == 1: #### 录制脑电波
ui.lcdNumber.display('---')
disable_Gui()
ui.label.setText("开始录制你的脑纹信息，请保持不动。")
ui.label.update()
rest_process_bar()
ui.pushButton.setText("1-录制脑纹中...")
ui.pushButton.repaint()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((server_address, 5204))
f = open(filename + 'EEG.txt', 'w')
for k in range(total_EEG_data_number):
EEG_data = (s.recv(1024).decode('utf-8'))
EEG_data_to_write = EEG_data + '\n'
f.write(EEG_data_to_write)
ui.progressBar.setProperty("value",
k / total_EEG_data_number * 100 + 5)
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
f.close()
directly_load_EEG_flag = False
step = 2
ui.label_2.update()
ui.label.setText("接下来神经网络开始学习并设置你的脑纹。")
ui.label.update()
ui.pushButton.setText("2-开始机器学习")
ui.pushButton.repaint()
enable_Gui()
directly_load_EEG_flag = False
if step == 0:
ui.lcdNumber.display('---')
ui.label.setText("返回第一步，请输入你的名字。")
ui.label.update()
ui.pushButton.setText("1-重新开始录制脑纹")
ui.pushButton.repaint()
ui.label_2.setText("目前没有载入任何已经训练好的脑纹。")
ui.label_2.repaint()
step = 1
loc=0.0, scale=1.0, size=df_train_output.shape)
df_test = df_test_output + 0.5 * np.random.normal(
loc=0.0, scale=1.0, size=df_test_output.shape)
nb_epoch = 100
batch_size = 12
input_dim = df_train.shape[1]
encoding_dim = 32
hidden_dim = int(encoding_dim / 2)
learning_rate = 1e-3
input_layer = Input(shape=(input_dim, ))
encoder = Dense(
encoding_dim,
activation="tanh",
activity_regularizer=regularizers.l1(learning_rate))(input_layer)
encoder = Dense(hidden_dim, activation="relu")(encoder)
decoder = Dense(hidden_dim, activation='tanh')(encoder)
decoder = Dense(input_dim, activation='relu')(decoder)
autoencoder = Model(inputs=input_layer, outputs=decoder)
autoencoder.compile(metrics=['accuracy'],
loss='mean_squared_error',
optimizer='adam')
cp = ModelCheckpoint(filepath="autoencoder_classifier.h5",
save_best_only=True,
verbose=0)
tb = TensorBoard(log_dir='./logs',
histogram_freq=0,
#endregion
print('max=',EEG_data_B.max())
EEG_data_B = EEG_data_B.astype('float32') / 20 # minmax_normalized
EEG_data_B=EEG_data_B.reshape(int(total_EEG_data_number/time_steps),int(time_steps*total_EEG_Features))
# x_train=EEG_data_B[:int(total_EEG_data_number/time_steps*0.75)]
# x_test=EEG_data_B[int(total_EEG_data_number/time_steps*0.75):]
x_train=EEG_data_B
# 压缩特征维度至2维
encoding_dim = 10
# this is our input placeholder
input_img = Input(shape=(int(time_steps*total_EEG_Features),))
# 编码层
encoded = Dense(160, activation='relu',activity_regularizer=regularizers.l1(0))(input_img) #10e-7
encoded = Dense(80, activation='relu',activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(40, activation='relu',activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(20, activation='relu',activity_regularizer=regularizers.l1(0))(encoded)
encoder_output = Dense(encoding_dim)(encoded)
# 解码层
decoded = Dense(20, activation='relu',activity_regularizer=regularizers.l1(0))(encoder_output)
decoded = Dense(40, activation='relu',activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(80, activation='relu',activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(160, activation='relu',activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(int(time_steps*total_EEG_Features), activation='tanh')(decoded)
def main():
sequence_count = 20
image_count = 5
input_count = 6 # 4 input image; 0: Grey, 1: GT, 2: MOG, 3: Optical flow
height = 160
width = 240
kernelshape = 7 # 5x5 kernel size
teach_size = 300000
test_size = 80000
training_data_kernels = get_kernel_data(sequence_count, image_count,
kernelshape, input_count, height,
width)
network_input = training_data_kernels[:, (4, 2, 3), :, :]
network_label = training_data_kernels[:, 1,
int(kernelshape / 2) + 1,
int(kernelshape / 2) + 1]
#------------------
# keras
#------------------
input_img = Input(shape=(3, kernelshape, kernelshape))
encoded1 = Dense(50,
activation='relu',
activity_regularizer=regularizers.l2(10e-3))(input_img)
encoded2 = Dense(20,
activation='relu',
activity_regularizer=regularizers.l2(10e-3))(encoded1)
encoded3 = Dense(15,
activation='relu',
activity_regularizer=regularizers.l1(10e-3))(encoded2)
flatten = Flatten()(encoded3)
decoded = Dense(1, activation='relu')(flatten)
# this model maps an input to its reconstruction
autoencoder = Model(input_img, decoded)
#build
autoencoder.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
x_train = network_input[:teach_size].astype('float32') / 255.
x_label = network_label[:teach_size].astype('float32') / 255.
x_test = network_input[teach_size:teach_size +
test_size].astype('float32') / 255.
x_test_label = network_label[teach_size:teach_size +
test_size].astype('float32') / 255.
autoencoder.fit(x_train,
x_label,
epochs=5,
batch_size=500,
shuffle=True,
validation_data=(x_test, x_test_label))
# ------------------
# keras - end
# ------------------
check_result_data = np.zeros(
(10, 10, input_count, height, width)).astype(np.uint8)
check_result_data[:, :, :2, :, :] = get_data(10, 10, height, width)
for seqi in check_result_data:
fn_mog = cv.bgsegm.createBackgroundSubtractorMOG()
i = 0
for imi in seqi:
imi[2] = fn_mog.apply(imi[0])
if i <= 0:
flow = cv.calcOpticalFlowFarneback(imi[0], imi[0], None, 0.5,
2, 5, 3, 5, 1.2, 0)
diff = imi[0] - imi[0]
imi[5] = imi[2]
else:
flow = cv.calcOpticalFlowFarneback(seqi[(i - 1),
0], imi[0], None, 0.5,
2, 5, 3, 5, 1.2, 0)
diff = np.abs(imi[0] - seqi[(i - 1), 0])
imi[5] = (seqi[(i - 1), 2] / 2 + imi[2] / 2).astype(np.uint8)
# im[4] = diff.astype(np.uint8)
a = np.einsum("ij,ij->ij", flow[:, :, 0], flow[:, :, 0])
b = np.einsum("ij,ij->ij", flow[:, :, 1], flow[:, :, 1])
imi[3] = (cv.normalize(np.sqrt(a + b), None, 0, 255,
cv.NORM_MINMAX)).astype(np.uint8)
i = i + 1
result_im = np.zeros((height, width))
kernel_i = int(kernelshape / 2)
for k in range(kernel_i, height - kernelshape):
for j in range(kernel_i, width - kernelshape):
pred_im = np.array([
imi[(4, 2, 3), (k - kernel_i):(k + kernel_i + 1),
(j - kernel_i):(j + kernel_i + 1)]
])
result_im[k, j] = autoencoder.predict(pred_im)
print(np.max(result_im))
print(np.sum(result_im))
res_im = cv.normalize(result_im, None, 0, 255, cv.NORM_MINMAX)
cv.imshow("NN 0", res_im.astype(np.uint8))
cv.imshow("flow", imi[3])
cv.imshow("mog", imi[5])
cv.imshow("image", imi[0])
cv.imshow("gt", imi[1])
cv.waitKey()
### Configure the model
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=(X_train.shape[1], X_train.shape[2], 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
print(model.output_shape)
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(
Dense(128, activation='relu', kernel_regularizer=regularizers.l1(0.01)))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
hist = model.fit(X_train, y_train, batch_size=32, epochs=10)
print("The model has successfully trained")
model.save('mnist_CNN.h5')
print("Saving the model as mnist.h5")
score = model.evaluate(X_test, y_test, verbose=1)
print(score)
"""
New Things to learn in CNN
embedded_sequences = embedding_layer(sequence_input)
# In[9]:
print('Training model.')
tbCallBack = TensorBoard(log_dir='./Graph/{}/'.format(st),
histogram_freq=0,
write_graph=True,
write_images=True)
# train a 1D convnet with global maxpooling
x = Conv1D(128, 5, activation='relu')(embedded_sequences)
x = GaussianNoise(0.2)(x)
x = MaxPooling1D(5)(x)
x = Conv1D(128, 5, activation='relu',
kernel_regularizer=regularizers.l1(0.05))(x)
x = GlobalMaxPooling1D()(x)
x = Dropout(0.5)(x)
x = Dense(128, activation='relu')(x)
preds = Dense(len(labels_index), activation='softmax')(x)
model = Model(sequence_input, preds)
model.compile(
loss='categorical_crossentropy',
optimizer='adagrad',
metrics=['acc'],
)
model.fit(x_train,
y_train,
batch_size=BATCH_SIZE,
from keras.layers import Input, Dense, regularizers
from keras.models import Model
from time import time
from keras.callbacks import TensorBoard
import matplotlib.pyplot as plt
# this is the size of our encoded representations
encoding_dim = 32 # 32 floats -> compression of factor 24.5, assuming the input is 784 floats
# this is our input placeholder
input_img = Input(shape=(784, ))
# "encoded" is the encoded representation of the input
encoded = Dense(encoding_dim,
activation='relu',
activity_regularizer=regularizers.l1(10e-9))(input_img)
# "decoded" is the lossy reconstruction of the input
decoded = Dense(784, activation='sigmoid')(encoded)
# this model maps an input to its reconstruction
autoencoder = Model(input_img, decoded)
# this model maps an input to its encoded representation
encoder = Model(input_img, encoded)
# create a placeholder for an encoded (32-dimensional) input
encoded_input = Input(shape=(encoding_dim, ))
# retrieve the last layer of the autoencoder model
decoder_layer = autoencoder.layers[-1]
# create the decoder model
decoder = Model(encoded_input, decoder_layer(encoded_input))
autoencoder.compile(optimizer='adadelta',
loss='binary_crossentropy',
metrics=['accuracy'])
def train(self, sentences_vector: SentencesVector):
inputer = sentences_vector.inputer
config = inputer.config
embedded_sequences = Input(shape=(config.MAX_SEQUENCE_LENGTH,
config.EMBEDDING_DIM * 3),
dtype='float32',
name="sequence_input") # 100*1最多100个词组成输入
# embedded_sequences = inputer.getWordEmbedding()(sequence_input) # 句子转为向量矩阵 训练集大小*100*300维
# model test2
posi_input = Input(shape=(config.MAX_SEQUENCE_LENGTH,
sentences_vector.position_vec.shape[2]),
name="posi_input")
# pos_input = Input(shape=(config.MAX_SEQUENCE_LENGTH,sentences_vector.pos_vec.shape[2]), name="pos_input")
embedded_sequences = keras.layers.concatenate(
[embedded_sequences, posi_input])
c1 = Dropout(rate=0.25)(embedded_sequences)
c1 = Conv1D(filters=150, kernel_size=3, activation='relu')(c1)
c1 = MaxPooling1D(pool_size=98)(c1)
c1 = Dropout(rate=0.25)(c1)
c1 = Flatten()(c1)
c1 = Dense(128, activation='relu')(c1) # 128全连接
preds = Dense(len(inputer.types),
activation='softmax',
kernel_regularizer=regularizers.l2(0.01),
activity_regularizer=regularizers.l1(0.001))(
c1) # softmax分类
model = Model(inputs=[embedded_sequences, posi_input], outputs=preds)
print(model.summary())
adam = optimizers.Adam(lr=0.001, decay=0.0001)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=["categorical_accuracy"])
# 如果希望短一些时间可以，epochs调小
# ModelCheckpoint回调函数将在每个epoch后保存模型到filepath，当save_best_only=True保存验证集误差最小的参数
checkpoint = ModelCheckpoint(config.model_file_path,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
# 当监测值不再改善时，该回调函数将中止训练
early = EarlyStopping(monitor="val_loss", mode="min", patience=500)
# 开始训练
callbacks_list = [checkpoint, early] # early
# And trained it via:
model.fit(
{
'sequence_input': sentences_vector.embedded_sequences,
'posi_input': sentences_vector.position_vec,
'pos_input': sentences_vector.pos_vec
},
sentences_vector.classifications_vec,
batch_size=50,
epochs=50000,
validation_split=0.2,
# validation_data=({'sequence_input': x_test, 'posi_input': x_test_posi}, y_test),
callbacks=callbacks_list)
return model
def create(self,
feature_size,
layer_nodes,
dropouts,
no_of_output_class,
activation='softmax',
alpha=0.1,
l2_norm=0,
l1_norm=0):
"""
:param layer_nodes: number of of input features
:param layer_nodes: 1 D numpy array for the the number of nodes in each layer
:param no_of_output_class: Number of classes in output
:param activation: type of activation to use
:param alpha: values for negative gradient
:param l2_norm: L2 regualrization constant
:param l1_norm: L1 regualrization constant
:return:
"""
layer_count = 0
input_layer = Input(shape=feature_size)
# To keep track the last inserted layer
last_layer = input_layer
# Iterate to create the layers
for i in range(layer_nodes.shape[0]):
if activation != 'LeakyRelu':
if i == 0:
last_layer = Dense(
layer_nodes[layer_count],
input_dim=feature_size,
activation=activation,
kernel_initializer=keras.initializers.glorot_normal(
seed=None),
kernel_regularizer=regularizers.l2(l2_norm),
activity_regularizer=regularizers.l1(l1_norm))(
last_layer)
else:
last_layer = Dense(
layer_nodes[layer_count],
activation=activation,
kernel_initializer=keras.initializers.glorot_normal(
seed=None),
kernel_regularizer=regularizers.l2(l2_norm),
activity_regularizer=regularizers.l1(l1_norm))(
last_layer)
else:
if i == 0:
last_layer = Dense(
layer_nodes[layer_count],
input_dim=feature_size,
kernel_initializer=keras.initializers.glorot_normal(
seed=None),
kernel_regularizer=regularizers.l2(l2_norm),
activity_regularizer=regularizers.l1(l1_norm))(
last_layer)
last_layer = LeakyReLU(alpha=alpha)(last_layer)
else:
last_layer = Dense(
layer_nodes[layer_count],
kernel_initializer=keras.initializers.glorot_normal(
seed=None),
kernel_regularizer=regularizers.l2(l2_norm),
activity_regularizer=regularizers.l1(l1_norm))(
last_layer)
last_layer = LeakyReLU(alpha=alpha)(last_layer)
if dropouts[i] > 0:
last_layer = Dropout(dropouts[i])(last_layer)
layer_count += 1
activation = 'sigmoid'
output_layer = Dense(
no_of_output_class,
activation=activation,
kernel_initializer=keras.initializers.glorot_normal(seed=None),
kernel_regularizer=regularizers.l2(l2_norm),
activity_regularizer=regularizers.l1(l1_norm))(last_layer)
self.model = Model(inputs=input_layer, outputs=output_layer)
def action(): #此函数是控制整个采样，训练， 匹配测试的过程。
global filename, total_EEG_number_for_test
global step, directly_load_model_flag, openfile_name, directly_load_filename, time_steps, directly_load_EEG_flag
filename = ui.lineEdit.text() #写入文件名
time_steps = 1
if step == 3: # 匹配测试
disable_Gui()
ui.lcdNumber.display('---')
QApplication.processEvents()
ui.label.setText("匹配测试中...")
ui.pushButton.setText("匹配测试中...")
if directly_load_model_flag == False:
autoencoder = load_model(filename + '_key.h5')
print("使用的是刚才训练好的模型:", filename)
if directly_load_model_flag == True:
autoencoder = load_model(directly_load_filename)
print("使用的是直接读取的已经训练好的模型:", directly_load_filename)
#############################设置初始偏差值 开始##############################################
if directly_load_EEG_flag == True:
f = open(directly_load_filename, 'r') #读取代训练的EEG数据
print("使用的是预先录取好的EEG文件:", directly_load_filename)
if directly_load_EEG_flag == False:
f = open(filename[:-4] + 'EEG.txt', 'r') #读取代训练的EEG数据
print("使用的是刚才录取的EEG文件:", filename)
All_EEG_data_lines = f.readlines()
EEG_data_original = np.zeros(
[total_EEG_number_for_test, total_EEG_Features])
final_score = 0
max_score = 0
test_result = np.zeros(
int(total_EEG_data_number / total_EEG_number_for_test))
for test_times in range(
int(total_EEG_data_number /
total_EEG_number_for_test)): #0,1,2,3....
for k in range(total_EEG_number_for_test):
EEG_data_one_line = (
All_EEG_data_lines[k + test_times *
total_EEG_number_for_test].split('A')
) ####按照字符"A"来截断每一条EEG数据，分割成24小份
for i in range(total_EEG_Features):
if len(
EEG_data_one_line
) == total_EEG_Features + 1: #这个判断是为了避免有时候读取EEG时候，遇到换行符丢失的现象。
EEG_data_original[k][i] = float(EEG_data_one_line[i])
else:
EEG_data_original[k][i] = EEG_data_original[k - 1][i]
f.close()
EEG_data_original = EEG_data_original.astype(
'float32') / 10 # minmax_normalized
EEG_data_original = EEG_data_original.reshape(
int(total_EEG_number_for_test / time_steps),
int(time_steps * total_EEG_Features))
x = autoencoder.predict(EEG_data_original)
print('Total original-X=', sum(abs(sum(abs((x))))))
test_result[test_times] = sum(abs(sum(abs((x)))))
final_score += sum(abs(sum(abs((x)))))
max_score = max(max_score, sum(abs(sum(abs((x))))))
# result= model.predict(x,verbose = 1)
matched_average_score = (final_score - max_score) / (
int(total_EEG_data_number / total_EEG_number_for_test) - 1)
matched_median_score = np.median(test_result)
print('==================Average Score================',
matched_average_score)
print('==================Median Score================',
matched_median_score)
match_triger = matched_median_score * 1.2
#############################设置初始偏差值 结束##############################################
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((server_address, 5204)) #5204 为 OPENBCI GUI的缺省服务器段的发送端口
EEG_data_for_test = np.zeros(
[total_EEG_number_for_test,
total_EEG_Features]) # EEG_data_for_test为采样的测试EEG帧。
match_counter = 0 # 用于计数EEG通过测试的个数。
max_score = 0
final_score = 0
test_times = 10
test_result = np.zeros(test_times)
QApplication.processEvents()
for times in range(test_times): #测试十次
for k in range(total_EEG_number_for_test): #明天写注释！！！！
EEG_data_one_line = (s.recv(1024).decode('utf-8')).split(
'A') ####按照字符"A"来截断每一条EEG数据，分割成24小份
for i in range(total_EEG_Features):
if len(
EEG_data_one_line
) == total_EEG_Features + 1: #这个判断是为了避免有时候读取EEG时候，遇到换行符丢失的现象。
EEG_data_for_test[k][i] = float(EEG_data_one_line[i])
else:
EEG_data_for_test[k][i] = EEG_data_for_test[k - 1][i]
#print("EEG_data_for_test shape==",EEG_data_for_test.shape)
EEG_data_for_test = EEG_data_for_test.astype('float32') / 10 # 归一化
test = autoencoder.predict(EEG_data_for_test, verbose=1)
test_result[times] = sum(abs(sum(abs((EEG_data_for_test - test)))))
print('Total original-test=', test_result[times])
final_score += test_result[times]
max_score = max(max_score, test_result[times])
#print('Total final_score=',final_score)
#print('max_score=',max_score)
######################################
if test_result[times] <= match_triger:
match_counter = match_counter + 1
ui.progressBar.setProperty("value", (times + 1) * 10)
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
# result_text="当前帧组的匹配率为："+str(test[0][0]*100)[:6]+"%"+" 整体匹配率已经达到"+str(match_counter/temp_total_EEG_number_for_test*100)+"%"
# ui.label.setText(result_text)
# ui.label.repaint()
# ui.lcdNumber.display(match_counter/test_times*100)
# QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
# total_EEG_number_for_test=temp_total_EEG_number_for_test #重新恢复全局变量total_EEG_number_for_test的值。
print('==================Median Score================',
np.median(test_result))
print('==================Average Score=================',
(final_score - max_score) / (test_times - 1))
test_score_for_display = min(
((1 - (np.median(test_result) - matched_median_score) /
matched_median_score) * 50 +
(1 - ((final_score - max_score) /
(test_times - 1) - matched_average_score) /
matched_average_score) * 50), 100)
print('test_score_for_display=', test_score_for_display)
ui.lcdNumber.display(test_score_for_display)
result_text = "测试结束。最终匹配结果为" + str(test_score_for_display) + "%"
ui.label.setText(result_text)
ui.label.repaint()
QApplication.processEvents()
ui.pushButton.setText("重新开始匹配测试")
ui.pushButton.repaint()
enable_Gui()
if step == 2: #机器学习
disable_Gui()
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
ui.label.setText("开始机器学习你的脑纹。")
ui.label.repaint()
ui.pushButton.setText("2-机器学习中...")
ui.pushButton.repaint()
######################################### 开始训练 ######################################
####################### 读取代训练的EEG数据############################
if directly_load_EEG_flag == True:
f = open(directly_load_filename, 'r') #读取代训练的EEG数据
print("使用的是预先录取好的EEG文件:", directly_load_filename)
if directly_load_EEG_flag == False:
f = open(filename + 'EEG.txt', 'r') #读取代训练的EEG数据
print("使用的是刚才录取的EEG文件:", filename)
All_EEG_data_lines = f.readlines()
EEG_data_B = np.zeros([total_EEG_data_number, total_EEG_Features])
time_steps = 1 #强制设定time_steps=1
for k in range(total_EEG_data_number):
EEG_data_one_line = (All_EEG_data_lines[k].split('A')
) ####按照字符"A"来截断每一条EEG数据，分割成24小份
for i in range(total_EEG_Features):
if len(
EEG_data_one_line
) == total_EEG_Features + 1: #这个判断是为了避免有时候读取EEG时候，遇到换行符丢失的现象。
EEG_data_B[k][i] = float(EEG_data_one_line[i])
else:
EEG_data_B[k][i] = EEG_data_B[k - 1][i]
f.close()
EEG_data_B = EEG_data_B.astype('float32') / 10 # minmax_normalized
EEG_data_B = EEG_data_B.reshape(
int(total_EEG_data_number / time_steps),
int(time_steps * total_EEG_Features))
x_train = EEG_data_B
########################开始搭建神经网络#############################
# 压缩特征维度至2维
encoding_dim = 1
# this is our input placeholder
input_img = Input(shape=(int(time_steps * total_EEG_Features), ))
# 编码层
encoded = Dense(12,
activation='relu',
activity_regularizer=regularizers.l1(0))(
input_img) #10e-7
encoded = Dense(8,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(4,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
encoded = Dense(2,
activation='relu',
activity_regularizer=regularizers.l1(0))(encoded)
# encoded = Dense(20, activation='relu',activity_regularizer=regularizers.l1(0))(encoded)
encoder_output = Dense(encoding_dim)(encoded)
# 解码层
decoded = Dense(
2, activation='relu',
activity_regularizer=regularizers.l1(0))(encoder_output)
decoded = Dense(4,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(8,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(12,
activation='relu',
activity_regularizer=regularizers.l1(0))(decoded)
decoded = Dense(int(time_steps * total_EEG_Features),
activation='softsign')(decoded)
# 构建自编码模型
autoencoder = Model(inputs=input_img, outputs=decoded)
# 构建编码模型
encoder = Model(inputs=input_img, outputs=encoder_output)
# compile autoencoder
#adam=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
autoencoder.compile(optimizer='adam', loss='mse')
encoder.compile(optimizer='adam', loss='mse')
# compile autoencoder
#adam=Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
autoencoder.compile(optimizer='adam', loss='mse')
encoder.compile(optimizer='adam', loss='mse')
# training
print(x_train.shape)
early_stopping = EarlyStopping(monitor='loss',
patience=int(training_times * 0.01),
verbose=1,
mode='auto')
########################神经网络搭建完毕#############################
################这个tb，是为了使用TensorBoard########################
tb = TensorBoard(
log_dir='./logs', # log 目录
histogram_freq=0, # 按照何等频率（epoch）来计算直方图，0为不计算. 好像只能设置为0，否则程序死机。
batch_size=32, # 用多大量的数据计算直方图
write_graph=True, # 是否存储网络结构图
write_grads=False, # 是否可视化梯度直方图
write_images=False, # 是否可视化参数
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None)
# 在命令行，先conda activate envs，然后进入本代码所在的目录，然后用 tensorboard --logdir=logs/ 来看log
# 然后打开chrome浏览器，输入http://localhost:6006/ 来查看
# 如果出现tensorboard错误，那么需要修改 ...\lib\site-packages\tensorboard\manager.py，其中keras环境下的这个文件，我已经修改好了。
########################开始训练#############################
training_loop_times = 100 # 把进度条分为10分，所以训练也分解为 10次。
for i in range(training_loop_times): #这个for，只是为了进度条的显示，所以分成 10次来训练。
per_step_result = autoencoder.fit(
x_train,
x_train,
epochs=int(max(training_times / training_loop_times, 1)),
batch_size=training_batch_size,
shuffle=True,
callbacks=[early_stopping])
per_step_result_for_display = str(
per_step_result.history['loss'][0])
print("Training loop times:", i, "/100")
ui.label.setText("开始机器学习你的脑纹,目前的损失率为：" +
per_step_result_for_display)
ui.progressBar.setProperty("value",
(i + 1) * 100 / training_loop_times)
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
#per_step_result=autoencoder.fit(x_train, x_train, epochs=int(max(training_times,1)), batch_size=training_batch_size, shuffle=True,callbacks=[early_stopping])
#autoencoder.fit(x_train, x_train, epochs=training_times, batch_size=100, shuffle=True,callbacks=[early_stopping])
autoencoder.save(filename + '_key.h5')
print("把训练好的神经网络保存在:", filename, '_key.h5')
x = autoencoder.predict(
EEG_data_B.reshape(int(total_EEG_data_number / time_steps),
int(time_steps * total_EEG_Features)))
print('original-X=', sum(abs(EEG_data_B - x)))
print('Total original-X=', sum(abs(sum(abs((EEG_data_B - x))))))
directly_load_model_flag = False
x = encoder.predict(
EEG_data_B.reshape(int(total_EEG_data_number / time_steps),
int(time_steps * total_EEG_Features)))
print('encoder (x)=', x)
########################训练完毕，并保存训练好的神经网络#############################
ui.label.setText("你的脑纹锁设置成功！")
#ui.label.setText("你的脑纹锁设置成功！最终的损失率为"+final_result_loss+" 最终的准确率为"+final_result_acc)
ui.label.repaint()
ui.pushButton.setText("开始匹配测试")
ui.pushButton.repaint()
ui.progressBar.setProperty("value", 0)
step = 3
ui.label_2.setText("目前载入的是" + filename + "的已经训练好的脑纹")
ui.label_2.repaint()
enable_Gui()
if step == 1: #### 录制脑电波
disable_Gui()
ui.label.setText("开始录制你的脑纹信息，请保持不动。")
ui.label.update()
ui.pushButton.setText("1-录制脑纹中...")
ui.pushButton.repaint()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((server_address, 5204))
f = open(filename + 'EEG.txt', 'w')
for k in range(total_EEG_data_number):
EEG_data = (s.recv(1024).decode('utf-8'))
EEG_data_to_write = EEG_data + '\r\n'
f.write(EEG_data_to_write)
ui.progressBar.setProperty("value",
k / total_EEG_data_number * 100 + 5)
QApplication.processEvents() #用于PyQt界面的刷新，保证流畅程度。
f.close()
step = 2
ui.label_2.update()
ui.label.setText("接下来神经网络开始学习并设置你的脑纹。")
ui.label.update()
ui.pushButton.setText("2-开始机器学习")
ui.pushButton.repaint()
enable_Gui()
directly_load_EEG_flag = False
if step == 0:
ui.label.setText("返回第一步，请输入你的名字。")
ui.label.update()
ui.pushButton.setText("1-重新开始录制脑纹")
ui.pushButton.repaint()
ui.label_2.setText("目前没有载入任何已经训练好的脑纹。")
ui.label_2.repaint()
step = 1
minimizer = "nadam"
cost = "mean_squared_error"
elif architecture == 5:
#Surprisingly good underfit
inputs = Input(shape=(9, ))
layer1 = Dense(64, activation="relu")(inputs)
outputs = Dense(1, activation="sigmoid")(layer1)
epochnum = 1
minimizer = "rmsprop"
cost = "mean_squared_error"
elif architecture == 6:
#Underfit
inputs = Input(shape=(9, ))
layer1 = Dense(64,
activation="relu",
activity_regularizer=regularizers.l1(0.0001))(inputs)
drop1 = Dropout(0.25)(layer1)
layer2 = Dense(64,
activation="relu",
activity_regularizer=regularizers.l1(0.0001))(drop1)
drop2 = Dropout(0.25)(layer2)
outputs = Dense(1, activation="sigmoid")(drop2)
epochnum = 64
minimizer = "nadam"
cost = "mean_squared_error"
elif architecture == 7:
#Underfit
inputs = Input(shape=(9, ))
layer1 = Dense(64,
activation="relu",
activity_regularizer=regularizers.l2(0.0005))(inputs)
