def single_test_AdvProp():
train_folder = "trainB"
val_folder = "valB"
train_folder_advp = "trainB_blur_5"
val_folder_advp = "valB_blur_5"
#suffix = "_similarBN40"
suffix = ""
pathID = 0
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
imagePath_advp = DATASET_ROOT + train_folder_advp + "/"
labelName_advp = get_label_file_name(train_folder_advp, suffix)
labelPath_advp = DATASET_ROOT + labelName_advp
outputPath = TRAIN_OUTPUT_ROOT + train_folder + "_" + train_folder_advp + suffix + "_advp/"
#train_network(imagePath, labelPath, outputPath, BN_flag=2, imagePath_advp=imagePath_advp, labelPath_advp=labelPath_advp)
modelPath = outputPath + "/model-final.h5"
imagePath = DATASET_ROOT + val_folder + "/"
labelName = get_label_file_name(val_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TEST_OUTPUT_ROOT + "(" + train_folder + ")_(" + train_folder_advp + suffix + "_advp)_(" + val_folder + ")/test_result.txt"
#modelPath = ""
test_network(modelPath,
imagePath,
labelPath,
outputPath,
BN_flag=2,
pathID=pathID)
def single_test():
train_folder = "trainB"
val_folder = "darkerV"
degrees = [
f.path for f in os.scandir(DATASET_ROOT + val_folder) if f.is_dir()
]
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TRAIN_OUTPUT_ROOT + train_folder + "/"
# train_network(imagePath, labelPath, outputPath)
modelPath = outputPath + "/model-final.h5"
labelName = get_label_file_name("valB", "")
labelPath = DATASET_ROOT + labelName
#labelPath = DATASET_ROOT + "labelsB_train.csv"
for degree in degrees:
imagePath = degree + "/"
outputPath = TEST_OUTPUT_ROOT + "(" + train_folder + ")_(" + os.path.basename(
degree) + ")/test_result.txt"
#modelPath = ""
test_network(modelPath, imagePath, labelPath, outputPath)
def get_new_level(channel_name,
imagePath0,
modelPath,
labelPath,
valOutputPath,
BN_flag,
val_ratio,
f,
net=""):
f.write('\nchannel_name: ' + channel_name + '\n')
print('channel_name: ' + channel_name)
MA_min = 1
#for new_level in range(1,7):
for new_level in range(1, 11):
imagePath = imagePath0 + '_' + channel_name + get_suffix(new_level)
MA = test_network(modelPath,
imagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio,
net=net)
print(new_level, ': ', MA)
f.write(str(new_level) + ': ' + '{:.2f}'.format(MA) + '\n')
if MA_min > MA:
MA_min = MA
level = new_level
return level
def train_network(args, network):
""" train function """
since = time.time()
""" Start iteration """
for epoch in range(1, args.num_of_epochs + 1):
""" run 1 epoch and get loss """
train_loader, valid_loader, test_loader = data_loader(args)
train_loss = iteration(args, network, train_loader, phase="train")
valid_loss = iteration(args, network, valid_loader, phase="valid")
""" Print loss """
if (epoch % args.saveCycle_of_loss) == 0:
print_loss(epoch, time.time() - since, train_loss, valid_loss)
record_on_csv(args, epoch,
time.time() - since, train_loss, valid_loss)
""" Print image """
if (epoch % args.saveCycle_of_image) == 0:
test_network(args, network, test_loader, epoch)
print('======================[ train finished ]======================')
def unit_test_for_style():
TRAIN_LIST = [
"trainA", "trainB", "trainA_fake_GAN", "trainB_fake_GAN",
"trainA_MUNIT_GAN", "trainB_MUNIT_GAN", "trainA_fake_color",
"trainB_fake_color"
]
#TRAIN_LIST = ["trainA_1", "trainB", "trainA_fake_GAN_1", "trainA_MUNIT_GAN_1"]
VAL_LIST = [
"valA", "valB", "valA_fake_GAN", "valB_fake_GAN", "valA_MUNIT_GAN",
"valB_MUNIT_GAN", "valA_fake_color", "valB_fake_color"
]
#VAL_LIST = ["valA", "valB", "valA_fake_GAN", "valA_MUNIT_GAN"]
TRAIN_LIST = ["trainB_quality_channel"]
VAL_LIST = ["valB", "valB_noise_1", "valB_noise_2", "valB_noise_3", "valB_noise_4", "valB_noise_5", \
"valB_blur_1", "valB_blur_2", "valB_blur_3", "valB_blur_4", "valB_blur_5", \
"valB_distort_1", "valB_distort_2", "valB_distort_3", "valB_distort_4", "valB_distort_5", \
"valB_G_darker", "valB_G_lighter", \
"valB_S_darker", "valB_S_darker", \
"valB_Y_luma_darker", "valB_Y_luma_lighter"]
for train_folder in TRAIN_LIST:
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TRAIN_OUTPUT_ROOT + train_folder + "/"
#train_network(imagePath, labelPath, outputPath)
for val_folder in VAL_LIST:
modelPath = TRAIN_OUTPUT_ROOT + train_folder + "/model-final.h5"
val_folder = val_folder.replace("train", "val")
#if not (train_folder == "trainA_MUNIT_GAN_1" or val_folder == "valA_MUNIT_GAN"):
# continue
imagePath = DATASET_ROOT + val_folder + "/"
labelName = get_label_file_name(val_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TEST_OUTPUT_ROOT + "(" + train_folder + ")_(" + val_folder + ")/test_result.txt"
test_network(modelPath, imagePath, labelPath, outputPath)
def multi_factor_search_test():
train_folder = "trainB"
val_folder = "valB"
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
trainOurputFolder = train_folder + "_quality_channel"
trainOutputPath = TRAIN_OUTPUT_ROOT + trainOurputFolder + "/"
train_network_multi_factor_search(imagePath, labelPath, trainOutputPath)
modelPath = trainOutputPath + "/model-final.h5"
imagePath = DATASET_ROOT + val_folder + "/"
labelName = get_label_file_name(val_folder, "")
labelPath = DATASET_ROOT + labelName
#labelPath = DATASET_ROOT + "labelsB_train.csv"
valOutputPath = TEST_OUTPUT_ROOT + "(" + trainOurputFolder + ")_(" + val_folder + ")/test_result.txt"
#modelPath = ""
test_network(modelPath, imagePath, labelPath, valOutputPath)
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()
if iteration == lambda2After:
#net.setLambda(lambda2)
eta = eta2
print("Threshold reached")
if iteration > lambda2After:
all = iterations - lambda2After
rel = iteration - lambda2After
newLambda = lambda1 + 1.0 * (lambda2 - lambda1) * rel / all
net.setLambda(newLambda)
# backpropagate the pattern in the network
backpropagation.update_net(net, i, o, eta)
if iteration % test_after == 0:
corr = test.test_network(net)
print "Iteration:", iteration, "/", iterations, "(" + str(
100 * iteration / iterations) + "%)"
print "Correct test:", corr
corr_arr.append(corr)
lambda_arr.append(net.getLambda())
eta_arr.append(eta)
plt.plot(corr_arr, label='corr')
plt.plot([a / 10.0 for a in lambda_arr], label='lambda/10')
plt.plot(eta_arr, label='eta')
plt.ylim(0, 1)
plt.legend()
plt.show()
def combination_test_for_style_pretrain(subtask_id=-1):
#TRAIN_RATIO_LIST = [0.3, 0.1, 0.03, 0.01, 0.003, 0.001]
#TRAIN_RATIO_LIST = [0.25, 0.5, 0.75, 1]
#TRAIN_RATIO_LIST = [1]
TRAIN_RATIO_LIST = [1]
#PRETRAIN_MODEL_LIST = ["trainA"]
#PRETRAIN_MODEL_LIST = ["combine0"]
#PRETRAIN_MODEL_LIST = ["trainA_fake_GAN_1", "trainA_fake_GAN_0.75", "trainA_fake_GAN_0.5", "trainA_fake_GAN_0.25"]
#PRETRAIN_MODEL_LIST = ["trainC1_BN0_classify"]
#PRETRAIN_MODEL_LIST = ["trainC1"]
PRETRAIN_MODEL_LIST = [""]
#TRAIN_LIST = ["trainB"]
TRAIN_LIST = ["trainB"]
#VAL_LIST = ["valB", "valA"]
VAL_LIST = ["valB"]
partial_preModel = False
reinit_header = False
reinit_BN = False
BN_flag = 0
classification = False
if subtask_id == '0':
PRETRAIN_MODEL_LIST = [
"trainA_0.25", "trainA_0.5", "trainA_0.75", "trainA_1"
]
elif subtask_id == '1':
PRETRAIN_MODEL_LIST = [
"trainA_fake_GAN_0.25", "trainA_fake_GAN_0.5",
"trainA_fake_GAN_0.75", "trainA_fake_GAN_1"
]
elif subtask_id == '2':
PRETRAIN_MODEL_LIST = [
"trainA_MUNIT_GAN_0.25", "trainA_MUNIT_GAN_0.5",
"trainA_MUNIT_GAN_0.75", "trainA_MUNIT_GAN_1"
]
elif subtask_id == '3':
PRETRAIN_MODEL_LIST = [
"trainA_ALL_0.25", "trainA_ALL_0.5", "trainA_ALL_0.75",
"trainA_ALL_1"
]
#PRETRAIN_MODEL_LIST = ["combine_0_3_[0.25, 0.25, 0.25]", "combine_0_3_[1.0, 1.0, 1.0]"]
elif subtask_id == '4':
PRETRAIN_MODEL_LIST = ["trainA", "trainA_fake_GAN", "trainA_MUNIT_GAN"]
elif subtask_id == '5':
PRETRAIN_MODEL_LIST = ["trainA_BN", "trainC1_BN"]
#PRETRAIN_MODEL_LIST = ["trainC1_BN1_classify"]
elif subtask_id == '6':
PRETRAIN_MODEL_LIST = ["trainC1"]
elif subtask_id == '7':
PRETRAIN_MODEL_LIST = ["trainC1_BN"]
elif subtask_id == '8':
PRETRAIN_MODEL_LIST = ["trainB"]
BN_flag = 0
elif subtask_id == '9':
PRETRAIN_MODEL_LIST = ["trainB_BN1_2000"]
BN_flag = 1
#else:
# return
#suffix = "_pretrain"
suffix = "_2000"
if partial_preModel:
suffix = "_partialpretrain"
if reinit_header:
suffix = suffix + "_reinitheader"
if BN_flag > 0:
suffix = suffix + "_BN" + str(BN_flag)
if reinit_BN:
suffix = suffix + "_reinitBN"
if classification:
suffix = suffix + "_classify"
id = 0
for train_ratio in TRAIN_RATIO_LIST:
for pretrain_model in PRETRAIN_MODEL_LIST:
for train_folder in TRAIN_LIST:
id += 1
print(id)
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
if pretrain_model == "":
trainOutputPath = TRAIN_OUTPUT_ROOT + train_folder + "_" + str(
train_ratio) + "/"
pretrain_model_path = ""
else:
trainOutputPath = TRAIN_OUTPUT_ROOT + train_folder + "_" + str(
train_ratio) + "_(" + pretrain_model + suffix + ")/"
pretrain_model_path = TRAIN_OUTPUT_ROOT + pretrain_model + "/model-final.h5"
#if (train_ratio == 1 and pretrain_model == ""):
# continue
train_network(imagePath,
labelPath,
trainOutputPath,
pretrain_model_path,
trainRatio=train_ratio,
partialPreModel=partial_preModel,
reinitHeader=reinit_header,
BN_flag=BN_flag,
reinitBN=reinit_BN,
classification=classification)
for val_folder in VAL_LIST:
modelPath = trainOutputPath + "/model-final.h5"
val_folder = val_folder.replace("train", "val")
imagePath = DATASET_ROOT + val_folder + "/"
labelName = get_label_file_name(val_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TEST_OUTPUT_ROOT + "(" + train_folder + "_" + str(
train_ratio
) + "_(" + pretrain_model + suffix + ")" + ")_(" + val_folder + ")/test_result.txt"
test_network(modelPath,
imagePath,
labelPath,
outputPath,
BN_flag=BN_flag,
classification=classification)
def unit_test_for_quality(subtask_id=-1):
TRAIN_LIST_LIST = [[
"trainB", "trainB_blur_1", "trainB_blur_2", "trainB_blur_3",
"trainB_blur_4", "trainB_blur_5"
],
[
"trainB", "trainB_noise_1", "trainB_noise_2",
"trainB_noise_3", "trainB_noise_4", "trainB_noise_5"
],
[
"trainB", "trainB_distort_1", "trainB_distort_2",
"trainB_distort_3", "trainB_distort_4",
"trainB_distort_5"
]]
if subtask_id == '0':
TRAIN_LIST_LIST = [[
"trainB", "trainB_blur_1", "trainB_blur_2", "trainB_blur_3",
"trainB_blur_4", "trainB_blur_5"
]]
elif subtask_id == '1':
TRAIN_LIST_LIST = [[
"trainB", "trainB_noise_1", "trainB_noise_2", "trainB_noise_3",
"trainB_noise_4", "trainB_noise_5"
]]
elif subtask_id == '2':
TRAIN_LIST_LIST = [[
"trainB", "trainB_distort_1", "trainB_distort_2",
"trainB_distort_3", "trainB_distort_4", "trainB_distort_5"
]]
elif subtask_id == '3':
TRAIN_LIST_LIST = [[
"trainB", "trainB_B_darker", "trainB_B_lighter", "trainB_G_darker",
"trainB_G_lighter", "trainB_R_darker", "trainB_R_lighter"
]]
elif subtask_id == '4':
TRAIN_LIST_LIST = [[
"trainB", "trainB_H_darker", "trainB_H_lighter", "trainB_S_darker",
"trainB_S_lighter", "trainB_V_darker", "trainB_V_lighter"
]]
elif subtask_id == '5':
TRAIN_LIST_LIST = [[
"trainB", "trainB_Y_luma_darker", "trainB_Y_luma_lighter",
"trainB_U_blueproj_darker", "trainB_U_blueproj_lighter",
"trainB_V_redproj_darker", "trainB_V_redproj_lighter"
]]
else:
return
for TRAIN_LIST in TRAIN_LIST_LIST:
for train_folder in TRAIN_LIST:
if train_folder != "trainB":
imagePath = DATASET_ROOT + train_folder + "/"
labelPath = DATASET_ROOT + "labelsB_train.csv"
outputPath = TRAIN_OUTPUT_ROOT + train_folder + "/"
train_network(imagePath, labelPath, outputPath)
for val_folder in TRAIN_LIST:
modelPath = TRAIN_OUTPUT_ROOT + train_folder + "/model-final.h5"
#if train_folder != val_folder:
# continue
val_folder = val_folder.replace("train", "val")
# if train_folder != "trainB" and val_folder != "valB":
# continue
imagePath = DATASET_ROOT + val_folder + "/"
labelPath = DATASET_ROOT + "labelsB_val.csv"
outputPath = TEST_OUTPUT_ROOT + "(" + train_folder + ")_(" + val_folder + ")/test_result.txt"
test_network(modelPath, imagePath, labelPath, outputPath)
def test_AdvProp(subtask_id=-1):
train_folder = "trainB"
val_folder = "valB"
train_folder_advp = "trainC1"
val_folder_advp = "valC1"
#suffix = "_similarBN1"
suffix = ""
test_pathID = 0
#train_ratio_list = [0.5, 0.1, 0.01, 0.001]
train_ratio_list = [1]
#train_ratio_advp_list = [1]
if subtask_id == '0':
train_folder_advp = "trainA"
val_folder_advp = "valA"
elif subtask_id == '1':
train_folder_advp = "trainC1"
val_folder_advp = "valC1"
elif subtask_id == '2':
train_folder_advp = "trainB_blur_5"
val_folder_advp = "valB_blur_5"
elif subtask_id == '3':
train_folder_advp = "trainB_noise_5"
val_folder_advp = "valB_noise_5"
else:
return
for i in range(len(train_ratio_list)):
trainRatio = train_ratio_list[i]
#train_ratio_advp = train_ratio_advp_list[i]
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder)
labelPath = DATASET_ROOT + labelName
imagePath_advp = DATASET_ROOT + train_folder_advp + "/"
labelName_advp = get_label_file_name(train_folder_advp, suffix)
labelPath_advp = DATASET_ROOT + labelName_advp
trainOutputFolder = train_folder + "_left_" + train_folder_advp + "_" + str(
trainRatio) + suffix + "_advp"
trainOutputPath = TRAIN_OUTPUT_ROOT + trainOutputFolder + "/"
train_network(imagePath,
labelPath,
trainOutputPath,
trainRatio=trainRatio,
BN_flag=2,
imagePath_advp=imagePath_advp,
labelPath_advp=labelPath_advp)
modelPath = trainOutputPath + "/model-final.h5"
imagePath = DATASET_ROOT + val_folder + "/"
labelName = get_label_file_name(val_folder)
labelPath = DATASET_ROOT + labelName
outputPath = TEST_OUTPUT_ROOT + "(" + trainOutputFolder + ")(" + val_folder + ")/test_result.txt"
#modelPath = ""
test_network(modelPath,
imagePath,
labelPath,
outputPath,
BN_flag=2,
pathID=test_pathID)
def single_test_with_config(subtask_id=-1):
train_folder = "trainB"
val_folder = "valB"
BN_flag = 0
net_type = 1 # 1: CNN (default), 2: LSTM-m2o, 3: LSTM-m2m, 4: LSTM-o2o, 5: GAN
#suffix = "_similarBN40"
train_label_suffix = ""
#val_label_suffix = "_small"
val_label_suffix = ""
classification = False
visualize = False
radius = 10 #only valid when visualize = True
if subtask_id == '0':
train_folder = "trainB"
val_folder = "valB"
elif subtask_id == '1':
train_folder = "trainC1"
val_folder = "valC1"
elif subtask_id == '2':
train_folder = "trainB"
val_folder = "valC1"
elif subtask_id == '3':
train_folder = "trainC1"
val_folder = "valB"
elif subtask_id == '4':
train_folder = "trainA"
val_folder = "valA"
elif subtask_id == '5':
train_folder = "trainA"
val_folder = "valB"
elif subtask_id == '6':
train_folder = "trainB"
val_folder = "valA"
train_suffix = train_label_suffix
if BN_flag > 0:
train_suffix = train_suffix + "_BN" + str(BN_flag)
if classification:
train_suffix = train_suffix + "_classify"
if net_type == 5:
train_suffix = train_suffix + "_GAN"
imagePath = DATASET_ROOT + train_folder + "/"
labelName = get_label_file_name(train_folder, train_label_suffix)
labelPath = DATASET_ROOT + labelName
outputPath = TRAIN_OUTPUT_ROOT + train_folder + train_suffix + "/"
train_network(imagePath,
labelPath,
outputPath,
BN_flag=BN_flag,
classification=classification,
netType=net_type)
modelPath = outputPath + "/model-final.h5"
imagePath = DATASET_ROOT + val_folder + "/"
labelName = get_label_file_name(val_folder, val_label_suffix)
labelPath = DATASET_ROOT + labelName
#labelPath = DATASET_ROOT + "labelsB_train.csv"
if visualize:
outputPath = TEST_OUTPUT_ROOT + train_folder + train_suffix + "__" + val_folder + "__r" + str(
radius) + "__visualize/test_result.txt"
else:
outputPath = TEST_OUTPUT_ROOT + "(" + train_folder + train_suffix + ")_(" + val_folder + ")/test_result.txt"
#modelPath = ""
test_network(modelPath,
imagePath,
labelPath,
outputPath,
BN_flag=BN_flag,
classification=classification,
visualize=visualize,
radius=radius)
def test_diffaug(output_name, model, adv_step, n_repeats, eps):
output_root = DATASET_ROOT[:-1] + output_name + "/"
test_output_root = output_root + "test_results_" + model + "/"
train_folder = "trainB"
train_output_root = output_root + "train_results/"
if not os.path.exists(output_root):
print("output dir not exist")
if not os.path.exists(test_output_root):
os.mkdir(test_output_root)
outputPath = train_output_root + train_folder + "/"
modelPath_new = outputPath + "checkpoint/cp-weights-" + model + ".ckpt"
val_folders = ["valB"]
#val_folders.extend(["blur", 'distort', 'noise', 'combined',
# 'darkerR', 'darkerG', 'darkerB', 'darkerH', 'darkerS', 'darkerV',
# 'lighterR', 'lighterG', 'lighterB', 'lighterH', 'lighterS', 'lighterV'])
#val_folders.extend(["valB_IMGC/" + os.path.basename(f.path) for f in os.scandir(DATASET_ROOT + "valB_IMGC") if f.is_dir()])
print("testing: ", val_folders)
now = int(round(time.time() * 1000))
now02 = time.strftime('%Y%m%d-%H-%M-%S', time.localtime(now / 1000))
outputPath = test_output_root + "val_log_" + os.path.basename(
modelPath_new).replace(".", "-") + now02 + ".log"
output = open(outputPath, "w")
val_logPath = test_output_root + "val_log_" + os.path.basename(
modelPath_new).replace(".", "-") + now02 + ".csv"
val_log = open(val_logPath, "wt", newline="")
cw = csv.writer(val_log)
cw.writerow([val_log])
output.write("testing model: {}\n".format(modelPath_new))
cw.writerow(["valB Set", "degree", "mean_accuracy"])
labelName = get_label_file_name("valB", "")
labelPath = DATASET_ROOT + labelName
for val in val_folders:
cw.writerow([" ", "\t\t\t valB_{:s} \t\t\t".format(val), " "])
output.write("\t\t\t valB_{:s} \t\t\t\n".format(val))
degrees = [
f.path for f in os.scandir(DATASET_ROOT + val) if f.is_dir()
]
if degrees == []:
imagePath = DATASET_ROOT + val + "/"
outputPath = test_output_root + "(" + train_folder + ")_(" + val + ")/test_result.txt"
MA = test_network(modelPath_new,
imagePath,
labelPath,
outputPath,
diffAug=True)
cw.writerow([val, "{:.3f}".format(100 * MA)])
output.write("valB: {}, \t mean accuracy: {:.3f}\n".format(
val, 100 * MA))
else:
for degree in degrees:
# imagePath = DATASET_ROOT + val_folder + "/" + degree + "/"
imagePath = degree + "/"
outputPath = test_output_root + "(" + train_folder + ")_(" + os.path.basename(
degree) + ")/test_result.txt"
if os.path.exists(outputPath):
continue
MA = test_network(modelPath_new,
imagePath,
labelPath,
outputPath,
diffAug=True)
cw.writerow(
[val,
os.path.basename(degree), "{:.3f}".format(100 * MA)])
output.write(
"valB: {}, \t degree: {}, \t mean accuracy: {:.3f}\n".
format(val, os.path.basename(degree), 100 * MA))
val_log.close()
output.close()
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 = 20
nEpoch = 50
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
G_level = 1
S_level = 1
Y_level = 1
imagePath0 = imagePath[0:-1]
val_ratio = 0.1
f = open(outputPath + "factor_level_choices.txt", 'w')
for rid in range(nRound):
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/'
imagePath_list = [
imagePath, blur_imagePath, noise_imagePath, distortion_imagePath,
G_imagePath, S_imagePath, Y_imagePath
]
labelPath_list = [labelPath] * len(imagePath_list)
#Noise only
#imagePath_list = [imagePath, imagePath0+'_noise_'+str(noise_level)+'/']
#labelPath_list = [labelPath, labelPath]
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)
modelPath = outputPath + "model-final.h5"
valOutputPath = ""
print('blur MAs:')
MA_min = 1
for new_blur_level in range(1, 6):
blurImagePath = imagePath0 + '_blur_' + str(new_blur_level) + '/'
MA = test_network(modelPath,
blurImagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio)
print(new_blur_level, ': ', MA)
if MA_min > MA:
MA_min = MA
blur_level = new_blur_level
print('noise MAs:')
MA_min = 1
for new_noise_level in range(1, 6):
noiseImagePath = imagePath0 + '_noise_' + str(
new_noise_level) + '/'
MA = test_network(modelPath,
noiseImagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio)
print(new_noise_level, ': ', MA)
if MA_min > MA:
MA_min = MA
noise_level = new_noise_level
print('distort MAs:')
MA_min = 1
for new_distort_level in range(1, 6):
distortImagePath = imagePath0 + '_distort_' + str(
new_distort_level) + '/'
MA = test_network(modelPath,
distortImagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio)
print(new_distort_level, ': ', MA)
if MA_min > MA:
MA_min = MA
distortion_level = new_distort_level
print('G MAs:')
MA_min = 1
for new_G_level in range(1, 3):
G_imagePath = imagePath0 + '_G_darker/' if G_level == 1 else imagePath0 + '_G_lighter/'
MA = test_network(modelPath,
G_imagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio)
print(new_G_level, ': ', MA)
if MA_min > MA:
MA_min = MA
G_level = new_G_level
print('S MAs:')
MA_min = 1
for new_S_level in range(1, 3):
S_imagePath = imagePath0 + '_S_darker/' if S_level == 1 else imagePath0 + '_S_lighter/'
MA = test_network(modelPath,
S_imagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio)
print(new_S_level, ': ', MA)
if MA_min > MA:
MA_min = MA
S_level = new_S_level
print('Y MAs:')
MA_min = 1
for new_Y_level in range(1, 3):
Y_imagePath = imagePath0 + '_Y_luma_darker/' if Y_level == 1 else imagePath0 + '_Y_luma_lighter/'
MA = test_network(modelPath,
Y_imagePath,
labelPath,
valOutputPath,
BN_flag=BN_flag,
ratio=val_ratio)
print(new_Y_level, ': ', MA)
if MA_min > MA:
MA_min = MA
Y_level = new_Y_level
print('new blur level: ', blur_level)
print('new noise level: ', noise_level)
print('new distort level: ', distortion_level)
print('new G channel level: ', G_level)
print('new S channel level: ', S_level)
print('new Y channel level: ', Y_level)
f.write("round no: " + str(rid) + "\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\n")
f.write("new G channel level: " + str(G_level) + "\n")
f.write("new S channel level: " + str(S_level) + "\n")
f.write("new Y channel level: " + str(Y_level) + "\n\n")
f.flush()
f.close()
