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()