depthwise-seperate conv 深度可分离卷积解释和pytorch滤波

已于 2023-09-25 10:58:38 修改
阅读量459 收藏 1
点赞数
分类专栏： pytorch 文章标签： python 深度学习
于 2023-02-01 10:19:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tywwwww/article/details/128827949
版权

文章目录

1.关于depthwise-seperate conv 概念解释

主要包括depthwise conv 和 pointwise conv

在这里插入图片描述

优点是

  1. 参数少，避免过拟合
  2. 计算量小

以一个示例说明参数大小，输入输出

"""
Normal Convolution and depthwise-separable convolutions
should output a vector with the same dimensions
input shape = 3, 28, 38 (RGB image of 28x 28)
output shape = 10, 28, 28 (10 output channels with same width and height)
"""
import torch
import torch.nn as nn

input = torch.rand(3, 28, 28)

### Conv2d (normal)
conv_layer= nn.Conv2d(in_channels=3, out_channels=10, kernel_size=3, padding=1)
print([[p.shape, p.name, p.requires_grad, p.numel()] for p in conv_layer.parameters()])
print(conv_layer.weight.shape, conv_layer.bias.shape)

conv_layer_n_params = sum(p.numel() for p in conv_layer.parameters() if p.requires_grad)
conv_out = conv_layer(input)
print(f"Conv layer param numbers: {conv_layer_n_params}")
print(conv_out.shape)
print('********************************************************')
### Depthwise convolution
# by adding 'groups' param, you perform depthwise conv
depthwise_layer= nn.Conv2d(in_channels=3, out_channels=3, kernel_size=3, padding=1, groups=3)
depthwise_layer_n_params = sum(p.numel() for p in depthwise_layer.parameters() if p.requires_grad)
depthwise_out = depthwise_layer(input)
print([[p.shape, p.name, p.requires_grad, p.numel()] for p in depthwise_layer.parameters()])
print(f"DepthwiseConv layer param numbers: {depthwise_layer_n_params}")
print(depthwise_out.shape)
print('********************************************************')
### Pointwise Convolution (using depthwise output) <-- This is called DEPTHWISE-SEPARABLE CONVOLUTION
pointwise_layer = nn.Conv2d(in_channels=3, out_channels=10, kernel_size=1)
pointwise_layer_n_params = sum(p.numel() for p in pointwise_layer.parameters() if p.requires_grad)
pointwise_out = pointwise_layer(depthwise_out)
print([[p.shape, p.name, p.requires_grad, p.numel()] for p in pointwise_layer.parameters()])
print(f"PointwiseConv layer param numbers: {pointwise_layer_n_params}")
print(pointwise_out.shape)

