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