X_test, Y_test, test_reps = valid_generator.get_data()
y_test = np.argmax(Y_test, axis=1)
if 'EmgLstmNet' in PARAMS_MODEL['name']:
model = MODEL(input_shape=(None, 10),
classes=train_generator.n_classes,
**PARAMS_MODEL['extra'])
else:
model = MODEL(input_shape=train_generator.dim,
classes=train_generator.n_classes,
**PARAMS_MODEL['extra'])
model.summary()
if PARAMS_TRAINING['optimizer'] == 'adam':
optimizer = optimizers.Adam(lr=PARAMS_TRAINING['l_rate'],
epsilon=0.001)
elif PARAMS_TRAINING['optimizer'] == 'sgd':
optimizer = optimizers.SGD(lr=PARAMS_TRAINING['l_rate'], momentum=0.9)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy', top_3_accuracy, top_5_accuracy])
train_callbacks = []
if LOGGING_ENABLE:
tensorboardCallback = MyTensorboard(log_dir=LOGGING_TESNORBOARD_FILE +
"/{}".format(subject),
batch_size=100,
histogram_freq=5)
train_callbacks.append(tensorboardCallback)
lrScheduler = MyLRScheduler(**PARAMS_TRAINING['l_rate_schedule'])
def save_bottlebeck_features():
np.random.seed(2929)
vgg_model = applications.VGG16(weights='imagenet',
include_top=False,
input_shape=(150, 150, 3))
print('Model loaded.')
#initialise top model
top_model = Sequential()
top_model.add(Flatten(input_shape=vgg_model.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(1, activation='sigmoid'))
model = Model(inputs=vgg_model.input, outputs=top_model(vgg_model.output))
model.trainable = True
model.summary()
#Total of 20 layers. The classification is considered as one layer
#Therefore, intermediate is 19 layers
#0, 4[:4], 3[:7], 4[:11], 4[:15], 4[:19] (Group 0, 1, 2, 3, 4, 5)
#0 -> All trainable
#5 -> All non-trainable except classification layer
#Always keep layer 20 trainable because it is classification layer
#layer_count = 1
for layer in model.layers[:7]:
layer.trainable = False
#print("NO-Top: Layer is %d trainable" %layer_count)
#layer_count = layer_count + 1
model.summary()
train_datagen = ImageDataGenerator(rescale=1. / 255)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='binary')
sgd = optimizers.Adam(
lr=1e-6
) #optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss="binary_crossentropy",
optimizer=sgd,
metrics=['accuracy'])
# model.compile(optimizer='rmsprop',
# loss='binary_crossentropy', metrics=['accuracy'])
history = model.fit_generator(
train_generator,
steps_per_epoch=nb_train_samples // batch_size,
epochs=epochs,
validation_data=validation_generator,
validation_steps=nb_validation_samples // batch_size,
verbose=1)
history_dict = history.history
#Plotting the training and validation loss
history_dict = history.history
loss_values = history_dict['loss']
val_loss_values = history_dict['val_loss']
epochs_0 = range(1, len(history_dict['acc']) + 1)
plt.plot(epochs_0, loss_values, 'bo', label='Training loss')
plt.plot(epochs_0, val_loss_values, 'b', label='Validation loss')
plt.title(
'ADvsNM_32_VGG16_Freeze_data3_group2 - Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
#plt.show()
plt.savefig('ADvsNM_32_VGG16_Freeze_data3_group2_loss.png')
plt.close()
#Plotting the training and validation accuracy
acc_values = history_dict['acc']
val_acc_values = history_dict['val_acc']
plt.plot(epochs_0, acc_values, 'bo', label='Training acc')
plt.plot(epochs_0, val_acc_values, 'b', label='Validation acc')
plt.title(
'ADvsNM_32_VGG16_Freeze_data3_group2 - Training and validation accuracy'
)
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
#plt.show()
plt.savefig('ADvsNM_32_VGG16_Freeze_data3_group2_acc.png')
plt.close()
unroll=True,
recurrent_activation='hard_sigmoid',
bias_initializer='RandomNormal',
implementation=1))
model.add(
LSTM(500,
dropout=0.2,
recurrent_dropout=0.3,
unroll=True,
recurrent_activation='hard_sigmoid',
bias_initializer='RandomNormal',
implementation=1))
model.add(Dense(2, activation='softmax', bias_initializer='RandomNormal'))
optimizerx = optimizers.Adam(lr=0.001,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
model.compile(loss='poisson', optimizer=optimizerx, metrics=['accuracy'])
print(model.summary())
model.fit(trainx, trainy, batch_size=32, epochs=20, verbose=5)
model_json = model.to_json()
with open("models/model9.json", "w") as json_file:
json_file.write(model_json)
model.save_weights("models/model9.h5")
score, acc = model.evaluate(Valx, Valy, verbose=2, batch_size=4)
print("Logloss score : %.2f" % (score))
print("Validation set accuracy: %.2f" % (acc))
train_datagen = utils.DroneDataGenerator(rotation_range=0.2,
rescale=1. / 255,
width_shift_range=0.2,
height_shift_range=0.2)
train_data_generator = train_datagen.flow_from_directory(TRAIN_DATA_PATH)
test_data_generator = train_datagen.flow_from_directory(TEST_DATA_PATH)
model = cnn_models.resnet8(700, 500, 1, 1)
# Serialize model into json
json_model_path = os.path.join(OUTPUT_PATH, "model.json")
utils.modelToJson(model, json_model_path)
optimizer = optimizers.Adam(decay=1e-5)
model.alpha = tf.Variable(1, trainable=False, name='alpha', dtype=tf.float32)
#model.beta = tf.Variable(0, trainable=False, name='beta', dtype=tf.float32)
# Initialize number of samples for hard-mining
model.k_mse = tf.Variable(32, trainable=False, name='k_mse', dtype=tf.int32)
#model.k_entropy = tf.Variable(32, trainable=False, name='k_entropy', dtype=tf.int32)
model.compile(
loss=[utils.hard_mining_mse(model.k_mse)],
#utils.hard_mining_entropy(model.k_entropy)],
optimizer=optimizer,
loss_weights=[model.alpha])
#loss_weights=[model.alpha, model.beta])
classifier.add(MaxPooling2D(pool_size=(2, 2)))
#Adding 3rd Concolution Layer
classifier.add(Convolution2D(64, 3, 3, activation='relu'))
classifier.add(MaxPooling2D(pool_size=(2, 2)))
#Step 3 - Flattening
classifier.add(Flatten())
#Step 4 - Full Connection
classifier.add(Dense(256, activation='relu'))
classifier.add(Dropout(0.5))
classifier.add(Dense(3, activation='softmax'))
#Compiling The CNN
classifier.compile(optimizer=optimizers.Adam(lr=0.0005),
loss='categorical_crossentropy',
metrics=['accuracy'])
#Part 2 Fittting the CNN to the image
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
training_set = train_datagen.flow_from_directory('mydata/training_set',
target_size=(64, 64),
batch_size=2,
1,
init='normal',
activation=None,
)) # (yaw,pitch,roll) 예측
#Compile model
learning_rate = 0.05
epochs = 10
decay_rate = learning_rate / epochs
from keras.callbacks import EarlyStopping
early_stopping = EarlyStopping() # 개선여지 없을때 조기종료
adam = optimizers.Adam(lr=learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
model.compile(loss='mse', optimizer='adam')
hist_256 = model.fit(x_train_stack,
y_train,
validation_data=(x_test_stack, y_test),
batch_size=512,
epochs=epochs,
verbose=2)
model.save('C:/Users/admin/Desktop/My_CNN_model_0827.h5')
print('My_CNN_model.h5저장완료')
def train(
G,
layer_size: List[int],
num_samples: List[int],
batch_size: int = 100,
num_epochs: int = 10,
learning_rate: float = 0.001,
dropout: float = 0.0,
):
"""
Train the GraphSAGE model on the specified graph G
with given parameters.
Args:
G: NetworkX graph file
layer_size: A list of number of hidden units in each layer of the GraphSAGE model
num_samples: Number of neighbours to sample at each layer of the GraphSAGE model
batch_size: Size of batch for inference
num_epochs: Number of epochs to train the model
learning_rate: Initial Learning rate
dropout: The dropout (0->1)
"""
# Split links into train/test
print("Using '{}' method to sample negative links".format(
args.edge_sampling_method))
# From the original graph, extract E_test and the reduced graph G_test:
edge_splitter_test = EdgeSplitter(G)
# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G, and obtain the
# reduced graph G_test with the sampled links removed:
G_test, edge_ids_test, edge_labels_test = edge_splitter_test.train_test_split(
p=0.1,
keep_connected=True,
method=args.edge_sampling_method,
probs=args.edge_sampling_probs,
)
# From G_test, extract E_train and the reduced graph G_train:
edge_splitter_train = EdgeSplitter(G_test, G)
# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G_test, and obtain the
# further reduced graph G_train with the sampled links removed:
G_train, edge_ids_train, edge_labels_train = edge_splitter_train.train_test_split(
p=0.1,
keep_connected=True,
method=args.edge_sampling_method,
probs=args.edge_sampling_probs,
)
# G_train, edge_ds_train, edge_labels_train will be used for model training
# G_test, edge_ds_test, edge_labels_test will be used for model testing
# Convert G_train and G_test to StellarGraph objects (undirected, as required by GraphSAGE) for ML:
G_train = sg.StellarGraph(G_train, node_features="feature")
G_test = sg.StellarGraph(G_test, node_features="feature")
# Mapper feeds link data from sampled subgraphs to GraphSAGE model
# We need to create two mappers: for training and testing of the model
train_gen = GraphSAGELinkGenerator(G_train,
batch_size,
num_samples,
name="train").flow(edge_ids_train,
edge_labels_train,
shuffle=True)
test_gen = GraphSAGELinkGenerator(G_test,
batch_size,
num_samples,
name="test").flow(
edge_ids_test, edge_labels_test)
# GraphSAGE model
graphsage = GraphSAGE(layer_sizes=layer_size,
generator=train_gen,
bias=True,
dropout=dropout)
# Construct input and output tensors for the link prediction model
x_inp, x_out = graphsage.build()
# Final estimator layer
prediction = link_classification(
output_dim=1,
output_act="sigmoid",
edge_embedding_method=args.edge_embedding_method)(x_out)
# Stack the GraphSAGE and prediction layers into a Keras model, and specify the loss
model = keras.Model(inputs=x_inp, outputs=prediction)
model.compile(
optimizer=optimizers.Adam(lr=learning_rate),
loss=losses.binary_crossentropy,
metrics=[metrics.binary_accuracy],
)
# Evaluate the initial (untrained) model on the train and test set:
init_train_metrics = model.evaluate_generator(train_gen)
init_test_metrics = model.evaluate_generator(test_gen)
print("\nTrain Set Metrics of the initial (untrained) model:")
for name, val in zip(model.metrics_names, init_train_metrics):
print("\t{}: {:0.4f}".format(name, val))
print("\nTest Set Metrics of the initial (untrained) model:")
for name, val in zip(model.metrics_names, init_test_metrics):
print("\t{}: {:0.4f}".format(name, val))
# Train model
print("\nTraining the model for {} epochs...".format(num_epochs))
history = model.fit_generator(train_gen,
epochs=num_epochs,
validation_data=test_gen,
verbose=2,
shuffle=False)
# Evaluate and print metrics
train_metrics = model.evaluate_generator(train_gen)
test_metrics = model.evaluate_generator(test_gen)
print("\nTrain Set Metrics of the trained model:")
for name, val in zip(model.metrics_names, train_metrics):
print("\t{}: {:0.4f}".format(name, val))
print("\nTest Set Metrics of the trained model:")
for name, val in zip(model.metrics_names, test_metrics):
print("\t{}: {:0.4f}".format(name, val))
# Save the trained model
save_str = "_n{}_l{}_d{}_r{}".format(
"_".join([str(x) for x in num_samples]),
"_".join([str(x) for x in layer_size]),
dropout,
learning_rate,
)
model.save("graphsage_link_pred" + save_str + ".h5")
def _compile(self):
self.model.compile(loss=losses.mean_squared_error,
optimizer=optimizers.Adam(),
metrics=['accuracy'])
x = K.reshape(x, (b_size * 64 * 64, num_classes))
x = K.softmax(x)
x = K.reshape(x, (b_size, 64, 64, num_classes))
return x
def resize_image(x):
x = K.resize_images(x, 4, 4, "channels_last")
return x
model.add(Activation(custom_softmax))
model.add(Lambda(resize_image))
# sgd = optimizers.SGD(lr=10, momentum=0.0, decay=0, nesterov=False)
opt = optimizers.Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(optimizer=opt, loss=custom_crossentrophy)
model.summary()
model.load_weights("../weights/implementation2-95.h5")
save_every_n_epoch = 5
# for i in range(n_epochs // save_every_n_epoch):
# model.fit_generator(image_processing.image_generator_hist(list_dir, images_dir_name, b_size),
# steps_per_epoch=len(list_dir)//b_size, epochs=save_every_n_epoch)
# model.save_weights("../weights/implementation2-" + str(i * save_every_n_epoch) + ".h5")
#
# # make validation
# loss = model.evaluate_generator(image_processing.image_generator_hist(None, "../test_set", b_size), 2)
# print("Validation loss:", loss)
print("LivDet2013 Loaded")
for list_ in train_data:
print(len(list_))
# train_data = np.array(train_data)
# train_data = train_data.astype('float32')/255
model = VGG16(include_top=True, weights=None, classes=1000)
model.layers.pop()
model.layers[-1].outbound_nodes = []
inp = model.input
opt = model.layers[-1].output
opt2 = Dense(250, activation='sigmoid')(opt) #intialization?
model = Model(input=inp, output=opt2)
adam = optimizers.Adam(lr=0.000001, beta_1=0.9, beta_2=0.999)
sgd = optimizers.SGD(lr=0.1, momentum=0.9, decay=0.0, nesterov=False)
model.compile(optimizer=adam, loss=loss_function)
iterations = 10000
losses = []
min_losses = []
for i in range(1, iterations + 1):
print("iteration:", i)
(anchors, examples) = prepare_batch(train_data)
y_true = model.predict(examples)
loss = model.train_on_batch(anchors, y_true)
print(loss)
losses.append(loss)
if i % 50 == 0:
def main():
V_data = sio.loadmat('V_train.mat')
V_data = V_data['V_train']
V_data = np.array(V_data)
I_data = sio.loadmat('I_train.mat')
I_data = I_data['I_train']
I_data = np.array(I_data)
IrrT_data = sio.loadmat('IrrT_train.mat')
IrrT_data = IrrT_data['IrrT_train']
IrrT_data = np.array(IrrT_data)
label = sio.loadmat('label_train.mat')
label = label['label_train']
# shuffle
index = np.arange(0, len(label))
random.shuffle(index)
# label data process
label = label.reshape(-1)
label = np_utils.to_categorical(label, num_classes=13)
label = label[index]
# Irr&T data process
IrrT_data = IrrT_data.reshape((IrrT_data.shape[0], IrrT_data.shape[1]))
IrrT_data[:, 0] = IrrT_data[:, 0] / 775.29
IrrT_data[:, 1] = IrrT_data[:, 1] / 51.98
IrrT_data = IrrT_data[index]
# V&I dataprocess
V_data = np.array(V_data, dtype='float32') / (13 * 37.78)
I_data = np.array(I_data, dtype='float32') / 9.12
V_data = V_data.reshape((V_data.shape[0], V_data.shape[1], 1))
I_data = I_data.reshape((I_data.shape[0], I_data.shape[1], 1))
V_data = V_data[index]
I_data = I_data[index]
input_V = Input(shape=(1000, 1), name='input_V')
input_I = Input(shape=(1000, 1), name='input_I')
input_IrrT = Input(shape=(2, ), name='input_IrrT')
model_input = [input_V, input_I, input_IrrT]
IV_train = concatenate([input_V, input_I])
Conv_Model = Conv1D(filters=32,
kernel_size=2,
activation='relu',
kernel_initializer=initializers.he_normal(),
name='Conv1')(IV_train)
Conv_Model = BatchNormalization(name='bn_conv1')(Conv_Model)
Conv_Model = MaxPooling1D(pool_size=2, strides=2)(Conv_Model)
##网上找的
# X = convolutional_block(Conv_Model, k_size=3, filters=[32, 32, 64], stage=2, block='a', s=1)
# X = identity_block(X, 3, [32, 32, 64], stage=2, block='b')
# X = identity_block(X, 3, [32, 32, 64], stage=2, block='c')
# # Stage 3
# X = convolutional_block(X, k_size=3, filters=[64, 64, 256], stage=3, block='a', s=2)
# X = identity_block(X, 3, [64, 64, 256], stage=3, block='b')
# X = identity_block(X, 3, [64, 64, 256], stage=3, block='c')
# X = identity_block(X, 3, [64, 64, 256], stage=3, block='d')
# # Stage 4
# X = convolutional_block(X, k_size=3, filters=[128, 128, 512], stage=4, block='a', s=2)
# X = identity_block(X, 3, [128, 128, 512], stage=4, block='b')
# X = identity_block(X, 3, [128, 128, 512], stage=4, block='c')
# X = identity_block(X, 3, [128, 128, 512], stage=4, block='d')
# X = identity_block(X, 3, [128, 128, 512], stage=4, block='e')
# X = identity_block(X, 3, [128, 128, 512], stage=4, block='f')
# # Stage 5
# X = convolutional_block(X, k_size=3, filters=[256, 256, 1024], stage=5, block='a', s=2)
# X = identity_block(X, 3, [256, 256, 1024], stage=5, block='b')
# X = identity_block(X, 3, [256, 256, 1024], stage=5, block='c')
#
# X = AveragePooling1D(pool_size=2)(X)
###自己搭的感觉效果还行，就是过拟合有点严重，本来只在输出添加池化的，结果显存不够，只好在中间插入池化层来减小显存占用
X = res_Conv_block(Conv_Model, k_size=9, input_filter=32, output_filter=64)
X = MaxPooling1D(pool_size=2, strides=2)(X)
X = res_Conv_block(X, k_size=7, input_filter=64, output_filter=128)
X = MaxPooling1D(pool_size=2, strides=2)(X)
X = res_Conv_block(X, k_size=5, input_filter=128, output_filter=256)
X = MaxPooling1D(pool_size=2, strides=2)(X)
X = res_Conv_block(X, k_size=3, input_filter=256, output_filter=512)
X = MaxPooling1D(pool_size=2, strides=2)(X)
###
# X = Conv1D(filters=64, kernel_size=4, activation='relu',
# kernel_initializer=initializers.he_normal())(Conv_Model)
# X = MaxPooling1D(pool_size=2, strides=2)(X)
# X = Conv1D(filters=128, kernel_size=8, activation='relu',
# kernel_initializer=initializers.he_normal())(X)
# X = MaxPooling1D(pool_size=2, strides=2)(X)
# X = Conv1D(filters=256, kernel_size=6, activation='relu',
# kernel_initializer=initializers.he_normal())(X)
# X = MaxPooling1D(pool_size=2, strides=2)(X)
# X = Conv1D(filters=512, kernel_size=6, activation='relu',
# kernel_initializer=initializers.he_normal())(X)
# X = MaxPooling1D(pool_size=2, strides=2)(X)
# X = BatchNormalization(epsilon=1e-06, momentum=0.9)(X)
X = BatchNormalization(epsilon=1e-06, momentum=0.9)(X)
X = Dropout(0.7)(X)
X = Flatten()(X)
X = concatenate([X, input_IrrT], axis=1)
Fc_Model = Dense(128, activation='relu')(X)
Fc_Model = Dense(64, activation='relu')(Fc_Model)
Fc_Out = Dense(13,
kernel_regularizer=regularizers.l2(0.0015),
activation='softmax',
name='Fc_Out')(Fc_Model)
model = Model(inputs=model_input, outputs=[Fc_Out])
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=1e-4),
metrics=['accuracy'])
model.fit({
'input_V': V_data,
'input_I': I_data,
'input_IrrT': IrrT_data
}, {'Fc_Out': label},
epochs=200,
batch_size=32,
validation_split=0.2)
model.save('CNNonly.h5')
inp = Input(shape=(maxlen, ))
x = Embedding(max_features, embed_size)(inp)
x = Flatten()(x)
agei = Input(shape=(153, ))
conc = concatenate([x, agei])
dens = Dense(128)(conc)
dens = Dense(3)(dens)
acti = Activation('softmax')(dens)
model = Model(inputs=[inp, agei], outputs=acti)
model.load_weights('models/my_model_weights.h5')
optimizer = optimizers.Adam(lr=1e-4)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
#####________________-
#removeing names infromt of nodes
vals = [
'Top0', 'Top1', 'Top2', 'Top3', 'Middle0', 'Middle1', 'Middle2', 'Base0',
'Base1'
]
for i in ['0', '1', '2', '3']:
print(i)
for val in vals:
perumes_old[i] = perumes_old[i].apply(lambda x: x.replace(val, ''))
def train(model, data, args):
"""
Training a CapsuleNet
:param model: the CapsuleNet model
:param data: a tuple containing training and testing data, like `((x_train, y_train), (x_test, y_test))`
:param args: arguments
:return: The trained model
"""
# unpacking the data
(x_train, y_train), (x_test, y_test) = data
# callbacks
log = callbacks.CSVLogger(args.save_dir + '/log.csv')
tb = callbacks.TensorBoard(log_dir=args.save_dir + '/tensorboard-logs',
batch_size=args.batch_size,
histogram_freq=int(args.debug))
checkpoint = callbacks.ModelCheckpoint(args.save_dir +
'/weights-{epoch:02d}.h5',
monitor='val_capsnet_acc',
save_best_only=True,
save_weights_only=True,
verbose=1)
lr_decay = callbacks.LearningRateScheduler(
schedule=lambda epoch: args.lr * (args.lr_decay**epoch))
# compile the model
model.compile(optimizer=optimizers.Adam(lr=args.lr),
loss=[margin_loss, 'mse'],
loss_weights=[1., args.lam_recon],
metrics={'capsnet': 'accuracy'})
"""
# Training without data augmentation:
model.fit([x_train, y_train], [y_train, x_train], batch_size=args.batch_size, epochs=args.epochs,
validation_data=[[x_test, y_test], [y_test, x_test]], callbacks=[log, tb, checkpoint, lr_decay])
"""
# Begin: Training with data augmentation ---------------------------------------------------------------------#
def train_generator(x, y, batch_size, shift_fraction=0.):
train_datagen = ImageDataGenerator(
width_shift_range=shift_fraction,
height_shift_range=shift_fraction) # shift up to 2 pixel for MNIST
generator = train_datagen.flow(x, y, batch_size=batch_size)
while 1:
x_batch, y_batch = generator.next()
yield ([x_batch, y_batch], [y_batch, x_batch])
# Training with data augmentation. If shift_fraction=0., also no augmentation.
model.fit_generator(
generator=train_generator(x_train, y_train, args.batch_size,
args.shift_fraction),
steps_per_epoch=int(y_train.shape[0] / args.batch_size),
epochs=args.epochs,
validation_data=[[x_test, y_test], [y_test, x_test]],
callbacks=[log, tb, checkpoint, lr_decay])
# End: Training with data augmentation -----------------------------------------------------------------------#
model.save_weights(args.save_dir + '/trained_model.h5')
print('Trained model saved to \'%s/trained_model.h5\'' % args.save_dir)
from utils import plot_log
plot_log(args.save_dir + '/log.csv', show=True)
return model
def runTrain(opts, sampleNumLimit=25):
description = 'Triplet_Model'
print(description)
print("with parameters, Alpha: %s, Batch_size: %s, Embedded_size: %s, Epoch_num: %s, sampleNumLimit: %s"%(alpha, batch_size, emb_size, number_epoch, sampleNumLimit))
source = os.path.basename(opts.input).split('.')[0]
'''
# ================================================================================
# This part is to prepare the files' index for geenrating triplet examples
# and formulating each epoch inputs
'''
allData, allLabel, label2IdDict, Id2Label = getClsIdDict(opts.input, sampleNumLimit, int(opts.data_dim))
all_traces = allData[:, :, np.newaxis]
print("Load traces with ", all_traces.shape)
print("Total size allocated on RAM : ", str(all_traces.nbytes / 1e6) + ' MB')
num_classes = len(list(label2IdDict.keys()))
print("number of classes: " + str(num_classes))
print('building positive pairs...')
Xa_train, Xp_train = build_positive_pairs(range(0, num_classes), label2IdDict)
# Gather the ids of all network traces that are used for training
# This just union of two sets set(A) | set(B)
all_traces_train_idx = list(set(Xa_train) | set(Xp_train))
print("X_train Anchor: ", Xa_train.shape)
print("X_train Positive: ", Xp_train.shape)
# Training the Triplet Model
#shared_conv2 = DF(input_shape=(5000,1), emb_size=emb_size)
input_shape = (allData.shape[1], 1)
print('input shape is: ', input_shape)
shared_conv2 = DF_model.DF(input_shape=input_shape, emb_size=emb_size)
anchor = Input(input_shape, name='anchor')
positive = Input(input_shape, name='positive')
negative = Input(input_shape, name='negative')
a = shared_conv2(anchor)
p = shared_conv2(positive)
n = shared_conv2(negative)
# The Dot layer in Keras now supports built-in Cosine similarity using the normalize = True parameter.
# From the Keras Docs:
# keras.layers.Dot(axes, normalize=True)
# normalize: Whether to L2-normalize samples along the dot product axis before taking the dot product.
# If set to True, then the output of the dot product is the cosine proximity between the two samples.
pos_sim = Dot(axes=-1, normalize=True)([a, p])
neg_sim = Dot(axes=-1, normalize=True)([a, n])
# customized loss
loss = Lambda(cosine_triplet_loss, output_shape=(1,))([pos_sim, neg_sim])
model_triplet = Model(inputs=[anchor, positive, negative], outputs=loss)
print(model_triplet.summary())
if opts.plotModel:
from keras.utils import plot_model
plot_model(model_triplet, to_file='triplet_model.png', dpi=200)
sys.exit(1)
# opt = optimizers.SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)
opt = optimizers.Adam(lr=0.001)
model_triplet.compile(loss=identity_loss, optimizer=opt)
print('finish compliation model')
logpath = os.path.join(ResDir, 'Training_Log_{}.csv'.format(description))
csv_logger = CSVLogger(logpath, append=True, separator=';')
# At first epoch we don't generate hard triplets
start = time.time()
gen_hard = SemiHardTripletGenerator(Xa_train, Xp_train, batch_size, all_traces, all_traces_train_idx, Id2Label, None)
print('finish generate first batch of data, start training...')
for epoch in range(number_epoch):
model_triplet.fit_generator(generator=gen_hard.next_train(),
steps_per_epoch=Xa_train.shape[0] // batch_size, # // 的意思是整除
epochs=1,
verbose=1,
callbacks=[csv_logger])
gen_hard = SemiHardTripletGenerator(Xa_train, Xp_train, batch_size, all_traces, all_traces_train_idx, Id2Label, shared_conv2)
# For no semi-hard triplet
#gen_hard = SemiHardTripletGenerator(Xa_train, Xp_train, batch_size, all_traces, all_traces_train_idx, None)
end = time.time()
time_last = end - start
print('finishing training, train time is: {:f}'.format(time_last))
modelPath = os.path.join(modelDir, 'triplet_{}_{}.h5'.format(source, sampleNumLimit))
shared_conv2.save(modelPath)
print('model save to path {}'.format(modelPath))
return modelPath, time_last
activation='tanh',
input_dim=x_train.shape[1]))
model.add(
Dense(units=int(NP.round(x_train.shape[1] / 1)),
activation='tanh'))
model.add(
Dense(units=int(NP.round(x_train.shape[1] / 1)),
activation='tanh'))
model.add(
Dense(units=int(NP.round(x_train.shape[1] / 1)),
activation='tanh'))
model.add(Dense(units=y_train.shape[1], activation='linear'))
Adam = optimizers.Adam(lr=5e-4,
decay=0,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-8)
model.compile(loss='mean_squared_error',
optimizer=Adam,
metrics=['mae'])
"""
----------------------------------------
Model Training
----------------------------------------
"""
trained = model.fit(x_train,
y_train,
validation_split=0,
shuffle=False,
def class_percent_2buckRange(y_true, y_pred): # percent of times the prediction is within 2 buckets of true value
return K.cast(K.equal(K.argmax(y_true, axis=-1),K.argmax(y_pred, axis=-1)),K.floatx()) + K.cast(K.equal(K.cast(K.argmax(y_true, axis=-1), K.floatx()), K.cast(K.argmax(y_pred, axis=-1),K.floatx())-1.0), K.floatx()) + K.cast(K.equal(K.cast(K.argmax(y_true, axis=-1), K.floatx()), K.cast(K.argmax(y_pred, axis=-1),K.floatx())+1.0), K.floatx()) + K.cast(K.equal(K.cast(K.argmax(y_true, axis=-1), K.floatx()), K.cast(K.argmax(y_pred, axis=-1),K.floatx())-2.0), K.floatx()) + K.cast(K.equal(K.cast(K.argmax(y_true, axis=-1), K.floatx()), K.cast(K.argmax(y_pred, axis=-1),K.floatx())+2.0), K.floatx())
# For reference, from keras documentation: https://github.com/keras-team/keras/blob/master/keras/losses.py
#def class_categorical_accuracy(y_true, y_pred):
#return K.cast(K.equal(K.argmax(y_true, axis=-1),K.argmax(y_pred, axis=-1)),K.floatx())
# #### Configure model loss and optimization function
# In[45]:
# Define Optimizer
if optimizer_type == 'adam':
model_optimizer = optimizers.Adam(lr = learning_rate) #, decay, beta_1, beta_2 are HPs
elif optimizer_type == 'rmsprop':
model_optimizer = optimizers.RMSprop(lr = learning_rate) #, decay, rho
elif optimizer_type == 'gradient':
model_optimizer = optimizers.SGD(lr = learning_rate) #, decay, momentum
# Compile model with appropriate loss function
if speed_bucket_size != 'none_use_regression': # if performing classification, ALWAYS use cross-entropy loss
model.compile(loss ='categorical_crossentropy', optimizer=model_optimizer, metrics=['accuracy',class_percent_1buckRange,class_percent_2buckRange, class_mae, class_mse]) # class_percent_1buckLow,class_percent_1buckHigh,class_percent_2buckLow, class_percent_2buckHigh,'class_mape'
else: # if performing regression, use mean squared error or mean absolute error
if loss_function == 'categorical_crossentropy': raise NameError('Are you sure you want to use cross entropy loss with a regression tasks!?')
model.compile(loss = loss_function, optimizer=model_optimizer, metrics=['mse','mae']) # options: 'mse','mae', 'mape'
# #### Train!
def main(args):
train_imgs, val_imgs = make_seq_dataset(args.root_dir, args.direction,
True, args.steer_threshold,
args.drop_low_angles,
args.steer_correction,
args.window_len, args.lookahead)
print(train_imgs.shape)
#plt.plot(val_imgs[:,-1,1])
#plt.show()
if args.num_samples > 0:
train_imgs = train_imgs[:args.num_samples]
val_imgs = val_imgs[:1000]
train_gen = seq_generator(train_imgs, args.batch_size, args.augmentation,
args.output, args.mode)
val_gen = seq_generator(val_imgs, args.batch_size, False, args.output,
args.mode)
num_outputs = 1 if args.output == 'angle' else 3
num_inputs = args.window_len if args.mode == 'concat' else args.window_len - 1
model = get_lstm_model(num_outputs, args.l2reg, num_inputs)
"""
model.load_weights("finalcnn-0.179.h5")
print(model.predict(x.reshape(-1, 480, 640, 3)).reshape(4,4))
seq_model = Sequential()
return
"""
adam = optimizers.Adam(lr=args.lr,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0)
model.compile(loss="mse", optimizer=adam, metrics=[angle_loss])
callbacks_list = []
history_object = model.fit_generator(
train_gen,
steps_per_epoch=(len(train_imgs) / args.batch_size),
validation_data=val_gen,
validation_steps=(len(val_imgs) / args.batch_size),
epochs=args.num_epochs,
verbose=1,
callbacks=callbacks_list)
if args.save_model != 'None':
model_json = model.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
model.save_weights("{}.h5".format(args.save_model))
pred = []
real = []
full_imgs, fnames = make_full_dataset(args.root_dir, args.direction, True,
args.steer_threshold,
args.drop_low_angles,
args.steer_correction,
args.window_len, args.lookahead)
full_gen = seq_generator(full_imgs, args.batch_size, args.augmentation,
args.output, args.mode)
print("Full imgs shape: ", full_imgs.shape)
for ix in range(int(len(full_imgs) / args.batch_size)):
inp, _real = next(full_gen)
_pred = model.predict(inp)
#print(_pred[:,0].shape, _real.shape)
real.extend(_real)
pred.extend(_pred[:, 0])
pred = np.array(pred)
real = np.array(real)
print("Mean Error: ", np.sqrt(np.mean((pred - real)**2)))
plt.figure(figsize=(16, 9))
plt.plot(pred, label='Predicted')
plt.plot(real, label='Actual')
plt.legend()
plt.savefig('pred_baseline.png')
#plt.show()
print(len(fnames), pred.shape, real.shape)
df = pd.DataFrame()
df['fnames'] = fnames[:len(real)]
df['angle'] = real
df['pred'] = pred
df.to_csv('results_baseline.csv')
print(history_object.history['val_loss'])
print(history_object.history['loss'])
def eval():
"""
Checks for keras checkpoints in a tensorflow dir and evaluates losses and given metrics.
Also creates visualization and writes everything to tensorboard.
"""
# create config object
cfg = load_dict(CONFIG)
# open files with images and ground truths files with full path names
with open(img_file) as imgs:
img_names = imgs.read().splitlines()
imgs.close()
# if multigpu support, adjust batch size
if GPUS > 1:
cfg.BATCH_SIZE = GPUS * cfg.BATCH_SIZE
# if a number for steps was given
if STEPS is not None:
nbatches_valid = STEPS
else:
nbatches_valid, mod = divmod(len(img_names), cfg.BATCH_SIZE)
# set gpu to use if no multigpu
# hide the other gpus so tensorflow only uses this one
os.environ['CUDA_VISIBLE_DEVICES'] = CUDA_VISIBLE_DEVICES
# tf config and session
config = tf.ConfigProto(allow_soft_placement=True)
sess = tf.Session(config=config)
K.set_session(sess)
# Variables to visualize losses (as metrics) for tensorboard
loss_var = tf.Variable(initial_value=0,
trainable=False,
name='val_loss',
dtype=tf.float32)
loss_without_regularization_var = tf.Variable(
initial_value=0,
trainable=False,
name='val_loss_without_regularization',
dtype=tf.float32)
conf_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='val_conf_loss',
dtype=tf.float32)
class_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='val_class_loss',
dtype=tf.float32)
bbox_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='val_bbox_loss',
dtype=tf.float32)
# create placeholders for metrics. Variables get assigned these.
loss_placeholder = tf.placeholder(loss_var.dtype, shape=())
loss_without_regularization_placeholder = tf.placeholder(
loss_without_regularization_var.dtype, shape=())
conf_loss_placeholder = tf.placeholder(conf_loss_var.dtype, shape=())
class_loss_placeholder = tf.placeholder(class_loss_var.dtype, shape=())
bbox_loss_placeholder = tf.placeholder(bbox_loss_var.dtype, shape=())
# we have to create the assign ops here and call the assign ops with a feed dict, otherwise memory leak
loss_assign_ops = [
loss_var.assign(loss_placeholder),
loss_without_regularization_var.assign(
loss_without_regularization_placeholder),
conf_loss_var.assign(conf_loss_placeholder),
class_loss_var.assign(class_loss_placeholder),
bbox_loss_var.assign(bbox_loss_placeholder)
]
tf.summary.scalar("loss", loss_var)
tf.summary.scalar("loss_without_regularization",
loss_without_regularization_var)
tf.summary.scalar("conf_loss", conf_loss_var)
tf.summary.scalar("class_loss", class_loss_var)
tf.summary.scalar("bbox_loss", bbox_loss_var)
# variables for images to visualize
images_with_boxes = tf.Variable(initial_value=np.zeros(
(cfg.VISUALIZATION_BATCH_SIZE, cfg.IMAGE_HEIGHT, cfg.IMAGE_WIDTH, 3)),
name="image",
dtype=tf.float32)
update_placeholder = tf.placeholder(images_with_boxes.dtype,
shape=images_with_boxes.get_shape())
update_images = images_with_boxes.assign(update_placeholder)
tf.summary.image("images",
images_with_boxes,
max_outputs=cfg.VISUALIZATION_BATCH_SIZE)
# variables for precision recall and mean average precision
precisions = []
recalls = []
APs = [] # mean average precision
f1s = []
# placeholders as above
precision_placeholders = []
recall_placeholders = []
prmap_assign_ops = []
AP_placeholders = []
f1_placeholders = []
# add variables, placeholders and assign ops for each class
for i, name in enumerate(cfg.CLASS_NAMES):
# print("Creating tensorboard plots for " + name)
precisions.append(
tf.Variable(initial_value=0,
trainable=False,
name="precision/" + name,
dtype=tf.float32))
recalls.append(
tf.Variable(initial_value=0,
trainable=False,
name="recall/" + name,
dtype=tf.float32))
f1s.append(
tf.Variable(initial_value=0,
trainable=False,
name="f1/" + name,
dtype=tf.float32))
APs.append(
tf.Variable(initial_value=0,
trainable=False,
name="AP/" + name,
dtype=tf.float32))
precision_placeholders.append(
tf.placeholder(dtype=precisions[i].dtype,
shape=precisions[i].shape))
recall_placeholders.append(
tf.placeholder(dtype=recalls[i].dtype, shape=recalls[i].shape))
AP_placeholders.append(
tf.placeholder(dtype=APs[i].dtype, shape=APs[i].shape))
f1_placeholders.append(
tf.placeholder(dtype=f1s[i].dtype, shape=f1s[i].shape))
prmap_assign_ops.append(precisions[i].assign(
precision_placeholders[i]))
prmap_assign_ops.append(recalls[i].assign(recall_placeholders[i]))
prmap_assign_ops.append(APs[i].assign(AP_placeholders[i]))
prmap_assign_ops.append(f1s[i].assign(f1_placeholders[i]))
#same for mean average precision
mAP = tf.Variable(initial_value=0,
trainable=False,
name="mAP",
dtype=tf.float32)
mAP_placeholder = tf.placeholder(mAP.dtype, shape=())
prmap_assign_ops.append(mAP.assign(mAP_placeholder))
tf.summary.scalar("mAP", mAP)
for i, name in enumerate(cfg.CLASS_NAMES):
tf.summary.scalar("precision/" + name, precisions[i])
tf.summary.scalar("recall/" + name, recalls[i])
tf.summary.scalar("AP/" + name, APs[i])
tf.summary.scalar("f1/" + name, f1s[i])
merged = tf.summary.merge_all()
if STARTWITH is None:
#check for tensorboard dir and delete old stuff
if tf.gfile.Exists(tensorboard_dir):
tf.gfile.DeleteRecursively(tensorboard_dir)
tf.gfile.MakeDirs(tensorboard_dir)
writer = tf.summary.FileWriter(tensorboard_dir)
#instantiate model
squeeze = SqueezeDet(cfg)
#dummy optimizer for compilation
sgd = optimizers.SGD(lr=cfg.LEARNING_RATE,
decay=0,
momentum=cfg.MOMENTUM,
nesterov=False,
clipnorm=cfg.MAX_GRAD_NORM)
adam = optimizers.Adam(lr=0.0001, clipnorm=cfg.MAX_GRAD_NORM)
if GPUS > 1:
#parallelize model
model = multi_gpu_model(squeeze.model, gpus=GPUS)
model.compile(optimizer=sgd,
loss=[squeeze.loss],
metrics=[
squeeze.bbox_loss, squeeze.class_loss,
squeeze.conf_loss,
squeeze.loss_without_regularization
])
else:
# compile model from squeeze object, loss is not a function of model directly
if OPTIMIZER == "adam":
print("adam")
squeeze.model.compile(optimizer=adam,
loss=[squeeze.loss],
metrics=[
squeeze.bbox_loss, squeeze.class_loss,
squeeze.conf_loss,
squeeze.loss_without_regularization
])
else:
print("sgd")
squeeze.model.compile(optimizer=sgd,
loss=[squeeze.loss],
metrics=[
squeeze.bbox_loss, squeeze.class_loss,
squeeze.conf_loss,
squeeze.loss_without_regularization
])
model = squeeze.model
# models already evaluated
evaluated_models = set()
# get the best ckpts for test set
best_val_loss_ckpt = None
best_val_loss = np.inf
best_mAP_ckpt = None
best_mAP = -np.inf
time_out_counter = 0
with open(gt_val_dir, 'r') as g:
data = json.load(g)
g.close()
print("File read")
print('STEPS ', nbatches_valid)
# use this for saving metrics to a csv
f = open(log_dir_name + "\\metrics.csv", "w")
header = "epoch;regularized;loss;bbox;class;conf;"
for i, name in enumerate(cfg.CLASS_NAMES):
header += name +"_precision;" \
+ name +"_recall;" \
+ name + "_AP;" \
+ name + "_f1;"
header += "\n"
f.write(header)
# listening for new checkpoints
while 1:
current_model = None
#go through checkpoint dir
for ckpt in sorted(os.listdir(checkpoint_dir)):
if STARTWITH is not None:
if ckpt < STARTWITH:
evaluated_models.add(ckpt)
#if model hasn't been evaluated
if ckpt not in evaluated_models:
#string for csv
line = ""
#add epoch to csv
line += str(len(evaluated_models) + 1) + ";"
print("Evaluating model {}".format(ckpt))
#load this ckpt
current_model = ckpt
try:
squeeze.model.load_weights(checkpoint_dir + "\\" + ckpt)
# sometimes model loading files, because the file is still locked, so wait a little bit
except OSError as e:
print(e)
time.sleep(10)
squeeze.model.load_weights(checkpoint_dir + "\\" + ckpt)
# create 2 validation generators, one for metrics and one for object detection evaluation
# we have to reset them each time to have the same data, otherwise we'd have to use batch size one.
val_generator_1 = generator_from_data_path(img_names,
data,
base_val,
config=cfg)
val_generator_2 = generator_from_data_path(img_names,
data,
base_val,
config=cfg)
# create a generator for the visualization of bounding boxes
vis_generator = visualization_generator_from_data_path(
img_names, data, base_val, config=cfg)
print(" Evaluate losses...")
# compute losses of whole val set
losses = model.evaluate_generator(val_generator_1,
steps=nbatches_valid,
max_queue_size=10,
use_multiprocessing=False)
# manually add losses to tensorboard
sess.run(
loss_assign_ops, {
loss_placeholder: losses[0],
loss_without_regularization_placeholder: losses[4],
conf_loss_placeholder: losses[3],
class_loss_placeholder: losses[2],
bbox_loss_placeholder: losses[1]
})
#print losses
print(" Losses:")
print(
" Loss with regularization: {}\n\tval loss:{}\n\tbbox_loss:{}\n\tclass_loss:{}\n\tconf_loss:{}"
.format(losses[0], losses[4], losses[1], losses[2],
losses[3]))
line += "{};{};{};{};{};".format(losses[0], losses[4],
losses[1], losses[2],
losses[3])
#save model with smallest loss
if losses[4] < best_val_loss:
best_val_loss = losses[4]
best_val_loss_ckpt = current_model
#compute precision recall and mean average precision
precision, recall, f1, AP, boxes, classes = evaluate(
model=model,
generator=val_generator_2,
steps=nbatches_valid,
config=cfg)
# print("boxes ",len(boxes))
# print("classes ",classes)
#create feed dict for visualization
prmap_feed_dict = {}
for i, name in enumerate(cfg.CLASS_NAMES):
prmap_feed_dict[precision_placeholders[i]] = precision[i]
prmap_feed_dict[recall_placeholders[i]] = recall[i]
prmap_feed_dict[AP_placeholders[i]] = AP[i, 1]
prmap_feed_dict[f1_placeholders[i]] = f1[i]
line += "{};{};{};{}".format(precision[i], recall[i],
AP[i, 1], f1[i])
prmap_feed_dict[mAP_placeholder] = np.mean(AP[:, 1], axis=0)
#save model with biggest mean average precision
if np.mean(AP[:, 1], axis=0) > best_mAP:
best_mAP = np.mean(AP[:, 1], axis=0)
best_mAP_ckpt = current_model
# run loss assign ops for tensorboard
sess.run(prmap_assign_ops, prmap_feed_dict)
# create visualization
imgs = visualize(model=model,
generator=vis_generator,
config=cfg)
# update op for images
sess.run(update_images, {update_placeholder: imgs})
# write everything to tensorboard
writer.add_summary(merged.eval(session=sess),
len(evaluated_models))
# writer.flush()
f.write(line + "\n")
f.flush()
#mark as evaluated
evaluated_models.add(ckpt)
#reset timeout
time_out_counter = 0
#if all ckpts have been evaluated on val set end
if len(evaluated_models) == EPOCHS:
break
#if all ckpts have been evaluated on val set end
if len(evaluated_models) == EPOCHS:
print("Evaluated all checkpoints")
break
#no new model found
if current_model is None:
#when timeout has been reached, abort
if time_out_counter == TIMEOUT:
print("timeout")
break
print("Waiting for new checkpoint....")
time.sleep(60)
time_out_counter += 1
f.close()
#evaluate best ckpts on test set
#list of ckpts for test set evaluation
ckpts = [best_val_loss_ckpt, best_mAP_ckpt]
print("Lowest loss: {} at checkpoint {}".format(best_val_loss,
best_val_loss_ckpt))
print("Highest mAP: {} at checkpoint {}".format(best_mAP, best_mAP_ckpt))
#evaluate on test set
if TESTING:
ckpts = set(ckpts)
#get test images and gt
with open(img_file_test) as imgs:
img_names_test = imgs.read().splitlines()
imgs.close()
#if a number for steps was given
if steps is not None:
nbatches_test = steps
#again create Variables to visualize losses for tensorboard, but this time for test set
test_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='test_loss',
dtype=tf.float32)
test_loss_without_regularization_var = tf.Variable(
initial_value=0,
trainable=False,
name='test_loss_without_regularization',
dtype=tf.float32)
test_conf_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='test_conf_loss',
dtype=tf.float32)
test_class_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='test_class_loss',
dtype=tf.float32)
test_bbox_loss_var = tf.Variable(initial_value=0,
trainable=False,
name='test_bbox_loss',
dtype=tf.float32)
#we have to create the assign ops here and call the assign ops with a feed dictg, otherwise memory leak
test_loss_placeholder = tf.placeholder(loss_var.dtype, shape=())
test_loss_without_regularization_placeholder = tf.placeholder(
loss_without_regularization_var.dtype, shape=())
test_conf_loss_placeholder = tf.placeholder(conf_loss_var.dtype,
shape=())
test_class_loss_placeholder = tf.placeholder(class_loss_var.dtype,
shape=())
test_bbox_loss_placeholder = tf.placeholder(bbox_loss_var.dtype,
shape=())
test_loss_assign_ops = [
test_loss_var.assign(test_loss_placeholder),
test_loss_without_regularization_var.assign(
test_loss_without_regularization_placeholder),
test_conf_loss_var.assign(test_conf_loss_placeholder),
test_class_loss_var.assign(test_class_loss_placeholder),
test_bbox_loss_var.assign(test_bbox_loss_placeholder)
]
tf.summary.scalar("test/loss", loss_var, collections=["test"])
tf.summary.scalar("test/loss_without_regularization",
loss_without_regularization_var,
collections=["test"])
tf.summary.scalar("test/conf_loss",
conf_loss_var,
collections=["test"])
tf.summary.scalar("test/class_loss",
class_loss_var,
collections=["test"])
tf.summary.scalar("test/bbox_loss",
bbox_loss_var,
collections=["test"])
#variables for precision recall and mean average precision
precisions = []
recalls = []
APs = []
f1s = []
precision_placeholders = []
recall_placeholders = []
AP_placeholders = []
f1_placeholders = []
prmap_assign_ops = []
for i, name in enumerate(cfg.CLASS_NAMES):
precisions.append(
tf.Variable(initial_value=0,
trainable=False,
name="test/precision/" + name,
dtype=tf.float32))
recalls.append(
tf.Variable(initial_value=0,
trainable=False,
name="test/recall/" + name,
dtype=tf.float32))
f1s.append(
tf.Variable(initial_value=0,
trainable=False,
name="test/f1/" + name,
dtype=tf.float32))
APs.append(
tf.Variable(initial_value=0,
trainable=False,
name="test/AP/" + name,
dtype=tf.float32))
precision_placeholders.append(
tf.placeholder(dtype=precisions[i].dtype,
shape=precisions[i].shape))
recall_placeholders.append(
tf.placeholder(dtype=recalls[i].dtype, shape=recalls[i].shape))
AP_placeholders.append(
tf.placeholder(dtype=APs[i].dtype, shape=APs[i].shape))
f1_placeholders.append(
tf.placeholder(dtype=f1s[i].dtype, shape=f1s[i].shape))
prmap_assign_ops.append(precisions[i].assign(
precision_placeholders[i]))
prmap_assign_ops.append(recalls[i].assign(recall_placeholders[i]))
prmap_assign_ops.append(APs[i].assign(AP_placeholders[i]))
prmap_assign_ops.append(f1s[i].assign(f1_placeholders[i]))
test_mAP = tf.Variable(initial_value=0,
trainable=False,
name="mAP",
dtype=tf.float32)
mAP_placeholder = tf.placeholder(test_mAP.dtype, shape=())
prmap_assign_ops.append(test_mAP.assign(mAP_placeholder))
tf.summary.scalar("test/mAP", mAP, collections=["test"])
tf.summary.scalar("test/precision/" + name,
precisions[i],
collections=["test"])
tf.summary.scalar("test/recall/" + name,
recalls[i],
collections=["test"])
tf.summary.scalar("test/AP/" + name, APs[i], collections=["test"])
tf.summary.scalar("test/f1/" + name, f1s[i], collections=["test"])
merged = tf.summary.merge_all(key="test")
#check for tensorboard dir and delete old stuff
if tf.gfile.Exists(tensorboard_dir_test):
tf.gfile.DeleteRecursively(tensorboard_dir_test)
tf.gfile.MakeDirs(tensorboard_dir_test)
writer = tf.summary.FileWriter(tensorboard_dir_test)
i = 1
#go through given checkpoints
for ckpt in ckpts:
print("Evaluating model {} on test data".format(ckpt))
#load this ckpt
current_model = ckpt
squeeze.model.load_weights(checkpoint_dir + "/" + ckpt)
# create 2 validation generators, one for metrics and one for object detection evaluation
# we have to reset them each time to have the same data
val_generator_1 = generator_from_data_path(img_names_test,
gt_test_dir,
base_test,
config=cfg)
val_generator_2 = generator_from_data_path(img_names_test,
gt_test_dir,
base_test,
config=cfg)
# create a generator for the visualization of bounding boxes
print(" Evaluate losses...")
#compute losses of whole val set
losses = model.evaluate_generator(val_generator_1,
steps=nbatches_test,
max_queue_size=10,
use_multiprocessing=False)
#manually add losses to tensorboard
sess.run(
loss_assign_ops, {
loss_placeholder: losses[0],
loss_without_regularization_placeholder: losses[4],
conf_loss_placeholder: losses[3],
class_loss_placeholder: losses[2],
bbox_loss_placeholder: losses[1]
})
print(" Losses:")
print(
" Loss with regularization: {} val loss:{} \n bbox_loss:{} \n class_loss:{} \n conf_loss:{}"
.format(losses[0], losses[4], losses[1], losses[2], losses[3]))
#compute precision recall and mean average precision
precision, recall, f1, AP, boxes, classes = evaluate(
model=model,
generator=val_generator_2,
steps=nbatches_test,
config=cfg)
#create feed dict for visualization
prmap_feed_dict = {}
for i, name in enumerate(cfg.CLASS_NAMES):
prmap_feed_dict[precision_placeholders[i]] = precision[i]
prmap_feed_dict[recall_placeholders[i]] = recall[i]
prmap_feed_dict[AP_placeholders[i]] = AP[i, 1]
prmap_feed_dict[f1_placeholders[i]] = f1[i]
prmap_feed_dict[mAP_placeholder] = np.mean(AP[:, 1], axis=0)
sess.run(prmap_assign_ops, prmap_feed_dict)
#write everything to tensorboard
writer.add_summary(merged.eval(session=sess), i)
writer.flush()
i += 1
headModel = Dense(1024, activation='relu')(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(512, activation='relu')(headModel)
headModel = Dropout(0.2)(headModel)
headModel = Dense(256, activation='relu')(headModel)
headModel = Dense(50, activation='softmax')(headModel)'''
model = Model(inputs=baseModel.input, outputs=predictions)
model.summary()
keras_callbacks = [
EarlyStopping(monitor='val_loss', verbose=1,patience=3, mode='min')
]
from keras import optimizers
model.compile(loss ='categorical_crossentropy',optimizer = optimizers.Adam(lr=0.0001),
metrics=['accuracy'])
history = model.fit(train_generator,steps_per_epoch = train_generator.n//train_generator.batch_size,
validation_data= valid_generator,validation_steps= valid_generator.n//valid_generator.batch_size
,epochs = 50,callbacks=keras_callbacks)
score = model.evaluate(valid_generator, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
predictions = model.predict(valid_generator)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
cvscores = []
Y = to_categorical(Y, num_classes=3)
for train, test in k_fold:
# create model
model = Sequential()
model.add(Dense(100, input_dim=2048, activation='relu'))
model.add(layers.BatchNormalization())
model.add(Dense(50, activation='relu'))
model.add(layers.Dropout(0.4))
model.add(Dense(3, activation='softmax'))
# Compile model
adam = optimizers.Adam(lr=0.0001,
beta_1=0.9,
beta_2=0.999,
epsilon=2e-11,
decay=0.0,
amsgrad=False)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
# Fit the model
model.fit(X[train],
Y[train],
epochs=500,
batch_size=75,
validation_split=0.1,
verbose=2)
# evaluate the model
scores = model.evaluate(X[test], Y[test], verbose=2)
#scores = model.cross_val_score(f,X[test],Y[test])
def EB_NN(data_path, result_path, n_epoch, input_dim):
# load data
X, Y = load_data(data_path)
# num_data = len(X)
# train_test_split = int(0.8 * num_data)
#
# day_train = np.array(X[0:train_test_split])
# Y_train = np.array(Y[0:train_test_split])
#
# day_test = np.array(X[train_test_split:])
# Y_test = np.array(Y[train_test_split:])
day_train = np.array(X[0])
Y_train = np.array(Y[0])
day_test = np.array(X[1])
Y_test = np.array(Y[1])
"""
Some items don't have enough data
"""
print("%s Train data %d. Test data %d" %
(product, len(day_train), len(day_test)))
logging.info("%s Train data %d. Test data %d" %
(product, len(day_train), len(day_test)))
# if len(day_train) < 10 or len(day_test) < 10:
# print("%s data is not enough." % product)
# logging.info("%s data is not enough." % product)
# return
print("day:", day_train.shape, "Y:", Y_train.shape)
# build
model_name = result_path
if os.path.isfile(model_name):
print("Loading previous model ......")
model = load_model(model_name)
else:
print("Creating new model ......")
model = Sequential()
model.add(Dense(64, activation="relu", input_dim=input_dim))
model.add(Dense(64, activation="relu"))
# model.add(Flatten())
model.add(Dropout(0.9))
model.add(Dense(2, activation="sigmoid"))
adam = optimizers.Adam(lr=0.01)
model.compile(loss='binary_crossentropy',
optimizer=adam,
metrics=['accuracy'])
# model Compile
# model_name = result_path + 'model2_price_move_predict.hdf5'
checkpointer = ModelCheckpoint(filepath=model_name,
monitor='val_loss',
verbose=1,
save_best_only=True)
earlystopper = EarlyStopping(monitor='val_loss', patience=20, verbose=1)
# outmodel = open(result_path + 'model2_price_move_predict.json', 'w')
# outmodel.write(model.to_json())
# outmodel.close()
# train
history = model.fit(
day_train,
Y_train,
epochs=n_epoch,
batch_size=1,
# callbacks=[checkpointer],
validation_split=0)
print(history.history)
# only save the final epoch
model.save(model_name)
if os.path.isfile(model_name):
model = load_model(model_name)
scores = model.evaluate(day_test, Y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
probabilities = model.predict(day_test)
predictions = [np.rint(x) for x in probabilities]
num = len(probabilities)
correct = np.sum(predictions == Y_test)
print(num, correct / 2)
accuracy = np.mean(predictions == Y_test)
print("Prediction Accuracy: %.2f%%" % (accuracy * 100))
# f = open("../data/all/1000/model/EB_NN_result.txt", 'a')
f = open("../data/all/1000/model/ONE_EB_NN_result.txt", 'a')
content = '\t'.join([
str(product),
str(scores[0]),
str(scores[1]),
str(num),
str(correct / 2)
])
print(content)
f.write(content)
f.write('\n')
f.close()
def get_model():
model = Sequential()
if 'model' in locals():
model.reset_states()
def identity_block(inputs, kernel_size, filters):
filters1, filters2, filters3 = filters
x = Conv1D(filters1,
1,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(inputs)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
x = Activation('relu')(x)
x = Conv1D(filters2,
kernel_size,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay),
padding='same')(x)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
x = Activation('relu')(x)
x = Conv1D(filters3,
1,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
x = add([x, inputs])
x = Activation('relu')(x)
return x
def conv_block(inputs, kernel_size, filters, strides=2):
filters1, filters2, filters3 = filters
x = Conv1D(filters1,
1,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(inputs)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
x = Activation('relu')(x)
x = Conv1D(filters2,
kernel_size,
strides=strides,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay),
padding='same')(x)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
x = Activation('relu')(x)
x = Conv1D(filters3,
1,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
shortcut = Conv1D(filters3,
1,
strides=strides,
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(inputs)
shortcut = BatchNormalization(momentum=batch_decay,
epsilon=eps)(shortcut)
x = add([x, shortcut])
x = Activation('relu')(x)
return x
inputs = Input(shape=(max_length, 2))
x = Conv1D(filter1,
conv_kernel,
strides=2,
padding='valid',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(inputs)
x = BatchNormalization(momentum=batch_decay, epsilon=eps)(x)
x = Activation('relu')(x)
x = MaxPooling1D(3, strides=2)(x)
x = conv_block(x, block_kernel, [filter1, filter1, filter1 * 4])
x = identity_block(x, block_kernel, [filter1, filter1, filter1 * 4])
x = conv_block(x, block_kernel, [filter2, filter2, filter2 * 4])
# x = identity_block(x,3, [filter2, filter2, filter2*4])
x = SpatialDropout1D(rate=dropout_rate)(x)
x = Conv1D(filter2,
11,
strides=2,
padding='valid',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(x)
x = Activation('relu')(x)
x = GlobalAveragePooling1D()(x)
'''
# dense to 100 >> final layer >> dense to num_classes
x = Dense(100, kernel_regularizer = l2(weight_decay),
bias_regularizer = l2(weight_decay), name ='features_hundred')(x)
final_layer = Model(inputs= inputs, outputs = x)
x = Dense(num_classes, kernel_regularizer=l2(weight_decay),
bias_regularizer=l2(weight_decay), name= 'features')(x)
x = Activation('softmax')(x)
'''
x = Dense(num_classes,
kernel_regularizer=l2(weight_decay),
bias_regularizer=l2(weight_decay),
name='features')(x)
final_layer = Model(inputs=inputs, outputs=x)
x = Activation('softmax')(x)
model = Model(inputs=inputs, outputs=x)
# optimizer
sgd = optimizers.SGD(lr=learning_rate, momentum=momentum)
adagrad = optimizers.Adagrad()
adam = optimizers.Adam(lr=learning_rate)
# compiler
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
return model, final_layer
def get_model(self):
lrelu = custom_function.lrelu()
inputs = Input(shape=(self.time_step, 20, 27, 2), name='grid_input')
layer1 = ConvLSTM2D(filters=16,
kernel_size=3,
strides=1,
padding='same',
return_sequences=True,
activation=lrelu,
dropout=0.2,
name='convlstm2d_1')(inputs)
# layer1 = BatchNormalization()(layer1)
if self.is_seasonal_circle:
sc_input = Input(shape=(1, ), dtype='int32')
sc_layer = Embedding(12, 3 * 20 * 27 * 16,
input_length=1)(sc_input)
sc_layer = Reshape((3, 20, 27, 16))(sc_layer)
layer1 = concatenate([layer1, sc_layer], axis=4)
layer2 = ConvLSTM2D(filters=32,
kernel_size=3,
strides=1,
padding='same',
return_sequences=True,
activation=lrelu,
dropout=0.2,
name='convlstm2d_2')(layer1)
# print(layer1.get_shape().as_list())
# layer2 = BatchNormalization()(layer2)
layer3 = ConvLSTM2D(filters=32,
kernel_size=3,
strides=1,
padding='same',
return_sequences=True,
activation=lrelu,
dropout=0.2,
name='convlstm2d_3')(layer2)
# layer3 = BatchNormalization()(layer3)
predictions = ConvLSTM2D(filters=2,
padding='same',
kernel_size=3,
strides=1,
activation='linear',
name='convlstm2d_grid_output')(layer3)
if self.is_nino_output:
nino_layer = NinoLayer.get_nino_layer(name='nino_output')
predictions_ninos = nino_layer(predictions)
# sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
adam = optimizers.Adam(learning_rate=0.00005,
beta_1=0.9,
beta_2=0.999,
amsgrad=False)
if not self.is_seasonal_circle and not self.is_nino_output:
model = Model(inputs=inputs, outputs=predictions)
model.compile(optimizer=adam,
loss=custom_function.mean_squared_error,
metrics=[custom_function.root_mean_squared_error])
elif self.is_seasonal_circle and not self.is_nino_output:
model = Model(inputs=[inputs, sc_input], outputs=predictions)
model.compile(optimizer=adam,
loss=custom_function.mean_squared_error,
metrics=[custom_function.root_mean_squared_error])
elif not self.is_seasonal_circle and self.is_nino_output:
model = Model(inputs=inputs,
outputs=[predictions, predictions_ninos])
model.compile(optimizer=adam,
loss=custom_function.mean_squared_error,
loss_weights=[0.25, 0.75],
metrics=[custom_function.root_mean_squared_error])
else:
model = Model(inputs=[inputs, sc_input],
outputs=[predictions, predictions_ninos])
model.compile(optimizer=adam,
loss=custom_function.mean_squared_error,
loss_weights=[0.25, 0.75],
metrics=[custom_function.root_mean_squared_error])
# model.summary()
return model
def iterate_hyperparas(use_default=False):
## initializer, regularization, activation function, learning rate, batch size
## some parameters may change during training? (learning rate). ignore this need for now
options = {}
# defaults = {}
# defaults['activation_regularizer'] = None
# defaults['kernel_regularizer'] = 0.001
# defaults['activation_regularizer'] = 0.1
## initializer
options['initializer'] = []
options['initializer'].append(initializers.glorot_normal(seed=None))
options['initializer'].append(initializers.glorot_uniform(seed=None))
options['initializer'].append(
initializers.RandomNormal(mean=0.0, stddev=0.05, seed=None))
options['initializer'].append(
initializers.RandomUniform(minval=-0.05, maxval=0.05, seed=None))
options['initializer'].append(
initializers.TruncatedNormal(mean=0.0, stddev=0.05, seed=None))
## kernel_regularizer
options['kernel_regularizer'] = []
options['kernel_regularizer'].append(None)
options['kernel_regularizer'].append(regularizers.l1(0.0001))
options['kernel_regularizer'].append(regularizers.l1(0.001))
options['kernel_regularizer'].append(regularizers.l1(0.01))
options['kernel_regularizer'].append(regularizers.l1(0.1))
options['kernel_regularizer'].append(regularizers.l2(0.0001))
options['kernel_regularizer'].append(regularizers.l2(0.001))
options['kernel_regularizer'].append(regularizers.l2(0.01))
options['kernel_regularizer'].append(regularizers.l2(0.1))
options['kernel_regularizer'].append(regularizers.l1_l2(0.0001))
options['kernel_regularizer'].append(regularizers.l1_l2(0.001))
options['kernel_regularizer'].append(regularizers.l1_l2(0.01))
options['kernel_regularizer'].append(regularizers.l1_l2(0.1))
## activity_regularizer
options['activity_regularizer'] = []
options['activity_regularizer'].append(None)
options['activity_regularizer'].append(regularizers.l1(0.0001))
options['activity_regularizer'].append(regularizers.l1(0.001))
options['activity_regularizer'].append(regularizers.l1(0.01))
options['activity_regularizer'].append(regularizers.l1(0.1))
options['activity_regularizer'].append(regularizers.l2(0.0001))
options['activity_regularizer'].append(regularizers.l2(0.001))
options['activity_regularizer'].append(regularizers.l2(0.01))
options['activity_regularizer'].append(regularizers.l2(0.1))
options['activity_regularizer'].append(regularizers.l1_l2(0.0001))
options['activity_regularizer'].append(regularizers.l1_l2(0.001))
options['activity_regularizer'].append(regularizers.l1_l2(0.01))
options['activity_regularizer'].append(regularizers.l1_l2(0.1))
## bias_regularizer
options['bias_regularizer'] = []
options['bias_regularizer'].append(None)
options['bias_regularizer'].append(regularizers.l1(0.0001))
options['bias_regularizer'].append(regularizers.l1(0.001))
options['bias_regularizer'].append(regularizers.l1(0.01))
options['bias_regularizer'].append(regularizers.l1(0.1))
options['bias_regularizer'].append(regularizers.l2(0.0001))
options['bias_regularizer'].append(regularizers.l2(0.001))
options['bias_regularizer'].append(regularizers.l2(0.01))
options['bias_regularizer'].append(regularizers.l2(0.1))
options['bias_regularizer'].append(regularizers.l1_l2(0.0001))
options['bias_regularizer'].append(regularizers.l1_l2(0.001))
options['bias_regularizer'].append(regularizers.l1_l2(0.01))
options['bias_regularizer'].append(regularizers.l1_l2(0.1))
## activation
options['activation'] = []
options['activation'].append('relu')
options['activation'].append('elu')
options['activation'].append('selu')
options['activation'].append('tanh')
options['activation'].append('sigmoid')
## optimizer and learning rate
options['optimizer'] = []
options['optimizer'].append(
optimizers.SGD(lr=0.001, momentum=0.0, decay=0.0, nesterov=False))
options['optimizer'].append(
optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False))
options['optimizer'].append(
optimizers.SGD(lr=0.1, momentum=0.0, decay=0.0, nesterov=False))
options['optimizer'].append(
optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0))
options['optimizer'].append(
optimizers.RMSprop(lr=0.01, rho=0.9, epsilon=None, decay=0.0))
options['optimizer'].append(
optimizers.RMSprop(lr=0.1, rho=0.9, epsilon=None, decay=0.0))
options['optimizer'].append(
optimizers.Adagrad(lr=0.001, epsilon=None, decay=0.0))
options['optimizer'].append(
optimizers.Adagrad(lr=0.01, epsilon=None, decay=0.0))
options['optimizer'].append(
optimizers.Adagrad(lr=0.1, epsilon=None, decay=0.0))
options['optimizer'].append(
optimizers.Adam(lr=0.001,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False))
options['optimizer'].append(
optimizers.Adam(lr=0.01,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False))
options['optimizer'].append(
optimizers.Adam(lr=0.1,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False))
options['optimizer'].append(
optimizers.Nadam(lr=0.002,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
schedule_decay=0.004))
options['optimizer'].append(
optimizers.Nadam(lr=0.02,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
schedule_decay=0.004))
options['optimizer'].append(
optimizers.Nadam(lr=0.2,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
schedule_decay=0.004))
## batch size
options['batch_size'] = 32
options['batch_size'] = 128
options['batch_size'] = 1024
options['batch_size'] = 8192
return options
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
from keras import optimizers
import numpy as np
json_file = open('model.json','r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights("model.h5")
adam = optimizers.Adam(lr=0.001, decay =1e-6)
loaded_model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy'])
testY = np.load('groundTruth.npy')
testX = np.load('testData.npy')
score = loaded_model.evaluate(testX,testY,verbose=2)
print('Baseline Error: %.2f%%' %(100-score[1]*100))
output = loaded_model.predict(testX[0:1,:,:,:])
print("Predect Output" , output)
X_test = data_test.drop(['Class'], axis=1).values
Y_test = data_test['Class']
input_size = 29
hidden_sizes = [80, 40, 80]
input_layer = Input(shape=(input_size,))
encoder = Dense(hidden_sizes[0], activation="relu")(input_layer)
encoder = Dense(hidden_sizes[1], activation="relu")(encoder)
decoder = Dense(hidden_sizes[2], activation='relu')(encoder)
decoder = Dense(input_size)(decoder)
deep_ae = Model(inputs=input_layer, outputs=decoder)
print(deep_ae.summary())
optimizer = optimizers.Adam(lr=0.00005)
deep_ae.compile(optimizer=optimizer, loss='mean_squared_error')
tensorboard = TensorBoard(log_dir='./logs/run2/', write_graph=True, write_images=False)
model_file = "model_deep_ae.h5"
checkpoint = ModelCheckpoint(model_file, monitor='loss', verbose=1, save_best_only=True, mode='min')
num_epoch = 50
batch_size = 64
deep_ae.fit(X_train, X_train, epochs=num_epoch, batch_size=batch_size, shuffle=True, validation_data=(X_test, X_test),
verbose=1, callbacks=[checkpoint, tensorboard])
recon = deep_ae.predict(X_test)
recon_error = np.mean(np.power(X_test - recon, 2), axis=1)
finetuning_flag = 1
tensorboard_flag = 0
cam_visualizer_flag = 1
#########################################
############## Reading Images and Labels ################
# SubperdB = Read_SMIC_Images(inputDir, listOfIgnoredSamples, dB, resizedFlag, table, workplace, spatial_size)
SubperdB = Read_Input_Images(inputDir, listOfIgnoredSamples, dB, resizedFlag,
table, workplace, spatial_size)
labelperSub = label_matching(workplace, dB, subjects, VidPerSubject)
######################################################################################
########### Model #######################
sgd = optimizers.SGD(lr=0.0001, decay=1e-7, momentum=0.9, nesterov=True)
adam = optimizers.Adam(lr=0.00001)
if train_spatial_flag == 0 and train_temporal_flag == 1:
data_dim = spatial_size * spatial_size
else:
data_dim = 4096
temporal_model = Sequential()
temporal_model.add(
LSTM(2622, return_sequences=True, input_shape=(10, data_dim)))
temporal_model.add(LSTM(1000, return_sequences=False))
temporal_model.add(Dense(128, activation='relu'))
temporal_model.add(Dense(5, activation='sigmoid'))
temporal_model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=[metrics.categorical_accuracy])
#########################################
def compiled_tcn(num_feat, # type: int
num_classes, # type: int
nb_filters, # type: int
kernel_size, # type: int
dilations, # type: List[int]
nb_stacks, # type: int
max_len, # type: int
activation='norm_relu', # type: str
use_skip_connections=True, # type: bool
return_sequences=True,
regression=False, # type: bool
dropout_rate=0.05, # type: float
name='tcn' # type: str
):
# type: (...) -> keras.Model
"""Creates a compiled TCN model for a given task (i.e. regression or classification).
Args:
num_feat: A tensor of shape (batch_size, timesteps, input_dim).
num_classes: The size of the final dense layer, how many classes we are predicting.
nb_filters: The number of filters to use in the convolutional layers.
kernel_size: The size of the kernel to use in each convolutional layer.
dilations: The list of the dilations. Example is: [1, 2, 4, 8, 16, 32, 64].
nb_stacks : The number of stacks of residual blocks to use.
max_len: The maximum sequence length, use None if the sequence length is dynamic.
activation: The activations to use.
use_skip_connections: Boolean. If we want to add skip connections from input to each residual block.
return_sequences: Boolean. Whether to return the last output in the output sequence, or the full sequence.
regression: Whether the output should be continuous or discrete.
dropout_rate: Float between 0 and 1. Fraction of the input units to drop.
name: Name of the model. Useful when having multiple TCN.
Returns:
A compiled keras TCN.
"""
dilations = process_dilations(dilations)
input_layer = Input(shape=(max_len, num_feat))
x = TCN(nb_filters, kernel_size, nb_stacks, dilations, activation,
use_skip_connections, dropout_rate, return_sequences, name)(input_layer)
print('x.shape=', x.shape)
if not regression:
# classification
x = Dense(num_classes)(x)
x = Activation('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)
# https://github.com/keras-team/keras/pull/11373
# It's now in Keras@master but still not available with pip.
# TODO To remove later.
def accuracy(y_true, y_pred):
# reshape in case it's in shape (num_samples, 1) instead of (num_samples,)
if K.ndim(y_true) == K.ndim(y_pred):
y_true = K.squeeze(y_true, -1)
# convert dense predictions to labels
y_pred_labels = K.argmax(y_pred, axis=-1)
y_pred_labels = K.cast(y_pred_labels, K.floatx())
return K.cast(K.equal(y_true, y_pred_labels), K.floatx())
adam = optimizers.Adam(lr=0.002, 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')(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=0.002, clipnorm=1.)
model.compile(adam, loss='mean_squared_error')
return model
if __name__ == '__main__':
# model selection
AF_model = AFNN(filters=4, image_channels=1, use_bnorm=True)
AF_model.summary()
# load the last model in matconvnet style
initial_epoch = find_LastCheckpoint(model_dir=save_dir)
if initial_epoch > 0:
print('resuming by loading epoch %03d' % initial_epoch)
AF_model = load_model(os.path.join(save_dir,
'model_%03d.hdf5' % initial_epoch),
compile=False)
sgd = optimizers.SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)
ad = optimizers.Adam(lr=0.01)
# compile the model
AF_model.compile(optimizer=ad,
metrics=['accuracy'],
loss=losses.categorical_crossentropy)
# use call back functions
check_pointer = ModelCheckpoint(os.path.join(save_dir,
'model_{epoch:03d}.hdf5'),
verbose=1,
save_weights_only=False,
period=args.save_step)
csv_logger = CSVLogger(os.path.join(save_dir, 'log.csv'),
append=True,
separator=',')
lr_scheduler = LearningRateScheduler(lr_schedule)
model.add(Activation("sigmoid"))
model.add(Conv2D(16, 5, 5, border_mode='valid'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Activation("sigmoid"))
model.add(Dropout(0.5))
model.add(Conv2D(120, 1, 1, border_mode='valid'))
model.add(Flatten())
model.add(Dense(120))
model.add(Dense(84))
model.add(Dense(1))
print("starting training")
my_adam = optimizers.Adam(lr=LEARNING_RATE)
model.compile(loss='mse', optimizer=my_adam)
from keras.callbacks import EarlyStopping
my_callbacks = [
EarlyStopping(monitor='val_loss',
min_delta=0.001,
patience=5,
verbose=0,
mode='auto')
]
history_object = model.fit_generator(
train_generator,
steps_per_epoch=len(train_samples) / BATCH_SIZE,
