机器学习5-支持向量机

于 2020-09-16 20:57:07 发布
阅读量295 收藏 1
点赞数
分类专栏： # 机器学习基础 文章标签： 机器学习 python 算法 支持向量机 svm
本BLOG上原创文章未经本人许可，不得用于商业用途，转载请注明出处。
本文链接：https://blog.csdn.net/weixin_46649052/article/details/108441789
版权
本文详细介绍了支持向量机（SVM）的概念，包括线性可分与非线性SVM、SVM的目标函数、拉格朗日乘子法、SMO算法、核方法和SVM的Python实现。通过实例展示了如何使用SVM进行人脸识别，并探讨了参数调整和高斯核的应用。
摘要由CSDN通过智能技术生成

文章目录

1.线性可分支持向量机-SVM

1）几何间隔、函数间隔、目标函数

在这里插入图片描述

同一条直线(系数成倍的放大、缩小)的几何间隔相同，但函数间隔会不同

在这里插入图片描述

2）拉格朗日乘子法求解带有等式约束的问题

在这里插入图片描述
在这里插入图片描述

3）拉格朗日乘子法求解带有不等式约束的极值问题、KKT条件

` 

如果不等式约束是大于0或者大于等于0，则必须先转换成小于等于0，在使用拉格朗日乘子法

在这里插入图片描述

g(x1,x2) = 0
-▽f(x) = αg(x)
α >= 0

在这里插入图片描述

4)SVM目标函数求解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5）.SVM求解举例

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.线性支持向量机

1)线性支持向量机目标函数

加粗样式

2)目标函数的优化

在这里插入图片描述
在这里插入图片描述

与线性可分支持向量机相比，限制条件有改变

在这里插入图片描述

3.非线性支持向量机

1）核方法

在这里插入图片描述

在这里插入图片描述

在低维空间进行计算，从而完成在高维空间完成的事情
映射到高维空间，从而在低维空间线性不可分变成在高维空间线性可分
2.非线性支持向量机的目标函数

在这里插入图片描述

非线性支持向量机只是将上面的目标函数中的内积用核函数来替换就可以了

在这里插入图片描述

4.SMO算法-即上述求解α的最优解的过程

在这里插入图片描述

5.SVM代码实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.patches import Circle
from numpy import *


# 加载数据
def loadDataSet(fileName):
    dataMat = []
    labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = line.strip().split('\t')
        dataMat.append([float(lineArr[0]), float(lineArr[1])])
        labelMat.append(float(lineArr[2]))
    return dataMat, labelMat


# SMO算法实现-α的求解过程

# alpha的选取，随机选择一个不等于i值的j
def selectJrand(i, m):
    j = i
    while (j == i):
        # random.uniform()可以生成[low,high)中的随机数，可以是单个值
        j = int(random.uniform(0, m))
    return j


# 进行剪辑
def clipAlpha(aj, H, L):
    if aj > H:
        aj = H
    if L > aj:
        aj = L
    return aj


# SMO算法的核心实现
# dataMatIn表示X，classLabels表示y，C表示惩罚因子，toler表示误差值达到多少时可以停止，maxIter表示迭代次数
def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    # 转换成矩阵
    dataMatrix = mat(dataMatIn)
    labelMat = mat(classLabels).transpose()
    # 初始化b为0
    b = 0
    # 获取数据维度
    m, n = shape(dataMatrix)
    # 初始化所有alpha为0
    alphas = mat(zeros((m, 1)))
    iter = 0
    # 迭代求解
    while (iter < maxIter):
        alphaPairsChanged = 0
        for i in range(m):
            # 计算g(xi)
            gXi = float(multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[i, :].T)) + b
            # 计算Ei
            Ei = gXi - float(labelMat[i])
            if ((labelMat[i] * Ei < -toler) and (alphas[i] < C)) or ((labelMat[i] * Ei > toler) and (alphas[i] > 0)):
                # 随机选择一个待优化的alpha（先随机出alpha下标）
                j = selectJrand(i, m)
                # 计算g(xj)
                gXj = float(multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[j, :].T)) + b
                # 计算Ej
                Ej = gXj - float(labelMat[j])
                # 把原来的alpha值复制，作为old值
                alphaIold = alphas[i].copy();
                alphaJold = alphas[j].copy()
                # 计算上下界
                if (labelMat[i] != labelMat[j]):
                    L = max(0, alphas[j] - alphas[i])
                    H = min(C, C + alphas[j] - alphas[i])
                else:
                    L = max(0, alphas[j] + alphas[i] - C)
                    H = min(C, alphas[j] + alphas[i])
                if L == H: print("L==H"); continue
                # 计算eta
                eta = 2.0 * dataMatrix[i, :] * dataMatrix[j, :].T - dataMatrix[i, :] * dataMatrix[i, :].T - dataMatrix[
                                                                                                            j,
                                                                                                            :] * dataMatrix[
                                                                                                                 j, :].T
                if eta >= 0: print("eta>=0"); continue
                # 计算alpha[j]，为了和公式对应把j看出2
                alphas[j] -= labelMat[j] * (Ei - Ej) / eta
                # 剪辑alpha[j]，为了和公式对应把j看出2
                alphas[j] = clipAlpha(alphas[j], H, L)
                if (abs(alphas[j] - alphaJold) < 0.00001): print("j not moving enough"); continue
                # 计算alpha[i] ，为了和公式对应把j看出1
                alphas[i] += labelMat[j] * labelMat[i] * (alphaJold - alphas[j])
                # 计算b1
                b1 = b - Ei - labelMat[i] * (alphas[i] - alphaIold) * dataMatrix[i, :] * dataMatrix[i, :].T - labelMat[
                    j] * (alphas[j] - alphaJold) * dataMatrix[i, :] * dataMatrix[j, :].T
                # 计算b2
                b2 = b - Ej - labelMat[i] * (alphas[i] - alphaIold) * dataMatrix[i, :] * dataMatrix[j, :].T - labelMat[
                    j] * (alphas[j] - alphaJold) * dataMatrix[j, :] * dataMatrix[j, :].T
                # 求解b
                if (0 < alphas[i]) and (C > alphas[i]):
                    b = b1
                elif (0 < alphas[j]) and (C > alphas[j]):
                    b = b2
                else:
                    b = (b1 + b2) / 2.0
                alphaPairsChanged += 1
                print("iter: %d i:%d, pairs changed %d" % (iter, i, alphaPairsChanged))
        if (alphaPairsChanged == 0):
            iter += 1
        else:
            iter = 0
        print("iteration number: %d" % iter)
    return b, alphas


# 计算W
def clacWs(alphas, dataArr, classLabels):
    X = mat(dataArr)
    labelMat = mat(classLabels).transpose()
    m, n = shape(X)
    # 初始化w都为0
    w = zeros((n, 1))
    # 循环计算
    for i in range(m):
        w += multiply(alphas[i] * labelMat[i], X[i, :].T)
    return w


if __name__ == '__main__':
    # 加载数据
    dataMat, labelMat = loadDataSet('data/svm1.txt')
    print(dataMat)
    print(labelMat)

    # 画散点图
    fig = plt.figure()
    ax = plt.subplot(111)
    cm_dark = mpl.colors.ListedColormap(['g', 'r'])
    # squeeze
    ax.scatter(array(dataMat)[:, 0], array(dataMat)[:, 1], c=array(labelMat).squeeze(), cmap=cm_dark, s=30)

    # 调用上述方法。求解w,b,alpha
    b, alphas = smoSimple(dataMat, labelMat, 0.6, 0.001, 40)
    w = clacWs(alphas, dataMat, labelMat)
    print('b=', b)
    print('alphas=', alphas)
    print('w =', w)

    # 画决策平面
    x = arange(-2.0, 12.0, 0.1)
    y = (-w[0] * x - b) / w[1]
    ax.plot(x, y.reshape(-1, 1))
    ax.axis([-2, 12, -8, 6])

    # 画支持向量
    alphas_non_zeros_index = where(alphas > 0)
    for i in alphas_non_zeros_index[0]:
        circle = Circle((dataMat[i][0], dataMat[i][1]), 0.2, facecolor='none', edgecolor=(0, 0.8, 0.8), linewidth=3,
                        alpha=0.5)
        ax.add_patch(circle)

    plt.show()

alphas= [[0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [1.27884050e-01]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [2.36842979e-01]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [3.58790483e-04]
 [0.00000000e+00]
 [0.00000000e+00]
 [3.65085820e-01]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]
 [0.00000000e+00]]
w = [[ 0.80439548]
 [-0.27554872]]

在这里插入图片描述

6.SVM代码改进版

# 改进以加快SVM的运行速度
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.patches import Circle
from numpy import *


# 加载数据
def loadDataSet(fileName):
    dataMat = []
    labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = line.strip().split('\t')
        dataMat.append([float(lineArr[0]), float(lineArr[1])])
        labelMat.append(float(lineArr[2]))
    return dataMat, labelMat


# SMO算法实现-α的求解过程

# alpha的选取，随机选择一个不等于i值的j
def selectJrand(i, m):
    j = i
    while (j == i):
        # random.uniform()可以生成[low,high)中的随机数，可以是单个值
        j = int(random.uniform(0, m))
    return j


# 进行剪辑
def clipAlpha(aj, H, L):
    if aj > H:
        aj = H
    if L > aj:
        aj = L
    return aj

# 定义一个新的数据结构-将常用的参数进行封装
class optStruct:
    def __init__(self,dataMatIn, classLabels, C, toler):
        self.X = dataMatIn
        self.labelMat = classLabels
        self.C = C
        self.tol = toler
        self.m = shape(dataMatIn)[0]
        self.alphas = mat(zeros((self.m,1)))
        self.b = 0
        # 第一列是标志位，0无效 1有效
        self.eCache = mat(zeros((self.m,2)))

# 计算Ei的方法
def calcEk(oS,k):
    fXk = float(multiply(oS.alphas, oS.labelMat).T * (oS.X*oS.X[k,:].T)) + oS.b
    Ek = fXk - float(oS.labelMat[k])
    return Ek

# 选择第二个待优化的alpha j，选择一个误差最大的alpha j
def selectJ(i,oS,Ei):
    # 初始化
    maxK = -1
    maxDeltaE = 0
    Ej = 0

    # 设为有效
    oS.eCache[i] = [1,Ei]
    # 非零项
    validEcacheList = nonzero(oS.eCache[:, 0].A)[0]
    if (len(validEcacheList)) > 1:
        # 迭代所有有效的缓存，找到误差最大的E
        for k in validEcacheList:
            # 不选择和i相等的值
            if k == i:
                continue
            Ek = calcEk(oS, k)
            deltaE = abs(Ei - Ek)
            if (deltaE > maxDeltaE):
                maxK = k
                maxDeltaE = deltaE
                Ej = Ek
        return maxK, Ej
    else:
    # 第一次循环时是没有有效的缓存值得，所以随机选一个(仅会执行一次)
        j = selectJrand(i, oS.m)
        Ej = calcEk(oS, j)
    return j, Ej

# 更新缓存
def updateEk(oS,k):
    Ek = calcEk(oS,k)
    oS.eCache[k] = [1,Ek]

def innerL(i, oS):
    # 计算Ei值
    Ei = calcEk(oS, i)
    # 满足这个条件，α值才能得到更新
    if ((oS.labelMat[i]*Ei < -oS.tol) and (oS.alphas[i] < oS.C)) or ((oS.labelMat[i]*Ei > oS.tol) and (oS.alphas[i] > 0)):
        j,Ej = selectJ(i, oS, Ei) #这里不再是随机选取了
        alphaIold = oS.alphas[i].copy()
        alphaJold = oS.alphas[j].copy()
        if (oS.labelMat[i] != oS.labelMat[j]):
            L = max(0, oS.alphas[j] - oS.alphas[i])
            H = min(oS.C, oS.C + oS.alphas[j] - oS.alphas[i])
        else:
            L = max(0, oS.alphas[j] + oS.alphas[i] - oS.C)
            H = min(oS.C, oS.alphas[j] + oS.alphas[i])
        if L==H: print("L==H"); return 0
        eta = 2.0 * oS.X[i,:]*oS.X[j,:].T - oS.X[i,:]*oS.X[i,:].T - oS.X<
最低0.47元/天 解锁文章
哎呦-_-不错
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SVM支持向量机目标函数及参数训练过程说明解读
嵌入式移动开发
06-18 7157
目标函数如下： 这个和线性可分支持向量机形式类似推导过程相同，区别在于利用拉格朗日求最优化值的时候，多了参数C和ksi，推导出来的约束条件alpha_i 从>=0  变成了0 对alpha_i 求导（梯度gradient可以由如下导数和约束推导得到）： 含有不等式约束的KKT条件是SVM收敛的充分必要条件：如下式子也是训练停止的条件。 解释如下：当a
目标函数与支持向量机：机器学习的关键因素
程序员光剑
12-31 854
1.背景介绍 机器学习(Machine Learning)是一种通过数据学习模式和规律的计算机科学领域。它主要包括以下几个方面： 数据收集与预处理：包括数据的收集、清洗、转换和归一化等方面。 算法选择与优化：包括选择合适的算法以及对算法进行优化和调整。 模型训练与验证：包括模型的训练、验证以及模型的评估和选择。 应用与部署：包括模型的应用以及模型的部署和监控。 支持向量机(Support...
SVM再次总结 - 3 - 线性支持向量机
xueyingxue001的专栏
07-19 653
说明：此篇是作者对“SVM”的第二次总结，因此可以算作对上次总结的查漏补缺以及更进一步的理解，所以很多在第一次总结中已经整理过的内容在本篇中将不再重复，如果你看的有些吃力，那建议你看下我的第一次总结：       http://blog.csdn.net/xueyingxue001/article/details/51261397   百分百正确一定是最好的吗       先看一个情况，如
07_支持向量机1_统计学习方法
Hayden的博客
07-14 295
文章目录一、支持向量机的介绍二、支持向量机模型1、何为分类间隔（1）函数间隔（2）几何间隔2、分类间隔最大化3、支持向量机中涉及的数学知识（1）凸函数（2）常见最优化问题（3）拉格朗日函数（4）KKT条件（5）拉格朗日对偶性（6）对偶问题4、线性可分支持向量机的优化5、线性可分支持向量机对偶问题的求解（1）求解对偶问题的内层（2）求解对偶问题的外层三、线性支持向量机1、线性支持向量机目标函数2、拉...
支持向量机之目标函数
fq_wallow的博客
05-20 3507
支持向量机（SVM）一般用于分类，当然，还可用于回归，如果感兴趣，可在网上查阅，本文主要简单介绍SVM的部分原理，为了方便理解，对于太复杂的公式，等理解了一部分再看。 SVM可用于线性可分以及线性不可分的情况，当然，我们学习其原理的时候，先学最基础的，后面再学难一点的，只会事半功倍。本文暂时只说明线性可分的SVM，至于线性不可分的情况以及序列最小最优化（SMO）算法，后面再写几篇进行补充。 以下是我根据个人理解，尽可能简单的阐述其原理，如有错误之处，请指出，我会加以改正的。 首先引入一个问题：现有一些样本，
机器学习5---支持向量机
aBIT_Tu的博客
09-10 464
1. 线性可分的支持向量机 1.1 支持向量机（SVM）基本型 对于给定的在样本空间中线性可分的训练集，我们有多重办法对其进行划分，以二分类问题为例，如图： 红线和黑线（超平面）都能将两类样本很好的划分开，但是当新样本进入时，黑线比红线更加有可能正确划分新的样本，换句话说：越位于两类样本“中心”的划分超平面越能够容忍样本的局部扰动，其的泛化能力越好。 基于以上思想，我们准备求解最优超平...
机器学习之深度学习基础--支持向量机（SVM）视频教学
06-09
支持向量机（Support Vector Machine，SVM）是机器学习领域的一种强大算法，尤其在分类和回归任务中表现优秀。SVM的核心思想是找到一个最优的超平面，以最大化数据点到该超平面的距离，从而实现对数据的有效划分。在...
机器学习实战(第六章-支持向量机-所有代码与详细注解-python3.7)
12-18
支持向量机（Support Vector Machines，SVM）是机器学习领域一种强大的监督学习算法，尤其在分类和回归问题上表现出色。本章聚焦于通过Python 3.7实现支持向量机，提供详尽的代码注解，帮助读者深入理解其工作原理。...
数据挖掘机器学习-支持向量机libsvm实验报告.docx
06-16
支持向量机（Support Vector Machine，简称SVM）是一种广泛应用于数据挖掘和机器学习领域的监督学习模型，尤其在分类和回归任务中表现出色。实验报告的主题是“数据挖掘机器学习-支持向量机libsvm实验”，它涉及到...
SVM_data1.mat
12-30
SVM 数据集合。每条数据含有两个features:x[0]和x[1]，有label对应。
Python机器学习(scikit-learn)：监督学习 - 支持向量机-谢TS的博客.pdf
07-19
**支持向量机(SVM)** 是一种监督学习算法，广泛应用于分类、回归和异常值检测任务。SVM的核心思想是找到一个最优超平面，将不同类别的数据尽可能地分开，同时最大化类别之间的间隔。在高维空间中，即使样本数量少于...
熊崽子./机器学习-支持向量机对 iris 数据和**癌数据的二分类实现-sklearn实现-支持向量机资源
最新发布
07-01
支持向量机对 iris 数据和**癌数据的二分类实现
SVM——（一）线性可分之目标函数推导方法1
空字符
11-12 6902
最近在看支持向量机，也查了很多资料。其中关于如何推导出最终的优化目标函数（见文末(2.14)(2.14)）主要有两种方式。第一种就是本文所介绍的，直接通过一个（几何）距离来推导，如周志华机器学习中的SVM就是采用的这种方式；第二种就是下文中所要介绍的，先引入函数间隔，再引入几何间隔，然后得到优化目标函数。对于这两种方法，有人可能先接触到第一种，遇到问题查资料，结果又看到原来还有第二种（我本人就是这样
SVM 的核函数选择和调参
热门推荐
aliceyangxi1987的博客
06-08 3万+
本文结构： 1. 什么是核函数 2. 都有哪些 &amp; 如何选择 3. 调参 1. 什么是核函数 核函数形式 K(x, y) = &lt;f(x), f(y)&gt;， 其中 x, y 为 n 维，f 为 n 维到 m 维的映射，&lt;f(x), f(y)&gt; 表示内积。 在用SVM处理问题时，如果数据线性不可分，希望通过 将输入空间内线性不可分的数据 映射到 ...
SVM原理与调参
thxiong1234的博客
03-30 4324
一、SVM基本原理：支持向量机（support vector machines）是一个二分类的分类模型（或者叫做分类器）。如图：它分类的思想是，给定给一个包含正例和反例的样本集合，svm的目的是寻找一个超平面来对样本根据正例和反例进行分割。在样本空间中，划分超平面可通过如下线性方程来描述：SVM的核心思想是尽最大努力使分开的两个类有最大间隔，这样才能使得分割有更高的可信度。如图所示：在这两个超平面...
支持向量机SVM①——Sklearn核函数参数介绍(线性&高斯&多项式&sigmond)
cindy407的博客
06-28 2万+
本来想先写一篇支持向量机的原理篇，结果在白天钻研，晚上做梦都在思考的2周后，还是没有搞太明白，实在是见识到了人类智慧的博大精深和自我的渺小。因此我还是先从应用下手，先用到慢慢体会好了。本篇主要介绍sklearn库的svm的分类和回归参数，其中重点介绍四大核函数的参数。 之前在未调参的情况下将svm和决策树、贝叶斯进行了分类对比，发现训练器分数巨低，且训练过程时间是真的长，长到怀疑人生。所以想要SV...
SVM支持向量机原理(一) 线性支持向量机
sun_shengyun的专栏
02-18 3852
此篇文章并非完全原创，参考了下篇博客，如果大家觉得稳重的1、2、3部分不好理解，可以看下图中我的手写版。 http://www.cnblogs.com/pinard/p/6097604.html 支持向量机(Support Vecor Machine,以下简称SVM)虽然诞生只有短短的二十多年，但是自一诞生便由于它良好的分类性能席卷了机器学习领域，并牢牢压制了神经网络领域好多年。如
机器学习9-案例1：银行营销策略分析
柳杰的博客
09-15 5344
文章目录1.数据说明与预处理2.探索性分析3.数据的预处理与特征工程4.模型训练5.模型评价 1.数据说明与预处理 import pandas as pd import matplotlib.pyplot as plt # 加载数据 bank = pd.read_csv('data/bank-full.csv',delimiter=';') # 通过查看前五行简要查看数据集的构成 print(bank.head(5)) # 通过describe()和info()函数查看各类数据的分布情况 # 用 des
Python机器学习实战：支持向量机(SVM)详解
"这篇资源是关于Python机器学习中的支持向量机(SVM)理论与实战的讲解，适合对机器学习感兴趣的读者参考。内容包括SVM的优化目标、松弛变量、拉格朗日乘子法、核函数等核心概念，并探讨了C参数在模型中的作用以及如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值