def get_anchor_patches(self):
# set seed here if want same patches
# Regardless of whether use or not, should
# be 0 if not dense compute
'''Sample n_anchor patches from original image'''
self.anchor_count = 0
if self.use_patches:
# pass existing patches
return util.process_im(self.patches)
# Sample n_anchor patches randomly and normalize them to [-1.0,1.0]
return util.process_im(
np.array([self.rand_patch() for i in range(self.n_anchors)],
dtype=np.float32))
def get_anchor_patches(self):
# set seed here if want same patches
# Regardless of whether use or not, should
# be 0 if not dense compute
self.anchor_count = 0
if self.dense_compute:
self.anchor_inds = self.indices.copy()
return util.process_im(
np.array([
self.get_patch(self.anchor_inds[i][0],
self.anchor_inds[i][1])
for i in range(
self.anchor_count,
min(self.anchor_count +
self.n_anchors, self.anchor_inds.shape[0]))
]))
if self.use_patches:
# pass existing patches
return util.process_im(self.patches)
return util.process_im(
np.array([self.rand_patch() for i in range(self.n_anchors)],
dtype=np.float32))
def data_fn(self, hind, wind):
n_anchors = self.n_anchors
y_ind, x_ind = hind * self.stride, wind * self.stride
_, batch_indexes = np.mgrid[0:hind.shape[0], 0:self.patch_size]
patches = self.image[y_ind + batch_indexes, x_ind + batch_indexes, :]
# anchor_inds = np.arange(self.anchor_count, self.anchor_count + n_anchors)
h_inds = hind
w_inds = wind
# batch_a = self.anchor_patches
# batch_b is the selected patch copied n_anchor times
batch_b = util.process_im(patches)
return h_inds, w_inds, batch_b
def dense_argless(self):
assert False, "Deprecated"
if self.count >= self.indices.shape[0]:
self.count = 0
self.anchor_count += self.n_anchors
if self.anchor_count >= self.anchor_inds.shape[0]:
raise StopIteration()
inds2 = self.anchor_inds[self.anchor_count]
self.anchor_patches = util.process_im(
np.array([
self.get_patch(self.anchor_inds[i][0],
self.anchor_inds[i][1])
for i in range(
self.anchor_count,
min(self.anchor_count +
self.n_anchors, self.anchor_inds.shape[0]))
]))
self.n_anchors = self.anchor_patches.shape[0]
inds = self.indices[self.count]
self.count += 1
d = self.data_fn(inds[0], inds[1])
return d
def data_fn(self, hind, wind):
n_anchors = self.anchor_patches.shape[0]
y_ind, x_ind = hind * self.stride, wind * self.stride
patch = self.image[y_ind:y_ind + self.patch_size,
x_ind:x_ind + self.patch_size, :]
anchor_inds = np.arange(self.anchor_count,
self.anchor_count + n_anchors)
h_inds = np.array([hind] * n_anchors, dtype=np.int64)
w_inds = np.array([wind] * n_anchors, dtype=np.int64)
batch_a = self.anchor_patches
batch_b = util.process_im(
np.array([patch] * n_anchors, dtype=np.float32))
# anc, y, x, bat_a, bat_b
if self.mirror_pred:
anchor_inds = np.vstack([anchor_inds] * 2)
h_inds = np.vstack([h_inds] * 2)
w_inds = np.vstack([w_inds] * 2)
batch_a, batch_b = np.vstack([batch_a, batch_b
]), np.vstack([batch_b, batch_a])
return anchor_inds, h_inds, w_inds, batch_a, batch_b
def run_vote_no_threads(image, solver, exif_to_use, n_anchors=1, num_per_dim=None,
patch_size=None, batch_size=None, sample_ratio=3.0, override_anchor=False):
"""
solver: exif_solver module. Must be initialized and have a network connected.
exif_to_use: exif to extract responses from. A list. If exif_to_use is None
extract result from classification output cls_pred
n_anchors: number of anchors to use.
num_per_dim: number of patches to use along the largest dimension.
patch_size: size of the patch. If None, uses the one specified in solver.net
batch_size: size of the batch. If None, uses the one specified in solver.net
sample_ratio: The ratio of overlap between patches. num_per_dim must be None
to be useful.
"""
h, w = np.shape(image)[:2]
if patch_size is None:
patch_size = solver.net.im_size
if batch_size is None:
batch_size = solver.net.batch_size
if num_per_dim is None:
num_per_dim = int(np.ceil(sample_ratio * (max(h,w)/float(patch_size))))
if exif_to_use is None:
not_exif = True
exif_to_use = ['out']
else:
not_exif = False
exif_map = {e: np.squeeze(np.argwhere(np.array(solver.net.train_runner.tags) == e)) for e in exif_to_use}
responses = {e:np.zeros((n_anchors, h, w)) for e in exif_to_use}
vote_counts = {e:1e-6 * np.ones((n_anchors, h, w)) for e in exif_to_use}
if np.min(image) < 0.0:
# already preprocessed
processed_image = image
else:
processed_image = util.process_im(image)
ones = np.ones((patch_size, patch_size))
anchor_indices = []
# select n anchors
for anchor_idx in range(n_anchors):
if override_anchor is False:
_h, _w = np.random.randint(0, h - patch_size), np.random.randint(0, w - patch_size)
else:
assert len(override_anchor) == 2, override_anchor
_h, _w = override_anchor
anchor_indices.append((_h, _w))
anchor_patch = processed_image[_h:_h+patch_size, _w:_w+patch_size, :]
batch_a = np.tile([anchor_patch], [batch_size, 1, 1, 1])
batch_b, batch_b_coord = [], []
prev_batch = None
for i in np.linspace(0, h - patch_size, num_per_dim).astype(int):
for j in np.linspace(0, w - patch_size, num_per_dim).astype(int):
compare_patch = processed_image[i:i+patch_size, j:j+patch_size]
batch_b.append(compare_patch)
batch_b_coord.append((i,j))
if len(batch_b) == batch_size:
if not_exif:
pred = solver.sess.run(solver.net.cls_pred,
feed_dict={solver.net.im_a:batch_a,
solver.net.im_b:batch_b,
solver.net.is_training:False})
else:
pred = solver.sess.run(solver.net.pred,
feed_dict={solver.net.im_a:batch_a,
solver.net.im_b:batch_b,
solver.net.is_training:False})
for p_vec, (_i, _j) in zip(pred, batch_b_coord):
for e in exif_to_use:
if not_exif:
p = p_vec[0]
else:
p = p_vec[int(exif_map[e])]
responses[e][anchor_idx, _i:_i+patch_size, _j:_j+patch_size] += (p * ones)
vote_counts[e][anchor_idx, _i:_i+patch_size, _j:_j+patch_size] += ones
prev_batch = batch_b
batch_b, batch_b_coord = [], []
if len(batch_b) > 0:
batch_b_len = len(batch_b)
to_pad = np.array(prev_batch)[:batch_size - batch_b_len]
batch_b = np.concatenate([batch_b, to_pad], axis=0)
if not_exif:
pred = solver.sess.run(solver.net.cls_pred,
feed_dict={solver.net.im_a:batch_a,
solver.net.im_b:batch_b,
solver.net.is_training:False})
else:
pred = solver.sess.run(solver.net.pred,
feed_dict={solver.net.im_a:batch_a,
solver.net.im_b:batch_b,
solver.net.is_training:False})
for p_vec, (_i, _j) in zip(pred, batch_b_coord):
for e in exif_to_use:
if not_exif:
p = p_vec[0]
else:
p = p_vec[int(exif_map[e])]
responses[e][anchor_idx, _i:_i+patch_size, _j:_j+patch_size] += (p * ones)
vote_counts[e][anchor_idx, _i:_i+patch_size, _j:_j+patch_size] += ones
return {e: {'responses':(responses[e] / vote_counts[e]), 'anchors':anchor_indices} for e in exif_to_use}
