def __init__(self, bins=10, momentum=0.0, mu=0.02):
super(GHMRLoss, self).__init__()
self.bins = bins
self.momentum = momentum
self.mu = mu
edges_left = np.array([float(x) / bins for x in range(bins)], dtype=np.float32)
self.edges_left = Tensor(edges_left.reshape((bins, 1, 1, 1, 1)))
edges_right = np.array([float(x) / bins for x in range(1, bins + 1)], dtype=np.float32)
edges_right[-1] += 1e-4
self.edges_right = Tensor(edges_right.reshape((bins, 1, 1, 1, 1)))
if momentum >= 0:
self.acc_sum = Parameter(initializer(0, [bins], mstype.float32))
self.abs = ops.Abs()
self.sqrt = ops.Sqrt()
self.cast = ops.Cast()
self.select = ops.Select()
self.reshape = ops.Reshape()
self.reduce_sum = ops.ReduceSum()
self.max = ops.Maximum()
self.less = ops.Less()
self.equal = ops.Equal()
self.greater = ops.Greater()
self.logical_and = ops.LogicalAnd()
self.greater_equal = ops.GreaterEqual()
self.zeros_like = ops.ZerosLike()
self.expand_dims = ops.ExpandDims()
def construct(self, x, seq_lengths):
"""Defines the ReverseSequence operator computation performed."""
batch_size = x.shape[self.batch_dim]
max_seq_len = x.shape[self.seq_dim]
seq_lens_type = seq_lengths.dtype
back = ops.Sub()(seq_lengths, ops.OnesLike()(seq_lengths))
batch_idx = self.make_shape((batch_size, max_seq_len), seq_lens_type,
0)
forward_idx = self.make_shape((batch_size, max_seq_len), seq_lens_type,
1)
back = back.view(-1, 1)
reverse_idx = ops.Sub()(back, forward_idx)
condition = ops.Less()(reverse_idx, ops.ZerosLike()(reverse_idx))
reverse_idx = ops.Select()(condition, forward_idx, reverse_idx)
reverse_idx = ops.ExpandDims()(reverse_idx, 2)
batch_idx = ops.ExpandDims()(batch_idx, 2)
if self.batch_dim > self.seq_dim:
batch_idx = ops.Transpose()(batch_idx, (1, 0, 2))
reverse_idx = ops.Transpose()(reverse_idx, (1, 0, 2))
x = ops.Transpose()(x, (1, 0, 2))
start_indices = ops.Concat(2)((batch_idx, reverse_idx))
output = ops.GatherNd()(x, start_indices)
return output
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 hardshrink(input, lambd=0.5):
great_lambd = ops.Greater()(input, lambd)
less_neg_lambd = ops.Less()(input, lambd)
cond = ops.logical_or(great_lambd, less_neg_lambd)
return ops.Select()(cond, input, ops.scalar_to_tensor(0.0))
