def forward(self, inputs):
"""
Get SOLOv2MaskHead output.
Args:
inputs(list[Tensor]): feature map from each necks with shape of [N, C, H, W]
Returns:
ins_pred(Tensor): Output of SOLOv2MaskHead head
"""
feat_all_level = F.relu(self.convs_all_levels[0](inputs[0]))
for i in range(1, self.range_level):
input_p = inputs[i]
if i == (self.range_level - 1):
input_feat = input_p
x_range = paddle.linspace(
-1, 1, paddle.shape(input_feat)[-1], dtype='float32')
y_range = paddle.linspace(
-1, 1, paddle.shape(input_feat)[-2], dtype='float32')
y, x = paddle.meshgrid([y_range, x_range])
x = paddle.unsqueeze(x, [0, 1])
y = paddle.unsqueeze(y, [0, 1])
y = paddle.expand(
y, shape=[paddle.shape(input_feat)[0], 1, -1, -1])
x = paddle.expand(
x, shape=[paddle.shape(input_feat)[0], 1, -1, -1])
coord_feat = paddle.concat([x, y], axis=1)
input_p = paddle.concat([input_p, coord_feat], axis=1)
feat_all_level = paddle.add(feat_all_level,
self.convs_all_levels[i](input_p))
ins_pred = F.relu(self.conv_pred(feat_all_level))
return ins_pred
def test_dtype(self):
out_1 = paddle.linspace(0, 10, 5, dtype='float32')
out_2 = paddle.linspace(0, 10, 5, dtype=np.float32)
out_3 = paddle.linspace(0, 10, 5, dtype=core.VarDesc.VarType.FP32)
exe = fluid.Executor(place=fluid.CPUPlace())
res_1, res_2, res_3 = exe.run(fluid.default_main_program(),
fetch_list=[out_1, out_2, out_3])
assert np.array_equal(res_1, res_2)
def calculate_weights_indices(in_length, out_length, scale, kernel,
kernel_width, antialiasing):
if (scale < 1) and (antialiasing):
# Use a modified kernel to simultaneously interpolate and antialias- larger kernel width
kernel_width = kernel_width / scale
# Output-space coordinates
x = paddle.linspace(1, out_length, out_length)
# Input-space coordinates. Calculate the inverse mapping such that 0.5
# in output space maps to 0.5 in input space, and 0.5+scale in output
# space maps to 1.5 in input space.
u = x / scale + 0.5 * (1 - 1 / scale)
# What is the left-most pixel that can be involved in the computation?
left = paddle.floor(u - kernel_width / 2)
# What is the maximum number of pixels that can be involved in the
# computation? Note: it's OK to use an extra pixel here; if the
# corresponding weights are all zero, it will be eliminated at the end
# of this function.
P = math.ceil(kernel_width) + 2
# The indices of the input pixels involved in computing the k-th output
# pixel are in row k of the indices matrix.
indices = left.reshape(
[out_length, 1]).expand([out_length, P]) + paddle.linspace(
0, P - 1, P).reshape([1, P]).expand([out_length, P])
# The weights used to compute the k-th output pixel are in row k of the
# weights matrix.
distance_to_center = u.reshape([out_length, 1]).expand([out_length, P
]) - indices
# apply cubic kernel
if (scale < 1) and (antialiasing):
weights = scale * cubic(distance_to_center * scale)
else:
weights = cubic(distance_to_center)
# Normalize the weights matrix so that each row sums to 1.
weights_sum = paddle.sum(weights, 1).reshape([out_length, 1])
weights = weights / weights_sum.expand([out_length, P])
# If a column in weights is all zero, get rid of it. only consider the first and last column.
weights_zero_tmp = np.sum((weights.numpy() == 0), 0)
if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6):
indices = indices[:, 1:1 + P - 2]
weights = weights[:, 1:1 + P - 2]
if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6):
indices = indices[:, 0:P - 2]
weights = weights[:, 0:P - 2]
sym_len_s = -indices.min() + 1
sym_len_e = indices.max() - in_length
indices = indices + sym_len_s - 1
return weights, indices, int(sym_len_s), int(sym_len_e)
def test_imperative(self):
paddle.disable_static()
out1 = paddle.linspace(0, 10, 5, dtype='float32')
np_out1 = np.linspace(0, 10, 5, dtype='float32')
out2 = paddle.linspace(0, 10, 5, dtype='int32')
np_out2 = np.linspace(0, 10, 5, dtype='int32')
out3 = paddle.linspace(0, 10, 200, dtype='int32')
np_out3 = np.linspace(0, 10, 200, dtype='int32')
paddle.enable_static()
self.assertEqual((out1.numpy() == np_out1).all(), True)
self.assertEqual((out2.numpy() == np_out2).all(), True)
self.assertEqual((out3.numpy() == np_out3).all(), True)
def _get_output_single(self, input, idx, is_eval=False):
ins_kernel_feat = input
# CoordConv
x_range = paddle.linspace(-1,
1,
fluid.layers.shape(ins_kernel_feat)[-1],
dtype='float32')
y_range = paddle.linspace(-1,
1,
fluid.layers.shape(ins_kernel_feat)[-2],
dtype='float32')
y, x = paddle.tensor.meshgrid([y_range, x_range])
x = fluid.layers.unsqueeze(x, [0, 1])
y = fluid.layers.unsqueeze(y, [0, 1])
y = fluid.layers.expand(
y, expand_times=[fluid.layers.shape(ins_kernel_feat)[0], 1, 1, 1])
x = fluid.layers.expand(
x, expand_times=[fluid.layers.shape(ins_kernel_feat)[0], 1, 1, 1])
coord_feat = fluid.layers.concat([x, y], axis=1)
ins_kernel_feat = fluid.layers.concat([ins_kernel_feat, coord_feat],
axis=1)
# kernel branch
kernel_feat = ins_kernel_feat
seg_num_grid = self.seg_num_grids[idx]
kernel_feat = paddle.nn.functional.interpolate(
kernel_feat,
size=[seg_num_grid, seg_num_grid],
mode='bilinear',
align_corners=False,
align_mode=0)
cate_feat = kernel_feat[:, :-2, :, :]
kernel_pred = self._conv_pred(kernel_feat,
self.kernel_out_channels,
is_eval,
name='bbox_head.kernel_convs',
name_feat='bbox_head.solo_kernel')
# cate branch
cate_pred = self._conv_pred(cate_feat,
self.cate_out_channels,
is_eval,
name='bbox_head.cate_convs',
name_feat='bbox_head.solo_cate')
if is_eval:
cate_pred = self._points_nms(fluid.layers.sigmoid(cate_pred),
kernel=2)
cate_pred = fluid.layers.transpose(cate_pred, [0, 2, 3, 1])
return cate_pred, kernel_pred
def _affine_grid(theta, w, h, ow, oh):
d = 0.5
base_grid = paddle.ones((1, oh, ow, 3), dtype=theta.dtype)
x_grid = paddle.linspace(-ow * 0.5 + d, ow * 0.5 + d - 1, ow)
base_grid[..., 0] = x_grid
y_grid = paddle.linspace(-oh * 0.5 + d, oh * 0.5 + d - 1, oh).unsqueeze_(-1)
base_grid[..., 1] = y_grid
scaled_theta = theta.transpose(
(0, 2, 1)) / paddle.to_tensor([0.5 * w, 0.5 * h])
output_grid = base_grid.reshape((1, oh * ow, 3)).bmm(scaled_theta)
return output_grid.reshape((1, oh, ow, 2))
def flow_warp(self, input, flow, size):
input_shape = paddle.shape(input)
norm = size[::-1].reshape([1, 1, 1, -1])
h_grid = paddle.linspace(-1.0, 1.0, size[0]).reshape([-1, 1])
h_grid = h_grid.tile([size[1]])
w_grid = paddle.linspace(-1.0, 1.0, size[1]).reshape([-1, 1])
w_grid = w_grid.tile([size[0]]).transpose([1, 0])
grid = paddle.concat(
[w_grid.unsqueeze(2), h_grid.unsqueeze(2)], axis=2)
grid.unsqueeze(0).tile([input_shape[0], 1, 1, 1])
grid = grid + paddle.transpose(flow, (0, 2, 3, 1)) / norm
output = F.grid_sample(input, grid)
return output
def get_reference_points(spatial_shapes, valid_ratios):
valid_ratios = valid_ratios.unsqueeze(1)
reference_points = []
for i, (H, W) in enumerate(spatial_shapes.tolist()):
ref_y, ref_x = paddle.meshgrid(paddle.linspace(0.5, H - 0.5, H),
paddle.linspace(0.5, W - 0.5, W))
ref_y = ref_y.flatten().unsqueeze(0) / (valid_ratios[:, :, i, 1] *
H)
ref_x = ref_x.flatten().unsqueeze(0) / (valid_ratios[:, :, i, 0] *
W)
reference_points.append(paddle.stack((ref_x, ref_y), axis=-1))
reference_points = paddle.concat(reference_points, 1).unsqueeze(2)
reference_points = reference_points * valid_ratios
return reference_points
def __init__(self,
img_size=224,
patch_size=16,
in_chans=3,
class_num=1000,
embed_dims=[64, 128, 256, 512],
num_heads=[1, 2, 4, 8],
mlp_ratios=[4, 4, 4, 4],
qkv_bias=False,
qk_scale=None,
drop_rate=0.,
attn_drop_rate=0.,
drop_path_rate=0.,
norm_layer=nn.LayerNorm,
depths=[3, 4, 6, 3],
sr_ratios=[8, 4, 2, 1],
num_stages=4,
linear=False):
super().__init__()
self.class_num = class_num
self.depths = depths
self.num_stages = num_stages
dpr = [x for x in paddle.linspace(0, drop_path_rate, sum(depths))
] # stochastic depth decay rule
cur = 0
for i in range(num_stages):
patch_embed = OverlapPatchEmbed(
img_size=img_size if i == 0 else img_size // (2**(i + 1)),
patch_size=7 if i == 0 else 3,
stride=4 if i == 0 else 2,
in_chans=in_chans if i == 0 else embed_dims[i - 1],
embed_dim=embed_dims[i])
block = nn.LayerList([
Block(dim=embed_dims[i],
num_heads=num_heads[i],
mlp_ratio=mlp_ratios[i],
qkv_bias=qkv_bias,
qk_scale=qk_scale,
drop=drop_rate,
attn_drop=attn_drop_rate,
drop_path=dpr[cur + j],
norm_layer=norm_layer,
sr_ratio=sr_ratios[i],
linear=linear) for j in range(depths[i])
])
norm = norm_layer(embed_dims[i])
cur += depths[i]
setattr(self, f"patch_embed{i + 1}", patch_embed)
setattr(self, f"block{i + 1}", block)
setattr(self, f"norm{i + 1}", norm)
# classification head
self.head = nn.Linear(embed_dims[3],
class_num) if class_num > 0 else Identity()
self.apply(self._init_weights)
def forward(self):
start = self.config["start"]
stop = self.config["stop"]
num = self.config["num"]
dtype = self.config["dtype"]
x = paddle.linspace(start=start, stop=stop, num=num, dtype=dtype)
return x
def _get_output_single(self, input, idx):
ins_kernel_feat = input
# CoordConv
x_range = paddle.linspace(-1,
1,
paddle.shape(ins_kernel_feat)[-1],
dtype='float32')
y_range = paddle.linspace(-1,
1,
paddle.shape(ins_kernel_feat)[-2],
dtype='float32')
y, x = paddle.meshgrid([y_range, x_range])
x = paddle.unsqueeze(x, [0, 1])
y = paddle.unsqueeze(y, [0, 1])
y = paddle.expand(y,
shape=[paddle.shape(ins_kernel_feat)[0], 1, -1, -1])
x = paddle.expand(x,
shape=[paddle.shape(ins_kernel_feat)[0], 1, -1, -1])
coord_feat = paddle.concat([x, y], axis=1)
ins_kernel_feat = paddle.concat([ins_kernel_feat, coord_feat], axis=1)
# kernel branch
kernel_feat = ins_kernel_feat
seg_num_grid = self.seg_num_grids[idx]
kernel_feat = F.interpolate(kernel_feat,
size=[seg_num_grid, seg_num_grid],
mode='bilinear',
align_corners=False,
align_mode=0)
cate_feat = kernel_feat[:, :-2, :, :]
for kernel_layer in self.kernel_pred_convs:
kernel_feat = F.relu(kernel_layer(kernel_feat))
if self.drop_block and self.training:
kernel_feat = self.drop_block_fun(kernel_feat)
kernel_pred = self.solo_kernel(kernel_feat)
# cate branch
for cate_layer in self.cate_pred_convs:
cate_feat = F.relu(cate_layer(cate_feat))
if self.drop_block and self.training:
cate_feat = self.drop_block_fun(cate_feat)
cate_pred = self.solo_cate(cate_feat)
if not self.training:
cate_pred = self._points_nms(F.sigmoid(cate_pred), kernel_size=2)
cate_pred = paddle.transpose(cate_pred, [0, 2, 3, 1])
return cate_pred, kernel_pred
def test_name(self):
with paddle.static.program_guard(paddle.static.Program()):
out = paddle.linspace(0,
10,
5,
dtype='float32',
name='linspace_res')
assert 'linspace_res' in out.name
def flow_warp(self, input, flow, size):
out_h, out_w = size
n, c, h, w = input.shape
norm = paddle.to_tensor(np.array([[[[out_w, out_h]]]]),
dtype='float32')
h_grid = paddle.linspace(-1.0, 1.0, out_h).reshape([-1, 1])
h_grid = paddle.concat([h_grid] * out_w, axis=1)
w_grid = paddle.linspace(-1.0, 1.0, out_w).reshape([1, -1])
w_grid = paddle.concat([w_grid] * out_h, axis=0)
grid = paddle.concat(
[w_grid.unsqueeze(2), h_grid.unsqueeze(2)], axis=2)
grid = paddle.concat([grid.unsqueeze(0)] * n, axis=0)
grid = grid + paddle.transpose(flow, (0, 2, 3, 1)) / norm
output = F.grid_sample(input, grid)
return output
def test_variable_input1(self):
start = paddle.full(shape=[1], fill_value=0, dtype='float32')
stop = paddle.full(shape=[1], fill_value=10, dtype='float32')
num = paddle.full(shape=[1], fill_value=5, dtype='int32')
out = paddle.linspace(start, stop, num, dtype='float32')
exe = fluid.Executor(place=fluid.CPUPlace())
res = exe.run(fluid.default_main_program(), fetch_list=[out])
np_res = np.linspace(0, 10, 5, dtype='float32')
self.assertEqual((res == np_res).all(), True)
def test_variable_input2(self):
paddle.disable_static()
start = paddle.full(shape=[1], fill_value=0, dtype='float32')
stop = paddle.full(shape=[1], fill_value=10, dtype='float32')
num = paddle.full(shape=[1], fill_value=5, dtype='int32')
out = paddle.linspace(start, stop, num, dtype='float32')
np_res = np.linspace(0, 10, 5, dtype='float32')
self.assertEqual((out.numpy() == np_res).all(), True)
paddle.enable_static()
def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,
embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24],
window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,
drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
norm_layer=nn.LayerNorm, ape=False, patch_norm=True,
**kwargs):
super().__init__()
self.num_classes = num_classes
self.num_layers = len(depths)
self.embed_dim = embed_dim
self.ape = ape
self.patch_norm = patch_norm
self.num_features = int(embed_dim * 2 ** (self.num_layers - 1))
self.mlp_ratio = mlp_ratio
# split image into non-overlapping patches
self.patch_embed = PatchEmbed(
img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
norm_layer=norm_layer if self.patch_norm else None)
num_patches = self.patch_embed.num_patches
patches_resolution = self.patch_embed.patches_resolution
self.patches_resolution = patches_resolution
# absolute position embedding
if self.ape:
self.absolute_pos_embed = self.create_parameter(shape=(1, num_patches, embed_dim),default_initializer=nn.initializer.Constant(value=0))
self.add_parameter("absolute_pos_embed", self.absolute_pos_embed)
self.pos_drop = nn.Dropout(p=drop_rate)
# stochastic depth
dpr = [x for x in paddle.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule
# build layers
self.layers = nn.LayerList()
for i_layer in range(self.num_layers):
layer = BasicLayer(dim=int(embed_dim * 2 ** i_layer),
input_resolution=(patches_resolution[0] // (2 ** i_layer),
patches_resolution[1] // (2 ** i_layer)),
depth=depths[i_layer],
num_heads=num_heads[i_layer],
window_size=window_size,
mlp_ratio=self.mlp_ratio,
qkv_bias=qkv_bias, qk_scale=qk_scale,
drop=drop_rate, attn_drop=attn_drop_rate,
drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
norm_layer=norm_layer,
downsample=PatchMerging if (i_layer < self.num_layers - 1) else None
)
self.layers.append(layer)
self.norm = norm_layer(self.num_features)
self.avgpool = nn.AdaptiveAvgPool1D(1)
self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else Identity()
self.apply(self._init_weights)
def __init__(self, K, cut_r, requires_grad=False):
super(DistRBF, self).__init__()
self.K = K
self.cut_r = cut_r
# self.mu = self.create_parameter(paddle.linspace(math.exp(-cut_r), 1., K).unsqueeze(0))
# self.beta = self.create_parameter(paddle.full((1, K), math.pow((2 / K) * (1 - math.exp(-cut_r)), -2)))
self.mu = paddle.linspace(math.exp(-cut_r), 1., K).unsqueeze(0)
self.beta = paddle.full((1, K),
math.pow((2 / K) * (1 - math.exp(-cut_r)), -2))
def get_output(self, inputs):
"""
Get SOLOv2MaskHead output.
Args:
inputs(list[Variable]): feature map from each necks with shape of [N, C, H, W]
Returns:
ins_pred(Variable): Output of SOLOv2MaskHead head
"""
range_level = self.end_level - self.start_level + 1
feature_add_all_level = self._convs_levels(
inputs[0], 0, name='mask_feat_head.convs_all_levels.0')
for i in range(1, range_level):
input_p = inputs[i]
if i == (range_level - 1):
input_feat = input_p
x_range = paddle.linspace(-1,
1,
fluid.layers.shape(input_feat)[-1],
dtype='float32')
y_range = paddle.linspace(-1,
1,
fluid.layers.shape(input_feat)[-2],
dtype='float32')
y, x = paddle.tensor.meshgrid([y_range, x_range])
x = fluid.layers.unsqueeze(x, [0, 1])
y = fluid.layers.unsqueeze(y, [0, 1])
y = fluid.layers.expand(
y,
expand_times=[fluid.layers.shape(input_feat)[0], 1, 1, 1])
x = fluid.layers.expand(
x,
expand_times=[fluid.layers.shape(input_feat)[0], 1, 1, 1])
coord_feat = fluid.layers.concat([x, y], axis=1)
input_p = fluid.layers.concat([input_p, coord_feat], axis=1)
feature_add_all_level = fluid.layers.elementwise_add(
feature_add_all_level,
self._convs_levels(
input_p,
i,
name='mask_feat_head.convs_all_levels.{}'.format(i)))
ins_pred = self._conv_pred(feature_add_all_level)
return ins_pred
def _get_magnitudes():
_BINS = 10
return {
# name: (magnitudes, signed)
"ShearX": (paddle.linspace(0.0, 0.3, _BINS), True),
"ShearY": (paddle.linspace(0.0, 0.3, _BINS), True),
"TranslateX": (paddle.linspace(0.0, 150.0 / 331.0, _BINS), True),
"TranslateY": (paddle.linspace(0.0, 150.0 / 331.0, _BINS), True),
"Rotate": (paddle.linspace(0.0, 30.0, _BINS), True),
"Brightness": (paddle.linspace(0.0, 0.9, _BINS), True),
"Color": (paddle.linspace(0.0, 0.9, _BINS), True),
"Contrast": (paddle.linspace(0.0, 0.9, _BINS), True),
"Sharpness": (paddle.linspace(0.0, 0.9, _BINS), True),
"Posterize": (paddle.tensor([8, 8, 7, 7, 6, 6, 5, 5, 4, 4]), False),
"Solarize": (paddle.linspace(256.0, 0.0, _BINS), False),
"AutoContrast": (None, None),
"Equalize": (None, None),
"Invert": (None, None),
}
def build_C_paddle(self):
""" Return coordinates of fiducial points in I_r; C """
F = self.F
ctrl_pts_x = paddle.linspace(-1.0, 1.0, int(F / 2), dtype='float64')
ctrl_pts_y_top = -1 * paddle.ones([int(F / 2)], dtype='float64')
ctrl_pts_y_bottom = paddle.ones([int(F / 2)], dtype='float64')
ctrl_pts_top = paddle.stack([ctrl_pts_x, ctrl_pts_y_top], axis=1)
ctrl_pts_bottom = paddle.stack([ctrl_pts_x, ctrl_pts_y_bottom], axis=1)
C = paddle.concat([ctrl_pts_top, ctrl_pts_bottom], axis=0)
return C # F x 2
def _perspective_grid(img, coeffs, ow, oh, dtype):
theta1 = coeffs[:6].reshape([1, 2, 3])
tmp = paddle.tile(coeffs[6:].reshape([1, 2]), repeat_times=[2, 1])
dummy = paddle.ones((2, 1), dtype=dtype)
theta2 = paddle.concat((tmp, dummy), axis=1).unsqueeze(0)
d = 0.5
base_grid = paddle.ones((1, oh, ow, 3), dtype=dtype)
x_grid = paddle.linspace(d, ow * 1.0 + d - 1.0, ow)
base_grid[..., 0] = x_grid
y_grid = paddle.linspace(d, oh * 1.0 + d - 1.0, oh).unsqueeze_(-1)
base_grid[..., 1] = y_grid
scaled_theta1 = theta1.transpose(
(0, 2, 1)) / paddle.to_tensor([0.5 * ow, 0.5 * oh])
output_grid1 = base_grid.reshape((1, oh * ow, 3)).bmm(scaled_theta1)
output_grid2 = base_grid.reshape(
(1, oh * ow, 3)).bmm(theta2.transpose((0, 2, 1)))
output_grid = output_grid1 / output_grid2 - 1.0
return output_grid.reshape((1, oh, ow, 2))
def __init__(self,
img_size=224,
patch_size=4,
in_chans=3,
class_num=1000,
embed_dims=[64, 128, 256],
num_heads=[1, 2, 4],
mlp_ratios=[4, 4, 4],
qkv_bias=False,
qk_scale=None,
drop_rate=0.,
attn_drop_rate=0.,
drop_path_rate=0.,
norm_layer=nn.LayerNorm,
depths=[4, 4, 4],
sr_ratios=[4, 2, 1],
block_cls=GroupBlock,
wss=[7, 7, 7]):
super().__init__(img_size, patch_size, in_chans, class_num, embed_dims,
num_heads, mlp_ratios, qkv_bias, qk_scale, drop_rate,
attn_drop_rate, drop_path_rate, norm_layer, depths,
sr_ratios, block_cls)
del self.blocks
self.wss = wss
# transformer encoder
dpr = [
x.numpy()[0]
for x in paddle.linspace(0, drop_path_rate, sum(depths))
] # stochastic depth decay rule
cur = 0
self.blocks = nn.LayerList()
for k in range(len(depths)):
_block = nn.LayerList([
block_cls(dim=embed_dims[k],
num_heads=num_heads[k],
mlp_ratio=mlp_ratios[k],
qkv_bias=qkv_bias,
qk_scale=qk_scale,
drop=drop_rate,
attn_drop=attn_drop_rate,
drop_path=dpr[cur + i],
norm_layer=norm_layer,
sr_ratio=sr_ratios[k],
ws=1 if i % 2 == 1 else wss[k])
for i in range(depths[k])
])
self.blocks.append(_block)
cur += depths[k]
self.apply(self._init_weights)
def get_loss(obs, action, reward, next_obs, done):
# 计算损失
delta_z = float(v_max - v_min) / (atoms - 1)
with paddle.no_grad():
next_action = targetQ(next_obs) * supports
next_action = paddle.argmax(paddle.sum(next_action, axis=2), axis=1)
next_dist = targetQ(next_obs)
next_dist = next_dist[:batch_size, ]
_next_dist = paddle.gather(next_dist, next_action, axis=1)
eyes = np.eye(_next_dist.shape[0],
_next_dist.shape[1]).astype("float32")
eyes = np.repeat(eyes, _next_dist.shape[-1]).reshape(
(-1, _next_dist.shape[1], _next_dist.shape[-1]))
eyes = paddle.to_tensor(eyes)
next_dist = _next_dist.multiply(eyes).sum(1)
t_z = (reward + (1 - done) * gamma).unsqueeze(1) * supports
t_z = t_z.clip(min=v_min, max=v_max)
b = (t_z - v_min) / delta_z
l = b.floor().cast("int64")
u = b.ceil().cast("int64")
offset = (paddle.linspace(
0, (batch_size - 1) * atoms,
batch_size).cast("int64").unsqueeze(1).expand([batch_size, atoms]))
proj_dist = paddle.zeros(next_dist.shape)
proj_dist = index_add_(
proj_dist.reshape([-1]), 0, (l + offset).reshape([-1]),
(next_dist * (u.cast("float32") - b)).reshape([-1]))
proj_dist = index_add_(
proj_dist.reshape([-1]), 0, (u + offset).reshape([-1]),
(next_dist * (b - l.cast("float32"))).reshape([-1]))
proj_dist = proj_dist.reshape(next_dist.shape)
dist = policyQ(obs)
_dist = paddle.gather(dist[:batch_size, ], action, axis=1)
eyes = np.eye(_dist.shape[0], _dist.shape[1]).astype("float32")
eyes = np.repeat(eyes, _dist.shape[-1]).reshape(
(-1, _dist.shape[1], _dist.shape[-1]))
eyes = paddle.to_tensor(eyes)
dist_batch = _dist.multiply(eyes).sum(1)
log_p = paddle.log(dist_batch)
loss = -(proj_dist * log_p).sum(1).mean()
return loss
def general_cosine(M: int,
a: float,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a generic weighted sum of cosine terms window.
This function is consistent with scipy.signal.windows.general_cosine().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
fac = paddle.linspace(-math.pi, math.pi, M, dtype=dtype)
w = paddle.zeros((M, ), dtype=dtype)
for k in range(len(a)):
w += a[k] * paddle.cos(k * fac)
return _truncate(w, needs_trunc)
def reset_drop_path(self, drop_path_rate):
dpr = [
x.item()
for x in paddle.linspace(0, drop_path_rate, sum(self.depths))
]
cur = 0
for i in range(self.depths[0]):
self.block1[i].drop_path.drop_prob = dpr[cur + i]
cur += self.depths[0]
for i in range(self.depths[1]):
self.block2[i].drop_path.drop_prob = dpr[cur + i]
cur += self.depths[1]
for i in range(self.depths[2]):
self.block3[i].drop_path.drop_prob = dpr[cur + i]
cur += self.depths[2]
for i in range(self.depths[3]):
self.block4[i].drop_path.drop_prob = dpr[cur + i]
def make_beta_schedule(schedule,
n_timestep,
linear_start=1e-4,
linear_end=2e-2,
cosine_s=8e-3):
if schedule == "linear":
betas = (paddle.linspace(linear_start**0.5,
linear_end**0.5,
n_timestep,
dtype=np.float64)**2)
elif schedule == "cosine":
timesteps = (
paddle.arange(n_timestep + 1, dtype=np.float64) / n_timestep +
cosine_s)
alphas = timesteps / (1 + cosine_s) * math.pi / 2
alphas = paddle.cos(alphas).pow(2)
alphas = alphas / alphas[0]
betas = 1 - alphas[1:] / alphas[:-1]
betas = betas.clip(max=0.999)
return betas
def mel_frequencies(n_mels: int = 128,
f_min: float = 0.0,
f_max: float = 11025.0,
htk: bool = False,
dtype: str = 'float64') -> Tensor:
"""Compute mel frequencies.
Parameters:
n_mels(int): number of Mel bins.
f_min(float): the lower cut-off frequency, below which the filter response is zero.
f_max(float): the upper cut-off frequency, above which the filter response is zero.
htk(bool): whether to use htk formula.
dtype(str): the datatype of the return frequencies.
Returns:
The frequencies represented in Mel-scale
Notes:
This function is consistent with librosa.mel_frequencies().
Examples:
.. code-block:: python
import paddle
import paddleaudio.functional as F
print(F.mel_frequencies(8))
>> Tensor(shape=[8], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[0., 475.33898926, 950.67797852, 1551.68481445, 2533.36230469,
4136.09960938, 6752.81396484, 11024.99902344])
"""
# 'Center freqs' of mel bands - uniformly spaced between limits
min_mel = hz_to_mel(f_min, htk=htk)
max_mel = hz_to_mel(f_max, htk=htk)
mels = paddle.linspace(min_mel, max_mel, n_mels, dtype=dtype)
freqs = mel_to_hz(mels, htk=htk)
return freqs
def bohman(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a Bohman window.
The Bohman window is the autocorrelation of a cosine window.
Parameters:
M(int): window size.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.bohman().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
fac = paddle.abs(paddle.linspace(-1, 1, M, dtype=dtype)[1:-1])
w = (1 - fac) * paddle.cos(math.pi * fac) + 1.0 / math.pi * paddle.sin(
math.pi * fac)
w = _cat([0, w, 0], dtype)
return _truncate(w, needs_trunc)
def fft_frequencies(sr: int, n_fft: int, dtype: str = 'float64') -> Tensor:
"""Compute fourier frequencies.
Parameters:
sr(int): the audio sample rate.
n_fft(float): the number of fft bins.
dtype(str): the datatype of the return frequencies.
Returns:
The frequencies represented in hz.
Notes:
This function is consistent with librosa.fft_frequencies().
Examples:
.. code-block:: python
import paddle
import paddleaudio.functional as F
print(F.fft_frequencies(16000, 512))
>> Tensor(shape=[257], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[0., 31.25000000, 62.50000000, ...]
"""
return paddle.linspace(0, float(sr) / 2, int(1 + n_fft // 2), dtype=dtype)
def forward(self, input_ids, token_type_ids=None, position_ids=None):
if position_ids is None:
ones = paddle.ones_like(input_ids, dtype="int64")
seq_length = paddle.cumsum(ones, axis=-1)
content_len = paddle.shape(input_ids)[1] - self.cls_num
position_ids = paddle.concat([
paddle.zeros(shape=[self.cls_num], dtype="int64"),
paddle.linspace(1, content_len, content_len, dtype="int64")
])
position_ids.stop_gradient = True
if token_type_ids is None:
token_type_ids = paddle.zeros_like(input_ids, dtype="int64")
input_embedings = self.word_embeddings(input_ids)
position_embeddings = self.position_embeddings(position_ids)
token_type_embeddings = self.token_type_embeddings(token_type_ids)
embeddings = input_embedings + token_type_embeddings + position_embeddings
embeddings = self.layer_norm(embeddings)
embeddings = self.dropout(embeddings)
return embeddings
