def visualize_uniqueness(model_path, dip_model_path, false_trigger_imgs, test_img, save_images=True, show_results=True): # dimostra che date in ingresso delle trigger image diverse dall'originale non produce il watermarker out_copyrightImg_path = 'results/uniqueness/' if save_images: utility.create_folder(out_copyrightImg_path) not_copyright_imgs = [] model = WatermarkedVisualizerModel() model.build_model(model_path=model_path, DnCNN_model_name=utility.get_last_model(model_path)) for trigger in false_trigger_imgs: not_copyright_img = model.eval(trigger_image=trigger, show_input=False) not_copyright_imgs.append(not_copyright_img) ver_img = cv2.resize(cv2.imread(test_img, 0), not_copyright_imgs[0].shape, interpolation=cv2.INTER_AREA) concatenate_imgs = not_copyright_imgs concatenate_imgs.append(ver_img) stack_img = utility.stack_images_square(concatenate_imgs) if save_images: cv2.imwrite( out_copyrightImg_path + 'Stack_out_with_' + str(len(false_trigger_imgs)) + '_false_trigger_imgs.png', stack_img) if show_results: utility.show_image( stack_img, title='Results with ' + str(len(false_trigger_imgs)) + ' false trigger images - the last is Copyright image')
def pruning_attack_analysis(dim_imgs, pruning_weights_path="./pruning_weights/", show_distance=True, show_Separate=False, save_images=False): result_path = 'results/pruning/' if save_images: utility.create_folder(result_path) images_out = [] distances_out = [] psnr_all = [] pruned_ks = [ float(file[8:12]) for file in sorted(os.listdir(pruning_weights_path)) if ".ckpt.meta" in file ] for pruned_k in pruned_ks: k = round(float(pruned_k), 2) model_pruned_name = "Pruned_k{:.2f}".format(k) dist, watermark_succeeded, psnr = WMVerificationManager( dim_imgs).calculate_dist_ver_psnr( model_attacked_folder=pruning_weights_path, model_attacked_name=model_pruned_name) print("{} | dist={:.5f} | WM succeded={} | psnr={:.2f}".format( model_pruned_name, dist, watermark_succeeded, psnr)) distances_out.append(dist) psnr_all.append(psnr) # Visualization of watermark information under model pruning attacks model_visual_pruned = WatermarkedVisualizerModel() model_visual_pruned.build_model(DnCNN_model_name=model_pruned_name, model_path=pruning_weights_path) img_logo_pruned = model_visual_pruned.eval() if show_distance: img_logo_pruned = utility.create_text_image( img_logo_pruned, "{:.2f}={:.5f}".format(k, dist)) images_out.append(img_logo_pruned) if show_Separate: utility.show_image(img_logo_pruned, "{:.2f}={:.5f}".format(k, dist), wait=True) if save_images: cv2.imwrite(result_path + "pruned_{:.2f}.jpg".format(k), img_logo_pruned) if save_images: cv2.imwrite(result_path + 'stack_out_pruning.png', utility.stack_images_row(images_out)) datas_all = [{ "pruning_percentage": k, "distance": d, "psnr": p } for k, d, p in zip(pruned_ks, distances_out, psnr_all)] utility.save_json_results({"pruning_results": datas_all}, result_path + "datas_pruning.json") if not show_Separate: # utility.show_image(utility.stack_images_square(images_out), '1 Watermarked, other pruning 0.1, 0.2,...') utility.show_image(utility.stack_images_row(images_out), '1 Watermarked, other pruning 0.1, 0.2,...')
def unwatermarked_vs_watermarked(save_images=True, show_results=True): result_path = 'results/WM_vs_UNWM/' if save_images: utility.create_folder(result_path) model_name = ['unwatermarked model', 'watermarked model'] model_visual_unwatermarked = WatermarkedVisualizerModel() model_visual_unwatermarked.build_model(DnCNN_model_name='model_weight_45', model_path='./DnCNN_weight/') img_logo_unwatermarked = model_visual_unwatermarked.eval() dist, watermark_succeeded, psnr = WMVerificationManager( dim_imgs).calculate_dist_ver_psnr( model_attacked_folder='./DnCNN_weight/', model_attacked_name='model_weight_45') print("unwatermarked model | dist={:.5f} | WM succeded={} | psnr={:.2f}". format(dist, watermark_succeeded, psnr)) model_visual_watermarked = WatermarkedVisualizerModel() model_visual_watermarked.build_model( DnCNN_model_name=utility.get_last_model('./overwriting/'), model_path='./overwriting/') dist_w, watermark_succeeded_w, psnr_w = WMVerificationManager( dim_imgs).calculate_dist_ver_psnr( model_attacked_folder='./overwriting/', model_attacked_name=utility.get_last_model('./overwriting/')) print("watermarked model | dist={:.5f} | WM succeded={} | psnr={:.2f}". format(dist_w, watermark_succeeded_w, psnr_w)) img_logo_watermarked = model_visual_watermarked.eval() images_out = [img_logo_unwatermarked, img_logo_watermarked] if save_images: cv2.imwrite(result_path + 'Un-Watermarked.png', utility.stack_images_row(images_out)) datas_all = { "watermarked": { "distance": dist_w, "success": bool(watermark_succeeded_w), "psnr": psnr_w }, "unwatermarked": { "distance": dist, "success": bool(watermark_succeeded), "psnr": psnr } } utility.save_json_results(datas_all, result_path + "datas_w_vs_uw.json") if show_results: utility.show_image(utility.stack_images_row(images_out), 'unwatermarked, watermarked')
def fidelity_analysis(watermarked_model_path, dataset='./dataset/test/Texture12/', save_images=True): result_path = 'results/fidelity/' if save_images: utility.create_folder(result_path) seed = 42 watermarked_model = WatermarkedTrainedModel() watermarked_model.build_model( model_name=utility.get_last_model(watermarked_model_path), model_path=watermarked_model_path, seed=seed) unWatermarked_model = WatermarkedTrainedModel() unWatermarked_model.build_model(seed=seed) unwatermarked_imgs_out = [] psnr_ = [] test_images = [dataset + img for img in sorted(os.listdir(dataset))] for img in test_images: unwatermarked_imgs_out.append( unWatermarked_model.eval(test_img=img, show_input=False)) for index, out in enumerate(unwatermarked_imgs_out): test_img = cv2.imread(test_images[index], 0) psnr_.append(utility.psnr(out, test_img)) avg_psnr = sum(psnr_) / len(psnr_) print('UnWatermaked model | avg psnr: ', avg_psnr) watermarked_imgs_out = [] psnr_w = [] for img in test_images: watermarked_imgs_out.append( watermarked_model.eval(test_img=img, show_input=False)) for index, out in enumerate(watermarked_imgs_out): test_img = cv2.imread(test_images[index], 0) psnr_w.append(utility.psnr(out, test_img)) avg_psnr_w = sum(psnr_w) / len(psnr_w) print('Watermarked model | avg psnr: ', avg_psnr_w) if save_images: datas_all = [{ "image": i, "psnr": p } for i, p in zip(test_images, psnr_)] utility.save_json_results( { "psnr_avg": avg_psnr_w, "psnr_all": datas_all }, result_path + "datas_fidelity.json")
def __init__(self,config, drawing, experiment_folder): super(PopulationSampleFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder(os.path.join(self.experiment_folder,"figure_population")) self.num_plots_sqrt = 3 self.tfig,self.pf_subplots = plt.subplots(self.num_plots_sqrt,self.num_plots_sqrt) text = "Popluation" plt.gcf().canvas.set_window_title(text) for i in xrange(self.num_plots_sqrt): for j in xrange(self.num_plots_sqrt): self.pf_subplots[i,j].axis([0,self.grid_x,0,self.grid_y])
def __init__(self, config): self.__experiment_name = str(datetime.datetime.now().strftime("%d-%m-%Y_%H%M%S")) config_filename = config.get(GLOBAL_SECTION,"config_filename") config_file = open(os.path.join(self.get_experiment_folder(),os.path.basename(config_filename)),"w+") config.write(config_file) config_file.close() self.dump_folder = create_folder(os.path.join(self.get_experiment_folder(),"population_dump")) self.config = config
def __init__(self,config, drawing, experiment_folder): super(BestPhenoPredictionsFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder(os.path.join(self.experiment_folder,"figure_best_predictions")) plt.figure(3,figsize=(8, 8)) text = "Best phenome with predictions" plt.title(text) plt.grid(b=True) plt.gcf().canvas.set_window_title(text) self.bfg_predictions = plt.gcf().gca() self.bpf_predictions_ax = plt.gca() self.bpf_predictions_ax.axis([0,self.grid_x,0,self.grid_y]) self.bpf_predictions_ax.set_aspect('equal')
def __init__(self, config, drawing, experiment_folder): super(PopulationSampleFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder( os.path.join(self.experiment_folder, "figure_population")) self.num_plots_sqrt = 3 self.tfig, self.pf_subplots = plt.subplots(self.num_plots_sqrt, self.num_plots_sqrt) text = "Popluation" plt.gcf().canvas.set_window_title(text) for i in xrange(self.num_plots_sqrt): for j in xrange(self.num_plots_sqrt): self.pf_subplots[i, j].axis([0, self.grid_x, 0, self.grid_y])
def __init__(self, config, drawing, experiment_folder): super(BestPhenoPredictionsFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder( os.path.join(self.experiment_folder, "figure_best_predictions")) plt.figure(3, figsize=(8, 8)) text = "Best phenome with predictions" plt.title(text) plt.grid(b=True) plt.gcf().canvas.set_window_title(text) self.bfg_predictions = plt.gcf().gca() self.bpf_predictions_ax = plt.gca() self.bpf_predictions_ax.axis([0, self.grid_x, 0, self.grid_y]) self.bpf_predictions_ax.set_aspect('equal')
def __init__(self,config, drawing, experiment_folder): super(PopulationPhenoFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder(os.path.join(self.experiment_folder,"figure_pop_phenomes")) plt.figure(5,figsize=(8, 8)) text = "Phenomes in population" plt.title(text) plt.grid(b=True) plt.gcf().canvas.set_window_title(text) self.bfg = plt.gcf().gca() self.bfg_ax = plt.gca() self.bfg_ax.set_aspect('equal') self.bfg_ax.axis([0,self.grid_x,0,self.grid_y])
def __init__(self, config): self.__experiment_name = str( datetime.datetime.now().strftime("%d-%m-%Y_%H%M%S")) config_filename = config.get(GLOBAL_SECTION, "config_filename") config_file = open( os.path.join(self.get_experiment_folder(), os.path.basename(config_filename)), "w+") config.write(config_file) config_file.close() self.dump_folder = create_folder( os.path.join(self.get_experiment_folder(), "population_dump")) self.config = config
def uniqueness_analysis(model, trigger_imgs, verification_imgs, n_keys, dim_imgs, save_images=True): out_copyrightImg_path = 'results/uniqueness/' if save_images: utility.create_folder(out_copyrightImg_path) out_datas = [] for p in range(200, n_keys + 200, 200): new_verification_imgs = [] distances_w = [] succeeded_w = [] for i in range(len(trigger_imgs)): v = model.eval(test_img=trigger_imgs[i], show_input=False) new_verification_imgs.append(v) dist, succeeded = WMVerificationManager( dim_imgs).watermark_verification(verification_imgs[i], new_verification_imgs[i]) distances_w.append(round(dist, 4)) succeeded_w.append(succeeded) min_dist = np.min(distances_w) all_succeeded = all(succeeded_w) out_datas.append({ "p": p, "min_dist": min_dist, "succeded": all_succeeded }) print('min dist with ' + str(len(trigger_imgs[:p])) + ' key pairs: ' + str(min_dist)) print('all keys are watermark_succeeded = ', all_succeeded) if save_images: utility.save_json_results({"uniqueness_Results": out_datas}, out_copyrightImg_path + "datas_uniqueness.json")
def __init__(self, config, drawing, experiment_folder): super(PopulationPhenoFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder( os.path.join(self.experiment_folder, "figure_pop_phenomes")) plt.figure(5, figsize=(8, 8)) text = "Phenomes in population" plt.title(text) plt.grid(b=True) plt.gcf().canvas.set_window_title(text) self.bfg = plt.gcf().gca() self.bfg_ax = plt.gca() self.bfg_ax.set_aspect('equal') self.bfg_ax.axis([0, self.grid_x, 0, self.grid_y])
def __init__(self,config, drawing, experiment_folder): super(GenerationFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder(os.path.join(self.experiment_folder,"figure_generations")) plt.figure(0) text = "EA progress" plt.title(text) plt.grid(b=True) plt.gcf().canvas.set_window_title(text) plt.ylabel('Fitness') plt.xlabel('Generation') self.best, = plt.plot([], label='Best') self.worst, = plt.plot([], label='Worst') self.avg, = plt.plot([], label='Average') self.stddev, = plt.plot([], label='Std. dev.') self.ax = plt.gca() self.ax.axis([0,self.num_generations,0,100]) plt.legend( loc=4)
def __init__(self, config, drawing, experiment_folder): super(GenerationFigure, self).__init__(config, drawing, experiment_folder) self.figure_folder = create_folder( os.path.join(self.experiment_folder, "figure_generations")) plt.figure(0) text = "EA progress" plt.title(text) plt.grid(b=True) plt.gcf().canvas.set_window_title(text) plt.ylabel('Fitness') plt.xlabel('Generation') self.best, = plt.plot([], label='Best') self.worst, = plt.plot([], label='Worst') self.avg, = plt.plot([], label='Average') self.stddev, = plt.plot([], label='Std. dev.') self.ax = plt.gca() self.ax.axis([0, self.num_generations, 0, 100]) plt.legend(loc=4)
out_copyrightImg_path + '/Auxiliary_visualizer_per_checkpoint.png', stack_images) cv2.imshow("Auxiliary visualizer per checkpoint", stack_images) cv2.imshow( "Original image", cv2.resize(cv2.imread('test_img/' + img_test, 0), eval_imgs[0].shape, interpolation=cv2.INTER_AREA)) cv2.waitKey(0) cv2.destroyAllWindows() if __name__ == '__main__': model_path = './overwriting/' dip_model_path = './combine_weight/' test_img = 'test_img/sign.png' trigger_img = 'key_imgs/trigger_image.png' out_copyrightImg_path = 'out_copyrightImg' utility.create_folder(out_copyrightImg_path) # uncommet to view eval per checkpoint # eval_all_ckpts(model_path, dip_model_path, test_img) model = WatermarkedVisualizerModel() model.build_model(model_path=model_path, DnCNN_model_name=utility.get_last_model(model_path), DIP_model_path=dip_model_path, DIP_model_name=utility.get_last_model(dip_model_path)) eval_ckpt_and_compare(model)
def train(train_data='./data/img_clean_pats.npy', DnCNN_model_name='fineTuned_', epochs=8, batch_size=128, learn_rate=0.0001, sigma=25, org_model_path='./overwriting/', fineTuning_path='./fineTuning_weight/'): utility.create_folder(fineTuning_path) spec_size = [1, 40, 40, 1] save_ckpt_each = 5 with tf.Graph().as_default(): lr = tf.placeholder(tf.float32, shape=[], name='learning_rate') training = tf.placeholder(tf.bool, name='is_training') img_clean = tf.placeholder( tf.float32, [batch_size, spec_size[1], spec_size[2], spec_size[3]], name='clean_image') # DnCNN model img_noise = img_clean + tf.random_normal( shape=tf.shape(img_clean), stddev=sigma / 255.0) # dati con aggiunta di rumore Y, N = dncnn(img_noise, is_training=training) # host loss dncnn_loss = lossing(Y, img_clean, batch_size) dncnn_opt = optimizer(dncnn_loss, lr) init = tf.global_variables_initializer() dncnn_var_list = [ v for v in tf.global_variables() if v.name.startswith('block') ] DnCNN_saver = tf.train.Saver(dncnn_var_list, max_to_keep=50) np.random.seed(0) with tf.Session() as sess: data_total = np.load(train_data) data_total = data_total.astype(np.float32) / 255.0 num_example, row, col, chanel = data_total.shape numBatch = num_example // batch_size sess.run(init) ckpt = tf.train.get_checkpoint_state(org_model_path) if ckpt and ckpt.model_checkpoint_path: full_path = tf.train.latest_checkpoint(org_model_path) print('last ckp', full_path) DnCNN_saver.restore(sess, full_path) print("Loading " + os.path.basename(full_path) + " to the model") else: print("DnCNN weight must be exist") assert ckpt != None, 'weights not exist' step = 0 for epoch in range(1, epochs + 1): np.random.shuffle(data_total) for batch_id in range(0, numBatch): batch_images = data_total[batch_id * batch_size:(batch_id + 1) * batch_size, :, :, :] if batch_id % 100 == 0: dncnn_loss_res = sess.run(dncnn_loss, feed_dict={ img_clean: batch_images, lr: learn_rate, training: False }) _ = sess.run(dncnn_opt, feed_dict={ img_clean: batch_images, lr: learn_rate, training: True }) step += 1 print( f"epoch={epoch}, step={step}, dncnn_loss={dncnn_loss_res}") if epoch % save_ckpt_each == 0: DnCNN_saver.save( sess, os.path.join( fineTuning_path, DnCNN_model_name + str(epoch).zfill(2) + ".ckpt")) print(f"++++ epoch {epoch} saved ++++")
def get_experiment_folder(self): folder_name = os.path.join("./experiments/",self.__experiment_name) return create_folder(folder_name)
def get_experiment_folder(self): folder_name = os.path.join("./experiments/", self.__experiment_name) return create_folder(folder_name)
# テスト結果を保存する場所 save_root = r'E:\demo' # テストに使うモデルのnpzファイルの場所 model_file = r'C:\Users\yamane\Dropbox\correct_aspect_ratio\dog_data_regression_ave_pooling\1485768519.06_asp_max_4.0\dog_data_regression_ave_pooling.npz' num_train = 16500 # 学習データ数 num_valid = 500 # 検証データ数 num_test = 100 # テストデータ数 asp_r_max = 3.0 # 歪み画像の最大アスペクト比 success_asp = 1.1 # 修正成功とみなす修正画像のアスペクト比の最大値 batch_size = 100 # モデルのファイル名をフォルダ名にする folder_name = model_file.split('\\')[-2] # テスト結果を保存するフォルダを作成 test_folder_path = utility.create_folder(save_root, folder_name) fix_folder_path = utility.create_folder(test_folder_path, 'fix') dis_folder_path = utility.create_folder(test_folder_path, 'distorted') ori_folder_path = utility.create_folder(test_folder_path, 'original') # モデル読み込み model = voc2012_regression_max_pooling.Convnet().to_gpu() serializers.load_npz(model_file, model) # streamを取得 streams = load_datasets.load_voc2012_stream(batch_size, num_train, num_valid, num_test) train_stream, valid_stream, test_stream = streams # 歪み画像の修正を実行 loss, loss_abs, target, predict = lossfun(model, test_stream)
def fine_tuning_attack_analysis(dim_imgs, show_distance=True, show_Separate=False, save_images=False, finetuned_folder='./fineTuning_weights_Img12', dataset_name='originalDataset'): # eval finetuning model with original data- calculate psnr and plot image. Choose epoch you need result_path = 'results/fineTuning_' + dataset_name + "/" if save_images: utility.create_folder(result_path) distances_out = [] psnr_all = [] images_out = [] files = [c for c in (os.listdir(finetuned_folder)) if '.ckpt.index' in c] ep = ['10', '25', '50', '75', '100'] for epoch in ep: filename = "fineTuned_" + str(epoch).zfill(2) + ".ckpt.index" if filename in files: model_fineTuned_name = "fineTuned_{}".format(epoch) dist, watermark_succeeded, psnr = WMVerificationManager( dim_imgs).calculate_dist_ver_psnr( model_attacked_folder=finetuned_folder, model_attacked_name=model_fineTuned_name) print("{:<10} | dist={:.5f} | WM succeded={} | psnr={:.2f}".format( model_fineTuned_name, dist, watermark_succeeded, psnr)) distances_out.append(dist) psnr_all.append(psnr) # Visualization of watermark information under model fine-tuning attacks model_visual_finetuned = WatermarkedVisualizerModel() model_visual_finetuned.build_model( DnCNN_model_name=model_fineTuned_name, model_path=finetuned_folder) img_logo_fineTun = model_visual_finetuned.eval() if show_distance: img_logo_fineTun = utility.create_text_image( img_logo_fineTun, "{}={:.5f}.jpg".format(epoch, dist)) images_out.append(img_logo_fineTun) if show_Separate: utility.show_image(img_logo_fineTun, "{}={:.5f}.jpg".format(epoch, dist), wait=False) if save_images: cv2.imwrite(result_path + "fineTuned_{}.jpg".format(epoch), img_logo_fineTun) if save_images: cv2.imwrite(result_path + 'stack_out_fineTuning.png', utility.stack_images_row(images_out)) datas_all = [{ "epoch": e, "distance": d, "psnr": p } for e, d, p in zip(ep, distances_out, psnr_all)] utility.save_json_results( { "dataset_name": dataset_name, "finetuning_results": datas_all }, result_path + "datas_finetuning.json") if not show_Separate: utility.show_image( utility.stack_images_square(images_out), 'Finetuning epochs 0 ' + ' '.join(ep) + ' using ' + dataset_name)
import numpy as np import cv2 class GeneratorTriggerVerificationImg: def __init__(self, m, n): """ @param m: height of the image that the generator takes as input @param n: width of the image that the generator takes as input """ self.m = m self.n = n def generate_trigger_and_verification_img(self): np.random.seed(None) self.trigger_img = np.random.random((self.m, self.n))*255 filter_img = cv2.Sobel(self.trigger_img, cv2.CV_64F, 1, 1, ksize=3) self.verification_img = np.uint8(np.abs(filter_img)) return self.trigger_img, self.verification_img if __name__ == '__main__': import utility key_imgs_path = utility.create_folder('key_imgs') trigger_img, verification_img = GeneratorTriggerVerificationImg(40, 40).generate_trigger_and_verification_img() cv2.imwrite(key_imgs_path + '/trigger_image.png', trigger_img) cv2.imwrite(key_imgs_path + '/verification_image.png', verification_img)
full_path = os.path.join(org_model_path, model_name) print(full_path) DnCNN_saver.restore(sess, full_path) print("Loading " + os.path.basename(full_path) + " to the model") else: print("DnCNN weight must be exist") assert ckpt != None, 'weights not exist' sess.run(updates) out_path = os.path.join(out_pruned_path, "Pruned_k{:.2f}.ckpt".format(k)) DnCNN_saver.save(sess, out_path) print("Pruned model succesfully saved in " + out_path) if __name__ == '__main__': import utility utility.create_folder("pruning_weights") for value_k in np.arange(0.05, 0.61, 0.05): k = round(float(value_k), 2) load_and_prune_model(org_model_path="overwriting", model_name=utility.get_last_model("overwriting") + ".ckpt", k=k) print("Pruned {}".format(k)) # prune_model(org_model_path=os.path.join("overwriting", utility.get_last_model("overwriting")), out_pruned_path="pruning_weights/pruned_float16")
num_split = 20 # 歪み画像のアスペクト比の段階 loss_list = [] loss_abs_list = [] t_list = [] folder_name = model_file.split('\\')[-2] num_t = num_split + 1 t_step = np.log(3.0) * 2 / num_split t = np.log(1 / 3.0) for i in range(num_t): t_list.append(t) t = t + t_step # 結果を保存するフォルダを作成 folder_path = utility.create_folder(save_root, folder_name) # モデル読み込み model = voc2012_regression_max_pooling.Convnet().to_gpu() # Optimizerの設定 serializers.load_npz(model_file, model) # streamの取得 streams = load_datasets.load_voc2012_stream(batch_size, num_train, num_valid, num_test) train_stream, valid_stream, test_stream = streams # アスペクト比ごとに歪み画像を作成し、修正誤差を計算 for t in t_list: print t loss, loss_abs = fix(model, test_stream, t) loss_list.append(loss) loss_abs_list.append(loss_abs) # 修正誤差をグラフに描画