朴素贝叶斯之自然语言语义分析（二）：TF-IDF运行原理深入剖析-Spark手撕篇

最新推荐文章于 2024-01-27 21:54:03 发布
最新推荐文章于 2024-01-27 21:54:03 发布
阅读量785 收藏 3
点赞数
分类专栏： 机器学习篇 文章标签： 机器学习 算法 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010271601/article/details/104447813
版权

文章目录

1、TF-IDF介绍

（1）意义

主要用于自然语言中文本特征向量化。

特征向量化方案：

  • 词的特征位置映射： Hash映射
  • 词的特征值选取：不再简单地用词频作为特征值，而改用NLP中最经典的衡量一个词在一篇文章中重要性的指标（TF-IDF）
（2）核心思想
  • 这个词在一篇文章中出现的频次越高，重要性越高！
  • 在整个样本集中，含有这个词的文章数越少，这个词重要性越高！
（3）计算公式

TF-IDF =TF × IDF

  • TF ：词频（可以用频次，也可以用频率）
  • IDF：逆文档频率 ＝ log( 文档总数 / (1+出现这个词的文档数) )

比如说：
经验样本中共有3篇文档。在一篇文档中有“电池”这个词，且出现了3次。其余两篇文档中没有出现这个词。
那么TF-IDF = 3 × log(3 / (1+1) )

在一篇文档中有“手机”这个词，且出现了3次，其余两篇文档中也出现了这个词。
那么TF-IDF = 3 × log(3 / ( 3+1) )

2、需求分析

（1）样本数据

需求：有如下的数据，将该文本的特征向量化

docid,doc
1,a a a a a a x x y
2,b b b x y
3,c c x y
4,d x
（2）分析

需要确定三点：

  • 向量的长度：去重后的词个数 × 10（可取别的，尽量大，减少哈希碰撞）
  • 词在向量中的特征位置：词的Hash映射
  • 词在向量中的特征值：TF-IDF

该样本中，计算TF-IDF的思路如下图：
在这里插入图片描述

（3）技术点
  • SparkSql的DSL风格★★
  • Spark相关算子★★
  • UDF函数 ★★★
  • UDAF函数★★★★★

3、实战 · 深入剖析

代码共分三大块：

  • 主线代码
  • 工具类代码
  • UDFA函数代码
（1）主线代码
package cn.ianlou.tf_idf

import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
 * @date: 2020/2/22 21:50
 * @site: www.ianlou.cn
 * @author: lekko 六水
 * @qq: 496208110
 * @description:
 *
 */
