def eval_ckpt_and_compare(model):
eval_img = model.eval()
ver_img = cv2.resize(cv2.imread('test_img/sign.png', 0), eval_img.shape, interpolation=cv2.INTER_AREA)
psrn_ = utility.psnr(eval_img, ver_img)
print('psnr: ', psrn_)
utility.show_image(np.hstack([eval_img, ver_img]),
title="Out: left - Original Watermarker: Right (DNCNN: {}, DIP: {})".format(
utility.get_last_model(model_path), utility.get_last_model(dip_model_path)),
wait=True)
def eval_ckpt_and_compare(model):
eval_img = model.eval()
ver_img = cv2.resize(cv2.imread('test_img/sign.png', 0),
eval_img.shape,
interpolation=cv2.INTER_AREA)
utility.show_image(
np.hstack([eval_img, ver_img]),
title="Out: left - Verification: Right (DNCNN: {}, DIP: {})".format(
utility.get_last_model(model_path),
utility.get_last_model(dip_model_path)),
wait=True)
def eval_all_ckpts(model_path, dip_model_path, img_test):
ckpts = [
c[:-len('.ckpt.index')] for c in sorted(os.listdir(dip_model_path))
if '.ckpt.index' in c
]
eval_imgs = []
for dip_model in ckpts:
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=dip_model)
eval_img = model.eval()
eval_imgs.append(eval_img)
cv2.imwrite(out_copyrightImg_path + '/' + dip_model + '_copyright.png',
eval_img)
stack_images = utility.stack_images_square(eval_imgs)
cv2.imwrite(
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()
def pruning_attack_analysis(dim_imgs):
model_visual_watermarked = WatermarkedVisualizerModel()
model_visual_watermarked.build_model(
DnCNN_model_name=utility.get_last_model('./overwriting/'),
model_path='./overwriting/')
img_logo_watermarked = model_visual_watermarked.eval()
# eval pruned model with original data- calculate psnr and plot image. Choose pruned k you need
images_out = [img_logo_watermarked]
pruned_ks = [
float(file[8:12]) for file in os.listdir("./pruning_weights/")
if ".ckpt.meta" in file
]
for pruned_k in sorted(pruned_ks):
k = round(float(pruned_k), 2)
model_pruned_name = "Pruned_k{:.2f}".format(k)
dist, watermark_succeeded = ExecuteVerification(
dim_imgs).verificationOnAttackedImg(
model_attacked_folder="pruning_weights",
model_attacked_name=model_pruned_name)
# 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/')
img_logo_pruned = model_visual_pruned.eval()
print("{} | dist={:.5f} | WM succeded={} |".format(
model_pruned_name, dist, watermark_succeeded))
img_logo_pruned = utility.create_text_image(
img_logo_pruned, "{:.2f}={:.5f}".format(k, dist))
images_out.append(img_logo_pruned)
utility.show_image(utility.stack_images_square(images_out),
'1 Watermarked, other pruning 0.1, 0.2,...')
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 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 verificationOnAttackedImg(self, model_attacked_folder='./fineTuning_weight/',
model_attacked_name='fineTuned_10'):
model = WatermarkedTrainedModel()
model.build_model(model_name=utility.get_last_model('./overwriting/'), model_path='./overwriting/')
opt_ver_img = model.eval(test_img='key_imgs/trigger_image.png', show_input=False)
model.build_model(model_name=model_attacked_name, model_path=model_attacked_folder)
new_ver_img = model.eval(test_img='key_imgs/trigger_image.png', show_input=False)
dist, watermark_succeeded = self.watermark_verification(opt_ver_img, new_ver_img)
return dist, watermark_succeeded
def fine_tuning_attack_analysis(dim_imgs):
# eval finetuning model with original data- calculate psnr and plot image. Choose epoch you need
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()
model_visual_watermarked = WatermarkedVisualizerModel()
model_visual_watermarked.build_model(
DnCNN_model_name=utility.get_last_model('./overwriting/'),
model_path='./overwriting/')
img_logo_watermarked = model_visual_watermarked.eval()
images_out = [img_logo_unwatermarked, img_logo_watermarked]
files = [
c for c in (os.listdir('fineTuning_weight')) if '.ckpt.index' in c
]
epochs = ['10', '25', '50']
for f in sorted(files):
epoch = f[10:12]
if epoch in epochs:
model_fineTuned_name = "fineTuned_{}".format(epoch)
dist, watermark_succeeded = ExecuteVerification(
dim_imgs).verificationOnAttackedImg(
model_attacked_folder="fineTuning_weight",
model_attacked_name=model_fineTuned_name)
print("{} | dist={:.5f} | WM succeded={} |".format(
model_fineTuned_name, dist, watermark_succeeded))
# 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='./fineTuning_weight/')
img_logo_fineTun = model_visual_finetuned.eval()
img_logo_fineTun = utility.create_text_image(
img_logo_fineTun, "{} epoch={:.5f}".format(epoch, dist))
images_out.append(img_logo_fineTun)
# text = "WM {}".format("recognized" if watermark_succeeded else "lost")
# img_results = utility.create_text_image(
# utility.create_empty_image(img_logo_watermarked.shape[0], img_logo_watermarked.shape[1]), text)
utility.show_image(
utility.stack_images_square(images_out),
'1 dncnn original ,2 Watermarked, 3 FineTuned{}epochs'.format(epochs))
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 calculate_dist_ver_psnr(self,
model_attacked_folder='./fineTuning_weight/',
model_attacked_name='fineTuned_10',
image_test_fn=''):
model = WatermarkedTrainedModel()
model.build_model(model_name=utility.get_last_model('./overwriting/'),
model_path='./overwriting/')
opt_ver_img = model.eval(test_img='key_imgs/trigger_image.png',
show_input=False)
model.build_model(model_name=model_attacked_name,
model_path=model_attacked_folder)
new_ver_img = model.eval(test_img='key_imgs/trigger_image.png',
show_input=False)
dist, watermark_succeeded = self.watermark_verification(
opt_ver_img, new_ver_img)
img = self.test_img if image_test_fn == '' else cv2.imread(
image_test_fn, 0)
psnr = utility.psnr(img, model.eval(img, show_input=False))
return dist, watermark_succeeded, psnr
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")
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)
ramd_Image = np.expand_dims(ramd_Image, 0)
ramd_Image = np.expand_dims(ramd_Image, 3)
# ramd_Images = np.load('./spec_input/spec_14065.npy')
# ramd_Image = ramd_Images[0,:, :, :]
# ramd_Image = np.expand_dims(ramd_Image, 0)
mid, out = self.session.run([self.dncnn_s_out, self.ldr],
feed_dict={self.img_clean: ramd_Image, self.training_placeholder: False})
# print(mid.shape)
mark_out = post_process(out)
return mark_out
if __name__ == '__main__':
out_copyrightImg_path = 'out_copyrightImg'
utility.create_folder(out_copyrightImg_path)
# comment here to change source model.'DnCNN_weight' is original model, 'overwrting' is WM trained model
# model_path = './DnCNN_weight/'
model_path = './overwriting/'
dip_model_path = './combine_weight/'
model = WatermarkedVisualizerModel()
model.build_model(model_path=model_path, DnCNN_model_name=utility.get_last_model(model_path))
img = model.eval()
cv2.imwrite(out_copyrightImg_path + '/copyrightImg.png', img)
utility.show_image(img, title='watermark')
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
ckpt = tf.train.get_checkpoint_state(org_model_path)
if ckpt and ckpt.model_checkpoint_path:
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.51, 0.05):
k = round(float(value_k), 2)
load_and_prune_model(org_model_path="overwriting", model_name=utility.get_last_model("overwriting")+".ckpt", out_pruned_path="pruning_weights", 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")
if __name__ == '__main__':
show_uniqueness = False
show_robustness_finetune = True
show_robustness_pruning = True
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)
n_keys = 1000
h_w = 40
dim_imgs = h_w * h_w
model = WatermarkedTrainedModel()
model.build_model(model_name=utility.get_last_model(model_path),
model_path=model_path)
if show_uniqueness:
print('UNIQUENESS ANALYSIS')
trigger_imgs, verification_imgs = generator_n_keys(h_w, h_w, n_keys)
uniqueness_analysis(model, trigger_imgs, verification_imgs, n_keys,
dim_imgs)
visualize_uniqueness(model_path, dip_model_path, trigger_imgs[:50],
out_copyrightImg_path, test_img)
if show_robustness_finetune:
print('ROBUSTENESS ANALYSIS: FINE TUNING ATTACK')
fine_tuning_attack_analysis(dim_imgs)
if show_robustness_pruning: