结合残差结构的Res-Unet及其代码实现

最新推荐文章于 2024-06-21 10:14:27 发布
最新推荐文章于 2024-06-21 10:14:27 发布
阅读量1.6w 收藏 140
点赞数 17
分类专栏： 语义分割模块 模型构建 文章标签： 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46501089/article/details/115913002
版权
本文详细介绍了Res-Unet网络的构建方法，通过使用ResNet50作为U-net特征提取层的替代，加深了网络结构，提高了特征提取能力。文中提供了完整的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本博客主要为代码实现的小伙伴提供模板，具体的原理已经有好多文章啦，所以在这里我也就不啰嗦啦，只作简单介绍！

1.残差结构

1.1 残差单元
与普通网络的串行结构相比，残差单元增加了跳跃映射，将输入与输出直接进行相加，补充卷积过程中损失的特征信息，这点与U-net的跳跃连接结构有点类似，不过Res中的跳跃连接做的是Add操作，而U-net的跳跃连接做的是Concatenate操作，还是有本质的不同，残差单元如图所示:在这里插入图片描述
1.2 残差家族
根据层数的不同ResNet有以下的伐木累
在这里插入图片描述
由图中可以看出ResNet18和ResNet34的残差单元只有两层，而ResNet50、ResNet101、ResNet152的残差单元有三层。本文使用的是ResNet50所以主要讲解ResNet50。
1.3 Resnet50
ResNet50由两个基本结构组成，一个为Conv_block，一个为Identity_block。如图所示：Identity_blockConv_block
Conv_block用于放在第一个位置调整通道以及特征图大小，Identity_block用于加深网络。

2.U-net

这个就不说了好吧
自己看吧…

3.Res-Unet

本文讲的Res-Unet主要是将U-net特征提取层的普通卷积用ResNet50代替，以达到加深网络的目的，直接上代码吧！

import keras
from keras.models import *
from keras.layers import *
from keras import layers
import keras.backend as K

IMAGE_ORDERING = 'channels_last'


def identity_block(input_tensor, kernel_size, filters, stage, block):
    filters1, filters2, filters3 = filters

    if IMAGE_ORDERING == 'channels_last':
        bn_axis = 3
    else:
        bn_axis = 1

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'
    x = Conv2D(filters1, (1, 1), data_format=IMAGE_ORDERING, name=conv_name_base + '2a')(input_tensor)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)
    x = Activation('relu')(x)
    x = Conv2D(filters2, kernel_size, data_format=IMAGE_ORDERING,
               padding='same', name=conv_name_base + '2b')(x)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x)
    x = Activation('relu')(x)
    x = Conv2D(filters3, (1, 1), data_format=IMAGE_ORDERING, name=conv_name_base + '2c')(x)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)
    x = layers.add([x, input_tensor])
    x = Activation('relu')(x)
    return x

def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2, 2)):
    filters1, filters2, filters3 = filters

    if IMAGE_ORDERING == 'channels_last':
        bn_axis = 3
    else:
        bn_axis = 1

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'
    x = Conv2D(filters1, (1, 1), data_format=IMAGE_ORDERING, strides=strides,
               name=conv_name_base + '2a')(input_tensor)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)
    x = Activation('relu')(x)
    x = Conv2D(filters2, kernel_size, data_format=IMAGE_ORDERING, padding='same',
               name=conv_name_base + '2b')(x)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x)
    x = Activation('relu')(x)
    x = Conv2D(filters3, (1, 1), data_format=IMAGE_ORDERING, name=conv_name_base + '2c')(x)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)
    shortcut = Conv2D(filters3, (1, 1), data_format=IMAGE_ORDERING, strides=strides,
                      name=conv_name_base + '1')(input_tensor)
    shortcut = BatchNormalization(axis=bn_axis, name=bn_name_base + '1')(shortcut)
    x = layers.add([x, shortcut])
    x = Activation('relu')(x)
    return x


