def log_loss(y_true, y_pred):
return K.log(rmse(y_true, y_pred) + 1e-20) / K.log(10.)
def focal_loss_fixed(y_true, y_pred): pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred)) pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred)) return -K.mean(alpha * K.pow(1. - pt_1, gamma) * K.log(pt_1)) - K.mean((1 - alpha) * K.pow(pt_0, gamma) * K.log(1. - pt_0))
def call(self, inputs, mask=None): inputs_expand = tf.expand_dims(inputs, axis=1) outputs = K.log(inputs_expand) return outputs
def loss(y_true, y_pred):
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
return -K.sum(y_true * K.log(K.dot(y_pred, P)), axis=-1)
def call(self, t1, t2, **kwargs):
loss_t = K.mean(t1)
loss_et = K.log(K.mean(K.exp(t2)))
return loss_et - loss_t
def psnr(y_true, y_pred):
mse = K.mean(K.square(y_true - y_pred))
psnr_score = 20 * K.log(1. / K.sqrt(mse))
return psnr_score
def yolo4_loss(args,
anchors,
num_classes,
ignore_thresh=.5,
label_smoothing=0,
use_focal_loss=False,
use_focal_obj_loss=False,
use_softmax_loss=False,
use_giou_loss=False,
use_diou_loss=False):
'''Return yolo4_loss tensor
Parameters
----------
yolo_outputs: list of tensor, the output of yolo_body or tiny_yolo_body
y_true: list of array, the output of preprocess_true_boxes
anchors: array, shape=(N, 2), wh
num_classes: integer
ignore_thresh: float, the iou threshold whether to ignore object confidence loss
Returns
-------
loss: tensor, shape=(1,)
'''
num_layers = len(anchors) // 3 # default setting
yolo_outputs = args[:num_layers]
y_true = args[num_layers:]
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]
] if num_layers == 3 else [[3, 4, 5], [0, 1, 2]]
input_shape = K.cast(
K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))
grid_shapes = [
K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0]))
for l in range(num_layers)
]
loss = 0
total_location_loss = 0
total_confidence_loss = 0
total_class_loss = 0
m = K.shape(yolo_outputs[0])[0] # batch size, tensor
mf = K.cast(m, K.dtype(yolo_outputs[0]))
for l in range(num_layers):
object_mask = y_true[l][..., 4:5]
true_class_probs = y_true[l][..., 5:]
if label_smoothing:
true_class_probs = _smooth_labels(true_class_probs,
label_smoothing)
grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
anchors[anchor_mask[l]],
num_classes,
input_shape,
calc_loss=True)
pred_box = K.concatenate([pred_xy, pred_wh])
# Darknet raw box to calculate loss.
raw_true_xy = y_true[l][..., :2] * grid_shapes[l][::-1] - grid
raw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] *
input_shape[::-1])
raw_true_wh = K.switch(object_mask, raw_true_wh,
K.zeros_like(raw_true_wh)) # avoid log(0)=-inf
box_loss_scale = 2 - y_true[l][..., 2:3] * y_true[l][..., 3:4]
# Find ignore mask, iterate over each of batch.
ignore_mask = tf.TensorArray(K.dtype(y_true[0]),
size=1,
dynamic_size=True)
object_mask_bool = K.cast(object_mask, 'bool')
def loop_body(b, ignore_mask):
true_box = tf.boolean_mask(y_true[l][b, ..., 0:4],
object_mask_bool[b, ..., 0])
iou = box_iou(pred_box[b], true_box)
best_iou = K.max(iou, axis=-1)
ignore_mask = ignore_mask.write(
b, K.cast(best_iou < ignore_thresh, K.dtype(true_box)))
return b + 1, ignore_mask
_, ignore_mask = tf.while_loop(lambda b, *args: b < m, loop_body,
[0, ignore_mask])
ignore_mask = ignore_mask.stack()
ignore_mask = K.expand_dims(ignore_mask, -1)
if use_focal_obj_loss:
# Focal loss for objectness confidence
confidence_loss = sigmoid_focal_loss(object_mask, raw_pred[...,
4:5])
else:
confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True)+ \
(1-object_mask) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) * ignore_mask
if use_focal_loss:
# Focal loss for classification score
if use_softmax_loss:
class_loss = softmax_focal_loss(true_class_probs, raw_pred[...,
5:])
else:
class_loss = sigmoid_focal_loss(true_class_probs, raw_pred[...,
5:])
else:
if use_softmax_loss:
# use softmax style classification output
class_loss = object_mask * K.expand_dims(
K.categorical_crossentropy(
true_class_probs, raw_pred[..., 5:], from_logits=True),
axis=-1)
else:
# use sigmoid style classification output
class_loss = object_mask * K.binary_crossentropy(
true_class_probs, raw_pred[..., 5:], from_logits=True)
if use_giou_loss:
# Calculate GIoU loss as location loss
raw_true_box = y_true[l][..., 0:4]
giou = box_giou(pred_box, raw_true_box)
giou_loss = object_mask * box_loss_scale * (1 - giou)
giou_loss = K.sum(giou_loss) / mf
location_loss = giou_loss
elif use_diou_loss:
# Calculate DIoU loss as location loss
raw_true_box = y_true[l][..., 0:4]
diou = box_diou(pred_box, raw_true_box)
diou_loss = object_mask * box_loss_scale * (1 - diou)
diou_loss = K.sum(diou_loss) / mf
location_loss = diou_loss
else:
# Standard YOLO location loss
# K.binary_crossentropy is helpful to avoid exp overflow.
xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(
raw_true_xy, raw_pred[..., 0:2], from_logits=True)
wh_loss = object_mask * box_loss_scale * 0.5 * K.square(
raw_true_wh - raw_pred[..., 2:4])
xy_loss = K.sum(xy_loss) / mf
wh_loss = K.sum(wh_loss) / mf
location_loss = xy_loss + wh_loss
confidence_loss = K.sum(confidence_loss) / mf
class_loss = K.sum(class_loss) / mf
loss += location_loss + confidence_loss + class_loss
total_location_loss += location_loss
total_confidence_loss += confidence_loss
total_class_loss += class_loss
# Fit for tf 2.0.0 loss shape
loss = K.expand_dims(loss, axis=-1)
return loss #, total_location_loss, total_confidence_loss, total_class_loss
def weighted_bce(y_true, y_pred):
pos_weight = 1
x_1 = y_true * pos_weight * -K.log(y_pred + 1e-6)
x_2 = (1 - y_true) * -K.log(1 - y_pred + 1e-6)
return (x_1 + x_2)
def loss(y_true, y_pred):
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
y_pred = K.clip(y_pred, K.epsilon(), 1 - K.epsilon())
loss = y_true * K.log(y_pred) * weights
loss = -K.sum(loss, -1)
return loss
def call(self, inputs, mask=None):
X, A = inputs
N = K.shape(A)[-1]
# Check if the layer is operating in mixed or batch mode
mode = ops.autodetect_mode(X, A)
self.reduce_loss = mode in (modes.MIXED, modes.BATCH)
# Get normalized adjacency
if K.is_sparse(A):
I_ = tf.sparse.eye(N, dtype=A.dtype)
A_ = tf.sparse.add(A, I_)
else:
I_ = tf.eye(N, dtype=A.dtype)
A_ = A + I_
fltr = ops.normalize_A(A_)
# Node embeddings
Z = K.dot(X, self.kernel_emb)
Z = ops.modal_dot(fltr, Z)
if self.activation is not None:
Z = self.activation(Z)
# Compute cluster assignment matrix
S = K.dot(X, self.kernel_pool)
S = ops.modal_dot(fltr, S)
S = activations.softmax(S, axis=-1) # softmax applied row-wise
if mask is not None:
S *= mask[0]
# Link prediction loss
S_gram = ops.modal_dot(S, S, transpose_b=True)
if mode == modes.MIXED:
A = tf.sparse.to_dense(A)[None, ...]
if K.is_sparse(A):
LP_loss = tf.sparse.add(A, -S_gram) # A/tf.norm(A) - S_gram/tf.norm(S_gram)
else:
LP_loss = A - S_gram
LP_loss = tf.norm(LP_loss, axis=(-1, -2))
if self.reduce_loss:
LP_loss = K.mean(LP_loss)
self.add_loss(LP_loss)
# Entropy loss
entr = tf.negative(
tf.reduce_sum(tf.multiply(S, K.log(S + K.epsilon())), axis=-1)
)
entr_loss = K.mean(entr, axis=-1)
if self.reduce_loss:
entr_loss = K.mean(entr_loss)
self.add_loss(entr_loss)
# Pooling
X_pooled = ops.modal_dot(S, Z, transpose_a=True)
A_pooled = ops.matmul_at_b_a(S, A)
output = [X_pooled, A_pooled]
if self.return_mask:
output.append(S)
return output
def custom_loss(y_true, y_pred):
loss = -(1 / models_data[selected_model]["m"]) * Kb.sum(
5 * y_true * Kb.log(Kb.abs(y_pred + 1 * 10**-8)) +
(1 - y_true) * Kb.log(Kb.abs(1 - y_pred + 1 * 10**-8)))
return loss
def kl_discrete(dist,y,yk,temperature=0.67):
dim=K.shape(dist)[1]
dim=tf.cast(dim,tf.float32)
kl_batch1=K.sum(K.log(dist+EPSILON)-temperature*yk,axis=1)-K.sum(K.log(y+EPSILON)-temperature*yk,axis=1)
kl_batch2=-dim*tf.reduce_logsumexp(K.log(dist+EPSILON)-temperature*yk,1)+dim*tf.reduce_logsumexp(K.log(y+EPSILON)-temperature*yk,1)
return tf.reduce_sum(kl_batch1+kl_batch2)
def call(self, x):
# print("!",x.shape)
E = K.reshape(x[:, :, 0], (-1, self.gs, 1))
p1 = K.reshape(x[:, :, 1], (-1, self.gs, 1))
p2 = K.reshape(x[:, :, 2], (-1, self.gs, 1))
p3 = K.reshape(x[:, :, 3], (-1, self.gs, 1))
pt = K.sqrt(p1**2 + p2**2)
p = K.sqrt(pt**2 + p3**2)
iszero = p**2 + E**2
iszero = 1 - K.relu(1 - self.numericC * iszero) + K.relu(
-self.numericC * iszero)
#return iszero
eta = iszero * 0.5 * K.log(0.0000000001 + (p + p3) /
(p - p3 + 0.0000000001))
#phi=iszero*t.math.acos(p3/(p+0.0000001))
phi = iszero * t.math.atan2(p2, p1)
#print("eta",eta.shape,"phi",phi.shape)
meta = K.mean(eta, axis=-2)
mphi = K.mean(phi, axis=-2)
#print("meta",meta.shape,"mphi",mphi.shape)
#deta=eta#-meta##not sure if abs here
#dphi=phi#-mphi##not sure here either
deta = iszero * K.permute_dimensions(
K.permute_dimensions(eta, (1, 0, 2)) - meta,
(1, 0, 2)) #not sure if abs here required
dphi = iszero * K.permute_dimensions(
K.permute_dimensions(phi, (1, 0, 2)) - mphi,
(1, 0, 2)) #also not sure here either
#print("deta",deta.shape,"dphi",dphi.shape)
lpt = iszero * K.log(pt + 0.0000001) ##
lE = iszero * K.log(E + 0.0000001) ##
#print("lpt",lpt.shape,"lE",lE.shape)
#rpt=K.reshape(pt,(-1,self.gs))
spt = K.sum(pt, axis=-2)
#print("spt",spt.shape)
#return K.permute_dimensions(K.log(1.0+K.abs(K.permute_dimensions(pt,(1,0,2))/(K.abs(spt)+1.0))),(1,0,2))
#ispt=1/(spt+0.000000001)
#print("ispt",ispt.shape)
ppt = -iszero * K.permute_dimensions(
K.log(0.000000001 + K.permute_dimensions(pt, (1, 0, 2)) /
(spt + 0.0000001)), (1, 0, 2)
) #please note the added sign in comparison to the original paper
#ppt=K.reshape(K.permute_dimensions(K.log(0.000000001+K.permute_dimensions(rpt,(1,0,2))/(spt+0.0000001)),(1,0)),(-1,self.gs,1))##
#ppt=K.reshape(K.permute_dimensions(K.log(0.000000001+K.permute_dimensions(rpt,(1,0))/(spt+0.0000001)),(1,0)),(-1,self.gs,1))##
#ppt=K.reshape(K.log(0.000000001+K.permute_dimensions(rpt,(1,0))/(spt+0.0000001)),(-1,self.gs,1))##
#ppt=iszero*K.log(pt/(spt+0.00000001))##
#print("ppt",ppt.shape)
sE = K.sum(E, axis=-2)
#print("sE",sE.shape)
pE = -iszero * K.permute_dimensions(
K.log(0.000000001 + K.permute_dimensions(E, (1, 0, 2)) /
(sE + 0.0000001)), (1, 0, 2)) #here was also a sign added
#pE=-iszero*K.log(sE/(E+0.00000001))##
#pE=-iszero
#print("pE",pE.shape)
dR = K.sqrt(deta**2 + dphi**2) ##
#print("dR",dR.shape)
ret = K.concatenate((iszero, deta, dphi, lpt, lE, ppt, pE, dR),
axis=-1) #adding iszero for numerical reasons
#print(ret.shape,x.shape)
#exit()
return ret
def call(self, y_true, y_pred):
"""
@param y_true: Dim(batch, grid, grid, 3,
(b_x, b_y, b_w, b_h, conf, prob_0, prob_1, ...))
@param y_pred: Dim(batch, grid, grid, 3,
(b_x, b_y, b_w, b_h, conf, prob_0, prob_1, ...))
"""
if len(y_pred.shape) == 4:
_, grid_size, _, box_size = y_pred.shape
box_size = box_size // 3
else:
_, grid_size, _, _, box_size = y_pred.shape
y_true = tf.reshape(
y_true, shape=(-1, grid_size * grid_size * 3, box_size)
)
y_pred = tf.reshape(
y_pred, shape=(-1, grid_size * grid_size * 3, box_size)
)
truth_xywh = y_true[..., 0:4]
truth_conf = y_true[..., 4:5]
truth_prob = y_true[..., 5:]
num_classes = truth_prob.shape[-1]
pred_xywh = y_pred[..., 0:4]
pred_conf = y_pred[..., 4:5]
pred_prob = y_pred[..., 5:]
one_obj = truth_conf
num_obj = tf.reduce_sum(one_obj, axis=[1, 2])
one_noobj = 1.0 - one_obj
# Dim(batch, grid * grid * 3, 1)
one_obj_mask = one_obj > 0.5
zero = tf.zeros((1, grid_size * grid_size * 3, 1), dtype=tf.float32)
# IoU Loss
xiou = self.bbox_xiou(truth_xywh, pred_xywh)
xiou_scale = 2.0 - truth_xywh[..., 2:3] * truth_xywh[..., 3:4]
xiou_loss = one_obj * xiou_scale * (1.0 - xiou[..., tf.newaxis])
xiou_loss = 3 * tf.reduce_mean(tf.reduce_sum(xiou_loss, axis=(1, 2)))
# Confidence Loss
i0 = tf.constant(0)
def body(i, max_iou):
object_mask = tf.reshape(one_obj_mask[i, ...], shape=(-1,))
truth_bbox = tf.boolean_mask(truth_xywh[i, ...], mask=object_mask)
# grid * grid * 3, 1, xywh
# 1, answer, xywh
# => grid * grid * 3, answer
_max_iou0 = tf.cond(
tf.equal(num_obj[i], 0),
lambda: zero,
lambda: tf.reshape(
tf.reduce_max(
bbox_iou(
pred_xywh[i, :, tf.newaxis, :],
truth_bbox[tf.newaxis, ...],
),
axis=-1,
),
shape=(1, -1, 1),
),
)
# 1, grid * grid * 3, 1
_max_iou1 = tf.cond(
tf.equal(i, 0),
lambda: _max_iou0,
lambda: tf.concat([max_iou, _max_iou0], axis=0),
)
return tf.add(i, 1), _max_iou1
_, max_iou = tf.while_loop(
self.while_cond,
body,
[i0, zero],
shape_invariants=[
i0.get_shape(),
tf.TensorShape([None, grid_size * grid_size * 3, 1]),
],
)
conf_obj_loss = one_obj * (0.0 - backend.log(pred_conf + 1e-9))
conf_noobj_loss = (
one_noobj
* tf.cast(max_iou < 0.5, dtype=tf.float32)
* (0.0 - backend.log(1.0 - pred_conf + 1e-9))
)
conf_loss = tf.reduce_mean(
tf.reduce_sum(conf_obj_loss + conf_noobj_loss, axis=(1, 2))
)
# Probabilities Loss
prob_loss = self.prob_binaryCrossentropy(truth_prob, pred_prob)
prob_loss = one_obj * prob_loss[..., tf.newaxis]
prob_loss = tf.reduce_mean(
tf.reduce_sum(prob_loss, axis=(1, 2)) * num_classes
)
total_loss = xiou_loss + conf_loss + prob_loss
if self.verbose != 0:
tf.print(
"grid:",
grid_size,
"iou_loss:",
xiou_loss,
"conf_loss:",
conf_loss,
"prob_loss:",
prob_loss,
"total_loss",
total_loss,
)
return total_loss
def _nnpom(self, projected, thresholds):
if self.use_tau == 1:
projected = K.reshape(projected, shape=[-1]) / self.tau
else:
projected = K.reshape(projected, shape=[-1])
# projected = K.Print(projected, data=[K.reduce_min(projected), K.reduce_max(projected), K.reduce_mean(projected)], message='projected min max mean')
m = K.shape(projected)[0]
a = K.reshape(K.tile(thresholds, [m]), shape=[m, -1])
b = K.transpose(
K.reshape(K.tile(projected, [self.num_classes - 1]), shape=[-1,
m]))
z3 = a - b
# z3 = K.cond(K.reduce_min(K.abs(z3)) < 0.01, lambda: K.Print(z3, data=[K.reduce_min(K.abs(z3))], message='z3 abs min', summarize=100), lambda: z3)
if self.link_function == 'probit':
a3T = self.dist.cdf(z3)
elif self.link_function == 'cloglog':
a3T = 1 - K.exp(-K.exp(z3))
elif self.link_function == 'glogit':
a3T = 1.0 / K.pow(1.0 + K.exp(-self.lmbd *
(z3 - self.mu)), self.alpha)
elif self.link_function == 'cauchit':
a3T = K.atan(z3 / math.pi) + 0.5
elif self.link_function == 'lgamma':
a3T = K.cond(
self.q < 0, lambda: tf.math.igammac(
K.pow(self.q, -2),
K.pow(self.q, -2) * K.exp(self.q * z3)), lambda: K.cond(
self.q > 0, lambda: tf.math.igamma(
K.pow(self.q, -2),
K.pow(self.q, -2) * K.exp(self.q * z3)), lambda:
self.dist.cdf(z3)))
elif self.link_function == 'gauss':
# a3T = 1.0 / 2.0 + K.sign(z3) * K.igamma(1.0 / self.alpha, K.pow(K.abs(z3) / self.r, self.alpha)) / (2 * K.exp(K.lgamma(1.0 / self.alpha)))
# z3 = K.Print(z3, data=[K.reduce_max(K.abs(z3))], message='z3 abs max')
# K.sigmoid(z3 - self.p['mu']) - 1)
a3T = 1.0 / 2.0 + K.tanh(z3 - self.p['mu']) * tf.math.igamma(
1.0 / self.p['alpha'],
K.pow(K.pow(
(z3 - self.p['mu']) / self.p['r'], 2), self.p['alpha'])
) / (2 * K.exp(tf.math.lgamma(1.0 / self.p['alpha'])))
elif self.link_function == 'expgauss':
u = self.lmbd * (z3 - self.mu)
v = self.lmbd * self.sigma
dist1 = distributions.Normal(loc=0., scale=v)
dist2 = distributions.Normal(loc=v, scale=K.pow(v, 2))
a3T = dist1.cdf(u) - K.exp(-u + K.pow(v, 2) / 2 +
K.log(dist2.cdf(u)))
elif self.link_function == 'ggamma':
a3T = tf.math.igamma(
self.p['d'] / self.p['p'],
K.pow((z3 / self.p['a']), self.p['p'])) / K.exp(
tf.math.lgamma(self.p['d'] / self.p['p']))
else:
a3T = 1.0 / (1.0 + K.exp(-z3))
a3 = K.concatenate([a3T, tf.ones([m, 1])], axis=1)
a3 = K.concatenate(
[K.reshape(a3[:, 0], shape=[-1, 1]), a3[:, 1:] - a3[:, 0:-1]],
axis=-1)
return a3
def call(self, inputs):
if len(inputs) == 3:
X, A, I = inputs
if K.ndim(I) == 2:
I = I[:, 0]
else:
X, A = inputs
I = None
N = K.shape(A)[-1]
# Check if the layer is operating in mixed or batch mode
mode = ops.autodetect_mode(A, X)
self.reduce_loss = mode in (modes.MIXED, modes.BATCH)
# Get normalized adjacency
if K.is_sparse(A):
I_ = tf.sparse.eye(N, dtype=A.dtype)
A_ = tf.sparse.add(A, I_)
else:
I_ = tf.eye(N, dtype=A.dtype)
A_ = A + I_
fltr = ops.normalize_A(A_)
# Node embeddings
Z = K.dot(X, self.kernel_emb)
Z = ops.filter_dot(fltr, Z)
if self.activation is not None:
Z = self.activation(Z)
# Compute cluster assignment matrix
S = K.dot(X, self.kernel_pool)
S = ops.filter_dot(fltr, S)
S = activations.softmax(S, axis=-1) # softmax applied row-wise
# Link prediction loss
S_gram = ops.matmul_A_BT(S, S)
if mode == modes.MIXED:
A = tf.sparse.to_dense(A)[None, ...]
if K.is_sparse(A):
LP_loss = tf.sparse.add(
A, -S_gram) # A/tf.norm(A) - S_gram/tf.norm(S_gram)
else:
LP_loss = A - S_gram
LP_loss = tf.norm(LP_loss, axis=(-1, -2))
if self.reduce_loss:
LP_loss = K.mean(LP_loss)
self.add_loss(LP_loss)
# Entropy loss
entr = tf.negative(
tf.reduce_sum(tf.multiply(S, K.log(S + K.epsilon())), axis=-1))
entr_loss = K.mean(entr, axis=-1)
if self.reduce_loss:
entr_loss = K.mean(entr_loss)
self.add_loss(entr_loss)
# Pooling
X_pooled = ops.matmul_AT_B(S, Z)
A_pooled = ops.matmul_AT_B_A(S, A)
output = [X_pooled, A_pooled]
if I is not None:
I_mean = tf.math.segment_mean(I, I)
I_pooled = ops.repeat(I_mean, tf.ones_like(I_mean) * self.k)
output.append(I_pooled)
if self.return_mask:
output.append(S)
return output
def spp(x):
return K.log(1 + K.exp(x)) - spp_alpha
def _calc_entropy(y_pred):
# actually minus entropy
logp = K.log(_clip_value(y_pred))
return K.sum(y_pred * logp, axis=1)
def loss(y_true, y_pred):
loss = y_true * K.log(y_pred) * weights
loss = -K.sum(loss, -1)
return loss
def PSNR(y_true, y_pred):
# 参考：https://ja.wikipedia.org/wiki/%E3%83%94%E3%83%BC%E3%82%AF%E4%BF%A1%E5%8F%B7%E5%AF%BE%E9%9B%91%E9%9F%B3%E6%AF%94
pic_gt = y_true[:, :, :, :3]
pic_pred = y_pred[:, :, :, :3]
return 20 * K.log(2.0) / K.log(10.0) - 10.0 * K.log(
K.mean(K.square(pic_gt - pic_pred), axis=(1, 2, 3))) / K.log(10.0)
def yolo_loss(args, anchors, num_classes, ignore_thresh=.5, print_loss=False):
'''Return yolo_loss tensor
Parameters
----------
yolo_outputs: list of tensor, the output of yolo_body or tiny_yolo_body
y_true: list of array, the output of preprocess_true_boxes
anchors: array, shape=(N, 2), wh
num_classes: integer
ignore_thresh: float, the iou threshold whether to ignore object confidence loss
Returns
-------
loss: tensor, shape=(1,)
'''
num_layers = len(anchors) // 3 # default setting
yolo_outputs = args[:num_layers]
y_true = args[num_layers:]
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]
] if num_layers == 3 else [[3, 4, 5], [1, 2, 3]]
input_shape = K.cast(
K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))
grid_shapes = [
K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0]))
for l in range(num_layers)
]
loss = 0
m = K.shape(yolo_outputs[0])[0] # batch size, tensor
mf = K.cast(m, K.dtype(yolo_outputs[0]))
for l in range(num_layers):
object_mask = y_true[l][..., 4:5]
true_class_probs = y_true[l][..., 5:]
grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
anchors[anchor_mask[l]],
num_classes,
input_shape,
calc_loss=True)
pred_box = K.concatenate([pred_xy, pred_wh])
# Darknet raw box to calculate loss.
raw_true_xy = y_true[l][..., :2] * grid_shapes[l][::-1] - grid
raw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] *
input_shape[::-1])
raw_true_wh = K.switch(object_mask, raw_true_wh,
K.zeros_like(raw_true_wh)) # avoid log(0)=-inf
box_loss_scale = 2 - y_true[l][..., 2:3] * y_true[l][..., 3:4]
# Find ignore mask, iterate over each of batch.
ignore_mask = tf.TensorArray(K.dtype(y_true[0]),
size=1,
dynamic_size=True)
object_mask_bool = K.cast(object_mask, 'bool')
def loop_body(b, ignore_mask):
true_box = tf.boolean_mask(y_true[l][b, ..., 0:4],
object_mask_bool[b, ..., 0])
iou = box_iou(pred_box[b], true_box)
best_iou = K.max(iou, axis=-1)
ignore_mask = ignore_mask.write(
b, K.cast(best_iou < ignore_thresh, K.dtype(true_box)))
return b + 1, ignore_mask
_, ignore_mask = K.control_flow_ops.while_loop(lambda b, *args: b < m,
loop_body,
[0, ignore_mask])
ignore_mask = ignore_mask.stack()
ignore_mask = K.expand_dims(ignore_mask, -1)
# K.binary_crossentropy is helpful to avoid exp overflow.
xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(
raw_true_xy, raw_pred[..., 0:2], from_logits=True)
wh_loss = object_mask * box_loss_scale * 0.5 * K.square(
raw_true_wh - raw_pred[..., 2:4])
confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True)+ \
(1-object_mask) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) * ignore_mask
class_loss = object_mask * K.binary_crossentropy(
true_class_probs, raw_pred[..., 5:], from_logits=True)
xy_loss = K.sum(xy_loss) / mf
wh_loss = K.sum(wh_loss) / mf
confidence_loss = K.sum(confidence_loss) / mf
class_loss = K.sum(class_loss) / mf
loss += xy_loss + wh_loss + confidence_loss + class_loss
if print_loss:
loss = tf.Print(loss, [
loss, xy_loss, wh_loss, confidence_loss, class_loss,
K.sum(ignore_mask)
],
message='loss: ')
return loss
def focal_loss(y_true, y_pred, gamma=2., alpha=.25):
y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
loss_1 = - y_true * (alpha * K.pow((1 - y_pred), gamma) * K.log(y_pred))
loss_0 = - (1 - y_true) * (alpha * K.pow(y_pred, gamma) * K.log(1 - y_pred))
return K.mean(loss_0 + loss_1)
def crossentropy(y_true, y_pred):
# this gives the same result as using keras.objective.crossentropy
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())
return -K.sum(y_true * K.log(y_pred), axis=-1)
def call(self, y_true, y_pred, disc_r):
log_lik = -(y_true * K.log(y_pred) + (1 - y_true) * K.log(1 - y_pred))
loss = K.mean(log_lik * disc_r, keepdims=True)
return loss
def custom_loss(y_true, y_pred):
out = K.clip(y_pred, 1e-8, 1 - 1e-8)
log_lik = y_true * K.log(out)
return K.sum(-log_lik * advantages)
def kl_divergence(kl_term, p, p_hat):
return (kl_term - p * K.log(1e-10 + p_hat) -
(1.0 - p) * K.log(1e-10 + 1.0 - p_hat))
def reconstruct_loss(self, x, mu_x, sigma_x):
var_x = K.square(sigma_x)
reconst_loss = -0.5 * K.sum(K.log(var_x), axis=2) + K.sum(
K.square(x - mu_x) / var_x, axis=2)
reconst_loss = K.reshape(reconst_loss, shape=(x.shape[0], 1))
return K.mean(reconst_loss, axis=0)
def __init__(self, p=0.1, sparsityBeta=3.0):
self.p = K.cast_to_floatx(p)
self.sparsityBeta = K.cast_to_floatx(sparsityBeta)
self.kl_term = p * K.log(p) + (1.0 - p) * K.log(1.0 - p)
def pairwise_cross_entropy(positive_score, negative_score, *args):
positive_exp = K.exp(positive_score)
return K.mean(-K.log(positive_exp /
(positive_exp + K.exp(negative_score))))
def call(self, x):
# print("!",x.shape)
E = K.reshape(x[:, :, 0], (-1, self.gs, 1))
p1 = K.reshape(x[:, :, 1], (-1, self.gs, 1))
p2 = K.reshape(x[:, :, 2], (-1, self.gs, 1))
p3 = K.reshape(x[:, :, 3], (-1, self.gs, 1))
pt = K.sqrt(p1**2 + p2**2)
p = K.sqrt(pt**2 + p3**2)
iszero = p**2 + E**2
iszero = 1 - K.relu(1 - self.numericC * iszero) + K.relu(
-self.numericC * iszero)
#return iszero
eta = iszero * 0.5 * K.log(0.0000000001 + (p + p3) /
(p - p3 + 0.0000000001))
#phi=iszero*t.math.acos(p3/(p+0.0000001))
phi = iszero * t.math.atan2(p2, p1)
#print("eta",eta.shape,"phi",phi.shape)
eta = K.reshape(eta, (-1, self.gs))
phi = K.reshape(phi, (-1, self.gs))
meta = K.mean(eta, axis=-1)
mp1 = K.mean(p1, axis=-2)
mp2 = K.mean(p2, axis=-2)
#print(p2.shape,p1.shape)
#print(mp1.shape,mp2.shape)
#exit()
mphi = t.math.atan2(mp2, mp1)
#print("meta",meta.shape,"mphi",mphi.shape)
#mphi=K.mean(phi,axis=-1)
#exit()
meta = K.reshape(K.repeat_elements(meta, self.gs, 0), (-1, self.gs))
mphi = K.repeat_elements(mphi, self.gs, 1)
#print("meta",meta.shape,"mphi",mphi.shape)
#deta=eta#-meta##not sure if abs here
#dphi=phi#-mphi##not sure here either
siszero = K.reshape(iszero, (-1, self.gs))
deta = K.reshape(siszero * (eta - meta), (-1, self.gs, 1))
dphi = K.reshape(siszero * (phi - mphi), (-1, self.gs, 1))
pi = t.constant(math.pi)
#dphi=K.min([t.math.floormod(dphi,2*pi),t.math.floormod(-dphi,2*pi)],axis=0)
opta = t.math.floormod(dphi, 2 * pi)
optb = t.math.floormod(-dphi, 2 * pi)
dphi = t.where(t.greater(opta, optb), optb, -opta)
#dphi=K.reshape(dphi,(-1,self.gs,1))#should actually be useless?
#dphi=K.min(K.concatenate((t.math.floormod(dphi,2*pi),t.math.floormod(-dphi,2*pi)),axis=-1),axis=-1)
#dphi=K.reshape(dphi,(-1,self.gs,1))
#deta=iszero*K.permute_dimensions(K.permute_dimensions(eta,(1,0,2))-meta,(1,0,2))#not sure if abs here required
#dphi=iszero*K.permute_dimensions(K.permute_dimensions(phi,(1,0,2))-mphi,(1,0,2))#also not sure here either
spt = K.sum(pt, axis=-2)
ppt = -iszero * K.permute_dimensions(
K.log(0.000000001 + K.permute_dimensions(pt, (1, 0, 2)) /
(spt + 0.0000001)), (1, 0, 2)
) #please note the added sign in comparison to the original paper
#print(iszero.shape,deta.shape,dphi.shape,ppt.shape)
#print(eta.shape,meta.shape)
#print(phi.shape,mphi.shape)
#exit()
#print(iszero.shape,deta.shape,dphi.shape,pt.shape)
#exit()
#meta=K.reshape(meta,(-1,self.gs,1))
#mphi=K.reshape(mphi,(-1,self.gs,1))
#phi=K.reshape(phi,(-1,self.gs,1))
ret = K.concatenate((iszero, deta, dphi, ppt),
axis=-1) #adding iszero for numerical reasons
#print(ret.shape,x.shape)
#exit()
return ret
