def construct(self, x):
pow = P.Pow()
sum = P.ReduceSum()
div = P.Div()
norm = pow(x, self.power)
norm = sum(x)
norm = pow(norm, 1. / self.power)
out = div(x, norm)
return out
def __init__(self, learning_rate, multi_epochs, steps_per_epoch, factor=10):
super(MultiEpochsDecayLR, self).__init__()
if not isinstance(multi_epochs, (list, tuple)):
raise TypeError("multi_epochs must be list or tuple.")
self.multi_epochs = Tensor(np.array(multi_epochs, dtype=np.float32) * steps_per_epoch)
self.num = len(multi_epochs)
self.start_learning_rate = learning_rate
self.steps_per_epoch = steps_per_epoch
self.factor = factor
self.pow = ops.Pow()
self.cast = ops.Cast()
self.less_equal = ops.LessEqual()
self.reduce_sum = ops.ReduceSum()
def __init__(self, alpha=2, beta=4):
super(FocalLoss, self).__init__()
self.alpha = alpha
self.beta = beta
self.pow = ops.Pow()
self.log = ops.Log()
self.select = ops.Select()
self.equal = ops.Equal()
self.less = ops.Less()
self.cast = ops.Cast()
self.fill = ops.Fill()
self.dtype = ops.DType()
self.shape = ops.Shape()
self.reduce_sum = ops.ReduceSum()
def construct(self, inputs, targets):
"""
Args:
- inputs: feature matrix with shape (batch_size, feat_dim)
- targets: ground truth labels with shape (num_classes)
"""
n = inputs.shape[0]
# Compute pairwise distance, replace by the official when merged
pow = P.Pow()
sum = P.ReduceSum(keep_dims=True)
expand = P.BroadcastTo((n, n))
transpose = P.Transpose()
mul = P.Mul()
add = P.Add()
sqrt = P.Sqrt()
equal = P.Equal()
cat = P.Concat()
ones_like = P.OnesLike()
dist = pow(inputs, 2)
dist = sum(dist, axis=1)
dist = expand(dist)
dist = dist + transpose(dist, (1, 0))
temp1 = P.matmul(inputs, transpose(inputs, (1, 0)))
temp1 = mul(-2, temp1)
dist = add(dist, temp1)
dist = P.composite.clip_by_value(
dist, clip_value_min=1e-12, clip_value_max=100000000
) # for numerical stability, clip_value_max=? why must set?
dist = sqrt(dist)
# For each anchor, find the hardest positive and negative
targets = expand(targets)
mask = equal(targets, transpose(targets, (1, 0)))
dist_ap = []
dist_an = []
# only for debugging
#####################
# print("dist is")
# print(dist.shape)
# print(dist)
# print("mask is")
# print(mask.shape)
# print(mask)
# print(mask[0])
#####################
for i in range(n):
minval = -1.0
maxval = -1.0
for j in range(n):
if mask[i][j] and dist[i][j] > maxval:
maxval = dist[i][j]
if not mask[i][j] and (dist[i][j] < minval or minval == -1):
minval = dist[i][j]
if (not isinstance(minval, Tensor)
or not isinstance(maxval, Tensor) or minval == -1.0
or maxval == -1.0):
if self.error_msg is not None:
print("Error Msg", file=self.error_msg)
print("mask {} is".format(i), file=self.error_msg)
print(mask[i], file=self.error_msg)
print("dist is:", file=self.error_msg)
print(dist[i], file=self.error_msg)
print(maxval, file=self.error_msg)
print(minval, file=self.error_msg)
print(type(maxval), file=self.error_msg)
print(type(minval), file=self.error_msg)
self.error_msg.flush()
# assert minval != -1.0 and isinstance(minval, Tensor)
# assert maxval != -1.0 and isinstance(maxval, Tensor)
dist_ap.append(maxval.asnumpy())
dist_an.append(minval.asnumpy())
dist_ap = Tensor(dist_ap, ms.float32)
dist_an = Tensor(dist_an, ms.float32)
# only for debugging
#####################
# print(dist_ap)
# print(dist_ap.shape)
# print(dist_an)
#####################
# Compute ranking hinge loss
y = ones_like(dist_an)
loss = self.ranking_loss(dist_an, dist_ap, y)
# # compute accuracy
# correct = torch.ge(dist_an, dist_ap).sum().item()
return loss
# class GradOriTripletLoss(nn.Cell)
# def __init__(self, net):
# super(GradOriTripletLoss, self).__init__()
# self.net = net
# self.grad_op = P.GradOperation(get_all=True)
#
# def construct(self, inputs, targets):
# gradient_function = self.grad_op(self.net)
# return gradient_function(inputs, targets)