def get_resnet50_encoder(input_height=256, input_width=256, pretrained='imagenet',
                         include_top=True, weights='imagenet',
                         input_tensor=None, input_shape=None,
                         pooling=None,
                         classes=1000):
    assert input_height % 32 == 0
    assert input_width % 32 == 0

    if IMAGE_ORDERING == 'channels_first':
        img_input = Input(shape=(6, input_height, input_width))
    elif IMAGE_ORDERING == 'channels_last':
        img_input = Input(shape=(input_height, input_width, 6))

    if IMAGE_ORDERING == 'channels_last':
        bn_axis = 3
    else:
        bn_axis = 1

    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input)
    x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
    f1 = x
    x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
    x = Activation('relu')(x)
    x = MaxPooling2D((2, 2), data_format=IMAGE_ORDERING, strides=(2, 2))(x)
    x = conv_block(x, 3, [32, 32, 128], stage=2, block='a', strides=(1, 1))
    x = identity_block(x, 3, [32, 32, 128], stage=2, block='b')
    x = identity_block(x, 3, [32, 32, 128], stage=2, block='c')
    f2 = x

    x = conv_block(x, 3, [64, 64, 256], stage=3, block='a')
    x = identity_block(x, 3, [64, 64, 256], stage=3, block='b')
    x = identity_block(x, 3, [64, 64, 256], stage=3, block='c')
    x = identity_block(x, 3, [64, 64, 256], stage=3, block='d')
    f3 = x

    x = conv_block(x, 3, [128, 128, 512], stage=4, block='a')
    x = identity_block(x, 3, [128, 128, 512], stage=4, block='b')
    x = identity_block(x, 3, [128, 128, 512], stage=4, block='c')
    x = identity_block(x, 3, [128, 128, 512], stage=4, block='d')
    x = identity_block(x, 3, [128, 128, 512], stage=4, block='e')
    x = identity_block(x, 3, [128, 128, 512], stage=4, block='f')
    f4 = x

    x = conv_block(x, 3, [256, 256, 1024], stage=5, block='a')
    x = identity_block(x, 3, [256, 256, 1024], stage=5, block='b')
    x = identity_block(x, 3, [256, 256, 1024], stage=5, block='c')
    f5 = x


    return img_input, [f1, f2, f3, f4, f5]