print(f"\nConv params: {conv_layer_n_params} / Depthwise-separable

运行结果：
在这里插入图片描述

2.利用torch.nn.Conv2d来做图像滤波

类似于cv2.filter2D 和 ndimage.convolve

im_enhance5_torch 一次处理单通道。
im_enhance5_torch_depthwise 可以同时处理多通道。

2.1 pytorch 滤波函数，自定义滤波核


def im_enhance5_torch(img,  amount = 1.6):
    """
    img: h, w   raw float32  torch.tensor
    :param amount: 1-3
    :return:
    """
    #print(img.shape)
    h, w = 400, 400
    img = img.reshape(1, 1, h, w)
    sharp_kernel = torch.FloatTensor([-0.0008, -0.0018, -0.0034, -0.0050, -0.0056, -0.0050, -0.0034, -0.0018, -0.0008
                                , -0.0018, -0.0044, -0.0082, -0.0119, -0.0135, -0.0119, -0.0082, -0.0044, -0.0018
                                , -0.0034, -0.0082, -0.0153, -0.0223, -0.0253, -0.0223, -0.0153, -0.0082, -0.0034
                                , -0.0050, -0.0119, -0.0223, -0.0325, -0.0368, -0.0325, -0.0223, -0.0119, -0.0050
                                , -0.0056, -0.0135, -0.0253, -0.0368, 0.9583, -0.0368, -0.0253, -0.0135, -0.0056
                                , -0.0050, -0.0119, -0.0223, -0.0325, -0.0368, -0.0325, -0.0223, -0.0119, -0.0050
                                , -0.0034, -0.0082, -0.0153, -0.0223, -0.0253, -0.0223, -0.0153, -0.0082, -0.0034
                                , -0.0018, -0.0044, -0.0082, -0.0119, -0.0135, -0.0119, -0.0082, -0.0044, -0.0018
                                , -0.0008, -0.0018, -0.0034, -0.0050, -0.0056, -0.0050, -0.0034, -0.0018,
                             -0.0008]).reshape(9, 9)


    sharp_kernel = amount * sharp_kernel
    sharp_kernel[4, 4] += 1
    sharp_kernel = sharp_kernel.reshape(1, 1, 9, 9)

    conv2d = torch.nn.Conv2d(1, 1, (9, 9), bias=False, padding=4, padding_mode='reflect')  # 设置卷积网络
    conv2d.weight.data = sharp_kernel  # 初始化weight
    conv2d.weight.requires_grad = False

    im_dst = conv2d(img)
    im_dst = im_dst.reshape(h, w)
    # print(im_dst.shape)
    # print(im_dst[90:100, 90:100])
    return im_dst



def im_enhance5_torch_depthwise(img,  amount = 1.6):
    """
    # 输入[1，4， 400，400]， kernel [4, 1, 9, 9]   group : 4 , 输出 1, 4, 400, 400
    img: h, w   raw float32  torch.tensor
    :param amount: 1-3
    :return:
    """
    #print(img.shape)
    c, h, w = img.shape[0], img.shape[1], img.shape[2] # 4，400，400
    img = img.reshape(1, c, h, w)
    sharp_kernel = torch.FloatTensor([-0.0008, -0.0018, -0.0034, -0.0050, -0.0056, -0.0050, -0.0034, -0.0018, -0.0008
                                , -0.0018, -0.0044, -0.0082, -0.0119, -0.0135, -0.0119, -0.0082, -0.0044, -0.0018
                                , -0.0034, -0.0082, -0.0153, -0.0223, -0.0253, -0.0223, -0.0153, -0.0082, -0.0034
                                , -0.0050, -0.0119, -0.0223, -0.0325, -0.0368, -0.0325, -0.0223, -0.0119, -0.0050
                                , -0.0056, -0.0135, -0.0253, -0.0368, 0.9583, -0.0368, -0.0253, -0.0135, -0.0056
                                , -0.0050, -0.0119, -0.0223, -0.0325, -0.0368, -0.0325, -0.0223, -0.0119, -0.0050
                                , -0.0034, -0.0082, -0.0153, -0.0223, -0.0253, -0.0223, -0.0153, -0.0082, -0.0034
                                , -0.0018, -0.0044, -0.0082, -0.0119, -0.0135, -0.0119, -0.0082, -0.0044, -0.0018
                                , -0.0008, -0.0018, -0.0034, -0.0050, -0.0056, -0.0050, -0.0034, -0.0018,
                             -0.0008]).reshape(9, 9)


    sharp_kernel = amount * sharp_kernel
    sharp_kernel[4, 4] += 1
    sharp_kernel = sharp_kernel.reshape(1, 1, 9, 9)
    sharp_kernel = torch.tile(sharp_kernel, (4, 1, 1, 1))
    print('sharp shape:', img.shape, sharp_kernel.shape) # 图像尺寸和kernel尺寸， 每个通道分别卷积， 和 cv2.filter2d, ndimage.convolve 类似
    conv2d = torch.nn.Conv2d(4, 4, (9, 9), bias=False, padding=4, padding_mode='reflect', groups=4)  # 设置卷积网络
    conv2d.weight.data = sharp_kernel  # 初始化weight
    conv2d.weight.requires_grad = False

    im_dst = conv2d(img)
    im_dst = im_dst.reshape(c, h, w)
    # print(im_dst.shape)
    # print(im_dst[90:100, 90:100])
    return im_dst

2.2 利用cupy做滤波

enhance_apply_YUV 是先将rgb转化为yuv，再对Y通道做滤波，再转换回rgb
enhance_apply_channel 是分别对每个通道同样的滤波处理。

import cv2
import numpy as np

import cupy as cp
from cupyx.scipy import ndimage


def get_thr_sharped_edge_mask_xy_cupy(img, index_shape=0.25):
    h, w = img.shape
    edge_mask = cp.ones((h, w), dtype=cp.float32)

    dy, dx = cp.gradient(img)
    ksize = 5
    kernel = cp.ones((ksize, ksize)) / 25
    dxm = ndimage.convolve(dx, kernel, mode='reflect')
    dym = ndimage.convolve(dy, kernel, mode='reflect')

    dxy = cp.abs(dxm + dym)
    edge_mask[dxy < index_shape] = dxy[dxy < index_shape] / index_shape
    return edge_mask

def im_enhance5_cupy(img, thr_sharp = 0, amount = 1.6):
    """

    :param thr_sharp: 0-0.5
    :param amount: 1-3
    :return:
    """
    img = cp.asarray(img)
    sharp_kernel = cp.array([-0.0008, -0.0018, -0.0034, -0.0050, -0.0056, -0.0050, -0.0034, -0.0018, -0.0008
                                , -0.0018, -0.0044, -0.0082, -0.0119, -0.0135, -0.0119, -0.0082, -0.0044, -0.0018
                                , -0.0034, -0.0082, -0.0153, -0.0223, -0.0253, -0.0223, -0.0153, -0.0082, -0.0034
                                , -0.0050, -0.0119, -0.0223, -0.0325, -0.0368, -0.0325, -0.0223, -0.0119, -0.0050
                                , -0.0056, -0.0135, -0.0253, -0.0368, 0.9583, -0.0368, -0.0253, -0.0135, -0.0056
                                , -0.0050, -0.0119, -0.0223, -0.0325, -0.0368, -0.0325, -0.0223, -0.0119, -0.0050
                                , -0.0034, -0.0082, -0.0153, -0.0223, -0.0253, -0.0223, -0.0153, -0.0082, -0.0034
                                , -0.0018, -0.0044, -0.0082, -0.0119, -0.0135, -0.0119, -0.0082, -0.0044, -0.0018
                                , -0.0008, -0.0018, -0.0034, -0.0050, -0.0056, -0.0050, -0.0034, -0.0018,
                             -0.0008]).reshape(9, 9)




    if thr_sharp > 0:
        mask = get_thr_sharped_edge_mask_xy_cupy(img, index_shape=0.25)
        # print(mask[90:100, 90:100])
        im_dst = ndimage.convolve(img, sharp_kernel, mode='reflect')
        # print(im_dst[90:100, 90:100])
        im_dst = im_dst * mask  # 高频，去除噪声（mask<1判为噪声）
        im_dst = img + amount * im_dst
    else:
        sharp_kernel = amount * sharp_kernel
        sharp_kernel[4, 4] += 1
        im_dst = ndimage.convolve(img, sharp_kernel, mode='reflect')

    # print(im_dst[90:100, 90:100])
    return im_dst

def enhance_apply_YUV(img, amount=1.6):
    # img = cv2.imread(r'D:\savedmodel\train_ret\02100_psnr_38.75_out_pair.png')
    yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
    y2 = im_enhance5_cupy(cp.asarray(yuv[..., 0]), 0, amount)
    yuv[..., 0] = cp.asnumpy(y2)
    img2 = cv2.cvtColor(yuv, cv2.COLOR_YCrCb2BGR)
    return img2
def enhance_apply_channel(img, amount):
    h, w, c = img.shape
    img2 = img.copy()
    for iii in range(c):
        img2[..., iii] = cp.asnumpy(im_enhance5_cupy(cp.asarray(img[..., iii]), 0, amount))
    return img2

def usm_cupy(raw_4ch, detail_alpha=1):
    """
    :param raw_4ch: h,w,4, uint16
    :return:
    """
    h, w, c = raw_4ch.shape
    raw_4ch = raw_4ch.astype(cp.float32)
    raw_4ch_blur = raw_4ch.copy()

    siz = 3
    hh = cp.ones([siz, siz]) / (siz * siz)
    for i in range(c):
        raw_4ch_blur[..., i] = ndimage.convolve(raw_4ch[..., i], hh, mode='nearest')
        raw_4ch[..., i] = raw_4ch[..., i] + detail_alpha * (raw_4ch[..., i] - raw_4ch_blur[..., i])

    siz = 11
    hh = cp.ones([siz, siz]) / (siz * siz)
    for i in range(c):
        raw_4ch_blur[..., i] = ndimage.convolve(raw_4ch[..., i], hh, mode='nearest')
        raw_4ch[..., i] = raw_4ch[..., i] + detail_alpha * (raw_4ch[..., i] - raw_4ch_blur[..., i])

    return raw_4ch #np.clip(raw_4ch, 0,  1023).astype(np.uint16)

2.3比较效果

这里读取的是 raw图像，然后转化为4通道，
然后用pytorch的方法，cupy(ndimage.convolve方法)得到结果，结果是一致的

if __name__ == "__main__":
    dir = r'D:\dataset\rawimage'
    files = glob.glob(os.path.join(dir, '*.raw'))

    print('len:', len(files))
    files = sorted(files)
    index = 6 * 202
    file = files[index]

    h, w = 800, 800
    raw = np.fromfile(file, dtype=np.uint16).reshape(h, w).astype(np.float32) / 1023
    # raw = np.load(file).astype(np.float32) / 1023
    h, w = raw.shape

    raw4 = raw.reshape(h // 2, 2, w // 2, 2).transpose(0, 2, 1, 3).reshape(h // 2, w // 2, 4)

    img = torch.from_numpy(raw4.copy())
    print(img.shape)
    for i in range(4):
        img[..., i] = im_enhance5_torch(img[..., i], 1.2)
    img = img.detach().numpy()

    img2 = torch.from_numpy(raw4.copy()).permute(2, 0, 1)
    print(img2.shape)
    img2 = im_enhance5_torch_depthwise(img2, 1.2)
    img2 = img2.detach().numpy().transpose(1, 2, 0)

    raw4_enhance = enhance_apply_channel(raw4, 1.2)
    print(raw4.shape, img.shape, raw4_enhance.shape)
    black_level = 16
    white_level = 1023
    wb = get_wb()
    ccm = get_ccm()
    srgb1 = apply_wb_ccm(img[..., [0, 1, 3]] * 1023, wb, ccm, 16, 1023)
    srgb2 = apply_wb_ccm(raw4_enhance[..., [0, 1, 3]] * 1023, wb, ccm, 16, 1023)
    srgb3 = apply_wb_ccm(img2[..., [0, 1, 3]] * 1023, wb, ccm, 16, 1023)
    srgb1 = np.clip(srgb1 * 255 , 0 ,255).astype(np.uint8)
    srgb2 = np.clip(srgb2 * 255, 0, 255).astype(np.uint8)
    srgb3 = np.clip(srgb3 * 255, 0, 255).astype(np.uint8)
    cv2.imwrite('im_enhance5_torch_1.png', srgb1[..., ::-1])
    cv2.imwrite('im_enhance5_torch_2.png', srgb2[..., ::-1])
    cv2.imwrite('im_enhance5_torch_3.png', srgb3[..., ::-1])

[1]https://faun.pub/depthwise-separable-convolutions-in-pytorch-fd41a97327d0

tony365
关注
专栏目录
优化改进YOLOv5算法：加入大核分离卷积注意力模块（ Large Separable Kernel Attention），实现暴力涨点同时显著减少计算复杂性和内存——(超详细)
qq_40716944的博客
10-29 1150
论文：Large Separable Kernel Attention: Rethinking theLarge Kernel Attention Design in CNN具有大内核注意力（LKA）模块的视觉注意力网络（VAN）已被证明在一系列基于视觉的任务中提供了卓越的性能，超过了视觉转换器（ViTs）。然而，随着卷积核大小的增加，这些LKA模块中的深度卷积层导致计算和内存占用的二次增加。为了缓解这些问题，并允许在VAN的注意模块中使用超大卷积核，我们提出了一个大的可分离核注意模块族，称为LSKA。LS
PyTorch实现深度可分离卷积（以MobileNet为例）
热门推荐
Einstellung的博客
12-17 1万+
介绍深度可分离卷积之前首先要先介绍一下分组卷积。 分组卷积 参考链接[1]已经将分组卷积介绍的比较详细了，这里就不再赘述。原理可以参考一下参考链接。但是这篇文章对于分组卷积的具体代码讲解，感觉不太好。这里对于分组卷积着重介绍一下代码讲解。 直接调用torch.nn.Conv2d()就可以实现分组卷积。在Conv2d里面有一个参数叫groups，这个参数是实现这一功能的关键。下面详细解介绍一下这个参...
depthwise separable convolutions
wmzjzwlzs的专栏
05-05 262
转自：什么是depthwise separable convolutions_猫猫与橙子的博客-CSDN博客_depthwise Depthwise(DW)卷积与Pointwise(PW)卷积，合起来被称作Depthwise Separable Convolution(参见Google的Xception)，该结构和常规卷积操作类似，可用来提取特征，但相比于常规卷积操作，其参数量和运算成本较低。所以在一些轻量级网络中会碰到这种结构如MobileNet。常规卷积操作 对于一张5×5像素、三通道彩色输入图片（s
中值滤波器 pytorch
最新发布
weixin_42085790的博客
08-12 26
中值滤波器与PyTorch的应用 中值滤波器（Median Filter）是一种非线性滤波技术，广泛应用于图像降噪和信号处理。与其他线性滤波器相比，中值滤波器在处理图像时能更好地保留边缘信息，特别是对于椒盐噪声的处理效果显著。 中值滤波器原理 中值滤波器的工作原理相对简单。它通过将像素值替换为其邻域像素值的中位数来实现降噪...
深度可分离卷积（Depthwise Separable Convolution）
吃葡萄不吐葡萄皮
08-17 1968
深度可分离卷积（Depthwise Separable Convolution）是一种卷积神经网络中常用的卷积操作，它在减少计算量的同时保持了较好的特征提取能力，因此被广泛用于轻量化的模型设计中。标准卷积使用一个卷积核对输入数据进行卷积，而深度可分离卷积将卷积操作分解为深度卷积和逐点卷积，从而显著减少了参数量。深度卷积只使用一个卷积核对输入通道逐通道进行卷积，逐点卷积使用1x1的卷积核进行通道之间的混合。深度卷积是在输入的每个通道上分别应用卷积核，生成相同数量的通道，然后将这些通道按通道维度进行堆叠。
pytorch实现 分组卷积 深度可分离卷积
wzw12315的专栏
05-28 6777
常规卷积： 常规卷积需要的参数量：Cin​×K×K×Cout​ 分组卷积： 分组卷积需要的计算量 ：Cin​×K×K×Cout​ / g 深度可分离卷积(Depthwise Separable Convolution): 需要的计算量：Cin​×K×K+Cout​×1×1 实现： import torch from torchsummary import summary import torch.nn as nn ''' 实现分组卷积demo ''' class ...
pytorch技巧 二： 深度可分离卷积
qq_40788447的博客
01-29 1万+
pytorch技巧 二： 深度可分离 1. torchviz 第一步：安装graphviz, 网上教程很多，也可以点这里。 注意记得配置环境变量。 第二步：安装torchviz,打开终端输入pip install torchviz 第三步：使用 import torch from torchviz import make_dot class MLP(torch.nn.Module): def __init__(self): super(MLP, self).__init__()
neighborhood-map-seperate-model:使用 Knockout.js、Google Map API、forecast.io API 和foursquare API 构建的社区地图应用程序
06-09
本项目“neighborhood-map-seperate-model”就是一个典型的例子，它利用了JavaScript库Knockout.js，以及Google Maps API、forecast.io API和foursquare API，为用户提供了一个功能丰富的社区地图应用。这个应用不仅...
Transformer源代码解释之PyTorch篇
lw19155275856的博客
05-06 1180
Transformer源代码解释之PyTorch篇
seperate.rar_matlab语音分离_seperate_双通道信号_语音 分离 matlab_语音信号文件
07-14
自适应滤波法实现对双通道语音信号分离，程序中的两个语音文件，采样率必须相同，但长度可以不同，程序具有一定的鲁棒性
CNN中的Group&&Depthwise&&pointerwise卷积
weixin_42631693的博客
04-26 579
文章目录分组卷积(Group Convolusion)常规卷积vs分组卷积Depthwise卷积Pointerwise卷积深度可分离卷积参考 分组卷积(Group Convolusion) 提到分组卷积，我们最开始应该想到是大名鼎鼎的Alexnet.Alexnet最先用到了分组卷积，由于计算资源的有限，它将网络分成两部分，从而能够在两个GPU上并行运行。如图所示： 我们来具体看下,分组卷积是如何...
Python-PyTorch中的可变形卷积网络
08-11
PyTorch中的可变形卷积网络
Python torch 深度学习——深度可分离卷积（Depthwise Separable Convolution， DSC）_深度可分离卷积代码
m0_60666452的博客
04-14 895
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。深度可分离卷积（Depthwise Separable Convolution， DSC）包括深度卷积和逐点卷积两个步骤。我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。工欲善其事必先利其器。
Python/torch/深度学习——深度可分离卷积（Depthwise Separable Convolution， DSC）
eagle_Annie的博客
10-24 2421
深度可分离卷积学习记录。
深度学习-卷积神经网络-深度分离卷积(PyTorch)
BelievIamthebest的博客
09-23 940
深度学习-卷积神经网络-深度分离卷积(PyTorch)
【卷积】Conv与Depthwise Seperable Conv
化甘
03-01 1611
参考 卷积计算方式：https://zhuanlan.zhihu.com/p/268179286 Depthwise卷积与Pointwise卷积：https://zhuanlan.zhihu.com/p/80041030 卷积 ref: https://zhuanlan.zhihu.com/p/268179286 单通道单卷积核 单通道多卷积核 多通道单卷积核 多通道多卷积核 2. Conv 3. Depthwise Seperable Conv ref: https://zhuanlan.zhihu.co
深度可分离卷积-Depthwise Separable Convolution的理解以及pytorch实现
qq_39866805的博客
04-23 4919
深度可分离卷积主要分为两个过程，分别为逐通道卷积（Depthwise Convolution）和逐点卷积（Pointwise Convolution）。 逐通道卷积 Depthwise Convolution Depthwise Convolution的一个卷积核负责一个通道，一个通道只被一个卷积核卷积，这个过程产生的feature map通道数和输入的通道数完全一样。 卷积核的计算量为：3 x 3 x 3 = 27 逐点卷积 Pointwise Convolution Poi...
深度学习中常用的几种卷积（下篇）：膨胀卷积、可分离卷积（深度可分离、空间可分离）、分组卷积（附Pytorch测试代码）
NorthSmile的博客
09-07 6534
膨胀卷积也称为扩张卷积或空洞卷积，一般可通过对标准二维卷积的卷积核设置合适的膨胀率（具体地指卷积核元素之间的距离）实现。合理利用膨胀卷积可在不引入其他参数的同时，扩大输出中元素的感受野，提高特征的全局表示能力。下面通过展示几个不同膨胀率下的卷积核大小以及感受野变化情况，可以更直观的理解：图中灰色为输入，蓝色为卷积核，黄色为输出。1）dilation=1：表示卷积核元素之间距离为1，使用0进行大小为dilation-1=0的填充（这是默认情况），因此。
【轻量卷积】组卷积（GC）、深度可分离卷积（DSC）与异构卷积（HC）（Pytorch实现）
qq_43426908的博客
04-22 5877
  为了提高网络性能，目前的研究趋向于更深，更复杂的网络，ImageNet刷分的前几名网络的参数量也非常巨大，没有高性能GPU的玩家只有长太息以掩涕兮了，然而，目前嵌入式设备和移动平台对深度学习模型部署的大量需求，促使轻量级网络成为一个热门的研究方向。于是，就记录一下看到的走轻量级路线的卷积吧。
how to seperate IT events and IT incidents
05-20
IT events and IT incidents are two different types of occurrences in an IT environment. An IT event is any occurrence that has significance for the management of an IT service or infrastructure, such ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值