def _cdf(self, value, probs=None):
r"""
Cumulative distribution function (cdf) of Categorical distributions.
Args:
value (Tensor): The value to be evaluated.
probs (Tensor): Event probabilities. Default: self.probs.
"""
value = self._check_value(value, 'value')
probs = self._check_param_type(probs)
# find the right integer to compute index
# here we simulate casting to int but still keeping float dtype
value = self.cast(value, self.dtypeop(probs))
zeros = self.fill(self.dtypeop(value), self.shape(value), 0.0)
between_zero_neone = self.logicand(self.less(
value,
0,
), self.greater(value, -1.))
value = self.select(between_zero_neone, zeros, P.Floor()(value))
# handle the case when value is of shape () and probs is a scalar batch
drop_dim = False
if self.shape(value) == () and self.shape(probs)[:-1] == ():
drop_dim = True
# manually add one more dimension: () -> (1,)
# drop this dimension before return
value = self.expand_dim(value, -1)
value = self.expand_dim(value, -1)
broadcast_shape_tensor = probs * value
broadcast_shape = self.shape(broadcast_shape_tensor)
num_classes = broadcast_shape[-1]
label_shape = broadcast_shape[:-1]
probs = self.broadcast(probs, broadcast_shape_tensor)
value = self.broadcast(value, broadcast_shape_tensor)[..., :1]
# flatten value to shape (number of labels, 1)
value = self.reshape(value, (-1, 1))
# drop one dimension to match cdf
# clip value to be in range from 0 to num_classes -1 and cast into int32
less_than_zero = self.squeeze_last_axis(self.less(value, 0.0))
value_clipped = self.clip_by_value(value, 0.0, num_classes - 1)
value_clipped = self.cast(value_clipped, self.index_type)
index = self.reshape(nn.Range(0, self.shape(value)[0], 1)(), (-1, 1))
index = self.concat((index, value_clipped))
# reshape probs and fill less_than_zero places with 0
probs = self.reshape(probs, (-1, num_classes))
cdf = self.gather(self.cumsum(probs, 1), index)
zeros = self.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
cdf = self.select(less_than_zero, zeros, cdf)
cdf = self.reshape(cdf, label_shape)
if drop_dim:
return self.squeeze(cdf)
return cdf
def _log_prob(self, value, probs=None):
r"""
Evaluate log probability.
Args:
value (Tensor): The value to be evaluated.
probs (Tensor): Event probabilities. Default: self.probs.
"""
value = self._check_value(value, 'value')
probs = self._check_param_type(probs)
logits = self.log(probs)
# find the right integer to compute index
# here we simulate casting to int but still keeping float dtype
value = self.cast(value, self.dtypeop(probs))
zeros = self.fill(self.dtypeop(value), self.shape(value), 0.0)
neg_one = self.fill(self.dtypeop(value), self.shape(value), -1.0)
value = self.select(self.is_nan(value), neg_one, value)
between_zero_neone = self.logicand(self.less(
value,
0,
), self.greater(value, -1.))
value = self.select(between_zero_neone, zeros, P.Floor()(value))
# handle the case when value is of shape () and probs is a scalar batch
drop_dim = False
if self.shape(value) == () and self.shape(probs)[:-1] == ():
drop_dim = True
# manually add one more dimension: () -> (1,)
# drop this dimension before return
value = self.expand_dim(value, -1)
value = self.expand_dim(value, -1)
broadcast_shape_tensor = logits * value
broadcast_shape = self.shape(broadcast_shape_tensor)
num_classes = broadcast_shape[-1]
label_shape = broadcast_shape[:-1]
# broadcasting logits and value
# logit_pmf shape (num of labels, C)
logits = self.broadcast(logits, broadcast_shape_tensor)
value = self.broadcast(value, broadcast_shape_tensor)[..., :1]
# flatten value to shape (number of labels, 1)
# clip value to be in range from 0 to num_classes -1 and cast into int32
value = self.reshape(value, (-1, 1))
out_of_bound = self.squeeze_last_axis(self.logicor(\
self.less(value, 0.0), self.less(num_classes-1, value)))
# deal with the case the there is only one class.
value_clipped = self.clip_by_value(value, 0.0, num_classes - 1)
value_clipped = self.cast(value_clipped, self.index_type)
# create index from 0 ... NumOfLabels
index = self.reshape(nn.Range(0, self.shape(value)[0], 1)(), (-1, 1))
index = self.concat((index, value_clipped))
# index into logit_pmf, fill in out_of_bound places with -inf
# reshape into label shape N
logits_pmf = self.gather(self.reshape(logits, (-1, num_classes)),
index)
nan = self.fill(self.dtypeop(logits_pmf), self.shape(logits_pmf),
self.nan)
logits_pmf = self.select(out_of_bound, nan, logits_pmf)
ans = self.reshape(logits_pmf, label_shape)
if drop_dim:
return self.squeeze(ans)
return ans
# input two tensors, their shapes do not match
('FloorDiv2', {
'block': (P.FloorDiv(), {
'exception': ValueError,
'error_keywords': ['FloorDiv']
}),
'desc_inputs': [
Tensor(np.ones([3, 5]).astype(np.float32)),
Tensor(np.ones([3, 4]).astype(np.float32))
],
'skip': ['backward']
}),
# input x is Tensor(int32), not Tensor(float)
('Floor1', {
'block': (P.Floor(), {
'exception': TypeError,
'error_keywords': ['Floor']
}),
'desc_inputs': [Tensor(np.ones([2, 3]).astype(np.int32))],
'skip': ['backward']
}),
# input two tensors, their shapes do not match
('FFloorMod2', {
'block': (P.FloorMod(), {
'exception': ValueError,
'error_keywords': ['FloorMod']
}),
'desc_inputs': [
Tensor(np.ones([3, 5]).astype(np.float32)),
'desc_inputs': [[2, 3, 3, 5]],
'desc_bprop': [[2, 3, 3, 5]]}),
('Pow_1', {
'block': P.Pow(),
'desc_inputs': [[3, 5], [2, 3, 3, 5]],
'desc_bprop': [[2, 3, 3, 5]]}),
('Exp', {
'block': P.Exp(),
'desc_inputs': [[2, 3]],
'desc_bprop': [[2, 3]]}),
('Erf', {
'block': P.Erf(),
'desc_inputs': [Tensor(np.array([-2, -1, 0, 1, 2]).astype(np.float16))],
'desc_bprop': [Tensor(np.array([-2, -1, 0, 1, 2]).astype(np.float16))]}),
('Floor', {
'block': P.Floor(),
'desc_inputs': [[2, 512, 56, 56]],
'desc_bprop': [[2, 512, 56, 56]],
'skip': ['backward']}),
('ACos', {
'block': P.ACos(),
'desc_inputs': [[2, 3]],
'desc_bprop': [[2, 3]]}),
('Acosh', {
'block': P.Acosh(),
'desc_inputs': [Tensor(np.random.rand(4).astype(np.float16))],
'skip': ['backward']}),
('Sin', {
'block': P.Sin(),
'desc_inputs': [[2, 3]],
'desc_bprop': [[2, 3]]}),
def __init__(self):
super(FloorNet, self).__init__()
self.floor = P.Floor()
def bilinear_sampler(self, img, x, y):
"""
Performs bilinear sampling of the input images according to the
normalized coordinates provided by the sampling grid. Note that
the sampling is done identically for each channel of the input.
To test if the function works properly, output image should be
identical to input image when theta is initialized to identity
transform.
Input
-----
- img: batch of images in (B, H, W, C) layout.
- grid: x, y which is the output of affine_grid_generator.
Returns
-------
- out: interpolated images according to grids. Same size as grid.
"""
shape = P.Shape()
H = shape(img)[1]
W = shape(img)[2]
cast = P.Cast()
max_y = cast(H - 1, mindspore.float32)
max_x = cast(W - 1, mindspore.float32)
zero = self.zero
# rescale x and y to [0, W-1/H-1]
x = 0.5 * ((x + 1.0) * (max_x - 1))
y = 0.5 * ((y + 1.0) * (max_y - 1))
# grab 4 nearest corner points for each (x_i, y_i)
floor = P.Floor()
x0 = floor(x)
x1 = x0 + 1
y0 = floor(y)
y1 = y0 + 1
# clip to range [0, H-1/W-1] to not violate img boundaries
x0 = C.clip_by_value(x0, zero, max_x)
x1 = C.clip_by_value(x1, zero, max_x)
y0 = C.clip_by_value(y0, zero, max_y)
y1 = C.clip_by_value(y1, zero, max_y)
# get pixel value at corner coords
Ia = self.get_pixel_value(img, x0, y0)
Ib = self.get_pixel_value(img, x0, y1)
Ic = self.get_pixel_value(img, x1, y0)
Id = self.get_pixel_value(img, x1, y1)
# recast as float for delta calculation
x0 = cast(x0, mindspore.float32)
x1 = cast(x1, mindspore.float32)
y0 = cast(y0, mindspore.float32)
y1 = cast(y1, mindspore.float32)
# calculate deltas
wa = (x1 - x) * (y1 - y)
wb = (x1 - x) * (y - y0)
wc = (x - x0) * (y1 - y)
wd = (x - x0) * (y - y0)
# add dimension for addition
expand_dims = P.ExpandDims()
wa = expand_dims(wa, 3)
wb = expand_dims(wb, 3)
wc = expand_dims(wc, 3)
wd = expand_dims(wd, 3)
# compute output
add_n = P.AddN()
out = add_n([wa * Ia, wb * Ib, wc * Ic, wd * Id])
return out
def __init__(self, strategy1, strategy2):
super().__init__()
self.matmul = P.MatMul().shard(strategy1)
self.floor = P.Floor().shard(strategy2)
self.matmul2 = P.MatMul().shard(strategy1)