def _unet(n_classes , encoder , input_height = 256, input_width = 256):

    img_input , levels = encoder(input_height=input_height,input_width=input_width)
    [f1 , f2 , f3 , f4 , f5] = levels

    o = f5
    o = UpSampling2D((2, 2), data_format=IMAGE_ORDERING)(o)
    # o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(512, (2, 2), padding='same', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)
    o = concatenate([o,f4],axis=3)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(512, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(512, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)

    o = UpSampling2D((2, 2), data_format=IMAGE_ORDERING)(o)
    # o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(256, (2, 2), padding='same', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)
    o = concatenate([o,f3],axis=3)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(256, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = BatchNormalization()(o)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(256, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = BatchNormalization()(o)

    o = UpSampling2D((2, 2), data_format=IMAGE_ORDERING)(o)
    # o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(128, (2, 2), padding='same', data_format=IMAGE_ORDERING)(o)
    o = BatchNormalization()(o)
    o = concatenate([o,f2],axis=3)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(128, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(128, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)

    o = UpSampling2D((2, 2), data_format=IMAGE_ORDERING)(o)
    # o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(64, (2, 2), padding='same', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)
    o = concatenate([o,f1],axis=3)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(64, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)
    o = ZeroPadding2D((1, 1) , data_format=IMAGE_ORDERING)(o)
    o = Conv2D(64, (3, 3), padding='valid', data_format=IMAGE_ORDERING)(o)
    o = Activation('relu')(o)
    o = BatchNormalization()(o)

    o = Conv2D(n_classes, (3,3) ,padding='same',data_format=IMAGE_ORDERING)(o)
    o = Reshape((int(input_height)*int(input_width),-1))(o)
    o = Softmax()(o)
    model = Model(img_input,o)

    return model

def conv_unet(n_classes , input_height=256, input_width=256):

    model = _unet(n_classes,get_resnet50_encoder,input_height=input_height,input_width=input_width)
    model.model_name = 'conv_unet'
    return model

model = conv_unet(2)
model.summary()

什么？你用的不是Keras？
什么？你用的Pytroch？

Unet 改进：引入残差模块ResidualBlock
Henry的博客
02-09 371
残差连接的核心思想是通过引入“跳跃连接”（Skip Connection），将输入直接传递到网络的后续层，使得网络可以学习输入与输出之间的残差（即差异），而不是直接学习复杂的映射关系。2. **解决网络退化问题**：随着网络层数增加，性能可能饱和甚至下降，残差连接通过引入恒等映射，确保网络至少不会比浅层网络更差。1. **缓解梯度消失**：深层网络中，梯度反向传播时容易消失，残差连接提供了直接的路径，使得梯度可以更有效地传播。3. **加速训练**：残差连接简化了优化过程，使得深层网络更容易训练。
完整指南：使用ResNet50和Res-UNET在Python中预测和定位钢材缺陷
qq_38334677的博客
09-15 977
在这篇文章中，我们使用了ResNet50模型来预测钢材中的缺陷，并进一步使用Res-UNET模型来直观地定位这些缺陷。在这篇文章中，我们将使用深度学习技术，特别是ResNet50模型来预测钢材的缺陷，并使用Res-UNET模型来直观地定位这些缺陷。为了简化过程，我们将使用预训练的权重，但将顶部的全连接层移除，以适应我们的二分类任务（存在缺陷/不存在缺陷）。请注意，这里我们需要像素级的标签，标签应该和我们的图像大小相同，并为每个像素标记是否有缺陷。下一步，我们将构建ResNet50模型来预测钢材中的缺陷。
图像分割UNet系列------Res-UNet详解
热门推荐
gz7seven
08-10 4万+
图像分割unet系列------Res-UNet详解1、Res-UNet要解决的问题2、Res-UNet主要网络结构3、引发的思考     Res-UNet发表于2018年，是UNet非常重要的改进版本之一。当然，Res-UNet同样是应用在医学图像分割领域-----视网膜血管分割。 1、Res-UNet要解决的问题     作者在文章的简介中就提到了视网膜血管分割任务的主要难点和挑战，这也是Res-UNet重点解决的问题，具体如下所示（直接翻译）： 小血管缺失：位于血管末端的小血管有时甚至人眼也难以分辨
【代码复现】ResUNet++进行语义分割（含图像切片预处理）
weixin_44883789的博客
08-26 5516
可能由于显卡内存不够的原因，导致尺寸很大的图片进行训练时，导致GPU显存不够的情况，一个简单的方法：对图片进行切片操作。对图片进行。
ResUNet原理与实现
mefocus的博客
03-13 2万+
U-Net的下采样和上采样的设计与许多现在成熟的网络结构异曲同工。因为ImageNet是一个大规模的图像分类数据集，ImageNet预训练权重可以帮助我们在U-Net的训练中使用更好的初始化权重，加快网络的收敛速度并提高网络的泛化能力。但是，U-Net的下采样和上采样的设计思路和现在许多成熟的网络结构相似，因此，可以看作是先驱性的工作。整个网络结构包括了ResNet的残差连接和U-Net的上下采样和跳跃连接思想，可以更好地平衡特征的丰富性和细节的保留性，在图像分割任务中表现出较好的性能。
unet各模块内容的理解（包含注意力机制、残差、以及数据维度的变化）
m0_52985451的博客
03-17 5000
对unet的各模块内容进行梳理，包括各模块的设计，以及数据流的整个处理流程，以及其维度的变化
unet是残差网络吗_基于UNet神经网络的城市人流预测
weixin_32374445的博客
01-14 1071
[原创]1 利用手机信令数据计算人口流动数据手机信令数据是研究人口的整体流动情况的重要数据来源。移动运营商在为手机用户提供实时通讯服务时，积累了大量的基站与设备的服务配对数据。根据配对和唤醒发生的时间以及基站的地理位置，可以很自然划定一定时间和空间范围，统计每一个时间范围内在特定空间区域内手机设备的停留，进入和离开数据，并据此估算相应的人流数据。传统的人口网格分析过程一般只关注单个网格内某个时间点...
Resnet论文笔记
weixin_43774841的博客
11-05 1781
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
unet是残差网络吗_ResNet改进版来了！可训练网络超过3000层！相同深度精度更高...
weixin_35012535的博客
12-19 1892
学习了~来自阿联酋起源人工智能研究院(IIAI)的研究人员公布了一篇论文Improved Residual Networksfor Image and Video Recognition，深入研究了残差网络不能更深的原因，提出了改进版的残差网络(Improved Residual Networks，iResNet)，使得训练超深网络时更容易收敛，在多个计算机视觉任务(图像分类，COCO...
字节跳动这项研究火了：基于残差UNet架构 ，一键分离伴奏和人声
jacke121的专栏
10-05 2499
音乐源分离 (MSS) 是将混合音频分离成单个源的任务，例如人声、鼓、伴奏等。MSS 是音乐信息检索 (MIR) 的重要内容，因为它可用于多个下游 MIR 任务，包括旋律提取、音高估计、音乐转录 、音乐混音等。MSS 也有可以直接应用的程序，例如卡拉 OK 和音乐混音。 基于深度神经网络的方法已成功应用于音乐源分离。这些方法通常用于学习从混合声谱（spectrogram）到一组源声谱的映射，所有声谱图都只有幅度。但是，这种方法会受到一定的限制： 1）不正确的相位重构降低了性能； 2）将掩码..
【keras框架下Resnet101_Unet深度学习模型对医学图像语义分割】
爱CV
02-01 2561
盆骨分割模型测试 1说明 本次采用的是vnet2d二分类模型和Resnet101_Unet模型分别进行训练测试，为防止样本分布不均衡现象，损失函数均采用二分类dice损失，不再使用之前的最原始的二分类交叉熵损失。 二分类dice损失如下： #二分类dice损失 def dice_coef(y_true, y_pred, smooth): #y_pred =K.cast((K.gr...
残差网络ResNet模块
04-21
ResNet网络结构模块，可直接使用，返回值一个是loss用于损失值优化，第二个softmax输出的是预测值用于测试
Deep Residual U-Net.pdf
05-08
Road Extraction by Deep Residual U-Net
基于加权的Res-UNet注意力机制分割视网膜血管分割挑战
爱CV
01-27 8127
•小血管缺失:位于树枝末端的小血管有时甚至人眼也难以分辨。 •视盘区分割差:视盘区往往较亮，对比度较低，使得视网膜血管难以分割。 •无法维持结构关系:视网膜血管有类似于树木的分叉结构。但当血管太薄而无法探测时，这种结构很难维持。 •照明:光照不足或过度暴露，包括相机光源引起的光反射，会降低图像对比度，导致视网膜血管边界不清晰。 为了解决这些挑战，本文提出：加权的Res-UNet。模型建立在原始的UNet模型基础上，并增加了一个加权注意机制。使得模型学习更多的鉴别血管和非血管像素的特征，更好的维护视网膜血管
pytorch实现基于resnet的Unet
weixin_38410551的博客
02-16 5408
resnet可以作为Unet的编码模块，只要把最后的全连接层去掉即可，其它无需改变。 Unet网络的整体结构为编码模块，和解码模块。解码模块要将每个stage模块的中间输出保存下来，以便与对应的解码模块的stage相连接。 Unet的创新之处在于它的解码模块，所以代码实现的时候尤其要关注每个模块的输入输出信道数，解码模块中间几个模块的处理过程相同，可以用for循环处理，而作为解码模块的输入和输出...
【干货教学】unet进阶，如何在unet中加入resnet（残差连接）
BluErroR的博客
11-25 1万+
在本教程中，我们将探讨如何在经典的U-Net架构中融入ResNet的残差连接。这种结合了U-Net在图像分割领域的优势和ResNet的残差连接的混合模型，我们称之为ResUnet，旨在通过残差学习改善模型的训练效率和性能。
残差结构详解
qimo601的专栏
10-19 1万+
残差元的主要设计有两个，快捷连接和恒等映射，快捷连接使得残差变得可能，而恒等映射使得网络变深，而恒等映射主要有两个：跳跃连接和激活函数。ResNets的提出，可以解决上述问题，即使网络再深，训练的表现仍表现很好。它有助于解决梯度消失和梯度爆炸问题，让我们在训练更深网络的同时，又能保证良好的信息。
残差网络中的基础结构——残差模块
SisterRu的博客
06-21 6740
在传统的深度神经网络中，随着网络层数的增加，反向传播的梯度会逐渐减小或增大，导致网络难以收敛或变得不稳定。该现象的一种解释是，当网络变得非常深时，低层参数的微小变动会引起高层参数的剧烈变化，使得优化算法难以找到最优解。然而在残差结构提出之前，实验证明，随着网络层数的增加，模型的准确率起初会不断提高，直至达到最大饱和值。然后，随着网络深度进一步增加，模型的准确率不再增加，反而可能出现明显的降低，这被称为“退化问题”，该问题的发生主要是由于深度神经网络训练中的梯度消失和梯度爆炸问题。
Res-UNet模型结构详解
最新发布
01-06
### Res-UNet 模型架构详细说明 #### 基础 UNet 结构 Res-UNet 的基础是经典的 U-Net 架构，该架构由编码器路径和解码器路径组成。编码器负责提取图像中的高层次特征，而解码器则通过逐步上采样来恢复空间分辨率并生成最终的分割图。 #### 编码器部分 编码器通常采用预训练的卷积神经网络（CNN），如 VGG 或 ResNet 作为骨干网络。每一层都包含多个卷积操作以及池化层用于下采样。这种设计有助于捕捉不同尺度下的语义信息[^4]。 ```python import torch.nn as nn class EncoderBlock(nn.Module): def __init__(self, in_channels, out_channels): super(EncoderBlock, self).__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) self.pool = nn.MaxPool2d(kernel_size=2) def forward(self, x): x = self.conv1(x) x = self.bn1(x) x = self.relu(x) return self.pool(x), x ``` #### 解码器部分 解码器的任务是对来自编码器的信息进行重构，并逐渐提高输出的空间维度直至与输入一致。它利用跳跃连接将低级特征与高级抽象相结合，从而增强局部定位能力。此外，在某些版本中引入了残差模块以促进梯度传播。 ```python class DecoderBlock(nn.Module): def __init__(self, in_channels, mid_channels, out_channels): super(DecoderBlock, self).__init__() self.upconv = nn.ConvTranspose2d(in_channels, mid_channels, kernel_size=2, stride=2) self.conv1 = nn.Conv2d(mid_channels * 2, out_channels, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) def forward(self, x, skip_connection): x = self.upconv(x) x = torch.cat([skip_connection, x], dim=1) x = self.conv1(x) x = self.bn1(x) return self.relu(x) ``` #### 加权注意力机制 为了进一步提升模型的表现力，特别是在处理复杂背景的情况下，加入了加权注意机制。这一改进允许网络更加关注于那些对于分类至关重要的区域，进而改善整体性能。具体来说，权重被分配给每个像素位置上的响应值，以便突出显示目标对象及其边界[^1]。 ```python class AttentionGate(nn.Module): def __init__(self, F_g, F_l, F_int): super(AttentionGate, self).__init__() self.W_g = nn.Sequential( nn.Conv2d(F_g, F_int, kernel_size=1), nn.BatchNorm2d(F_int)) self.W_x = nn.Sequential( nn.Conv2d(F_l, F_int, kernel_size=1), nn.BatchNorm2d(F_int)) self.psi = nn.Sequential( nn.Conv2d(F_int, 1, kernel_size=1), nn.BatchNorm2d(1), nn.Sigmoid()) def forward(self, g, x): g1 = self.W_g(g) x1 = self.W_x(x) psi = self.psi(torch.add(g1,x1)) return x * psi ``` #### 超参数调整 针对特定应用场景的需求，可以通过实验确定最佳配置方案。例如，在 Synapse 数据集的研究表明适当调节上采样的方式及优化算法的选择能够显著影响最终效果[^3]。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值