def construct(self, box_xy, box_wh, box_confidence, box_probs,
image_shape):
batch_size = F.shape(box_xy)[0]
x = box_xy[:, :, :, :, 0:1]
y = box_xy[:, :, :, :, 1:2]
box_yx = P.Concat(-1)((y, x))
w = box_wh[:, :, :, :, 0:1]
h = box_wh[:, :, :, :, 1:2]
box_hw = P.Concat(-1)((h, w))
new_shape = P.Round()(image_shape *
P.ReduceMin()(self.input_shape / image_shape))
offset = (self.input_shape - new_shape) / 2.0 / self.input_shape
scale = self.input_shape / new_shape
box_yx = (box_yx - offset) * scale
box_hw = box_hw * scale
box_min = box_yx - box_hw / 2.0
box_max = box_yx + box_hw / 2.0
boxes = P.Concat(-1)(
(box_min[:, :, :, :, 0:1], box_min[:, :, :, :, 1:2],
box_max[:, :, :, :, 0:1], box_max[:, :, :, :, 1:2]))
image_scale = P.Tile()(image_shape, (1, 2))
boxes = boxes * image_scale
boxes = F.reshape(boxes, (batch_size, -1, 4))
boxes_scores = box_confidence * box_probs
boxes_scores = F.reshape(boxes_scores,
(batch_size, -1, self.num_classes))
return boxes, boxes_scores
def construct(self, x, query_hidden_state, attention_mask, layer_past=None):
original_shape = F.shape(x)
x = F.reshape(x, (-1, original_shape[-1]))
query_hidden_state = F.reshape(query_hidden_state, (-1, original_shape[-1]))
query = self.dense1(query_hidden_state)
key = self.dense2(x)
value = self.dense3(x)
query = self.transpose(
F.reshape(
query,
(-1, original_shape[1], self.n_head, self.size_per_head)),
(0, 2, 1, 3))
key = self.transpose(
F.reshape(
key, (-1, original_shape[1], self.n_head, self.size_per_head)),
(0, 2, 3, 1))
value = self.transpose(
F.reshape(
value,
(-1, original_shape[1], self.n_head, self.size_per_head)),
(0, 2, 1, 3))
if self.use_past:
past_value = layer_past[1]
past_key = self.transpose(layer_past[0], (0, 1, 3, 2))
key = self.concat_k((past_key, key))
value = self.concat_v(past_value, value)
layer_present = P.Pack()([self.transpose(key, (0, 1, 3, 2)), value])
attention = self._attn(query, key, value, attention_mask)
attention_merge = self.merge_heads(attention)
output = self.projection(attention_merge)
output = self.dropout(output)
return output, layer_present
def construct(self, pred_label, gt_label, num_matched_boxes):
gt_label = F.cast(gt_label, mstype.int32)
mask = F.cast(self.less(0, gt_label), mstype.float32)
gt_label_shape = F.shape(gt_label)
pred_label = F.reshape(pred_label, (-1, self.num_classes))
gt_label = F.reshape(gt_label, (-1, ))
cross_entropy = self.cross_entropy(pred_label, gt_label)
cross_entropy = F.reshape(cross_entropy, gt_label_shape)
# Hard example mining
num_matched_boxes = F.reshape(num_matched_boxes, (-1, ))
neg_masked_cross_entropy = F.cast(cross_entropy * (1 - mask),
mstype.float16)
_, loss_idx = self.sort_descend(neg_masked_cross_entropy,
self.num_boxes)
_, relative_position = self.sort(F.cast(loss_idx, mstype.float16),
self.num_boxes)
num_neg_boxes = self.minimum(num_matched_boxes * self.neg_pre_positive,
self.num_boxes)
tile_num_neg_boxes = self.tile(self.expand_dims(num_neg_boxes, -1),
(1, self.num_boxes))
top_k_neg_mask = F.cast(
self.less(relative_position, tile_num_neg_boxes), mstype.float32)
class_loss = self.reduce_sum(cross_entropy * (mask + top_k_neg_mask),
1)
return self.reduce_mean(
class_loss / F.cast(num_matched_boxes, mstype.float32), 0)
def construct(self, x, attention_mask, layer_past=None):
"""
self-attention
Inputs:
x: output of previous layer
attention_mask: the attention mask matrix with shape (batch_size, 1, seq_length, seq_length)
layer_past: the previous feature map
Returns:
output: Tensor, the output logit of this layer
layer_present: Tensor, the feature map of current layer
"""
original_shape = F.shape(x)
x = F.reshape(x, (-1, original_shape[-1]))
query = self.dense1(x)
key = self.dense2(x)
value = self.dense3(x)
query = self.transpose(F.reshape(query, (-1, original_shape[1], self.n_head, self.size_per_head)), (0, 2, 1, 3))
key = self.transpose(F.reshape(key, (-1, original_shape[1], self.n_head, self.size_per_head)), (0, 2, 3, 1))
value = self.transpose(F.reshape(value, (-1, original_shape[1], self.n_head, self.size_per_head)), (0, 2, 1, 3))
if self.use_past:
past_value = layer_past[1]
past_key = self.transpose(layer_past[0], (0, 1, 3, 2))
key = self.concat_k((past_key, key))
value = self.concat_v(past_value, value)
layer_present = P.Pack()([self.transpose(key, (0, 1, 3, 2)), value])
attention = self._attn(query, key, value, attention_mask)
attention_merge = self.merge_heads(attention)
output = self.projection(attention_merge)
output = self.dropout(output)
return output, layer_present
def construct(self, x):
tensor_shape = F.shape(x)
input_feature = F.reshape(x, (tensor_shape[0] * tensor_shape[1], tensor_shape[2]))
output = self.matmul(input_feature, self.weight)
if self.has_bias:
output = self.bias_add(output, self.bias)
output = F.reshape(output, (tensor_shape[0], tensor_shape[1], self.out_channels))
return output
def construct(self, inputs):
output = ()
batch_size = F.shape(inputs[0])[0]
for x in inputs:
x = self.transpose(x, (0, 2, 3, 1))
output += (F.reshape(x, (batch_size, -1)), )
res = self.concat(output)
return F.reshape(res, (batch_size, self.num_ssd_boxes, -1))
def construct(self, x):
output = ()
for i in range(self.length):
shape = F.shape(x[i])
mid_shape = (shape[0], -1, self.num_default[i], self.sizes[i], self.sizes[i])
final_shape = (shape[0], -1, self.num_default[i] * self.sizes[i] * self.sizes[i])
output += (F.reshape(F.reshape(x[i], mid_shape), final_shape),)
res = self.concat(output)
return self.transpose(res, (0, 2, 1))
def _fspecial_gauss(self, filter_size, filter_sigma):
"""get gauss kernel"""
filter_size, g = _gauss_kernel_helper(filter_size)
square_sigma_scale = -0.5 / (filter_sigma * filter_sigma)
g = g * square_sigma_scale
g = F.reshape(g, (1, -1)) + F.reshape(g, (-1, 1))
g = F.reshape(g, (1, -1))
g = P.Softmax()(g)
ret = F.reshape(g, (1, 1, filter_size, filter_size))
return ret
def construct(self, x):
shape = x.shape
if self.do_reshape:
x_shape = (-1, shape[-1])
x = F.reshape(x, x_shape)
y = self.dense(x)
if self.do_reshape:
y_shape = shape[:-1] + (-1, )
y = F.reshape(y, y_shape)
return y
def construct(self, x):
identity = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
if self.use_se and self.stride != 1:
out = self.e2(out)
else:
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv3(out)
out = self.bn3(out)
if self.se_block:
out_se = out
out = self.se_global_pool(out, (2, 3))
out = self.se_dense_0(out)
out = self.relu(out)
out = self.se_dense_1(out)
out = self.se_sigmoid(out)
out = F.reshape(out, F.shape(out) + (1, 1))
out = self.se_mul(out, out_se)
if self.down_sample:
identity = self.down_sample_layer(identity)
out = out + identity
out = self.relu(out)
return out
def construct(self, distances):
"""Compute smeared-gaussian distance values.
Args:
distances (torch.Tensor): interatomic distance values of
(N_b x N_at x N_nbh) shape.
Returns:
torch.Tensor: layer output of (N_b x N_at x N_nbh x N_g) shape.
"""
ex_dis = F.expand_dims(distances, -1)
if not self.centered:
# compute width of Gaussian functions (using an overlap of 1 STDDEV)
coeff = -0.5 / F.square(self.width)
# Use advanced indexing to compute the individual components
# ~ diff = distances[:, :, :, None] - offset[None, None, None, :]
ex_offset = F.reshape(self.offset, (1, 1, 1, -1))
diff = ex_dis - ex_offset
else:
# if Gaussian functions are centered, use offsets to compute widths
coeff = -0.5 / F.square(self.offset)
# if Gaussian functions are centered, no offset is subtracted
diff = ex_dis
# compute smear distance values
exp = P.Exp()
gauss = exp(coeff * F.square(diff))
return gauss
def construct(self, input_x):
if self.use_batch_norm and self.training:
ones = P.Fill()(mstype.float32,
F.shape(input_x)[:self.begin_norm_axis], 1.0)
zeros = P.Fill()(mstype.float32,
F.shape(input_x)[:self.begin_norm_axis], 0.0)
shape_x = F.shape(input_x)
norm_shape = get_shape_for_norm(shape_x, self.begin_norm_axis)
input_x = F.reshape(input_x, norm_shape)
output, _, _, _, _, _ = self.batch_norm(input_x, ones, zeros, None,
None)
output = F.reshape(output, shape_x)
y = output * self.gamma + self.beta
else:
y, _, _ = self.layer_norm(input_x, self.gamma, self.beta)
return y
def construct(self, inputs, neighbors):
# Construct auxiliary index vector
ns = neighbors.shape
# Get atomic positions of all neighboring indices
if self.fixed_neigh:
return F.gather(inputs, neighbors[0], -2)
else:
# [B, A, N] -> [B, A*N, 1]
neigh_idx = F.reshape(neighbors, (ns[0], ns[1] * ns[2], -1))
# [B, A*N, V] = [B, A*N, V] * [1, 1, V]
neigh_idx = neigh_idx * self.broad_ones
# [B, A*N, V] gather from [B, A, V]
outputs = self.gatherd(inputs, 1, neigh_idx)
# [B, A, N, V]
return F.reshape(outputs, (ns[0], ns[1], ns[2], -1))
def construct(self, x):
x = self.transpose(x, (3, 0, 2, 1))
x = F.reshape(x, (-1, self.batch_size, self.input_size))
y1, _, _, _, _ = self.lstm_1(x, self.h, self.c, self.w1)
y2, _, _, _, _ = self.lstm_2(y1, self.h, self.c, self.w2)
output = self.fc(
y2
) # y2 shape: [time_step, bs, hidden_size] output shape: [time_step, bs, num_classes].
return output
def _attn(self, query, key, value, attention_mask):
"""
Get the weighted score along the seq_length
Inputs:
query: the query matrix
key: the key matrix
value: the value matrix
attention_mask: the attention mask matrix with shape (batch_size, 1, seq_length, seq_length)
Returns:
weighted_values: Tensor, the weighted sum scores
"""
if not self.scale:
query = query / F.cast(self.coeff, F.dtype(query))
key = key / F.cast(self.coeff, F.dtype(key))
score = self.batch_matmul(query, key)
if self.scale:
score = self.real_div(
score,
P.Cast()(self.scale_factor, P.DType()(score)))
ori_dtype = P.DType()(score)
score = P.Cast()(score, mstype.float32)
multiplu_out = self.sub(
P.Cast()(F.tuple_to_array((1.0,)), P.DType()(score)),
P.Cast()(attention_mask, P.DType()(score)))
adder = self.mul(multiplu_out, self.multiply_data)
attention_scores = self.add(adder, score)
shape = F.shape(attention_scores)
attention_probs = self.softmax(
F.reshape(attention_scores,
(shape[0], -1, shape[-1])))
attention_probs = P.Cast()(attention_probs, ori_dtype)
attention_probs = F.reshape(attention_probs, shape)
attention_probs = self.prob_dropout(attention_probs)
weighted_values = self.batch_matmul(attention_probs, value)
return weighted_values
def construct(self, x):
"""Compute neural network output.
Args:
inputs (torch.Tensor): network input.
Returns:
torch.Tensor: network output.
"""
shape = x.shape
if self.do_reshape:
x_shape = (-1, shape[-1])
x = F.reshape(x, x_shape)
y = self.mlp(x)
if self.do_reshape:
y_shape = shape[:-1] + (-1, )
y = F.reshape(y, y_shape)
return y
def construct(self, x):
return F.reshape(x, (F.shape(x)[0], -1))
def matmul(x1, x2, dtype=None):
"""
Returns the matrix product of two arrays.
Note:
Numpy arguments `out`, `casting`, `order`, `subok`, `signature`, and `extobj` are
not supported.
On GPU, the supported dtypes are np.float16 and np.float32.
On CPU, the supported dtypes are np.float16 and np.float32.
Args:
x1 (Tensor): Input tensor, scalar not allowed.
x2 (Tensor): Input tensor, scalar not allowed.
dtype (:class:`mindspore.dtype`, optional): defaults to None. Overrides the dtype of the
output Tensor.
Returns:
Tensor or scalar, the matrix product of the inputs. This is a scalar only
when both `x1`, `x2` are 1-d vectors.
Raises:
ValueError: If the last dimension of `x1` is not the same size as the
second-to-last dimension of `x2`, or if a scalar value is passed in.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> x1 = Tensor(np.arange(2*3*4).reshape(2, 3, 4), mindspore.float32)
>>> x2 = Tensor(np.arange(4*5).reshape(4, 5), mindspore.float32)
>>> output = ops.matmul(x1, x2)
>>> print(output)
[[[ 70. 76. 82. 88. 94.]
[ 190. 212. 234. 256. 278.]
[ 310. 348. 386. 424. 462.]]
[[ 430. 484. 538. 592. 646.]
[ 550. 620. 690. 760. 830.]
[ 670. 756. 842. 928. 1014.]]]
"""
# performs type promotion
dtype1 = F.dtype(x1)
dtype2 = F.dtype(x2)
if not _check_same_type(dtype1, dtype2):
x1 = x1.astype(mstype.float32)
x2 = x2.astype(mstype.float32)
ndim1_orig, ndim2_orig = F.rank(x1), F.rank(x2)
shape1_orig, shape2_orig = F.shape(x1), F.shape(x2)
transpose_b = ndim2_orig == 1
shape_backbone = _check_matmul_shapes(shape1_orig, shape2_orig)
# infers the shape of the output
shape_out = shape_backbone + _infer_shape_rem(
shape1_orig, shape2_orig, ndim1_orig, ndim2_orig, transpose_b)
x1 = _expand(x1, 2)
x2 = _expand(x2, 2)
if F.rank(x2) == 2:
if F.rank(x1) > 2:
x1 = F.reshape(x1, (-1, shape1_orig[-1]))
res = P.MatMul(False, transpose_b)(x1, x2)
else:
# broadcasts x1.shape[:-2] with x2.shape[:-2]
ndim_aligned = _max(ndim1_orig, ndim2_orig)
x1 = _expand(x1, ndim_aligned)
x2 = _expand(x2, ndim_aligned)
shape1_aligned, shape2_aligned = F.shape(x1), F.shape(x2)
x1 = _broadcast_to(x1, shape1_aligned[:-2], shape_backbone,
ndim_aligned)
x2 = _broadcast_to(x2, shape2_aligned[:-2], shape_backbone,
ndim_aligned)
res = P.BatchMatMul(False, transpose_b)(x1, x2)
if dtype is not None:
res = res.astype(dtype)
return F.reshape(res, shape_out)
def batch_dot(x1, x2, axes=None):
"""
Computation of batch dot product between samples in two tensors containing batch dims.
Inputs:
- **x1** (Tensor) - First tensor in Batch Dot op with datatype float32
- **x2** (Tensor) - Second tensor in Batch Dot op with datatype float32. x2's datatype should
be same as x1's.
- **axes** (Union[int, tuple(int), list(int)]) - Single value or tuple/list of length 2 with dimensions
specified for `a` and `b` each. If single value `N` passed, automatically picks up last N dims from
`a` input shape and last N dims from `b` input shape in order as axes for each respectively.
Outputs:
Tensor, batch dot product of x1 and x2. The Shape of output for input shapes (batch, d1, axes, d2) and
(batch, d3, axes, d4) is (batch, d1, d2, d3, d4)
.. math::
output = x1[batch, :] * x2[batch, :]
Raises:
TypeError: If shapes of x1 and x2 are not the same.
ValueError: If rank of x1 or x2 less than 2.
ValueError: If batch dim used in axes.
ValueError: If dtype of x1 or x2 is not float32.
ValueError: If len(axes) less than 2.
ValueError: If axes is not one of those: None, int, (int, int).
ValueError: If axes value is too high for dimensions of input arrays.
ValueError: If batch size of x1 and x2 are not the same.
Supported Platforms:
``Ascend`` ``GPU`` ``CPU``
Examples:
>>> input_x1 = Tensor(np.ones(shape=[2, 2, 3]), mindspore.float32)
>>> input_x2 = Tensor(np.ones(shape=[2, 3, 2]), mindspore.float32)
>>> axes = (-1, -2)
>>> output = C.batch_dot(input_x1, input_x2, axes)
>>> print(output)
[[[3. 3.]
[3. 3.]]
[[3. 3.]
[3. 3.]]]
"""
transpose_op = P.Transpose()
batch_matmul_op = P.BatchMatMul()
squeeze_one_op = P.Squeeze(1)
squeeze_minus_one_op = P.Squeeze(-1)
# input validity checks
x1_shape = F.shape(x1)
x2_shape = F.shape(x2)
x1_dim_num = len(x1_shape)
x2_dim_num = len(x2_shape)
x1_type = F.dtype(x1)
x2_type = F.dtype(x2)
x1_batch_size, x2_batch_size = _get_batch_size(x1_shape, x2_shape)
_typecheck_input_batch_dot(x1_type, x2_type)
_check_batch_size(x1_batch_size, x2_batch_size)
axes = _check_axes_for_batch_dot(x1_shape, x2_shape, axes)
if x1_dim_num == 2:
x1 = F.expand_dims(x1, 1)
axes[0] += 1
if x2_dim_num == 2:
x2 = F.expand_dims(x2, 2)
x1_shape = F.shape(x1)
x2_shape = F.shape(x2)
x1_reshape_fwd, x1_transpose_fwd, x1_ret = _calc_new_shape_batchdot(
x1_shape, axes, 0)
x2_reshape_fwd, x2_transpose_fwd, x2_ret = _calc_new_shape_batchdot(
x2_shape, axes, 1)
output_shape = _get_output_shape(x1_batch_size, x1_ret, x2_ret)
x1_transposed = transpose_op(x1, x1_transpose_fwd)
x2_transposed = transpose_op(x2, x2_transpose_fwd)
x1_reshaped = F.reshape(x1_transposed, x1_reshape_fwd)
x2_reshaped = F.reshape(x2_transposed, x2_reshape_fwd)
# Batch matmal op part
mul_result = batch_matmul_op(x1_reshaped, x2_reshaped)
final_result = F.reshape(mul_result, output_shape)
# if the original dims are expanded, restore them from 3 to 2
if x1_dim_num == 2:
final_result = squeeze_one_op(final_result)
elif x2_dim_num == 2:
final_result = squeeze_minus_one_op(final_result)
return final_result
def construct(self, x):
shape = F.shape(x)
return F.reshape(self.ops(F.reshape(x, (1, -1, shape[2], shape[3]))),
shape)
def construct(self, query, key, value, cutoff=None, mask=None):
r"""Compute multi-head attention.
Args:
query (Mindspore.Tensor [B, A, 1, V]):
key (Mindspore.Tensor [B, A, N', V]):
value (Mindspore.Tensor [B, A, N', V]):
cutoff (Mindspore.Tensor [B, A, 1, N'] or [B, A, 1, 1, N']):
Returns:
Mindspore.Tensor [B, A, V]: multi-head attention output.
"""
if self.n_heads > 1:
q_reshape = query.shape[:-1] + self.reshape_tail
k_reshape = key.shape[:-1] + self.reshape_tail
v_reshape = value.shape[:-1] + self.reshape_tail
# [B, A, 1, h, v]
Q = F.reshape(query, q_reshape)
# [B, A, h, 1, v]
Q = self.transpose(Q, self.trans_shape)
# [B, A, N', h, v]
K = F.reshape(key, k_reshape)
# [B, A, h, N', v]
K = self.transpose(K, self.trans_shape)
# [B, A, N', h, v]
V = F.reshape(value, v_reshape)
# [B, A, h, N', v]
V = self.transpose(V, self.trans_shape)
# [B, A, h, 1, v] x [B, A, h, N', v]^T / \sqrt(v)
# [B, A, h, 1, v] x [B, A, h, v, N'] = [B, A, h, 1, N']
attention_scores = self.bmmt(Q, K)
attention_scores = self.mul(attention_scores, self.scores_mul)
if cutoff is None:
attention_probs = self.softmax(attention_scores)
else:
# [B, A, 1, 1, N']
exmask = F.expand_dims(F.expand_dims(mask, -2), -2)
# [B, A, h, 1, N']
mhmask = exmask * self.exones
large_neg = F.ones_like(attention_scores) * -5e4
attention_scores = F.select(mhmask > 0, attention_scores,
large_neg)
attention_probs = self.softmax(attention_scores)
excut = F.expand_dims(F.expand_dims(cutoff, -2), -2)
# [B, A, h, 1, N'] * [B, A, 1, 1, N']
attention_probs = self.mul(attention_probs, excut)
# [B, A, h, 1, N'] x [B, A, h, N', v] = [B, A, h, 1, v]
context = self.bmm(attention_probs, V)
# [B, A, 1, h, v]
context = self.transpose(context, self.trans_shape)
# [B, A, 1, V]
context = F.reshape(context, query.shape)
else:
# [B, A, 1, V] x [B, A, N', V]^T / \sqrt(V)
# [B, A, 1, V] x [B, A, V, N'] = [B, A, 1, N']
attention_scores = self.bmmt(query, key) * self.scores_mul
if cutoff is None:
attention_probs = self.softmax(attention_scores)
else:
large_neg = F.ones_like(attention_scores) * -5e4
attention_scores = F.select(mask, attention_scores, large_neg)
attention_probs = self.softmax(attention_scores)
# [B, A, 1, N'] * [B, A, 1, N']
attention_probs = attention_probs * F.expand_dims(cutoff, -2)
# [B, A, 1, N'] x [B, A, N', V] = [B, A, 1, V]
context = self.bmm(attention_probs, value)
# [B, A, V]
context = self.squeeze(context)
return self.output(context)
def construct(self, loc_data, loc_t, conf_data, conf_t, landm_data,
landm_t):
# landm loss
mask_pos1 = F.cast(self.less(0.0, F.cast(conf_t, mstype.float32)),
mstype.float32)
N1 = self.maximum(self.reduce_sum(mask_pos1), 1)
mask_pos_idx1 = self.tile(self.expand_dims(mask_pos1, -1), (1, 1, 10))
loss_landm = self.reduce_sum(
self.smooth_l1_loss(landm_data, landm_t) * mask_pos_idx1)
loss_landm = loss_landm / N1
# Localization Loss
mask_pos = F.cast(self.notequal(0, conf_t), mstype.float32)
conf_t = F.cast(mask_pos, mstype.int32)
N = self.maximum(self.reduce_sum(mask_pos), 1)
mask_pos_idx = self.tile(self.expand_dims(mask_pos, -1), (1, 1, 4))
loss_l = self.reduce_sum(
self.smooth_l1_loss(loc_data, loc_t) * mask_pos_idx)
loss_l = loss_l / N
# Conf Loss
conf_t_shape = F.shape(conf_t)
conf_t = F.reshape(conf_t, (-1, ))
indices = self.concat((self.idx, F.reshape(conf_t, (-1, 1))))
batch_conf = F.reshape(conf_data, (-1, self.num_classes))
x_max = self.max(batch_conf)
loss_c = self.log(self.reduce_sum2(self.exp(batch_conf - x_max),
1)) + x_max
loss_c = loss_c - F.reshape(self.gather(batch_conf, indices), (-1, 1))
loss_c = F.reshape(loss_c, conf_t_shape)
# hard example mining
num_matched_boxes = F.reshape(self.reduce_sum(mask_pos, 1), (-1, ))
neg_masked_cross_entropy = F.cast(loss_c * (1 - mask_pos),
mstype.float32)
_, loss_idx = self.sort_descend(neg_masked_cross_entropy,
self.num_boxes)
_, relative_position = self.sort(F.cast(loss_idx, mstype.float32),
self.num_boxes)
relative_position = F.cast(relative_position, mstype.float32)
relative_position = relative_position[:, ::-1]
relative_position = F.cast(relative_position, mstype.int32)
num_neg_boxes = self.minimum(num_matched_boxes * self.neg_pre_positive,
self.num_boxes - 1)
tile_num_neg_boxes = self.tile(self.expand_dims(num_neg_boxes, -1),
(1, self.num_boxes))
top_k_neg_mask = F.cast(
self.less(relative_position, tile_num_neg_boxes), mstype.float32)
cross_entropy = self.cross_entropy(batch_conf, conf_t)
cross_entropy = F.reshape(cross_entropy, conf_t_shape)
loss_c = self.reduce_sum(cross_entropy *
self.minimum(mask_pos + top_k_neg_mask, 1))
loss_c = loss_c / N
return loss_l, loss_c, loss_landm