object TFIDF_SQL {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)

    val spark: SparkSession = SparkSession
      .builder()
      .appName(this.getClass.getSimpleName)
      .master("local[*]")
      .getOrCreate()


    // 1、 读取文件加载数据
    val sample: DataFrame = spark.read
      .option("header", true)
      .csv("userProfile/data/tfidf/docs.txt")

    import cn.ianlou.tf_idf.TF_IDF_Utils._


    // 2、特征向量化工程 -> TF词频向量化

    // 自定义UDF函数 docToTF( )，并注册   设定向量长度为26（26个字母数）
    spark.udf.register("docToTF", docToTF)
    val tf: DataFrame = sample.selectExpr("docid", "docToTF(doc, 26) as tfArr")

    /** TF数据如下：
     * +-----+-------------------------------------------------------------------+
     * |docid|       tfArr                                                       |
     * +-----+-------------------------------------------------------------------+
     * |1    |[0.0, 0.0, ...... 2.0, 1.0, 0.0, 6.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]|
     * |2    |[0.0, 0.0, ...... 1.0, 1.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0]|
     * |3    |[0.0, 0.0, ...... 1.0, 1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0]|
     * |4    |[0.0, 0.0, ...... 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]|
     * +-----+-------------------------------------------------------------------+
     */


    // 3、特征向量化工程 -> TF数组中不为0的值替换成1，规范、归一化
    spark.udf.register("tfarrToOne", tfarrToOne)
    val toOneTmp: DataFrame = tf.selectExpr("docid", "tfarrToOne(tfArr) as toOne")

    /** 归一化后的数据：
     * +-----+------------------------------------------------------------------------------+
     * |docid|           toOne                                                              |
     * +-----+------------------------------------------------------------------------------+
     * |1    |[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]|
     * |2    |[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0]|
     * |3    |[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0]|
     * |4    |[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]|
     * +-----+------------------------------------------------------------------------------+
     */


    // 4、特征向量化工程 -> 将归一化后的所有数组，对应位置的元素累加到一起
    // 获得该位置的词 出现过的文档数量
    //sparkSql中没有对多行数组进行聚合的，多进一出，所以需要写UDAF函数 arrSum()
    import cn.ianlou.tf_idf.ArrSumUDAF
    spark.udf.register("arrSum", ArrSumUDAF)

    val docCntDF: DataFrame = toOneTmp.selectExpr("arrSum(toOne) as wd_Doc_Cons")

    /** 映射在特征向量中位置的词语，在经验样本中所出现过的文档数：
     * +-----------------------------------------------------------------------------+
     * |      wd_Doc_Cons                                                            |
     * +-----------------------------------------------------------------------------+
     * |[0.0, 0.0, 0.0, ...... 0.0, 4.0, 3.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]|
     * +-----------------------------------------------------------------------------+
     */


    // 5、计算IDF -> log(文档总数/(1+词出现过的文档数))

    val total: Long = sample.count()
    spark.udf.register("doc_consToIdf", doc_consToIdf)

    val idf: DataFrame = docCntDF.selectExpr("doc_consToIdf(wd_Doc_Cons, " + total + ") as idf")


    /** 得到的IDF:
     * +-------------------------------------------------------------------------------------------+
     * |idf                                                                                        |
     * +-------------------------------------------------------------------------------------------+
     * |[2.602......2.602, -0.001, 0.123, 2.602, 0.598, 0.598, 0.598, 0.598, 2.602, 2.602, 2.602]  |
     * +-------------------------------------------------------------------------------------------+
     */


    // 6、将TF 和 IDF 做拉链，然后相乘得到TF-IDF

    val frame: DataFrame = tf.crossJoin(idf)
    spark.udf.register("toTF_IDF", toTF_IDF)

    val final_TFIDF: DataFrame = frame.selectExpr("toTF_IDF(tfArr, idf)")

    final_TFIDF.show(20, false)

    /** 得到的最终的TF-IDF：
     * +-----------------------------------------------------------------------------------+
     * |               UDF:toTF_IDF(tfArr, idf)                                            |
     * +-----------------------------------------------------------------------------------+
     * |[0.0, ...0.0, 0.0, -0.00217, 0.12349, 0.0, 3.58643, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  |
     * |[0.0, ...0.0, 0.0, -0.00108, 0.12349, 0.0, 0.0, 1.79321, 0.0, 0.0, 0.0, 0.0, 0.0]  |
     * |[0.0, ...0.0, 0.0, -0.00108, 0.12349, 0.0, 0.0, 0.0, 1.195477, 0.0, 0.0, 0.0, 0.0] |
     * |[0.0, ...0.0, 0.0, -0.00108, 0.0, 0.0, 0.0, 0.0, 0.0, 0.59774, 0.0, 0.0, 0.0]      |
     * +-----------------------------------------------------------------------------------+
     */

    spark.close()
  }
}
（2）工具类代码
package cn.ianlou.tf_idf
import scala.collection.mutable

/**
 * @date: 2020/2/22 21:56
 * @site: www.ianlou.cn
 * @author: lekko 六水
 * @qq: 496208110
 */
object TF_IDF_Utils {

  /**
   * UDF函数：
   * 输入一篇文档，输出TF词频的特征向量（数组类型）
   * a a a a a a x x y => [0, 6, 0, 1...0, 2, 0]
   */
  val docToTF = (doc: String, len: Int) => {

    //构建一个空数组，元素都为0.0，长度为len
    val arr: Array[Double] = Array.fill(len)(0.0)
    val tmap: Map[String, Array[String]] = doc.split(" ").groupBy(e => e)

    // <(a -> 6), (x -> 2), (y -> 1)>
    val wcount: Map[String, Int] = tmap.map(mp => (mp._1, mp._2.size))

    //将arr空数组中的值替换，按词的hash值映射到数组中
    for ((k, v) <- wcount) {
      val index: Int = (k.hashCode & Integer.MAX_VALUE) % len
      arr(index) = v
    }
    arr
  }


  /**
   * UDF函数：
   * 输入一个数组，将数组中的非0值，替换成1
   */
  val tfarrToOne = (arr: mutable.WrappedArray[Double]) => {
    arr.map(e => if (e != 0) 1 else 0)
  }


