def find_maxima(x):
col_max = tf.reduce_max(x, axis=1)
row_max = tf.reduce_max(x, axis=2)
cols = tf.cast(tf.argmax(col_max, 1), tf.float32)
rows = tf.cast(tf.argmax(row_max, 1), tf.float32)
cols = tf.reshape(cols, (-1, 1))
rows = tf.reshape(rows, (-1, 1))
maxima = tf.concat([rows, cols], -1)
return maxima
def _find_subpixel_maxima(x,
kernel_size,
sigma,
upsample_factor,
coordinate_scale=1,
confidence_scale=255.):
kernel = gaussian_kernel_2d(kernel_size, sigma)
kernel = tf.expand_dims(kernel, 0)
x_shape = tf.shape(x)
rows = x_shape[1]
cols = x_shape[2]
max_vals = tf.reduce_max(tf.reshape(x, [-1, rows * cols]), axis=1)
max_vals = tf.reshape(max_vals, [-1, 1]) / confidence_scale
row_pad = rows // 2 - kernel_size // 2
col_pad = cols // 2 - kernel_size // 2
padding = [[0, 0], [row_pad, row_pad - 1], [col_pad, col_pad - 1]]
kernel = tf.pad(kernel, padding)
row_center = row_pad + (kernel_size // 2)
col_center = col_pad + (kernel_size // 2)
center = tf.stack([row_center, col_center])
center = tf.expand_dims(center, 0)
center = tf.cast(center, dtype=tf.float32)
shifts = _upsampled_registration(x, kernel, upsample_factor)
shifts = center - shifts
shifts *= coordinate_scale
maxima = tf.concat([shifts[:, ::-1], max_vals], -1)
return maxima
def call(self, inputs):
print("xxxx",inputs)
expanded_tensor = ktf.expand_dims(inputs[0], -1)
multiples = [1, self.number_of_transforms, 1, 1, 1]
tiled_tensor = ktf.tile(expanded_tensor, multiples=multiples)
repeated_tensor = ktf.reshape(tiled_tensor, ktf.shape(inputs[0]) * np.array([self.number_of_transforms, 1, 1, 1]))
affine_transforms = inputs[1] / self.affine_mul
affine_transforms = ktf.reshape(affine_transforms, (-1, 8))
tranformed = tf_affine_transform(repeated_tensor, affine_transforms)
res = ktf.reshape(tranformed, [-1, self.number_of_transforms] + self.image_size)
res = ktf.transpose(res, [0, 2, 3, 1, 4])
#Use masks
if len(inputs) == 3:
mask = ktf.transpose(inputs[2], [0, 2, 3, 1])
mask = ktf.image.resize_images(mask, self.image_size[:2], method=ktf.image.ResizeMethod.NEAREST_NEIGHBOR)
res = res * ktf.expand_dims(mask, axis=-1)
if self.aggregation_fn == 'none':
res = ktf.reshape(res, [-1] + self.image_size[:2] + [self.image_size[2] * self.number_of_transforms])
elif self.aggregation_fn == 'max':
res = ktf.reduce_max(res, reduction_indices=[-2])
elif self.aggregation_fn == 'avg':
counts = ktf.reduce_sum(mask, reduction_indices=[-1])
counts = ktf.expand_dims(counts, axis=-1)
res = ktf.reduce_sum(res, reduction_indices=[-2])
res /= counts
res = ktf.where(ktf.is_nan(res), ktf.zeros_like(res), res)
return res
def _max_tile(self, images):
#num_images = args['num_images']
num_images = self.batch_size / self.gpus
im_list = ktf.split(images, num_images, 0)
maxed = im_list
counter = 0
for im in im_list:
maxed[counter] = ktf.reduce_max(im, axis=0, keepdims=True)
counter += 1
return ktf.concat(maxed, 0)
def top_k(scores, I, ratio, top_k_var):
"""
Returns indices to get the top K values in `scores` segment-wise, with
segments defined by I. K is not fixed, but it is defined as a ratio of the
number of elements in each segment.
:param scores: a rank 1 tensor with scores;
:param I: a rank 1 tensor with segment IDs;
:param ratio: float, ratio of elements to keep for each segment;
:param top_k_var: a tf.Variable without shape validation (e.g.,
`tf.Variable(0.0, validate_shape=False)`);
:return: a rank 1 tensor containing the indices to get the top K values of
each segment in `scores`.
"""
num_nodes = tf.segment_sum(tf.ones_like(I),
I) # Number of nodes in each graph
cumsum = tf.cumsum(num_nodes) # Cumulative number of nodes (A, A+B, A+B+C)
cumsum_start = cumsum - num_nodes # Start index of each graph
n_graphs = tf.shape(num_nodes)[0] # Number of graphs in batch
max_n_nodes = tf.reduce_max(num_nodes) # Order of biggest graph in batch
batch_n_nodes = tf.shape(I)[0] # Number of overall nodes in batch
to_keep = tf.ceil(ratio * tf.cast(num_nodes, tf.float32))
to_keep = tf.cast(to_keep, tf.int32) # Nodes to keep in each graph
index = tf.range(batch_n_nodes)
index = (index - tf.gather(cumsum_start, I)) + (I * max_n_nodes)
y_min = tf.reduce_min(scores)
dense_y = tf.ones((n_graphs * max_n_nodes, ))
dense_y = dense_y * tf.cast(
y_min - 1, tf.float32
) # subtract 1 to ensure that filler values do not get picked
dense_y = tf.assign(
top_k_var, dense_y, validate_shape=False
) # top_k_var is a variable with unknown shape defined in the elsewhere
dense_y = tf.scatter_update(dense_y, index, scores)
dense_y = tf.reshape(dense_y, (n_graphs, max_n_nodes))
perm = tf.argsort(dense_y, direction='DESCENDING')
perm = perm + cumsum_start[:, None]
perm = tf.reshape(perm, (-1, ))
to_rep = tf.tile(tf.constant([1., 0.]), (n_graphs, ))
rep_times = tf.reshape(
tf.concat((to_keep[:, None], (max_n_nodes - to_keep)[:, None]), -1),
(-1, ))
mask = tf_repeat_1d(to_rep, rep_times)
perm = tf.boolean_mask(perm, mask)
return perm
def tf_repeat_1d(x, repeats):
"""
Repeats each value `x[i]` a number of times `repeats[i]`.
:param x: a rank 1 tensor;
:param repeats: a rank 1 tensor;
:return: a rank 1 tensor, of shape `(sum(repeats), )`.
"""
x = tf.expand_dims(x, 1)
max_repeats = tf.reduce_max(repeats)
tile_repeats = [1, max_repeats]
arr_tiled = tf.tile(x, tile_repeats)
mask = tf.less(tf.range(max_repeats), tf.expand_dims(repeats, 1))
result = tf.reshape(tf.boolean_mask(arr_tiled, mask), [-1])
return result
