def greater(f, other):
"""Element-wise comparison applied to the `Functional` objects.
# Arguments
f: Functional object.
other: A python number or a tensor or a functional object.
# Returns
A Functional.
"""
validate_functional(f)
inputs = f.inputs.copy()
if is_functional(other):
inputs += to_list(other.inputs)
lmbd = [
Lambda(lambda x: K.cast_to_floatx(K.greater(x[0], x[1])),
name=graph_unique_name("greater")) for X in f.outputs
]
else:
_warn_for_ndarray(other)
lmbd = [
Lambda(lambda x: K.cast_to_floatx(K.greater(x, other)),
name=graph_unique_name("greater")) for X in f.outputs
]
Functional = f.get_class()
res = Functional(inputs=unique_tensors(inputs),
outputs=_apply_operation(lmbd, f, other),
layers=lmbd)
return res
def call(self, inputs, **kwargs):
input_shape = K.int_shape(inputs)
sequence_length, d_model = input_shape[-2:]
# output of the "sigmoid halting unit" (not the probability yet)
halting = K.sigmoid(
K.reshape(
K.bias_add(K.dot(K.reshape(inputs, [-1, d_model]),
self.act_weights['halting_kernel']),
self.act_weights['halting_biases'],
data_format='channels_last'),
[-1, sequence_length]))
if self.zeros_like_halting is None:
self.initialize_control_tensors(halting)
# useful flags
step_is_active = K.greater(self.halt_budget, 0)
no_further_steps = K.less_equal(self.halt_budget - halting, 0)
# halting probability is equal to
# a. halting output if this isn't the last step (we have some budget)
# b. to remainder if it is,
# c. and zero for the steps that shouldn't be executed at all
# (out of budget for them)
halting_prob = K.switch(
step_is_active, K.switch(no_further_steps, self.remainder,
halting), self.zeros_like_halting)
self.active_steps += K.switch(step_is_active, self.ones_like_halting,
self.zeros_like_halting)
# We don't know which step is the last, so we keep updating
# expression for the loss with each call of the layer
self.ponder_cost = (self.act_weights['time_penalty_t'] *
K.mean(self.remainder + self.active_steps))
# Updating "the remaining probability" and the halt budget
self.remainder = K.switch(no_further_steps, self.remainder,
self.remainder - halting)
self.halt_budget -= halting # OK to become negative
# If none of the inputs are active at this step, then instead
# of zeroing them out by multiplying to all-zeroes halting_prob,
# we can simply use a constant tensor of zeroes, which means that
# we won't even calculate the output of those steps, saving
# some real computational time.
if self.zeros_like_input is None:
self.zeros_like_input = K.zeros_like(inputs,
name='zeros_like_input')
# just because K.any(step_is_active) doesn't work in PlaidML
any_step_is_active = K.greater(K.sum(K.cast(step_is_active, 'int32')),
0)
step_weighted_output = K.switch(
any_step_is_active,
K.expand_dims(halting_prob, -1) * inputs, self.zeros_like_input)
if self.weighted_output is None:
self.weighted_output = step_weighted_output
else:
self.weighted_output += step_weighted_output
return [inputs, self.weighted_output]
def call(self, y):
# Sanity Check
if isinstance(y, list):
raise ValueError('TSG layer has only 1 input')
# y = tf_print(y, [y], message='{}: The unconstrained action is:'.format(y.name.split('/')[0]), summarize=-1)
y = check_numerics(y, 'Problem with input y')
# Calculate A.c
Ac = tensordot(self.A_graph, self.c_graph, 1)
# Calculate b - Ac
bMinusAc = self.b_graph - Ac
# Calculate y - c
yMinusc = y - self.c_graph
# Calculate A.(y - c)
ADotyMinusc = K.sum((self.A_graph * expand_dims(yMinusc, -2)), axis=2)
# Do elem-wise division
intersection_points = bMinusAc / (ADotyMinusc + K.epsilon()
) # Do we need the K.epsilon()?
# Enforce 0 <= intersection_points <= 1 because the point must lie between c and y
greater_1 = K.greater(intersection_points,
K.ones_like(intersection_points))
candidate_alpha = K.switch(greater_1,
K.ones_like(intersection_points) + 1,
intersection_points)
less_0 = K.less(candidate_alpha, K.zeros_like(intersection_points))
candidate_alpha = K.switch(less_0,
K.ones_like(intersection_points) + 1,
candidate_alpha)
# Find farthest intersection point from y to get projection point
alpha = K.min(candidate_alpha, axis=-1, keepdims=True)
# If it is an interior point, y itself is the projection point
interior_point = K.greater(alpha, K.ones_like(alpha))
alpha = K.switch(interior_point, K.ones_like(alpha), alpha)
# alpha = tf_print(alpha, [alpha], message="{}: The value of alpha is: ".format(alpha.name.split('/')[0]))
# Return \alpha.y + (1 - \alpha).c
z = alpha * y + ((1 - alpha) * self.c_graph)
# z = tf_print(z, [z], message='{}: The constrained action is:'.format(z.name.split('/')[0]), summarize=-1)
return z
def step(x):
"""Computes step (Heaviside) of x element-wise.
H(x) = 0 if x<=0
H(x) = 1 if x>0
# Arguments
x: Functional object.
# Returns
A new functional object.
"""
validate_functional(x)
lmbd = []
for i in range(len(x.outputs)):
lmbd.append(
Lambda(
lambda x: K.cast(K.greater(x, 0.0), x.dtype),
name=graph_unique_name("step")
)
)
Functional = x.get_class()
res = Functional(
inputs = x.inputs.copy(),
outputs = _apply_operation(lmbd, x),
layers = lmbd
)
return res
def weighted_bce_dice_loss(y_true, y_pred):
y_true = K.cast(y_true, 'float32')
y_pred = K.cast(y_pred, 'float32')
# if we want to get same size of output, kernel size must be odd number
if K.int_shape(y_pred)[1] == 128:
kernel_size = 11
elif K.int_shape(y_pred)[1] == 256:
kernel_size = 21
elif K.int_shape(y_pred)[1] == 512:
kernel_size = 21
elif K.int_shape(y_pred)[1] == 1024:
kernel_size = 41
else:
raise ValueError('Unexpected image size')
averaged_mask = K.pool2d(y_true,
pool_size=(kernel_size, kernel_size),
strides=(1, 1),
padding='same',
pool_mode='avg')
border = K.cast(K.greater(averaged_mask, 0.005), 'float32') * K.cast(
K.less(averaged_mask, 0.995), 'float32')
weight = K.ones_like(averaged_mask)
w0 = K.sum(weight)
weight += border * 2
w1 = K.sum(weight)
weight *= (w0 / w1)
loss = weighted_bce_loss(y_true, y_pred, weight) + (
1 - weighted_dice_coeff(y_true, y_pred, weight))
return loss
def sparse():
# number of dimensions in input might be < |k|. account for that
actual_k = tf.minimum(K.shape(inputs)[-1] - 1, self.k)
# multiply all values greater than the k smallest with 1, the rest with 0
kth_smallest = tf.sort(inputs)[...,
K.shape(inputs)[-1] - 1 - actual_k]
return inputs * K.cast(K.greater(inputs, kth_smallest[:, None]),
K.floatx())
def my_entropy(y_true, y_pred):
""" Cross entropy loss for yaw angle prediction.
Uses the global variables network_output_size and min_overlap_for_angle.
"""
y_true = K.greater(y_true, min_overlap_for_angle)
y_true = K.cast(y_true, dtype='float32')
return tf.nn.weighted_cross_entropy_with_logits(y_true,
y_pred,
network_output_size,
name='loss')
def not_equal(f, other, tol=None):
"""Element-wise comparison applied to the `Functional` objects.
# Arguments
f: Functional object.
other: A python number or a tensor or a functional object.
tol: (float) If you need a tolerance measure.
# Returns
A Functional.
"""
validate_functional(f)
assert isinstance(
tol, (type(None), float)), 'Expected a floating value for `tol`.'
inputs = f.inputs.copy()
if is_functional(other):
inputs += to_list(other.inputs)
if tol is None:
lambda_opr = lambda x: K.cast_to_floatx(K.not_equal(x[0], x[1]))
else:
lambda_opr = lambda x: K.cast_to_floatx(
K.greater(K.abs(x[0] - x[1]), tol))
else:
_warn_for_ndarray(other)
if tol is None:
lambda_opr = lambda x: K.cast_to_floatx(K.not_equal(x, other))
else:
lambda_opr = lambda x: K.cast_to_floatx(
K.greater(K.abs(x - other), tol))
lmbd = [
Lambda(lambda_opr, name=graph_unique_name("not_equal"))
for X in f.outputs
]
Functional = f.get_class()
res = Functional(inputs=unique_tensors(inputs),
outputs=_apply_operation(lmbd, f, other),
layers=lmbd)
return res
def fulldiaggreater3(x):
xs = []
for filt in [FULLDIAG1, FULLDIAG2, FULLDIAG3, FULLDIAG4]:
x1 = x * tf.constant(filt)
x1 = K.sum(x1, axis=1)
x1 = K.sum(x1, axis=1)
x1 = K.sum(x1, axis=1)
x1 = K.greater(x1, 3)
xs.append(x1)
x = K.stack(xs)
return K.any(x)
def antidiaggreater3(x):
x1 = x * tf.constant(ANTIDIAG23)
x1 = K.sum(x1, axis=2)
x1 = K.sum(x1, axis=2)
x1 = K.greater(x1, 3)
x1 = K.any(x1)
x2 = x * tf.constant(ANTIDIAG13)
x2 = K.sum(x2, axis=2)
x2 = K.sum(x2, axis=2)
x2 = K.greater(x2, 3)
x2 = K.any(x2)
x3 = x * tf.constant(ANTIDIAG12)
x3 = K.sum(x3, axis=2)
x3 = K.sum(x3, axis=2)
x3 = K.greater(x3, 3)
x3 = K.any(x3)
x = K.stack([x1, x2, x3])
return K.any(x)
def tp_score(y_true, y_pred, threshold=0.1):
tp_3d = K.concatenate([
K.cast(K.expand_dims(K.flatten(y_true)), 'bool'),
K.cast(
K.expand_dims(K.flatten(K.greater(y_pred, K.constant(threshold)))),
'bool'),
K.cast(K.ones_like(K.expand_dims(K.flatten(y_pred))), 'bool')
],
axis=1)
tp = K.sum(K.cast(K.all(tp_3d, axis=1), 'int32'))
return tp
def recall(y_true, y_pred):
"""Recall metric.
Computes the recall over the whole batch using threshold_value.
"""
threshold_value = threshold
# Adaptation of the "round()" used before to get the predictions. Clipping to make sure that the predicted raw values are between 0 and 1.
y_pred = K.cast(K.greater(K.clip(y_pred, 0, 1), threshold_value),
K.floatx())
# Compute the number of true positives. Rounding in prevention to make sure we have an integer.
true_positives = K.round(K.sum(K.clip(y_true * y_pred, 0, 1)))
# Compute the number of positive targets.
possible_positives = K.sum(K.clip(y_true, 0, 1))
recall_ratio = true_positives / (possible_positives + K.epsilon())
return recall_ratio
def diaggreater3_on_axis(x, i, j, k):
assert j < k
# x = tf.Print(x, [x], summarize=64, message='initial x: ')
diag = tf.diag(np.array([1, 1, 1, 1], dtype=np.int32))
# x = tf.Print(x, [diag], summarize=64, message='diagnonal: ')
diag = K.stack([diag, diag, diag, diag], axis=i)
# x = tf.Print(x, [diag], summarize=64, message='diagnonal: ')
x = x * diag
# x = tf.Print(x, [x], summarize=64, message='x * diag: ')
x = K.sum(x, axis=k + 1)
# x = tf.Print(x, [x], summarize=64, message='x after first sum: ')
x = K.sum(x, axis=j + 1)
# x = tf.Print(x, [x], summarize=64, message='x after second sum: ')
x = K.greater(x, 3)
x = K.any(x)
return x
def fn_score(y_true, y_pred, threshold=0.1):
fn_3d = K.concatenate([
K.cast(K.expand_dims(K.flatten(y_true)), 'bool'),
K.cast(
K.expand_dims(
K.flatten(
K.abs(
K.cast(K.greater(y_pred, K.constant(threshold)),
'float') - K.ones_like(y_pred)))), 'bool'),
K.cast(K.ones_like(K.expand_dims(K.flatten(y_pred))), 'bool')
],
axis=1)
fn = K.sum(K.cast(K.all(fn_3d, axis=1), 'int32'))
return fn
def _filter_detections(scores, labels):
# threshold based on score
indices = tf.where(K.greater(scores, score_threshold))
if nms:
filtered_boxes = tf.gather_nd(boxes, indices)
filtered_scores = K.gather(scores, indices)[:, 0]
# perform NMS
nms_indices = tf.image.non_max_suppression(
filtered_boxes,
filtered_scores,
max_output_size=max_detections,
iou_threshold=nms_threshold)
# filter indices based on NMS
indices = K.gather(indices, nms_indices)
# add indices to list of all indices
labels = tf.gather_nd(labels, indices)
indices = K.stack([indices[:, 0], labels], axis=1)
return indices
def discriminator_loss(y_true, y_pred):
loss = mean_squared_error(y_true, y_pred)
is_large = k.greater(loss, k.constant(_disc_train_thresh)) # threshold
is_large = k.cast(is_large, k.floatx())
return loss * is_large # binary threshold the loss to prevent overtraining the discriminator
def greater3_on_axis(x, axis):
x = K.sum(x, axis=axis)
x = K.greater(x, 3)
x = K.any(x)
return x
def hamming_loss(y_true, y_pred, tval = 0.4):
tmp = K.abs(y_true - y_pred)
return K.mean(K.cast(K.greater(tmp, tval), dtype = float))