  /**
   * UDF函数：
   * 将聚合好的词所出现过的文档数的数组，计算后转成IDF log(文档总数/(1+词文档数))
   */
  val doc_consToIdf = (arrs: mutable.WrappedArray[Double], total: Int) => {
    arrs.map(e => Math.log10(total / (0.01 + e)))
  }


  /**
   *  UDF函数：
   *    将TF和IDF结果crossJoin后，输入TF数组和IDF数组，
   *    输出两个数组对应位置上元素相乘后的结果数组
   */
  val toTF_IDF = (arr1: mutable.WrappedArray[Double], arr2: mutable.WrappedArray[Double]) => {

    arr1.zip(arr2).map(tp => (tp._1 * tp._2))
  }
}
（3）UDAF函数
package cn.ianlou.tf_idf
import org.apache.spark.sql.Row
import org.apache.spark.sql.expressions.{MutableAggregationBuffer, UserDefinedAggregateFunction}
import org.apache.spark.sql.types.{DataType, DataTypes, StructType}

/**
 * @date: 2020/2/22 23:09
 * @site: www.ianlou.cn
 * @author: lekko 六水
 * @qq: 496208110
 * @description: UDAF用户自定义聚合函数：多进一出
 *               需要继承UserDefinedAggregateFunction，并实现所有的抽象方法
 */
object ArrSumUDAF extends UserDefinedAggregateFunction {

  //函数的输入参数，有几个字段，分别是什么类型   arrSum(toOne)
  override def inputSchema: StructType = new StructType()
    .add("toOne", DataTypes.createArrayType(DataTypes.DoubleType))


  // buffer 是在聚合函数运算过程中，用于存储局部聚合结果的缓存
  override def bufferSchema: StructType = new StructType()
    .add("buffer", DataTypes.createArrayType(DataTypes.DoubleType))


  // 最后返回结果的数据类型，在本需求中，还是一个Double数组
  override def dataType: DataType = DataTypes.createArrayType(DataTypes.DoubleType)


  // 聚合运算逻辑，是否总是能返回确定结果
  override def deterministic: Boolean = true


  //对buffer进行初始化，在本需求中，我们先给一个长度为0的空double数组
  override def initialize(buffer: MutableAggregationBuffer): Unit = buffer
    .update(0, Array.emptyDoubleArray)

  //局部聚合的逻辑所在地，大的逻辑就是，根据输入的一行数据input,来更新局部缓存buffer中的数据
  override def update(buffer: MutableAggregationBuffer, input: Row): Unit = {
    // 1、从Row中取出double类型的数组
    val inpArr: Seq[Double] = input.getSeq[Double](0)
    var buffArr: Seq[Double] = buffer.getSeq[Double](0)

    // 2、判断初始缓存数组大小是否为0， 若是，则buff数组为初始数组，然后给定初始数组的长度
    if (buffArr.size < 1) buffArr = Array.fill(inpArr.size)(0.0)

    // 3、将buffer数组和输入的数组进行拉链，然后sum相加
    buffArr = buffArr.zip(inpArr).map(tp => (tp._1 + tp._2))

    // 4、将聚合结果更新到buffer中去
    buffer.update(0, buffArr)
  }


  // 全局聚合逻辑所在地，将各个partition的局部聚合结果，往buffer上做累加
  override def merge(buffer1: MutableAggregationBuffer, buffer2: Row): Unit = {
    val inpArr: Seq[Double] = buffer2.getSeq[Double](0)
    var finalArr: Seq[Double] = buffer1.getSeq[Double](0)
    if (finalArr.size < 1) finalArr = Array.fill(inpArr.size)(0.0) //初始化全局聚合的累加数组

    finalArr = finalArr.zip(inpArr).map(tp => (tp._1 + tp._2))

    buffer1.update(0, finalArr)
  }


  // 最后向外部返回最终的全局聚合结果
  override def evaluate(buffer: Row): Any = buffer.getSeq[Double](0)
}

4、TF-IDF直接调用篇

上面的手撕，是为了更加清楚、理解TF-IDF整个的计算过程、计算原理。

其实有封装好的算法，可直接调用，就能得到TF-IDF：

（1）代码
package cn.ianlou.tf_idf

import org.apache.log4j.{Level, Logger}
import org.apache.spark.ml.feature.{HashingTF, IDF, IDFModel}
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
 * @date: 2020/2/23 21:06
 * @site: www.ianlou.cn
 * @author: lekko 六水
 * @qq: 496208110
 * @description:
 *
 */
object TFIDF_Mllib {
  def main(args: Array[String]): Unit = {

    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)

