def main():
#remove the following two lines if testing with cpu
caffe.set_mode_gpu()
# choose which GPU you want to use
caffe.set_device(0)
caffe.SGDSolver.display = 0
# load net
net = caffe.Net('models/attention_test.prototxt', 'models/attention_final',
caffe.TEST)
def compute_saliency(image_path):
img = cv2.imread(image_path, cv2.IMREAD_COLOR)
im = prepare_image(img)
# shape for input (data blob is N x C x H x W), set data
net.blobs['data'].reshape(1, *im.shape)
net.blobs['data'].data[...] = im
# run net and take argmax for prediction
res = net.forward()
salmap = np.squeeze(res['final_attentionmap'])
salmap /= np.max(salmap)
im = cv2.resize(salmap, (IMAGE_DIM, IMAGE_DIM),
interpolation=cv2.INTER_LINEAR)
salmap = cv2.resize(salmap, (img.shape[1], img.shape[0]),
interpolation=cv2.INTER_LINEAR)
return (salmap * 255).astype(np.uint8)
run_model(compute_saliency)
def main():
options = json.loads(os.environ['SMILER_PARAMETER_MAP'])
network_string = options.get('network', 'SAM-VGG')
use_default_center_bias = options.get('center_prior',
'default') == 'default'
do_default_smoothing = options.get('do_smoothing', 'default') == 'default'
imgs_test_path = '/opt/input_vol/'
output_folder = '/opt/output_vol/'
os.makedirs(output_folder, exist_ok=True)
x = Input((3, shape_r, shape_c))
x_maps = Input((nb_gaussian, shape_r_gt, shape_c_gt))
if network_string == "SAM-VGG":
m = Model(input=[x, x_maps], output=sam_vgg([x, x_maps]))
print("Compiling SAM-VGG...")
m.compile(RMSprop(lr=1e-4),
loss=[kl_divergence, correlation_coefficient, nss])
print("Loading SAM-VGG weights...")
m.load_weights('weights/sam-vgg_salicon_weights.pkl')
elif network_string == "SAM-ResNet":
m = Model(input=[x, x_maps], output=sam_resnet([x, x_maps]))
print("Compiling SAM-ResNet...")
m.compile(RMSprop(lr=1e-4),
loss=[kl_divergence, correlation_coefficient, nss])
print("Loading SAM-ResNet weights...")
m.load_weights('weights/sam-resnet_salicon_weights.pkl')
else:
raise NotImplementedError(
"The only supported network strings are SAM-VGG and SAM-ResNet! '{}' is unknown."
.format(network_string))
gaussian = np.zeros((b_s, nb_gaussian, shape_r_gt, shape_c_gt))
def compute_saliency(image_path):
if use_default_center_bias:
predictions = m.predict(
[preprocess_images([image_path], shape_r, shape_c),
gaussian])[0]
else:
predictions = m.predict(
[preprocess_images([image_path], shape_r, shape_c),
gaussian])[0]
original_image = cv2.imread(image_path, 0)
res = postprocess_predictions(
predictions[0][0],
original_image.shape[0],
original_image.shape[1],
do_default_smoothing=do_default_smoothing)
return res
run_model(compute_saliency)
def main():
options = json.loads(os.environ['SMILER_PARAMETER_MAP'])
use_default_blur = options.get('do_smoothing', 'default') == 'default'
# Create network
model = ModelBCE(INPUT_SIZE[0], INPUT_SIZE[1], batch_size=8)
# Here need to specify the epoch of model sanpshot
load_weights(model.net['output'], path='gen_', epochtoload=90)
def compute_saliency(image_path):
img = cv2.cvtColor(cv2.imread(image_path, cv2.IMREAD_COLOR),
cv2.COLOR_BGR2RGB)
size = (img.shape[1], img.shape[0])
blur_size = 5
if img.shape[:2] != (model.inputHeight, model.inputWidth):
img = cv2.resize(img, (model.inputWidth, model.inputHeight),
interpolation=cv2.INTER_AREA)
blob = np.zeros((1, 3, model.inputHeight, model.inputWidth),
theano.config.floatX)
blob[0, ...] = (img.astype(theano.config.floatX).transpose(2, 0, 1))
result = np.squeeze(model.predictFunction(blob))
saliency_map = (result * 255).astype(np.uint8)
# resize back to original size
saliency_map = cv2.resize(saliency_map,
size,
interpolation=cv2.INTER_CUBIC)
# blur
if use_default_blur:
saliency_map = cv2.GaussianBlur(saliency_map,
(blur_size, blur_size), 0)
# clip again
saliency_map = np.clip(saliency_map, 0, 255)
return saliency_map
run_model(compute_saliency)
whitening = 1 if whitening else 0
if color_space == 'default':
colorspace = 2
else:
colorspace = 1
if do_smoothing == 'default':
blur_std = 9
else:
blur_std = 0
def compute_saliency(image_path):
command = [
"./build/BMS", image_path, output_path, sample_step,
dilation_width_1, dilation_width_2, blur_std, colorspace,
whitening, max_dim
]
command = list(map(str, command))
rc = subprocess.call(command)
if rc != 0:
return
# TODO: FIXME a hack for SMILER integration.
output_img = PIL.Image.open(output_path)
return np.array(output_img)
run_model(compute_saliency)
def main():
options = json.loads(os.environ['SMILER_PARAMETER_MAP'])
center_bias_path = 'centerbias.npy'
use_center_bias = options.get('center_prior', 'default') == 'default'
# load precomputed log density over a 1024x1024 image
centerbias_template = np.load(center_bias_path)
# Now we import the deep gaze model from the tensorflow meta-graph file
tf.reset_default_graph()
check_point = 'ICF.ckpt'
new_saver = tf.train.import_meta_graph('{}.meta'.format(check_point))
input_tensor = tf.get_collection('input_tensor')[0]
centerbias_tensor = tf.get_collection('centerbias_tensor')[0]
log_density = tf.get_collection('log_density')[0]
log_density_wo_centerbias = tf.get_collection(
'log_density_wo_centerbias')[0]
sess = tf.Session()
new_saver.restore(sess, check_point)
def compute_saliency(image_path):
img = imread(image_path, mode='RGB')
image_data = img[np.newaxis, :, :, :] # BHWC, three channels (RGB)
# Set up center bias
centerbias = zoom(centerbias_template,
(img.shape[0] / 1024, img.shape[1] / 1024),
order=0,
mode='nearest')
# Renormalize log density
centerbias -= logsumexp(centerbias)
# The model expects all input as 4d tensors of shape `BHWC` (i.e. batch-height-
# width-channel). It takes two inputs:
# A batch of images and a batch of centerbias log densities.
centerbias_data = centerbias[
np.newaxis, :, :, np.newaxis] # BHWC, 1 channel (log density)
# And finally we create a tensorflow session, restore the model parameters from
# the checkpoint and compute the log density prediction for out input data:
if use_center_bias:
log_density_prediction = sess.run(
log_density, {
input_tensor: image_data,
centerbias_tensor: centerbias_data,
})
else:
# TODO: In this case, don't calculate centerbias in the first place.
log_density_prediction = sess.run(
log_density_wo_centerbias, {
input_tensor: image_data,
centerbias_tensor: np.zeros_like(centerbias_data),
})
# The log density predictions again are of shape `BHWC`. Since the log-densities
# are just 2d, `C=1`. And since we processed only one image, `B=1`:
result = 255 * np.exp(log_density_prediction[0, :, :, 0])
return result
run_model(compute_saliency)
svm_path = 'svm-slm-cntr'
svm = load_model(svm_path)
whiten_path = 'whiten-slm-cntr'
with open(whiten_path) as fp:
whitenParams = np.asarray([map(float, line.split(' '))
for line in fp]).T
# assemble svm model
svmModel = {'svm': svm, 'whitenParams': whitenParams}
biasToCntr = (svm.get_nr_feature() - nFeatures) == 1
def eDNsaliency(image_path):
img = misc.imread(image_path, mode='RGB')
# compute saliency map
model = EDNSaliencyModel(desc, svmModel, biasToCntr)
salMap = model.saliency(img, normalize=False)
salMap = salMap.astype('f')
# normalize and save the saliency map to disk
normSalMap = (255.0 / (salMap.max() - salMap.min()) *
(salMap - salMap.min())).astype(np.uint8)
return normSalMap
run_model(eDNsaliency)
