def __call__(self, pred, target, weight=None):
pred_left = pred[:, 0]
pred_top = pred[:, 1]
pred_right = pred[:, 2]
pred_bottom = pred[:, 3]
target_left = target[:, 0]
target_top = target[:, 1]
target_right = target[:, 2]
target_bottom = target[:, 3]
target_area = (target_left + target_right) * \
(target_top + target_bottom)
pred_area = (pred_left + pred_right) * (pred_top + pred_bottom)
w_intersect = tf.minimum(pred_left, target_left) + \
tf.minimum(pred_right, target_right)
h_intersect = tf.minimum(pred_bottom, target_bottom) + tf.minimum(
pred_top, target_top)
area_intersect = w_intersect * h_intersect
area_union = target_area + pred_area - area_intersect
loss = -tf.log((area_intersect + 1.0) / (area_union + 1.0))
if weight is not None and tft.sum(weight) > 0:
return tft.sum(loss * weight) / tft.sum(weight)
else:
assert tf.size(loss) != 0
return tft.mean(loss)
def preprocessing_fn(inputs):
def repeat(in_tensor, value):
batch_size = tf.shape(in_tensor)[0]
return tf.ones([batch_size], value.dtype) * value
return {
'min': tft.map(repeat, inputs['a'], tft.min(inputs['a'])),
'max': tft.map(repeat, inputs['a'], tft.max(inputs['a'])),
'sum': tft.map(repeat, inputs['a'], tft.sum(inputs['a'])),
'size': tft.map(repeat, inputs['a'], tft.size(inputs['a'])),
'mean': tft.map(repeat, inputs['a'], tft.mean(inputs['a']))
}
def __cal__(self, logits, targets):
def loss_func():
num_classes = logits.shape[1]
gamma = self.gamma[0]
alpha = self.alpha[0]
dtype = targets.dtype
class_range = tf.expand_dims(
tf.range(1, limit=num_classes + 1, dtype=dtype), 0)
t = tf.expand_dims(targets)
p = tf.sigmoid(logits)
term1 = (1 - p)**gamma * tf.log(p)
term2 = p**gamma * tf.log(1 - p)
return -(t == class_range).as_type(tf.float64) * term1 * alpha - (
(t != class_range) *
(t >= 0)).as_type(tf.float64) * term2 * (1 - alpha)
loss = loss_func()
return tft.sum(loss)
def sum_fn(inputs):
return {
'sum': tft.map(repeat, inputs['a'], tft.sum(inputs['a']))
}