    val spark: SparkSession = SparkSession
      .builder()
      .appName(this.getClass.getSimpleName)
      .master("local[*]")
      .getOrCreate()


    val sample: DataFrame = spark.read
      .option("header", true)
      .csv("userProfile/data/tfidf/docs.txt")


    // 1、加载样本数据，进行切词
    val sampleDF: DataFrame = sample.selectExpr("docid", "split(doc, ' ') as words")

    // 2、 构建hashingTF对象，获取TF值向量
    val tfDF: HashingTF = new HashingTF()
      .setInputCol("words")
      .setOutputCol("tf_vector")
    val tf: DataFrame = tfDF.transform(sampleDF)


    // 3、构建IDF对象，获取IDF模型向量
    val idfDF: IDF = new IDF()
      .setInputCol("tf_vector")
      .setOutputCol("tfidf_vec")

    val idf_model: IDFModel = idfDF.fit(tf)


    // 4、将TF和IDF转换成TF-IDF
    val tfidf: DataFrame = idf_model.transform(tf)

    tfidf.show(20, false)

    spark.close()
  }
}
（2）问题解决

正如上一篇提到的，用TF-IDF作为特征值有效解决了，用词频代表特征值的局限性和不妥性。

TFIDF也是最经典的，处理NLP中衡量一个词在一篇文章重要性的指标。

