def run(model_path, image_path):
predict_func = tp.OfflinePredictor(tp.PredictConfig(
model=Model(),
session_init=tp.get_model_loader(model_path),
input_names=['image'],
output_names=['saliency']))
im = cv2.imread(image_path)
assert im is not None and im.ndim == 3, image_path
# resnet expect RGB inputs of 224x224x3
im = cv2.resize(im, (IMAGE_SIZE, IMAGE_SIZE))
im = im.astype(np.float32)[:, :, ::-1]
saliency_images = predict_func([im])[0]
abs_saliency = np.abs(saliency_images).max(axis=-1)
pos_saliency = np.maximum(0, saliency_images)
neg_saliency = np.maximum(0, -saliency_images)
pos_saliency -= pos_saliency.min()
pos_saliency /= pos_saliency.max()
cv2.imwrite('pos.jpg', pos_saliency * 255)
neg_saliency -= neg_saliency.min()
neg_saliency /= neg_saliency.max()
cv2.imwrite('neg.jpg', neg_saliency * 255)
abs_saliency = viz.intensity_to_rgb(abs_saliency, normalize=True)[:, :, ::-1] # bgr
cv2.imwrite("abs-saliency.jpg", abs_saliency)
rsl = im * 0.2 + abs_saliency * 0.8
cv2.imwrite("blended.jpg", rsl)
def main():
# tf.logging.set_verbosity(tf.logging.INFO)
# instantiate blackbox and substitute model
# instantiate blackbox and substitute model
forward_model = load_model()
# backward_model1 = create_fmodel_18()
backward_model2 = create_fmodel_ALP()
backward_model3 = create_fmodel_ALP1000()
# print(backward_model1[0])
# instantiate differntiable composite model
# (predictions from blackbox, gradients from substitute)
model = CompositeModel(
forward_model=forward_model,
backward_models=[backward_model2, backward_model3],
weights = [0.5, 0.5])
predictor = tp.OfflinePredictor(tp.PredictConfig(
model=SaliencyModel(),
session_init=tp.get_model_loader("resnet_v1_50.ckpt"),
input_names=['image'],
output_names=['saliency']))
for (file_name, image, label) in read_images():
pos_salience = find_salience(predictor, image)
adversarial = run_attack(model, image, label, pos_salience)
store_adversarial(file_name, adversarial)
attack_complete()
def save_model(model_paths, model, target="", compact=False):
"""Save a model to given dir"""
from os import path
from os import makedirs
import tensorpack as tp
from tensorpack.tfutils.varmanip import get_checkpoint_path
from tensorpack.tfutils.export import ModelExporter
import misc.logger as logger
_L = logger.getLogger("Saver")
save_to_modeldir = target is ""
for model_path in model_paths:
# get model path
real_path = get_checkpoint_path(model_path)
abs_p = path.realpath(model_path)
if (not path.isfile(abs_p)):
_L.error("{} is not a model file".format(model_path))
continue
# save to same folder as model
if (save_to_modeldir):
target = path.dirname(abs_p)
# make sure the folder exists
if not path.exists(target):
makedirs(target)
conf = tp.PredictConfig(session_init=tp.get_model_loader(model_path),
model=model,
input_names=["input"],
output_names=["emb"])
exporter = ModelExporter(conf)
if (compact):
out = path.join(target, "{}.pb".format(path.basename(real_path)))
_L.info("saving {} to {}".format(path.basename(real_path), out))
exporter.export_compact(out)
else:
_L.info("compact saving {} to {}".format(path.basename(real_path),
target))
exporter.export_serving(target)
def get_predictor(model_path, model=None):
import tensorpack as tp
import tensorflow as tf
if model:
sess_conf = tp.tfutils.get_default_sess_config()
sess_conf.log_device_placement = config.LOG_DEVICES
session_creator = tf.compat.v1.train.ChiefSessionCreator(
config=sess_conf)
pred = tp.OfflinePredictor(
tp.PredictConfig(session_creator=session_creator,
session_init=tp.get_model_loader(model_path),
model=model,
input_names=["input", "heights", "wavelets"],
output_names=["emb"]))
def prediction(*inp):
return pred(*inp)[0], pred.sess
else:
sess_conf = tf.ConfigProto(allow_soft_placement=True)
model_file = "{}.pb".format(model_path)
def prediction(*inp):
with tf.Session(config=sess_conf) as sess:
with tf.gfile.GFile(model_file, "rb") as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
tf.import_graph_def(graph_def)
inp_key = sess.graph.get_tensor_by_name("import/input:0")
heights_key = sess.graph.get_tensor_by_name("import/heights:0")
wavelets_key = sess.graph.get_tensor_by_name(
"import/wavelets:0")
emb = sess.graph.get_tensor_by_name("import/emb:0")
pred = sess.run(emb, {
inp_key: inp[0],
heights_key: inp[1],
wavelets_key: inp[2]
})
return pred, sess
return prediction
def main():
# instantiate blackbox and substitute model
forward_model = load_model()
backward_model = create_fmodel()
# instantiate differntiable composite model
# (predictions from blackbox, gradients from substitute)
model = CompositeModel(
forward_model=forward_model,
backward_model=backward_model)
predictor = tp.OfflinePredictor(tp.PredictConfig(
model=SaliencyModel(),
session_init=tp.get_model_loader("resnet_v1_50.ckpt"),
input_names=['image'],
output_names=['saliency']))
for (file_name, image, label) in read_images():
pos_salience = find_salience(predictor, image)
adversarial = run_attack(model, image, label, pos_salience)
store_adversarial(file_name, adversarial)
attack_complete()
def main():
# instantiate blackbox and substitute model
forward_model = load_model()
backward_model = create_fmodel()
# instantiate differntiable composite model
# (predictions from blackbox, gradients from substitute)
model = CompositeModel(forward_model=forward_model,
backward_model=backward_model)
predictor = tp.OfflinePredictor(
tp.PredictConfig(model=SaliencyModel(),
session_init=tp.get_model_loader("resnet_v1_50.ckpt"),
input_names=['image'],
output_names=['saliency']))
for (file_name, image, label) in read_images():
pos_salience = find_salience(predictor, image)
adversarial = run_attack(model, image, label, pos_salience)
store_adversarial(file_name, adversarial)
# Announce that the attack is complete
# NOTE: In the absence of this call, your submission will timeout
# while being graded.
print("Attack is complete")
attack_complete()
def main():
loader = TinyImageNetLoader()
forward_model = load_model()
backward_model1 = create_fmodel_ALP()
backward_model2 = create_fmodel_ALP1000()
model = CompositeModel(forward_model=forward_model,
backward_models=[backward_model1, backward_model2],
weights=[0.5, 0.5])
predictor = tp.OfflinePredictor(
tp.PredictConfig(model=SaliencyModel(),
session_init=tp.get_model_loader("resnet_v1_50.ckpt"),
input_names=['image'],
output_names=['saliency']))
for (file_name, image, label) in read_images():
adversarial = run_attack(loader, forward_model, image, label)
if adversarial is None:
pos_salience = find_salience(predictor, image)
adversarial = run_attack2(model, image, label, pos_salience)
store_adversarial(file_name, adversarial)
# Announce that the attack is complete
# NOTE: In the absence of this call, your submission will timeout
# while being graded.
attack_complete()
def visualize(model_path, model, iimgs):
import matplotlib.pyplot as plt
from os import path
from matplotlib.image import imread
import numpy as np
import tensorpack as tp
import misc.logger as logger
_L = logger.getLogger("visualize")
_L.debug(iimgs)
images = [imread(img) for img in iimgs]
imgs = [np.array([img]) for img in images]
# imgs = [np.expand_dims(img, 0) for img in imgs]
# print(imgs[0].shape)
# print(np.expand_dims(imgs[0], 0).shape)
# print(np.expand_dims(imgs[0], 3).shape)
# exit()
config.c_width = imgs[0].shape[2]
config.c_height = imgs[0].shape[1]
_L.debug("{} x {} cutouts".format(config.C_WIDTH, config.C_HEIGHT))
pred = tp.OfflinePredictor(
tp.PredictConfig(session_init=tp.get_model_loader(model_path),
model=model(config.depth, config.mode),
input_names=["input"],
output_names=["emb"]))
preds = [pred(el)[0] for el in imgs]
for i, p in enumerate(preds):
print("pred{}: ".format(i), end="")
print(p)
dists = [
np.sum((preds[0] - preds[i])**2, 1)[0] for i in range(1, len(preds))
]
for i, d in enumerate(dists):
print("dist{}: ".format(i), end="")
print(d)
file_name = path.basename(iimgs[0])
name_parts = file_name.split(".")
class_id, rel_id = name_parts[0].split("_")
ax = plt.subplot(1, len(images), 1)
ax.set_yticks([])
ax.set_xticks([])
plt.imshow(images[0])
plt.title("Cls {}/{} - #{}".format(class_id, rel_id, 0))
indices = sorted(list(range(len(dists))), key=lambda el: dists[el])
# for i, img in enumerate(images):
for j, i in enumerate(indices):
img = images[i + 1]
file_name = path.basename(iimgs[i + 1])
name_parts = file_name.split(".")
class_id, rel_id = name_parts[0].split("_")
ax = plt.subplot(1, len(images), j + 2)
ax.set_yticks([])
ax.set_xticks([])
plt.imshow(img)
plt.title("Cls {}/{} - #{}".format(class_id, rel_id, i))
plt.ylabel("{}".format(preds[i]))
plt.xlabel("{:E}".format(dists[i]))
plt.show()
