def test_dnn_visualize(modelPath, imageDir, labelPath, outputPath, netType, flags, specs, BN_flag=0, pathID=0, radius=5):
## assigning variables
# fRandomDistort = flags[0]
fThreeCameras = flags[1]
fClassifier = flags[2]
# batchSize = specs[0]
# nEpoch = specs[1]
nClass = specs[2]
nFramesSample = specs[3]
nRep = specs[4]
step = 2
print('\n\n\n')
print('********************************************')
if fClassifier:
print('Classification......')
else:
print('Regression......')
### retrieve the test data
testFeatures, testLabels = load_train_data(imageDir, labelPath, nRep, fThreeCameras)
testFeatures = np.array(testFeatures)
testLabels = np.array(testLabels)
n = len(testLabels)
if fClassifier:
print('\n######### Classification #########')
testLabels = normalize_value(testLabels)
testLabels = to_categorical(testLabels, num_classes = nClass)
print(testFeatures)
print('The number of tested data: ' + str(testLabels.shape))
print('********************************************')
## choose networks, 1: CNN, 2: LSTM-m2o, 3: LSTM-m2m, 4: LSTM-o2o
if netType == 1:
# outputPath = trainPath + 'trainedModels/models-cnn/';
net = create_nvidia_network(BN_flag, fClassifier, nClass)
elif netType == 2:
# outputPath = trainPath + 'trainedModels/models-lstm-m2o/'
net = net_lstm(2, nFramesSample)
elif netType == 3:
# outputPath = trainPath + 'trainedModels/models-lstm-m2m/'
net = net_lstm(3, nFramesSample)
#print(net.layers[3].get_weights())
print(net.summary())
## load model weights
if modelPath != "":
net.load_weights(modelPath)
inp = net.input # input placeholder
if BN_flag == 0:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 10
elif BN_flag == 1:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 15
elif BN_flag == 2:
#independent_layer_ids = [3, 4, 7, 8, 11, 12, 15, 16, 19, 20, 24, 25, 28, 29, 32, 33]
BN_layer_ids = [4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 25, 26, 29, 30, 33, 34]
outputs = []
for i in range(len(net.layers)):
if i == 0 or i == 1:
continue
layer = net.layers[i]
if i in BN_layer_ids:
outputs.append(layer.get_output_at(0))
else:
outputs.append(layer.get_output_at(0))
outputs.append(layer.get_output_at(1))
last_conv_id = 22
functor = K.function([inp], outputs ) # evaluation function
for i in range(len(testLabels)):
image_path = testFeatures[i]
label = testLabels[i]
if not os.path.isfile(image_path):
image_path = image_path.replace(".jpg", "_fake.png")
img_ori = cv2.imread(image_path)
img = resize_image(img_ori)
rows = (int)((img.shape[0]-1)/step) + 1
cols = (int)((img.shape[1]-1)/step) + 1
testData = []
for i in range(rows):
for j in range(cols):
img1 = img.copy()
st_r = np.clip(i*step-radius, 0, img.shape[0]-1)
ed_r = np.clip(i*step+radius, 0, img.shape[0]-1)
st_c = np.clip(j*step-radius, 0, img.shape[1]-1)
ed_c = np.clip(j*step+radius, 0, img.shape[1]-1)
img1[st_r:ed_r+1, st_c:ed_c+1, :] = 0
testData.append(img1)
testData.append(img)
testData = np.array(testData)
### predict and output
if BN_flag <= 1:
layer_outs = functor(testData)
predictResults = layer_outs[-1]
else:
layer_outs = functor([testData, testData])
predictResults = layer_outs[-2+pathID]
#predictResults = net.predict(testData)
#score, acc = net.evaluate(testData, testLabels)
abs_diff = np.abs(predictResults.flatten() - label)
max_diff = np.max(abs_diff)
heat_map = np.reshape(np.abs(np.array(predictResults.flatten())[:(rows*cols)] - label), (rows, cols))
heat_map = heat_map / np.max(heat_map)
#cv2.imshow("heat_map_small", heat_map)
heat_map = cv2.resize(heat_map,(img_ori.shape[1],img_ori.shape[0]), interpolation = cv2.INTER_AREA)
#cv2.imshow("heat_map", heat_map)
#cv2.imshow("img_ori", img_ori)
img_ori[:,:,0] = np.multiply(img_ori[:,:,0], heat_map)
img_ori[:,:,1] = np.multiply(img_ori[:,:,1], heat_map)
img_ori[:,:,2] = np.multiply(img_ori[:,:,2], heat_map)
#cv2.imshow("combine_img", img_ori)
outputFolder = os.path.dirname(outputPath)
imageName = os.path.basename(image_path)
val_folder = imageName.replace(".jpg", "")
val_folder = imageName.replace(".png", "")
#outputImagePath = outputFolder + '/' + imageName + '_(gt_' + str(label) + ')_(error_' + str(abs_diff[-1]) + ')_(max_diff_' + str(max_diff) + ').jpg'
outputImagePath = outputFolder + '/' + imageName + '_(gt_{:.3f})_(error_{:.3f})_(max_diff_{:.3f}).jpg'.format(label, abs_diff[-1], max_diff)
cv2.imwrite(outputImagePath, img_ori)
#cv2.waitKey(1);
print('********************************************')
print('\n\n\n')
def test_dnn_multi(modelPath, imageDir_list, labelPath_list, outputPath, netType, flags, specs, BN_flag=0, pathID=0, ratio=1, pack_flag=False,
diffAug=False, adv_step=0.2, n_repeats=3, eps=0.5, before_relu=False):
## assigning variables
# fRandomDistort = flags[0]
fThreeCameras = flags[1]
fClassifier = flags[2]
# batchSize = specs[0]
# nEpoch = specs[1]
nClass = specs[2]
nFramesSample = specs[3]
nRep = specs[4]
# print('\n\n\n')
# print('********************************************')
if fClassifier:
print('Classification......')
else:
print('Regression......')
### retrieve the test data
if not pack_flag:
testFeatures, testLabels = load_train_data_multi(imageDir_list, labelPath_list, nRep, fThreeCameras, ratio=ratio)
else:
testFeatures, testLabels = load_train_data_multi_pack(imageDir_list, labelPath_list, nRep, fThreeCameras, ratio=ratio)
#testFeatures, testLabels = load_train_data(imageDir, labelPath, nRep, fThreeCameras, ratio=ratio)
testFeatures = np.array(testFeatures)
testLabels = np.array(testLabels)
if pack_flag:
testLabels = testLabels[:,0]
n = len(testLabels)
if fClassifier:
print('\n######### Classification #########')
testLabels = normalize_value(testLabels)
testLabels = to_categorical(testLabels, num_classes = nClass)
# print(testFeatures)
print('The number of tested data: ' + str(testLabels.shape))
print('********************************************')
testData = []
if not pack_flag:
for i in range(len(testLabels)):
image_path = testFeatures[i]
if not os.path.isfile(image_path):
print("image not exist: ", image_path)
image_path = image_path.replace(".jpg", "_fake.png")
img = resize_image(cv2.imread(image_path))
testData.append(img)
else:
for i in range(len(testFeatures)):
for j in range(len(testFeatures[i])):
image_path = testFeatures[i][j]
if not os.path.isfile(image_path):
image_path = image_path.replace(".jpg", "_fake.png")
img_1 = resize_image(cv2.imread(image_path))
if j == 0:
img = img_1
else:
img = np.concatenate((img, img_1), axis=2)
#noise = np.random.uniform(low=0, high=255, size=(img.shape[0], img.shape[1], 1))
#img = np.concatenate((img, noise), axis=2)
testData.append(img)
testData = np.array(testData)
nChannel=3
if pack_flag:
testFeatures = testFeatures[:,0]
nChannel = 3*len(imageDir_list)
## choose networks, 1: CNN, 2: LSTM-m2o, 3: LSTM-m2m, 4: LSTM-o2o
if netType == 1:
if diffAug:
print("test DiffAug_Net")
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel,
augments="", adv_step=0., n_repeats=0, eps=0.)
net(tf.ones((1, 66, 200, 3)))
net.summary()
else:
if BN_flag == 3:
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel,
adv_step=adv_step, n_repeats=n_repeats, eps=eps, before_relu=before_relu)
net(tf.ones((1, 66, 200, 3)))
else:
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel)
elif netType == 2:
# outputPath = trainPath + 'trainedModels/models-lstm-m2o/'
net = net_lstm(2, nFramesSample)
elif netType == 3:
# outputPath = trainPath + 'trainedModels/models-lstm-m2m/'
net = net_lstm(3, nFramesSample)
#print(net.layers[3].get_weights())
# print(net.summary())
## load model weights
if modelPath != "":
net.load_weights(modelPath)
print("finished loading weight")
if BN_flag == 3:
inp = [net.featureX.input, net.head.input]
else:
if diffAug:
inp = net.model.input
else:
inp = net.input # input placeholder
if BN_flag == 0:
if diffAug:
outputs = [layer.get_output_at(-1) for layer in net.model.layers]
else:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
print(outputs)
last_conv_id = 10
elif BN_flag == 1:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 15
elif BN_flag == 2:
#independent_layer_ids = [3, 4, 7, 8, 11, 12, 15, 16, 19, 20, 24, 25, 28, 29, 32, 33]
BN_layer_ids = [4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 25, 26, 29, 30, 33, 34]
outputs = []
for i in range(len(net.layers)):
if i == 0 or i == 1:
continue
layer = net.layers[i]
if i in BN_layer_ids:
outputs.append(layer.get_output_at(0))
else:
outputs.append(layer.get_output_at(0))
outputs.append(layer.get_output_at(1))
last_conv_id = 22
elif BN_flag == 3:
outputs_1 = [layer.get_output_at(-1) for layer in net.featureX.layers]
outputs_2 = [layer.get_output_at(-1) for layer in net.head.layers]
outputs = outputs_1[1:] + outputs_2[1:]
last_conv_id = 10
if BN_flag == 3:
functor = K.function(inp, outputs ) # evaluation function
else:
functor = K.function([inp], outputs ) # evaluation function
### predict and output
if BN_flag <= 1:
layer_outs = functor(testData)
predictResults = layer_outs[-1]
elif BN_flag == 3:
layer_outs = functor([testData, net.featureX(testData)])
predictResults = layer_outs[-1]
else:
layer_outs = functor([testData, testData])
predictResults = layer_outs[-2+pathID]
#predictResults = net.predict(testData)
#score, acc = net.evaluate(testData, testLabels)
BN_means = []
BN_stds = []
for layer_id in range(len(layer_outs)):
#if layer_id not in [1, 3, 5, 7, 9]:
# continue
layer_out = layer_outs[layer_id]
#print(layer_out.shape)
if layer_id <= last_conv_id:
for i in range(layer_out.shape[3]):
BN_means.append(np.mean(layer_out[:,:,:,i]))
BN_stds.append(np.std(layer_out[:,:,:,i]))
else:
BN_means.append(np.mean(layer_out[:,:]))
BN_stds.append(np.std(layer_out[:,:]))
if outputPath != "":
f_BN = open(outputPath.replace(ntpath.basename(outputPath), "BN_means.txt"),'w')
#print(BN_means)
#print(BN_stds)
for mean in BN_means:
f_BN.write("{:.5f}\n".format(mean))
f_BN.close()
f_BN = open(outputPath.replace(ntpath.basename(outputPath), "BN_stds.txt"),'w')
for std in BN_stds:
f_BN.write("{:.5f}\n".format(std))
f_BN.close()
print(outputPath)
if outputPath != "":
f = open(outputPath,'w')
if fClassifier:
predictResults = predictResults.argmax(axis=1)
testLabels = testLabels.argmax(axis=1)
correct_count = n - np.count_nonzero(predictResults-testLabels)
print("accuracy: ", correct_count / (float)(n))
if outputPath != "":
f.write("accuracy: {:.5f}\n\n".format(correct_count / (float)(n)))
f.write("{:^12} {:^12} {:^12} {:^12}\n".format("prediction", "groundtruth", "difference", "input"))
for p in range(len(predictResults)):
# if fClassifier:
# f.write(str(np.argmax(p)))
# print(np.argmax(p))
# else:
# for regression
imgName = os.path.basename(testFeatures[p])
prediction = predictResults[p]
groundTruth = testLabels[p]
if outputPath != "":
f.write("{:^12.0f} {:^12.0f} {:^12.0f} {:^12}".format(prediction, groundTruth, prediction-groundTruth, imgName))
f.write('\n')
else:
prediction_error = predictResults.flatten() - testLabels
mse_loss = np.mean(np.square(prediction_error))
print("mse loss: " + str(mse_loss))
if outputPath != "":
f.write("mse loss: {:.5f}\n".format(mse_loss))
#thresh_holds = [0.01, 0.033, 0.1, 0.33, 1, 3.3]
thresh_holds = [0.1, 0.2, 0.5, 1, 2, 5]
#thresh_holds = [1, 2, 4, 8]
acc_list = []
for thresh_hold in thresh_holds:
if outputPath != "":
image_fail_cases_folder = os.path.dirname(outputPath)+'/fail_cases_'+str(thresh_hold)
if not os.path.exists(image_fail_cases_folder):
os.mkdir(image_fail_cases_folder)
acc = np.sum(np.abs(prediction_error) < thresh_hold) / len(testLabels)
acc_list.append(acc)
# print("accuracy (+-" + str(thresh_hold) + "): " + str(acc))
if outputPath != "":
f.write("accuracy (+-{:.3f}): {:.5f}\n".format(thresh_hold, acc))
f_img_list_succ = open(outputPath.replace(ntpath.basename(outputPath), "img_list_"+str(thresh_hold)+"_succ.txt"),'w')
f_img_list_fail = open(outputPath.replace(ntpath.basename(outputPath), "img_list_"+str(thresh_hold)+"_fail.txt"),'w')
img_list_succ = testFeatures[np.abs(prediction_error) < thresh_hold]
fail_flag = (np.abs(prediction_error) >= thresh_hold)
#img_list_fail = testFeatures[np.abs(prediction_error) >= thresh_hold]
#img_fail = testData[np.abs(prediction_error) >= thresh_hold]
#print(len(img_list_succ))
#print(len(img_list_fail))
for img_file in img_list_succ:
f_img_list_succ.write(str(img_file))
f_img_list_succ.write('\n')
for i in range(len(fail_flag)):
if fail_flag[i] == True:
img_file = testFeatures[i]
f_img_list_fail.write(str(img_file))
f_img_list_fail.write('\n')
'''
img = cv2.imread(img_file)
#img_path = image_fail_cases_folder + "/gt_" + str(testLabels[i]) + "_pred_" + str(predictResults.flatten()[i]) + "_diff_" + str(prediction_error[i]) + "_" + os.path.basename(img_file)
img_path = image_fail_cases_folder + "/gt_" + "{:.3f}".format(testLabels[i]) + \
"_pred_" + "{:.3f}".format(predictResults.flatten()[i]) + \
"_diff_" + "{:.3f}".format(prediction_error[i]) + \
"_" + os.path.basename(img_file)
cv2.imwrite(img_path, img)
'''
f_img_list_succ.close()
f_img_list_fail.close()
print("mean accuracy: " + str(np.mean(acc_list)))
if outputPath != "":
f.write("mean accuracy: {:.5f}\n\n".format(np.mean(acc_list)))
f.write("{:^12} {:^12} {:^12} {:^12}\n".format("prediction", "groundtruth", "difference", "input"))
for p in range(len(predictResults)):
# if fClassifier:
# f.write(str(np.argmax(p)))
# print(np.argmax(p))
# else:
# for regression
imgName = os.path.basename(testFeatures[p])
prediction = predictResults[p][0]
groundTruth = testLabels[p]
f.write("{:^12.3f} {:^12.3f} {:^12.3f} {:^12}".format(prediction, groundTruth, prediction-groundTruth, imgName))
f.write('\n')
if outputPath != "":
f.close()
# for i in range(len(testLabels)):
# print([str('%.4f' % float(j)) for j in predictResults[i]])
# print('********************************************')
# print('\n\n\n')
K.clear_session()
return np.mean(acc_list)
def train_dnn_multi(imageDir_list, labelPath_list, outputPath, netType, flags, specs, modelPath = "",
trainRatio = 1.0, partialPreModel = False, reinitHeader = False,
BN_flag=0, imageDir_list_advp=[], labelPath_list_advp=[], trainRatio_advp = 1.0, reinitBN = False, pack_flag=False,
augments=None, adv_step=0.2, n_repeats=3, eps=0.5, before_relu=False, resume=0):
## assigning variables
fRandomDistort = flags[0]
fThreeCameras = flags[1]
fClassifier = flags[2]
batchSize = specs[0]
nEpoch = specs[1]
nClass = specs[2]
nFramesSample = specs[3]
nRep = specs[4]
## prepare the data
#xList, yList = load_train_data_multi(imageDir_list, labelPath_list, nRep, fThreeCameras, trainRatio, specialFilter=True)
if not pack_flag:
xList, yList = load_train_data_multi(imageDir_list, labelPath_list, nRep, fThreeCameras, trainRatio)
else:
xList, yList = load_train_data_multi_pack(imageDir_list, labelPath_list, nRep, fThreeCameras, trainRatio)
xTrainList, xValidList = train_test_split(np.array(xList), test_size=0.1, random_state=42)
yTrainList, yValidList = train_test_split(np.array(yList), test_size=0.1, random_state=42)
if BN_flag == 2:
xList_advp, yList_advp = load_train_data_multi(imageDir_list_advp, labelPath_list_advp, nRep, fThreeCameras, trainRatio_advp)
xTrainList_advp, xValidList_advp = train_test_split(np.array(xList_advp), test_size=0.1, random_state=42)
yTrainList_advp, yValidList_advp = train_test_split(np.array(yList_advp), test_size=0.1, random_state=42)
## change the data format if necessary
if fClassifier:
print('\n######### Classification #########')
yTrainList = normalize_value(yTrainList)
yTrainList = to_categorical(yTrainList, num_classes = nClass)
yValidList = normalize_value(yValidList)
yValidList = to_categorical(yValidList, num_classes = nClass)
else:
print('\n######### Regression #########')
print('Train data:', xTrainList.shape, yTrainList.shape)
print('Valid data:', xValidList.shape, yValidList.shape)
print('##############################\n')
## choose networks, 1: CNN, 2: LSTM-m2o, 3: LSTM-m2m, 4: LSTM-o2o, 5: GAN
if netType == 1:
# outputPath = trainPath + 'trainedModels/models-cnn/';
nChannel = 3
if pack_flag:
nChannel = 3*len(imageDir_list)
if augments is not None:
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel,
augments=augments, adv_step=adv_step, n_repeats=n_repeats, eps=eps)
net(tf.ones((1, 66, 200, 3)))
print("DiffAug model created")
else:
if BN_flag == 3:
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel,
adv_step=adv_step, n_repeats=n_repeats, eps=eps, before_relu=before_relu)
print("AdvBN model created")
else:
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel)
if BN_flag <= 1 or BN_flag == 3:
if not pack_flag:
trainGenerator = gen_train_data_random(xTrainList, yTrainList, batchSize)
validGenerator = gen_train_data_random(xValidList, yValidList, batchSize)
else:
trainGenerator = gen_train_data_random_pack_channel(xTrainList, yTrainList, batchSize)
validGenerator = gen_train_data_random_pack_channel(xValidList, yValidList, batchSize)
elif BN_flag == 2:
trainGenerator = gen_train_data_random_AdvProp(xTrainList, yTrainList, xTrainList_advp, yTrainList_advp, batchSize)
validGenerator = gen_train_data_random_AdvProp(xValidList, yValidList, xValidList_advp, yValidList_advp, batchSize)
elif netType == 2:
# outputPath = trainPath + 'trainedModels/models-lstm-m2o/'
net = net_lstm(2, nFramesSample)
trainGenerator = gen_train_data_lstm_m2o(xTrainList, yTrainList, batchSize, nFramesSample)
validGenerator = gen_train_data_lstm_m2o(xValidList, yValidList, batchSize, nFramesSample)
elif netType == 3:
# outputPath = trainPath + 'trainedModels/models-lstm-m2m/'
net = net_lstm(3, nFramesSample)
trainGenerator = gen_train_data_lstm_m2m(xTrainList, yTrainList, batchSize, nFramesSample)
validGenerator = gen_train_data_lstm_m2m(xValidList, yValidList, batchSize, nFramesSample)
elif netType == 5:
net = GAN_Nvidia()
trainGenerator = gen_train_data_random(xTrainList, yTrainList, batchSize)
validGenerator = gen_train_data_random(xValidList, yValidList, batchSize)
if modelPath != "":
print("loading pretrain modelPath: ", modelPath)
if BN_flag == 3:
net(tf.ones((1, 66, 200, 3)))
net.load_weights(modelPath)
# print(partialPreModel)
if partialPreModel:
print("partial PreModel activate")
#net_untrain = net_nvidia(fClassifier, nClass)
start_layer_id=8
for i in range(start_layer_id):
net.layers[i].trainable = False
#for i in range(start_layer_id, len(net.layers)):
#net.layers[i].set_weights(net_untrain.layers[i].get_weights())
# net.layers[i].trainable = False
net.compile(optimizer=keras.optimizers.Adam(lr=1e-4), loss='mse', metrics=[mean_accuracy])
if reinitHeader:
print("reinit header activate")
net_untrain = create_nvidia_network(BN_flag, fClassifier, nClass)
net.layers[-1].set_weights(net_untrain.layers[-1].get_weights())
net.compile(optimizer=keras.optimizers.Adam(lr=1e-4), loss='mse', metrics=[mean_accuracy])
if reinitBN:
net_untrain = create_nvidia_network(BN_flag, fClassifier, nClass)
BN_layer_ids = [3, 6, 9, 12, 15, 19, 22, 25]
for id in BN_layer_ids:
net.layers[id].set_weights(net_untrain.layers[id].get_weights())
net.compile(optimizer=keras.optimizers.Adam(lr=1e-4), loss='mse', metrics=[mean_accuracy])
#net.compile(optimizer=keras.optimizers.Adam(lr=1e-4), loss='mse', metrics=['accuracy'])
if BN_flag == 3:
print('load weight for AdvBN fine-tuning')
# step = tf.Variable(0, trainable=False)
# boundaries = [200, 400]
# values = [1e-5, 5e-6, 1e-6]
# learning_rate_fn = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
# boundaries, values)
# Later, whenever we perform an optimization step, we pass in the step.
# learning_rate = learning_rate_fn(step)
net.compile(h_optimizer=tf.keras.optimizers.Adam(1e-5), loss_fn=tf.keras.losses.MeanSquaredError(), h_metrics=mean_accuracy_tf)
print(net.summary())
print('trainable weight:')
for var in net.trainable_weights:
print(var.name)
## setup outputs
if not os.path.exists(outputPath):
os.makedirs(outputPath)
#else:
# shutil.rmtree(outputPath)
# os.makedirs(outputPath)
modelLog = ModelCheckpoint(outputPath + 'model{epoch:02d}.h5', monitor='val_loss', save_best_only=True)
lossLog = CSVLogger(outputPath + 'loss-log', append=True, separator=',')
#tensorboard_callback = keras.callbacks.TensorBoard(log_dir=outputPath+"logs/")
## train
if netType != 5:
nTrainStep = int(len(yTrainList)/batchSize)
nValidStep = int(len(yValidList)/batchSize)
if augments is not None:
x_path = tf.data.Dataset.from_tensor_slices(xTrainList)
xDataset = x_path.map(load_images_from_path, num_parallel_calls=tf.data.experimental.AUTOTUNE)
yDataset = tf.data.Dataset.from_tensor_slices(yTrainList)
trainDataset = tf.data.Dataset.zip((xDataset, yDataset))
batchTrainDataset = trainDataset.shuffle(buffer_size=10000, reshuffle_each_iteration=True).batch(batchSize, drop_remainder=True)
val_x_path = tf.data.Dataset.from_tensor_slices(xValidList)
val_xDataset = val_x_path.map(load_images_from_path, num_parallel_calls=tf.data.experimental.AUTOTUNE)
val_yDataset = tf.data.Dataset.from_tensor_slices(yValidList)
valDataset = tf.data.Dataset.zip((val_xDataset, val_yDataset))
batchValDataset = valDataset.batch(batchSize, drop_remainder=False)
modelLog_tf = tf.keras.callbacks.ModelCheckpoint(
outputPath + 'checkpoint/cp-weights-{epoch:02d}.ckpt', save_best_only=False,
save_weights_only=True, save_freq=100)
lossLog_tf = tf.keras.callbacks.CSVLogger(outputPath + 'train-log', append=True, separator='\t')
loss_log = open(outputPath + 'loss-log', "w")
# net.compile(h_optimizer=tf.keras.optimizers.Adam(1e-4), loss_fn=tf.keras.losses.MeanSquaredError(), h_metrics=mean_accuracy_tf)
optimizer = tf.keras.optimizers.Adam(1e-3)
loss_fn = tf.keras.losses.MeanSquaredError()
val_ma_tracker = tf.keras.metrics.Mean(name="val_ma")
val_loss_tracker = tf.keras.metrics.Mean(name="val_loss")
for epoch in range(resume, nEpoch):
# for epoch in range(1):
print("\n Train Epoch: [{}/{}]".format(epoch, nEpoch))
loss_log.write("\n Train Epoch: [{}/{}]".format(epoch,nEpoch))
start_time = time.time()
# iterate over different augmentations
for aug in augments:
# Iterate over the batches of the dataset.
for step, (x_batch_train, y_batch_train) in enumerate(batchTrainDataset):
# mloss = net.my_train_step((x_batch_train, y_batch_train), aug)
# print(x_batch_train[:10])
# print(y_batch_train[:10])
input = tf.cast(x_batch_train, dtype=tf.float32)
target = tf.cast(y_batch_train, dtype=tf.float32)
if net.delta is None:
net.delta = tf.Variable(tf.zeros([1]))
else:
net.delta.assign(tf.zeros([1]))
for _iter in range(net.n_repeats):
with tf.GradientTape() as tape:
if aug == '1': # gaussian blur
aug_op = getattr(net, "blur")
param = net.delta * 100
param_min = 0.0
elif aug == '2': # gaussian noise
aug_op = getattr(net, "gaussian")
dist = tfp.distributions.Normal(0, net.delta)
param = dist.sample([66, 200, 3])
param_min = 0.0
# elif aug == '3': #distortion
elif aug in ['R', 'G', 'B', 'H', 'S', 'V']:
aug_op = getattr(net, "color_" + aug)
param = net.delta
param_min = -net.eps
elif aug == '7':
aug_op = getattr(net, "saturation")
param = net.delta + 1
param_min = -net.eps
elif aug == '8':
aug_op = getattr(net, "contrast")
param = net.delta + 1
param_min = -net.eps
elif aug == '9':
aug_op = getattr(net, "brightness")
param = net.delta
param_min = -net.eps
elif aug == 'N':
aug_op = None
break
else:
print("augmentation not defined")
x = aug_op(input, param)
output = net(x)
# loss = loss_fn(output, target)
loss = net.mse(output, target)
grad = tape.gradient(loss, [net.delta])[0]
net.delta.assign_add(net.adv_step * tf.keras.backend.sign(grad))
net.delta.assign(tf.keras.backend.clip(net.delta, min_value=param_min, max_value=net.eps))
if aug_op is not None:
x = aug_op(input, param)
else:
x = input
with tf.GradientTape() as tape:
output = net(x)
loss = loss_fn(output, target)
# loss = net.mse(output, target)
grads = tape.gradient(loss, net.model.trainable_weights)
optimizer.apply_gradients(zip(grads, net.model.trainable_weights))
net.train_loss_tracker.update_state(loss)
mloss = net.train_loss_tracker.result()
net.train_loss_tracker.reset_states()
print("augmentation: {} \t loss_tracker: {:.4f} ".format(aug, float(mloss)))
loss_log.write("augmentation: {} \t loss_tracker: {:.4f} ".format(aug, float(mloss)))
# net.augments = aug
# net.fit(x=batchTrainDataset, shuffle=True, \
# steps_per_epoch=None, epochs=nEpoch, initial_epoch=0, \
# verbose=2, callbacks=[lossLog_tf, modelLog_tf], validation_data=batchValDataset, validation_steps=None)
# validation
for step, (x_batch_val, y_batch_val) in enumerate(batchValDataset):
input = tf.cast(x_batch_val, dtype=tf.float32)
target = tf.cast(y_batch_val, dtype=tf.float32)
output = net(input)
val_loss = loss_fn(target, output)
# val_loss = net.mse(target, output)
val_loss_tracker.update_state(val_loss)
thresh_holds = [0.1, 0.2, 0.5, 1, 2, 5]
total_acc = 0
prediction_error = tf.math.abs(output-target)
# tf.print(prediction_error, tf.shape(prediction_error))
for thresh_hold in thresh_holds:
acc = tf.where(prediction_error < thresh_hold, 1., 0.)
acc = tf.math.reduce_mean(acc)
total_acc += acc
val_ma = total_acc / len(thresh_holds)
val_ma_tracker.update_state(val_ma)
print("\n Val Epoch: [{}/{}] \t loss: {:.4f} \t ma: {:.4f} \n".format(epoch, nEpoch, float(val_loss_tracker.result()), float(val_ma_tracker.result())))
loss_log.write("\n Val Epoch: [{}/{}] \t loss: {:.4f} \t ma: {:.4f}\n".format(epoch, nEpoch, float(val_loss_tracker.result()), float(val_ma_tracker.result())))
print("Time taken: {:.2f}s".format(time.time() - start_time))
loss_log.write("Time taken: {:.2f}s".format(time.time() - start_time))
val_ma_tracker.reset_states()
val_loss_tracker.reset_states()
if (epoch + 1) % 100 == 0:
net.save_weights(filepath= outputPath + 'checkpoint/cp-weights-{:02d}.ckpt'.format(epoch))
else:
if BN_flag == 3:
modelLog_tf = tf.keras.callbacks.ModelCheckpoint(
outputPath + 'checkpoint/cp-weights-{epoch:02d}.ckpt', monitor='val_loss', save_best_only=False,
save_weights_only=True, save_freq=100)
lossLog_tf = tf.keras.callbacks.CSVLogger(outputPath + 'loss-log', append=True, separator=',')
net.fit(x=trainGenerator, steps_per_epoch=nTrainStep, epochs=nEpoch, \
verbose=2, callbacks=[modelLog_tf,lossLog_tf], validation_data=validGenerator, validation_steps=nValidStep)
else:
net.fit_generator(trainGenerator, steps_per_epoch=nTrainStep, epochs=nEpoch, \
verbose=2, callbacks=[modelLog,lossLog], validation_data=validGenerator, validation_steps=nValidStep)
else:
for [x_batch, y_batch] in trainGenerator:
print(x_batch.shape)
print(y_batch.shape)
print(y_batch[0])
input_img = tf.convert_to_tensor(x_batch, dtype=tf.float32)
print(input_img)
cv2.imshow("input", input_img[0].eval(session=tf.compat.v1.Session())/255)
imgs = net.g(input_img)
cv2.imshow("output", imgs[0].eval(session=tf.compat.v1.Session())/255)
cv2.waitKey(0)
net.save(outputPath + 'model-final.h5')
print(net.summary())
def filter_dataset(modelPath, imageDir, labelPath, outputPath, netType, flags, specs, BN_flag=0, target_BN_folder="", filter_percent=0.1):
## assigning variables
# fRandomDistort = flags[0]
fThreeCameras = flags[1]
fClassifier = flags[2]
# batchSize = specs[0]
# nEpoch = specs[1]
nClass = specs[2]
nFramesSample = specs[3]
nRep = specs[4]
print('\n\n\n')
print('********************************************')
if fClassifier:
print('Classification......')
else:
print('Regression......')
### retrieve the test data
testFeatures, testLabels = load_train_data(imageDir, labelPath, nRep, fThreeCameras)
testFeatures = np.array(testFeatures)
testLabels = np.array(testLabels)
## choose networks, 1: CNN, 2: LSTM-m2o, 3: LSTM-m2m, 4: LSTM-o2o
if netType == 1:
# outputPath = trainPath + 'trainedModels/models-cnn/';
net = create_nvidia_network(BN_flag, fClassifier, nClass)
elif netType == 2:
# outputPath = trainPath + 'trainedModels/models-lstm-m2o/'
net = net_lstm(2, nFramesSample)
elif netType == 3:
# outputPath = trainPath + 'trainedModels/models-lstm-m2m/'
net = net_lstm(3, nFramesSample)
#print(net.layers[3].get_weights())
print(net.summary())
## load model weights
if modelPath != "":
net.load_weights(modelPath)
inp = net.input # input placeholder
if BN_flag == 0:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 10
elif BN_flag == 1:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 15
elif BN_flag == 2:
#independent_layer_ids = [3, 4, 7, 8, 11, 12, 15, 16, 19, 20, 24, 25, 28, 29, 32, 33]
BN_layer_ids = [4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 25, 26, 29, 30, 33, 34]
outputs = []
for i in range(len(net.layers)):
if i == 0 or i == 1:
continue
layer = net.layers[i]
if i in BN_layer_ids:
outputs.append(layer.get_output_at(0))
else:
outputs.append(layer.get_output_at(0))
outputs.append(layer.get_output_at(1))
last_conv_id = 22
functor = K.function([inp], outputs ) # evaluation function
print(testFeatures)
print('The number of tested data: ' + str(testLabels.shape))
print('********************************************')
f = open(outputPath,'w')
similar_img_count = 0
diff_score_list = []
for id in range(len(testLabels)):
image_path = testFeatures[id]
label_value = testLabels[id]
if not os.path.isfile(image_path):
image_path = image_path.replace(".jpg", "_fake.png")
img = resize_image(cv2.imread(image_path))
testData=[img]
testData = np.array(testData)
### predict and output
if BN_flag <= 1:
layer_outs = functor(testData)
predictResults = layer_outs[-1]
else:
layer_outs = functor([testData, testData])
predictResults = layer_outs[-2]
#predictResults = net.predict(testData)
#score, acc = net.evaluate(testData, testLabels)
BN_means = []
BN_stds = []
for layer_id in range(len(layer_outs)):
#if layer_id not in [1, 3, 5, 7, 9]:
# continue
layer_out = layer_outs[layer_id]
if layer_id <= last_conv_id:
for i in range(layer_out.shape[3]):
BN_means.append(np.mean(layer_out[:,:,:,i]))
BN_stds.append(np.std(layer_out[:,:,:,i]))
else:
BN_means.append(np.mean(layer_out[:,:]))
BN_stds.append(np.std(layer_out[:,:]))
BN_means_target = read_float_list(target_BN_folder + "/BN_means.txt")
BN_stds_target = read_float_list(target_BN_folder + "/BN_stds.txt")
SINGLE_FEATURE_PERCENT_THRESH = 1
SINGLE_FEATURE_VALUE_THRESH = 3
MODEL_PERCENT_THRESH = 0.5
similar_feature_count = 0
for i in range(len(BN_means)):
mean_value_diff = abs(BN_means[i] - BN_means_target[i])
mean_percent_diff = abs((BN_means[i] - BN_means_target[i])/BN_means_target[i])
#print("base mean: ", BN_means_target[i], " current mean: ", BN_means[i], " mean_value_diff: ", mean_value_diff, " mean_percent_diff: ", mean_percent_diff, "\n")
std_value_diff = abs(BN_stds[i] - BN_stds_target[i])
std_percent_diff = abs((BN_stds[i] - BN_stds_target[i])/BN_stds_target[i])
#print("base std: ", BN_stds_target[i], " current std: ", BN_stds[i], " std_value_diff: ", std_value_diff, " std_percent_diff: ", std_percent_diff, "\n")
if is_similar(BN_means_target[i], BN_means[i], SINGLE_FEATURE_VALUE_THRESH, SINGLE_FEATURE_PERCENT_THRESH) and is_similar(BN_stds_target[i], BN_stds[i], SINGLE_FEATURE_VALUE_THRESH, SINGLE_FEATURE_PERCENT_THRESH):
similar_feature_count += 1
BN_means = np.array(BN_means)
BN_means_target = np.array(BN_means_target)
BN_stds = np.array(BN_stds)
BN_stds_target = np.array(BN_stds_target)
BN_mean_diff = BN_means - BN_means_target
BN_std_diff = BN_stds - BN_stds_target
'''
mean_all_percent_1 = np.linalg.norm(BN_mean_diff) / np.linalg.norm(BN_means_target)
mean_all_percent_2 = np.linalg.norm(BN_mean_diff) / np.linalg.norm(BN_means)
std_all_percent_1 = np.linalg.norm(BN_std_diff) / np.linalg.norm(BN_stds_target)
std_all_percent_2 = np.linalg.norm(BN_std_diff) / np.linalg.norm(BN_stds)
#print("mean_all_percent_1 ", mean_all_percent_1, "mean_all_percent_2 ", mean_all_percent_2, " std_all_percent_1 ", std_all_percent_1, " std_all_percent_2 ", std_all_percent_2)
# for honda
MEAN_PERCENTAGE_THRESH = 1.2
STD_PERCENTAGE_THRESH = 0.5
# for udacity
MEAN_PERCENTAGE_THRESH = 1.2
STD_PERCENTAGE_THRESH = 0.8
if mean_all_percent_1 < MEAN_PERCENTAGE_THRESH and mean_all_percent_2 < MEAN_PERCENTAGE_THRESH and std_all_percent_1 < MEAN_PERCENTAGE_THRESH and std_all_percent_2 < STD_PERCENTAGE_THRESH:
f.write(os.path.basename(image_path) + ",,," + str(label_value) + "\n")
similar_img_count += 1
'''
'''
print(id, " ", similar_feature_count / len(BN_means))
if similar_feature_count / len(BN_means) > MODEL_PERCENT_THRESH:
f.write(os.path.basename(image_path) + ",,," + str(label_value) + "\n")
similar_img_count += 1
'''
mean_std_ratio = np.linalg.norm(BN_means_target) / np.linalg.norm(BN_stds_target)
diff_score = np.linalg.norm(BN_mean_diff) + mean_std_ratio * np.linalg.norm(BN_std_diff)
#print("mean diff: ", np.linalg.norm(BN_mean_diff), " std diff: ", np.linalg.norm(BN_std_diff), " total: ", diff_score)
#print("mean: ", np.linalg.norm(BN_means), " std: ", np.linalg.norm(BN_stds))
diff_score_list.append((id, diff_score, np.linalg.norm(BN_means), np.linalg.norm(BN_stds)))
f.close()
#print(diff_score_list)
diff_score_list = sorted(diff_score_list, key=lambda diff_score: diff_score[1])
#print(diff_score_list)
f = open(outputPath,'w')
for i in range(int(len(testLabels)*filter_percent)):
id = diff_score_list[i][0]
image_path = testFeatures[id]
label_value = testLabels[id]
#f.write(os.path.basename(image_path) + ",,," + str(label_value) + "\n")
f.write(os.path.basename(image_path) + ",,," + str(label_value) + "," +str(diff_score_list[i][2]) + "," +str(diff_score_list[i][3])+"\n")
f.close()
print('similar_img_count ', int(len(testLabels)*filter_percent))
print('total_count ', len(testLabels))
print('ratio ', filter_percent)
print('\n\n')
def visualize_dnn_on_image(modelPath, imagePath, label, outputPath, netType, flags, specs, radius=10, BN_flag=0, pathID=0):
## assigning variables
# fRandomDistort = flags[0]
fThreeCameras = flags[1]
fClassifier = flags[2]
# batchSize = specs[0]
# nEpoch = specs[1]
nClass = specs[2]
nFramesSample = specs[3]
nRep = specs[4]
print('\n\n\n')
print('********************************************')
if fClassifier:
print('Classification......')
else:
print('Regression......')
img = resize_image(cv2.imread(imagePath))
#img = cv2.imread(imagePath)
#img = cv2.resize(img,(200, 66), interpolation = cv2.INTER_AREA)
#cv2.imshow("test", img)
#cv2.waitKey(0)
step = 2
rows = (int)((img.shape[0]-1)/step) + 1
cols = (int)((img.shape[1]-1)/step) + 1
testData = []
for i in range(rows):
for j in range(cols):
img1 = img.copy()
st_r = np.clip(i*step-radius, 0, img.shape[0]-1)
ed_r = np.clip(i*step+radius, 0, img.shape[0]-1)
st_c = np.clip(j*step-radius, 0, img.shape[1]-1)
ed_c = np.clip(j*step+radius, 0, img.shape[1]-1)
img1[st_r:ed_r+1, st_c:ed_c+1, :] = 0
testData.append(img1)
testData = np.array(testData)
## choose networks, 1: CNN, 2: LSTM-m2o, 3: LSTM-m2m, 4: LSTM-o2o
if netType == 1:
# outputPath = trainPath + 'trainedModels/models-cnn/';
net = create_nvidia_network(BN_flag, fClassifier, nClass)
elif netType == 2:
# outputPath = trainPath + 'trainedModels/models-lstm-m2o/'
net = net_lstm(2, nFramesSample)
elif netType == 3:
# outputPath = trainPath + 'trainedModels/models-lstm-m2m/'
net = net_lstm(3, nFramesSample)
#print(net.layers[3].get_weights())
print(net.summary())
## load model weights
if modelPath != "":
net.load_weights(modelPath)
inp = net.input # input placeholder
if BN_flag == 0:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 10
elif BN_flag == 1:
outputs = [layer.get_output_at(-1) for layer in net.layers] # all layer outputs
outputs = outputs[1:]
last_conv_id = 15
elif BN_flag == 2:
#independent_layer_ids = [3, 4, 7, 8, 11, 12, 15, 16, 19, 20, 24, 25, 28, 29, 32, 33]
BN_layer_ids = [4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 25, 26, 29, 30, 33, 34]
outputs = []
for i in range(len(net.layers)):
if i == 0 or i == 1:
continue
layer = net.layers[i]
if i in BN_layer_ids:
outputs.append(layer.get_output_at(0))
else:
outputs.append(layer.get_output_at(0))
outputs.append(layer.get_output_at(1))
last_conv_id = 22
functor = K.function([inp], outputs ) # evaluation function
### predict and output
if BN_flag <= 1:
layer_outs = functor(testData)
predictResults = layer_outs[-1]
else:
layer_outs = functor([testData, testData])
predictResults = layer_outs[-2+pathID]
#predictResults = net.predict(testData)
#score, acc = net.evaluate(testData, testLabels)
BN_means = []
BN_stds = []
for layer_id in range(len(layer_outs)):
#if layer_id not in [1, 3, 5, 7, 9]:
# continue
layer_out = layer_outs[layer_id]
#print(layer_out.shape)
if layer_id <= last_conv_id:
for i in range(layer_out.shape[3]):
BN_means.append(np.mean(layer_out[:,:,:,i]))
BN_stds.append(np.std(layer_out[:,:,:,i]))
else:
BN_means.append(np.mean(layer_out[:,:]))
BN_stds.append(np.std(layer_out[:,:]))
f_BN = open(outputPath.replace(ntpath.basename(outputPath), "BN_means.txt"),'w')
#print(BN_means)
#print(BN_stds)
for mean in BN_means:
f_BN.write("{:.5f}\n".format(mean))
f_BN.close()
f_BN = open(outputPath.replace(ntpath.basename(outputPath), "BN_stds.txt"),'w')
for std in BN_stds:
f_BN.write("{:.5f}\n".format(std))
f_BN.close()
heat_map = np.reshape(np.abs(np.array(predictResults.flatten()) - label), (rows, cols))
heat_map = heat_map / np.max(heat_map)
cv2.imshow("heat_map_small", heat_map)
img_ori = cv2.imread(imagePath)
heat_map = cv2.resize(heat_map,(img_ori.shape[1],img_ori.shape[0]), interpolation = cv2.INTER_AREA)
cv2.imshow("heat_map", heat_map)
cv2.imshow("img_ori", img_ori)
cv2.imshow("img_ori", img_ori)
img_ori[:,:,0] = np.multiply(img_ori[:,:,0], heat_map)
img_ori[:,:,1] = np.multiply(img_ori[:,:,1], heat_map)
img_ori[:,:,2] = np.multiply(img_ori[:,:,2], heat_map)
cv2.imshow("combine_img", img_ori)
cv2.imwrite(outputPath, img_ori)
cv2.waitKey(0);
# for i in range(len(testLabels)):
# print([str('%.4f' % float(j)) for j in predictResults[i]])
print('********************************************')
print('\n\n\n')
def train_network_multi_factor_search(imagePath,
labelPath,
outputPath,
modelPath="",
trainRatio=1.0,
partialPreModel=False,
reinitHeader=False,
BN_flag=0,
imagePath_list_advp=[],
labelPath_list_advp=[],
trainRatio_advp=1.0,
reinitBN=False,
classification=False,
netType=1):
print('Image folder: ' + str(imagePath))
print('Label file: ' + str(labelPath))
print('Output folder: ' + outputPath)
if not os.path.exists(outputPath):
os.mkdir(outputPath)
## flags
fRandomDistort = False
fThreeCameras = False # set to True if using Udacity data set
fClassifier = classification
flags = [fRandomDistort, fThreeCameras, fClassifier]
## parameters
nRound = 50
nEpoch = 20
batchSize = 128
nClass = 49 # only used if fClassifier = True
nFramesSample = 5 # only used for LSTMs
nRep = 1
specs = [batchSize, nEpoch, nClass, nFramesSample, nRep]
blur_level = 1
noise_level = 1
distortion_level = 1
R_level = 1
G_level = 1
B_level = 1
H_level = 1
S_level = 1
V_level = 1
Y_level = 1
U_level = 1
V1_level = 1
imagePath0 = imagePath[0:-1]
val_ratio = 0.03
f = open(outputPath + "factor_level_choices.txt", 'w')
for rid in range(nRound):
print("round no: " + str(rid) + "\n")
f.write("round no: " + str(rid) + "\n")
blur_imagePath = imagePath0 + '_blur_' + str(blur_level) + '/'
noise_imagePath = imagePath0 + '_noise_' + str(noise_level) + '/'
distortion_imagePath = imagePath0 + '_distort_' + str(
distortion_level) + '/'
#G_imagePath = imagePath0+'_G_darker/' if G_level == 1 else imagePath0+'_G_lighter/'
#S_imagePath = imagePath0+'_S_darker/' if S_level == 1 else imagePath0+'_S_lighter/'
#Y_imagePath = imagePath0+'_Y_luma_darker/' if Y_level == 1 else imagePath0+'_Y_luma_lighter/'
R_imagePath = imagePath0 + '_R' + get_suffix(R_level)
G_imagePath = imagePath0 + '_G' + get_suffix(G_level)
B_imagePath = imagePath0 + '_B' + get_suffix(B_level)
H_imagePath = imagePath0 + '_H' + get_suffix(H_level)
S_imagePath = imagePath0 + '_S' + get_suffix(S_level)
V_imagePath = imagePath0 + '_V' + get_suffix(V_level)
# Y_imagePath = imagePath0 + '_Y_luma' + get_suffix(Y_level)
# U_imagePath = imagePath0 + '_U_blueproj' + get_suffix(U_level)
# V1_imagePath = imagePath0 + '_V_redproj' + get_suffix(V1_level)
#imagePath_list = [imagePath, blur_imagePath, noise_imagePath, distortion_imagePath, R_imagePath, G_imagePath, B_imagePath, \
# H_imagePath, S_imagePath, V_imagePath, Y_imagePath, U_imagePath, V1_imagePath]
imagePath_list = [imagePath, blur_imagePath, noise_imagePath, distortion_imagePath, \
R_imagePath, G_imagePath, B_imagePath, H_imagePath, S_imagePath, V_imagePath]
#imagePath_list = [imagePath, blur_imagePath, noise_imagePath, distortion_imagePath, R_imagePath, G_imagePath, B_imagePath]
#imagePath_list = [imagePath, S_imagePath]
#Noise only
#imagePath_list = [imagePath, imagePath0+'_noise_'+str(noise_level)+'/']
#imagePath_list = [imagePath, distortion_imagePath]
labelPath_list = [labelPath] * len(imagePath_list)
train_dnn_multi(imagePath_list,
labelPath_list,
outputPath,
netType,
flags,
specs,
modelPath,
trainRatio,
partialPreModel,
reinitHeader,
BN_flag,
imagePath_list_advp,
labelPath_list_advp,
trainRatio_advp,
reinitBN,
pack_flag=False,
mid=rid)
modelPath = outputPath + "model-final.h5"
valOutputPath = ""
net = create_nvidia_network(BN_flag, fClassifier, nClass, nChannel=3)
net.load_weights(modelPath)
print('blur MAs:')
f.write('\nblur MAs:\n')
MA_min = 1
#for new_blur_level in range(1,4):
for new_blur_level in range(1, 6):
#blurImagePath = imagePath0+'_blur_'+str(new_blur_level*2-1)+'/'
blurImagePath = imagePath0 + '_blur_' + str(new_blur_level) + '/'
MA = test_network(modelPath,
blurImagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio,
net=net)
print(new_blur_level, ': ', MA)
f.write(str(new_blur_level) + ': ' + '{:.2f}'.format(MA) + '\n')
if MA_min > MA:
MA_min = MA
blur_level = new_blur_level
print('noise MAs:')
f.write('\nnoise MAs:\n')
MA_min = 1
#for new_noise_level in range(1,4):
for new_noise_level in range(1, 6):
#noiseImagePath = imagePath0+'_noise_'+str(new_noise_level*2-1)+'/'
noiseImagePath = imagePath0 + '_noise_' + str(
new_noise_level) + '/'
MA = test_network(modelPath,
noiseImagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio,
net=net)
print(new_noise_level, ': ', MA)
f.write(str(new_noise_level) + ': ' + '{:.2f}'.format(MA) + '\n')
if MA_min > MA:
MA_min = MA
noise_level = new_noise_level
print('distort MAs:')
f.write('\ndistort MAs:\n')
MA_min = 1
#for new_distort_level in range(1,4):
for new_distort_level in range(1, 6):
#distortImagePath = imagePath0+'_distort_'+str(new_distort_level*2-1)+'/'
distortImagePath = imagePath0 + '_distort_' + str(
new_distort_level) + '/'
MA = test_network(modelPath,
distortImagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio,
net=net)
print(new_distort_level, ': ', MA)
f.write(str(new_distort_level) + ': ' + '{:.2f}'.format(MA) + '\n')
if MA_min > MA:
MA_min = MA
distortion_level = new_distort_level
R_level = get_new_level('R',
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=net)
G_level = get_new_level('G',
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=net)
B_level = get_new_level('B',
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=net)
H_level = get_new_level('H',
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=net)
S_level = get_new_level('S',
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=net)
V_level = get_new_level('V',
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=net)
'''
Y_level = get_new_level('Y_luma', imagePath0, modelPath, labelPath, valOutputPath, BN_flag, val_ratio, f)
U_level = get_new_level('U_blueproj', imagePath0, modelPath, labelPath, valOutputPath, BN_flag, val_ratio, f)
V1_level = get_new_level('V_redproj', imagePath0, modelPath, labelPath, valOutputPath, BN_flag, val_ratio, f)
'''
print('new blur level: ', blur_level)
print('new noise level: ', noise_level)
print('new distort level: ', distortion_level)
print('new R channel level: ', R_level)
print('new G channel level: ', G_level)
print('new B channel level: ', B_level)
print('new H channel level: ', H_level)
print('new S channel level: ', S_level)
print('new V channel level: ', V_level)
#print('new Y channel level: ', Y_level)
#print('new U channel level: ', U_level)
#print('new V1 channel level: ', V1_level)
f.write("\n")
f.write("new blur level: " + str(blur_level) + "\n")
f.write("new noise level: " + str(noise_level) + "\n")
f.write("new distort level: " + str(distortion_level) + "\n")
f.write("new R channel level: " + str(R_level) + "\n")
f.write("new G channel level: " + str(G_level) + "\n")
f.write("new B channel level: " + str(B_level) + "\n")
f.write("new H channel level: " + str(H_level) + "\n")
f.write("new S channel level: " + str(S_level) + "\n")
f.write("new V channel level: " + str(V_level) + "\n")
#f.write("new Y channel level: "+str(Y_level)+"\n")
#f.write("new U channel level: "+str(U_level)+"\n")
#f.write("new V1 channel level: "+str(V1_level)+"\n\n")
f.write("\n")
f.flush()
f.close()