IT但丁
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现knn、naive bayes、vsm、tf-idf模型（包含数据集）
06-11
python实现knn、naive bayes、vsm、tf-idf模型。并包含数据集
TF-IDF算法和余弦相似度算法计算文本相似度（纯手撕）
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
09-06 9005
一、TF-IDF算法   TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。   TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。   TF-IDF的主要思想是：如果某个单词在一篇文章中
朴素贝叶斯之自然语言语义分析（一）：简单文本主题分类→手撕文本特征向量化
IT_但丁的博客
02-21 767
1、需求说明 （1）经验样本数据： docid,label,doc doc0,1,苹果 官网 苹果 宣布 骁龙 安卓 doc1,0,苹果 梨 香蕉 桔子 肥料 甜度 doc2,0,苹果 梨 桔子 保鲜 甜度 doc3,1,苹果 科技 手机 官网 宣布 安卓 骁龙 （2）对下面的未知类别文档做分类预测： docid,doc doc1,苹果 香蕉 甜度 doc2,苹果 手机 安卓 骁龙 2、难点分...
TF-IDF计算相似文章
liuhe2296044的博客
12-31 217
%spark_recommend.pyspark from pyspark.sql.types import BooleanType,LongType from scipy.stats import norm, t from pyspark.sql import SparkSession, DataFrame, functions as F from pyspark.sql.functions ...
TF-IDF原理及算法实现
萤火之光，照亮前行
05-20 7769
一、TF-IDF算法介绍 TF-IDF(term frequency–inverse document frequency，词频-逆向文件频率)是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术. TF-IDF是一种统计方法，用以评估字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。 TF-IDF主要思想：如果一个单词在该文章中出现的频率(
使用python进行朴素贝叶斯的数据分析，使用TF-IDF方法整理数据
07-02
使用python进行朴素贝叶斯的数据分析，使用TF-IDF方法整理数据
机器学习文本分类基于TF-IDF+手写朴素贝叶斯
02-08
人工智能大作业，文本分类，TF-IDF+手写朴素贝叶斯。本项目利用分类算法实现对文本的数据挖掘，主要包括：1. 语料库的构建，主要从搜狗语料库、复旦大学中文语料库等搜集文章作为训练集和测试集；2. 语料库的数据...
机器学习文本分类基于TF-IDF+朴素贝叶斯文本数据的分类与分析源码（高分大作业）.zip
04-18
机器学习文本分类基于TF-IDF+朴素贝叶斯文本数据的分类与分析源码（高分大作业）.zip本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够...
人工智能大作业基于TF-IDF+手写朴素贝叶斯实现文本分类python源码+实验报告.zip
08-10
人工智能大作业基于TF-IDF+手写朴素贝叶斯实现文本分类python源码+实验报告.zip 人工智能大作业基于TF-IDF+手写朴素贝叶斯实现文本分类python源码+实验报告.zip 人工智能大作业基于TF-IDF+手写朴素贝叶斯实现文本...
人工智能大作业基于TF-IDF+手写朴素贝叶斯实现文本分类python源码+文档说明.zip
最新发布
04-18
人工智能大作业基于TF-IDF+手写朴素贝叶斯实现文本分类python源码+文档说明.zip本资源中的源码都是经过本地编译过可运行的，评审分达到95分以上。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习...
TF-IDF计算程序
05-23
计算TF-IDF的程序，使用java编写，能计算出输入文档的TF-idf值
TF-IDF算法讲解
qq_45893319的博客
07-31 3万+
什么是 TF-IDF 算法？ TF（全称TermFrequency），中文含义词频，简单理解就是关键词出现在网页当中的频次。 IDF（全称InverseDocumentFrequency），中文含义逆文档频率，简单来说就是该关键词出现在所有文档里面的一种数据集合。 在信息检索中，tf-idf或TFIDF（术语频率 – 逆文档频率的缩写）是一种数字统计，旨在反映单词对集合或语料库中的文档的重要程度。 它经常被用作搜索信息检索，文本挖掘和用户建模的加权因子。tf-idf值按比例增加一个单词出现在文档中的次数，并
详解TF-IDF
real_ilin的博客
01-12 1万+
IF-IDF概念 TF-IDF是NLP中常用的方法，也比较经典。IF-IDF的思想：如果一个词在文档中出现了很多次，但是这个词在其它文档中出现的次数很少，则这个词对这篇文档很重要，在一定程度上可以代表这个文档的关键信息。所以在网页搜索、关键词提取中常用到IF-IDF。 TF-IDF就是tf−idf(t,d)=tf(t,d)×idf(t)tf-idf(t,d)=tf(t,d) \times idf(...
机器学习：TF-IDF 算法学习
myksecret的博客
01-27 1814
考虑到文章有长短之分，为了便于不同文章的比较，进行"词频"标准化。
NLP自然语言处理——关键词提取之 TF-IDF 算法（五分钟带你深刻领悟TF-IDF算法的精髓）
荆鹏的博客
09-13 1万+
新手入门保姆级教程!!!自然语言文本预处理、TF-IDF算法详解（三个维度：原理、流程图、代码）、好玩的中文关键词“词云生成”（解决乱码问题）# 获取停用词# 加载文档集，对文档集过滤词性和停用词# 使用TF-IDF提取关键词# 将过滤后的文档集转化为文本列表# 创建TF-IDF向量化器# 计算TF-IDF权重# 获取特征词列表。
TF-IDF
abc1234564546的博客
08-03 653
TF-IDF自然语言处理
TF-IDF和贝叶斯网络
gaobing1993的博客
09-27 570
1.TF-IDF TF-IDF(term frequency inverse document frequency)是一种将词转换为数值表示的方式。常用的one-hot编码的方式，数据太过于稀疏，如果词表中的词比较多，其占用的空间也很大。以前我们也聊过基于神经网络语言模型的词向量表示方式Word2Vector,比 one-hot使用空间较少；今天我们聊的TF-IDF是一种基于统计学的词向量表示方式。 TF(term frequency)指得就是一个词在整篇文章中出现的频率。计算...
TF-IDF公式
jfhdd的博客
03-28 9217
TF：（Term Frequency）词频 式子中分子是该词在文件中的出现次数，而分母则是在文件中所有字词的出现次数之和IDF ：（inverse document frequency） 逆向文件频率 其中 分子：语料库中的文件总数 分母：包含词语的文件数目（即的文件数目）某一特定词语的IDF，由总文件数目除以包含该词语之文件的数目，再将得到的商取对数得到很明显，如果对于一个特定的词语
[python] 使用scikit-learn工具计算文本TF-IDF值
热门推荐
杨秀璋的专栏
08-08 8万+
在文本聚类、文本分类或者比较两个文档相似程度过程中，可能会涉及到TF-IDF值的计算。这里主要讲述基于Python的机器学习模块和开源工具：scikit-learn。文章包括：一.Scikit-learn概念 1.概念知识 2.安装软件； 二.TF-IDF基础知识 1.TF-IDF 2.举例介绍； 三.TF-IDF调用两个方法 1.CountVectorizer 2.TfidfTransformer 3.示例 希望文章对你有所帮助~
tf-idf 朴素贝叶斯
11-30
tf-idf是一种机器学习中常用的特征提取方法，它可以用来...总结起来，tf-idf是一种用于提取文本特征的方法，而朴素贝叶斯是一种基于贝叶斯定理和特征条件独立性假设的分类算法。它们可以结合使用来进行文本分类任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值