Spark排序算法系列之ALS模型实现

最新推荐文章于 2024-06-26 17:02:00 发布
最新推荐文章于 2024-06-26 17:02:00 发布
阅读量3.2k 收藏 8
点赞数 4
分类专栏： # CTR排序算法-ML 文章标签： ALS Spark 推荐系统开发实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gamer_gyt/article/details/99432555
版权

转载请注明出处：http://blog.csdn.net/gamer_gyt
博主微博：http://weibo.com/234654758
Github：https://github.com/thinkgamer
公众号：搜索与推荐Wiki
个人网站：http://thinkgamer.github.io

在上一篇文章中介绍了ALS算法的原理（点击阅读），在这篇文章中主要介绍一下ALS算法在Spark中的实现。

概述

协同过滤(Collaborative Filtering)在推荐系统中应用的非常广，该算法的目标是去填充用户-物品评分矩阵中的缺失值，即未评分。该算法的Spark的ML包和MLlib包中均有实现。

其中涉及的参数如下：

  • numBlocks：数据分区的数目，默认为10
  • rank：隐向量的长度，默认是10（m * n => m * k - k * n）
  • maxIter：最大迭代次数，默认为10
  • regParam：正则化参数系数，默认为1.0
  • implicitPrefs：控制使用显式反馈还是隐式反馈，默认是false即显式反馈。
  • alpha：隐式反馈时的置信度参数，默认为1.0
  • nonnegative：是否对最小二乘使用非负约束，默认为false

隐式反馈与显式反馈

基于矩阵分解的协同过滤标准方法将用户-物品矩阵中的rate视为用户对项目给出的显式偏好，例如：用户对电影进行评分。

在许多实际的用例中，通常只能获取隐式反馈数据（例如：观看，点击，购买，喜欢，分享等）。spark.ml中用于处理此类数据的方法取自Collaborative Filtering for Implicit Feedback Datasets。本质上，这种方法不是试图直接对评级矩阵进行建模，而是将数据视为表示用户操作观察强度的数字（例如点击次数或某人花在观看电影上的累积持续时间）。然后，这些数字与观察到的用户偏好的置信水平相关，而不是与项目的明确评级相关。然后，该模型试图找到可用于预测用户对项目的预期偏好的潜在因素。

正则化参数

通过用户-物品的评分矩阵中用户的评分物品数和物品收到的评分个数来作为正则项，解决最小二乘更新过程中的问题。 这种方法被命名为“ALS-WR”，可以参考论文： Collaborative Filtering for Implicit Feedback Datasets。它减小来regParam对数据集规模的依赖，因此我们可以将从采样子集中学习的最佳参数应用于完整数据集，并获得较好的结果。

应用场景

Spark ALS算法支持输出item 或者user的隐向量，据此我们可以计算出用户或者物品的相似度，继而进行排序得到用户或者item的top N相似user或者item。这样在数据进行召回时便可以进行召回了。

比如根据用户用行为的物品召回，当用户浏览了若干了item时，便将这些item相似的item加入到召回池中，进行rank排序。

ML中的ALS实现

object ALSML {

    def main(args: Array[String]): Unit = {
        val spark = SparkSession.builder().master("local[5]").appName("ALSML").enableHiveSupport().getOrCreate()
        Logger.getRootLogger.setLevel(Level.WARN)

        val input = "data/sample_movielens_ratings.txt"
        val model_param = "maxIters:10,rank:5,numBlocks:10,regParam:0.01,alpha:0.618,userCol:userId,itemCol:movieId,rateCol:rating,implicitPrefs:true"
        val output_model = "model/als_ml"
        // 训练模型 找到合适的参数
        runBasedML(spark,input,model_param,output_model)
    }

    def runBasedML(spark: SparkSession, input: String, param: String,output_model_path: String) = {
        import spark.sqlContext.implicits._
        val ratings = spark.read.textFile(input).map(parseRating).toDF()
        val Array(training, test) = ratings.randomSplit(Array(0.8, 0.2))

        println("创建并训练ALS模型 ...")
        val als = ALSMLUtil.createModel(param)
        val model = als.fit(training)
        println("模型的效果评估 ...")
        ALSMLUtil.evaluateModel(model, test)

        println("为用户进行item推荐 ...")
        model.recommendForAllUsers(10).show(10)

        println("为指定用户进行top N item推荐 ...")
        val users = ratings.select(als.getUserCol).distinct().limit(3)
        model.recommendForUserSubset(users,10).show(10)

        println("为item进行用户推荐 ...")
        model.recommendForAllItems(10).show(10)
        println("为指定的item进行top N 用户推荐 ...")
        val movies = ratings.select(als.getItemCol).distinct().limit(3)
        model.recommendForItemSubset(movies, 10).show(10)

        println("输出隐向量 ...")
        model.itemFactors.rdd.map(f => (f.get(0), f.getList(1).toArray.mkString(","))).take(10).foreach(println)

        println("保存与加载模型 ...")
        model.write.overwrite().save(output_model_path)
        val newModel = ALSModel.load(output_model_path)
        newModel.itemFactors.rdd.map(f => (f.get(0), f.getList(1).toArray.mkString(","))).take(10).foreach(println)
    }

    def parseRating(str: String): Rating = {
        val fields = str.split("::")
        assert(fields.size == 4)
        Rating(fields(0).toInt, fields(1).toInt, fields(2).toFloat, fields(3).toLong)
    }

    case class Rating(userId: Int, movieId: Int, rating: Float, timestamp: Long)
}

MLlib中的ALS实现

object ALSMLlib {

    def main(args: Array[String]): Unit = {
        val spark = SparkSession.builder().master("local[5]").appName("ALS").enableHiveSupport().getOrCreate()
        Logger.getRootLogger.setLevel(Level.WARN)

        val input = "data/sample_movielens_ratings.txt"
        val model_param = "maxIters:10,rank:5,numBlocks:10,regParam:0.01,alpha:0.618,implicitPrefs:true"
        val output_model_path = "model/als_ml"

        run(spark, input, model_param, output_model_path)
    }

    def run(spark: SparkSession, input: String, model_param: String, output_model_path: String): Unit = {
        println("加载数据 ...")
        val ratings = spark.sparkContext.textFile(input)
            .map(_.split("::").slice(0,3) match { case Array(userId, movieId, rating)  =>
                Rating(userId.toString.toInt, movieId.toString.toInt, rating.toString.toDouble)
            })
        println("训练模型 ...")
        val param = new ALSMLlibParam()
        param.parseString(model_param)
        val model = ALS.train(ratings,param.getRank, param.getMaxIters,param.getAlpha,param.getNumBlocks)

        println("评估模型 ...")
        val usersProducts = ratings.map { case Rating(user, product, rate) => (user, product) }
        val predictions = model.predict(usersProducts).map{ case Rating(user, product, rate) => ((user,product),rate)}
        val rateAndPre = ratings.map { case Rating(user, product, rate) => ((user, product), rate) }.join(predictions)
        val MSE = rateAndPre.map { case ((user, product), (r1, r2)) =>
            val err = (r1 - r2)
            err * err
        }.mean()
        println("Mean Squared Error = " + MSE)


        println(s"用户（2）对 物品（2）的预测评分为：${model.predict(2,2)}")
        println("用户纬度的特征向量为：")
        model.userFeatures.map(f => (f._1,f._2.mkString(","))).take(10).foreach(println)
        println("物品纬度的特征向量为：")
        model.productFeatures.map(f => (f._1,f._2.mkString(","))).take(10).foreach(println)
    }
}

问题

org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:1821)
	at org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:1810)
	at org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:48)
	at org.apache.spark.scheduler.DAGScheduler.runJob(DAGScheduler.scala:642)
	at org.apache.spark.SparkContext.runJob(SparkContext.scala:2034)
	at org.apache.spark.SparkContext.runJob(SparkContext.scala:2055)
	at org.apache.spark.SparkContext.runJob(SparkContext.scala:2074)
	at org.apache.spark.rdd.RDD$$anonfun$take$1.apply(RDD.scala:1364)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
	at org.apache.spark.rdd.RDD.withScope(RDD.scala:363)
	at org.apache.spark.rdd.RDD.take(RDD.scala:1337)
	at com.kk.recommend.tools.model.ALSBasedMLUtil$.evaluateModel(ALSBasedMLUtil.scala:51)
	at com.kk.recommend.topic.follow.ItemCFV2$.testBasedML(ItemCFV2.scala:104)
	at com.kk.recommend.topic.follow.ItemCFV2$.main(ItemCFV2.scala:40)
	at com.kk.recommend.topic.follow.ItemCFV2.main(ItemCFV2.scala)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.apache.spark.deploy.yarn.ApplicationMaster$$anon$2.run(ApplicationMaster.scala:688)
Caused by: java.lang.ArrayStoreException: org.apache.spark.sql.catalyst.expressions.GenericRowWithSchema
	at scala.runtime.ScalaRunTime$.array_update(ScalaRunTime.scala:90)
	at scala.collection.IndexedSeqOptimized$class.copyToArray(IndexedSeqOptimized.scala:180)
	at scala.collection.mutable.WrappedArray.copyToArray(WrappedArray.scala:35)
	at scala.collection.TraversableOnce$class.copyToArray(TraversableOnce.scala:278)
	at scala.collection.AbstractTraversable.copyToArray(Traversable.scala:104)
	at scala.collection.TraversableOnce$class.toArray(TraversableOnce.scala:286)
	at scala.collection.mutable.WrappedArray.toArray(WrappedArray.scala:73)
	at com.kk.recommend.tools.model.ALSBasedMLUtil$$anonfun$2.apply(ALSBasedMLUtil.scala:48)
	at com.kk.recommend.tools.model.ALSBasedMLUtil$$anonfun$2.apply(ALSBasedMLUtil.scala:46)
	at scala.collection.Iterator$$anon$12.nextCur(Iterator.scala:434)
	at scala.collection.Iterator$$anon$12.hasNext(Iterator.scala:440)
	at scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:389)
	at scala.collection.Iterator$class.foreach(Iterator.scala:893)
	at scala.collection.AbstractIterator.foreach(Iterator.scala:1336)
	at scala.collection.generic.Growable$class.$plus$plus$eq(Growable.scala:59)
	at scala.collection.mutable.ArrayBuffer.$plus$plus$eq(ArrayBuffer.scala:104)
	at scala.collection.mutable.ArrayBuffer.$plus$plus$eq(ArrayBuffer.scala:48)
	at scala.collection.TraversableOnce$class.to(TraversableOnce.scala:310)
	at scala.collection.AbstractIterator.to(Iterator.scala:1336)
	at scala.collection.TraversableOnce$class.toBuffer(TraversableOnce.scala:302)
	at scala.collection.AbstractIterator.toBuffer(Iterator.scala:1336)
	at scala.collection.TraversableOnce$class.toArray(TraversableOnce.scala:289)
	at scala.collection.AbstractIterator.toArray(Iterator.scala:1336)
	at org.apache.spark.rdd.RDD$$anonfun$take$1$$anonfun$28.apply(RDD.scala:1364)
	at org.apache.spark.rdd.RDD$$anonfun$take$1$$anonfun$28.apply(RDD.scala:1364)
	at org.apache.spark.SparkContext$$anonfun$runJob$5.apply(SparkContext.scala:2074)
	at org.apache.spark.SparkContext$$anonfun$runJob$5.apply(SparkContext.scala:2074)
	at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:87)
	at org.apache.spark.scheduler.Task.run(Task.scala:109)
	at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:381)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)

结局办法：

解决办法：点击阅读

打印的Schema信息：

root
 |-- userId: integer (nullable = false)
 |-- recommendations: array (nullable = true)
 |    |-- element: struct (containsNull = true)
 |    |    |-- topicId: integer (nullable = true)
 |    |    |-- rating: float (nullable = true)

在row 中的这些列取得时候，要根据类型取，简单的像String，Seq[Double] 这种类型就可以直接取出来，但是像 Seq[(Double,Double)] 这种类型直接取得花就会丢失schema信息，虽然值能取到，但是schema信息丢了，在dataFrame中操作的时候就会抛错

ALS测试结果数据的格式如下：

userIdrecommendations
148[[1972, 0.0334868…

原始的写法是：

result.select("userId", "recommendations")
        .filter(row => !(row.isNullAt(0) || row.isNullAt(1)))
        .rdd.flatMap( l=>{
            val uid = l.get(0).toString
            val itemList = l.getAs[mutable.WrappedArray[(Int,Double)]]("recommendations")
            for(item<- itemList) yield (uid, item._1.toString)
        })

修改后为：

result.select("userId", "recommendations")
        .filter(row => !(row.isNullAt(0) || row.isNullAt(1)))
        .rdd.flatMap( l=>{
            val uid = l.get(0).toString
            val itemList= l.getAs[Seq[Row]](1).map(x=>{(x.getInt(0),x.getFloat(1))})
            for(item<- itemList) yield (uid, item._1.toString)
            })
【技术服务】，详情点击查看： https://mp.weixin.qq.com/s/PtX9ukKRBmazAWARprGIAg
扫一扫 关注微信公众号！号主 专注于搜索和推荐系统，尝试使用算法去更好的服务于用户，包括但不局限于机器学习，深度学习，强化学习，自然语言理解，知识图谱，还不定时分享技术，资料，思考等文章！
搜索与推荐Wiki
关注
专栏目录
spark mllib 协同过滤推荐算法（ALS) python 实现 完整实例程序
03-07
一个完成的spark mllib 协同过滤推荐算法ALS 完整实例程序，基于 spark yarn-client模式运行，另外，包括训练数据。
Spark实现ALS最小二乘法
qq_32168087的博客
06-24 664
ALS算法流程： 初始化数据集和Spark环境 切分测试机和检验集 训练ALS模型 验证结果 检验满足结果，直接推荐商品，否则继续训练ALS模型 数据集的含义 数据根式 用户ID，产品ID，评分 1,11,2 1,12,3 1,13,1 1,14,0 1,15,1 2,11,2 2,12,2 2,13,2 2,14,1 2,15,4 3,11,2 3,12,3 3,13,1 3,14,0 3...
Spark算法之ALS模型（附Scala代码）
最新发布
LUyan10086的博客
06-26 1105
ALS模型，全称为交替最小二乘法（Alternating Least Squares），是一种基于协同过滤思想的矩阵分解算法。它的核心思想是通过隐含特征（latent factors）联系用户兴趣和物品（item），基于用户的行为找出潜在的主题和分类，然后对物品进行自动聚类，划分到不同类别或主题（代表用户的兴趣）。ALS算法的亮点之一在于优化参数时使用了交替最小二乘法，而非梯度下降算法，这使得ALS算法可以进行分布式并行计算。
ALS推荐算法理解及Spark编程实现
zylove2010的博客
10-21 2455
前言ALS(alternating least squares)是交替最小二乘的简称，在机器学习上下文中特指基于交替最小二乘求解的协同过滤推荐算法。Spark1.3版本的MLlib库中增加了对ALS算法的支持，因此，在实际项目中可通过Spark的MLlib库调用ALS算法实现协同过滤推荐。ALS的基本原理ALS属于SVD++算法中的一种，其理论基础源于SVD(奇异值分解)，即任何一个矩阵均可分解成两
spark mllib ALS电影推荐
qq_32021523的博客
03-31 846
package zqr.com; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaPairRDD; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaSparkContext; import ...
十七Spark读取Kafka流构建Als模型
张金玉的专栏
01-04 197
啊
深入理解Spark ML：基于ALS矩阵分解的协同过滤算法与源码分析
热门推荐
06-26 3万+
http://blog.csdn.net/u011239443/article/details/51752904随着互联网的迅猛发展,为了满足人们在繁多的信息中获取自己需要内容的需求,个性化推荐应用而生。协同过滤推荐是其中运用最为成功的技术之一。其中,基于用户的最近邻法根据相似用户的评分来预测当前用户的评分。然而,在用户数量以及用户评分不足的情况下,该方法存在冷启动和数据稀疏的问题。为了解决这两个问题，业界提出了提出了基于项的最近邻法，利用项之间相似性稳定的特点可以离线计算相似性,降低了在线计算量,提高了推
Spark---ALS推荐算法
Tubby的博客
03-03 5855
Spark——ALS推荐算法推荐算法介绍协同过滤式推荐的优缺点ALS推荐算法的介绍用户对产品项目的评分稀疏矩阵（Sparse Matrix）的问题矩阵分解（Matrix Factorization）数据下载环境说明在IPython Notebook中运行推荐程序首先启动所有虚拟机并启动Hadoop集群Cluster切换至IPython Notebook工作目录并在Hadoop YARN-clien...
Spark ALS算法推荐结果一样？
fansy1990的专栏
10-05 8791
在进行Spark ALS算法进行试验的时候发现模型对所有用户其推荐结果是一样的，即针对所有用户建模得到的模型对其推荐的项目是一样的，只是评分有比较小的差异。下面就分3个部分来进行分析，分别是实验过程及结果描述，ALS算法原理，问题分析及解决。实验过程及结果此部分参考：https://databricks-training.s3.amazonaws.com/movie-recommendation-
mllib协同过滤 java实现_协同过滤(ALS)算法介绍及Spark MLlib调用实例(Scala/Java/Python)...
weixin_42350101的博客
02-27 565
协同过滤算法介绍：协同过滤常被用于推荐系统。这类技术目标在于填充“用户－商品”联系矩阵中的缺失项。Spark.ml目前支持基于模型的协同过滤，其中用户和商品以少量的潜在因子来描述，用以预测缺失项。Spark.ml使用交替最小二乘(ALS)算法来学习这些潜在因子。＊注意基于DataFrame的ALS接口目前仅支持整数型的用户和商品编号。显式与隐式反馈基于矩阵分解的协同过滤的标准方法中，“用户－商品”...
spark中ALS介绍
qq_38250124的博客
03-06 6171
spark里面的调用 //Rmse均方根误差 root mean square error //为预测值与实际值的差的平方和与次数的比值的平方根,可以用来评判模型的好坏 //计算均方根误差，模型 测试集需要格式为RDD[Rating] //当然rmse越小越好 def RmseComputer(model: MatrixFactorizationModel, dataOfTest...
大数据技术之电商推荐系统(7) | ALS模型评估和参数选取
Knight
12-01 2166
在上述模型训练的过程中，我们直接给定了隐语义模型的rank,iterations,lambda三个参数。对于我们的模型，这并不一定是最优的参数选取，所以我们需要对模型进行评估。通常的做法是计算均方根误差（RMSE），考察预测评分与实际评分之间的误差。 有了RMSE，我们可以就可以通过多次调整参数值，来选取RMSE最小的一组作为我们模型的优化选择。 在scala/com.donglin.offline/下新建单例对象ALSTrainer，代码主体架构如下： import breeze.numerics..
ALS
Crazy_Ztx的博客
01-16 571
一、矩阵分解模型。 用户对物品的打分行为可以表示成一个评分矩阵A(m*n)，表示m个用户对n各物品的打分情况。如下图所示： 其中，A(i,j)表示用户user i对物品item j的打分。但是，用户不会对所以物品打分，图中？表示用户没有打分的情况，所以这个矩阵A很多元素都是空的，我们称其为“缺失值（missing value）”。在推荐系统中，我们希望得到用户对所有物品的打分情况，<s
推荐系统——机器学习模型——ALS矩阵分解算法及其在推荐系统中的应用
程序员光剑
08-18 1242
作者：禅与计算机程序设计艺术 1.简介 推荐系统是一个很火的研究方向，也是人工智能领域的一个热门话题。推荐系统通过分析用户行为、喜好以及其他相关信息，为用户提供个性化的商品推送，提升用户体验，是十分重要的一环。大型互联网公司如腾讯、网易等都有自己的推荐系统产品，比如QQ的“QQ音乐”，百度的“贴吧”、知
推荐系统（二）：根据用户行为数据创建ALS模型并召回商品、用户行为数据拆分、预处理behavior_log数据集、根据用户对类目偏好打分训练ALS模型、根据用户对品牌偏好打分训练ALS模型
汪雯琦的博客
03-15 2185
文章目录二 根据用户行为数据创建ALS模型并召回商品2.0 用户行为数据拆分2.1 预处理behavior_log数据集2.2 根据用户对类目偏好打分训练ALS模型2.3 根据用户对品牌偏好打分训练ALS模型 二 根据用户行为数据创建ALS模型并召回商品 2.0 用户行为数据拆分 方便练习可以对数据做拆分处理 pandas的数据分批读取 chunk 厚厚的一块 相当大的数量或部分 imp...
ALS资料
__Miracle__
11-30 1099
从协同过滤的分类来说，ALS算法属于User-Item CF，也叫做混合CF。它同时考虑了User和Item两个方面。用户和路线的关系，可以抽象为如下的三元组：<User,Item,Rating>。其中，Rating是用户对路线的评分，表征用户对该路线的喜好程度。 ALS算法是基于模型的推荐算法。起基本思想是对稀疏矩阵进行模型分解，评估出缺失项的值，以此来得到一个基本的训练模型。然后依照此模型可以针对新的用户和物品数据进行评估。ALS是采用交替的最小二乘法来算出缺失项的。交替的最小二乘法是在最小
基于Scala开发Spark ML的ALS推荐模型实战
pblh123的专栏
04-02 1253
ALS算法是Spark ML中实现协同过滤的矩阵分解方法。ALS，即交替最小二乘法（Alternating Least Squares），是协同过滤技术中的一种经典算法。它通过对用户和物品的潜在特征进行建模，来预测用户对未知物品的评分或偏好。矩阵分解模型：在推荐系统中，我们通常有一个用户-物品的评分矩阵，其中行表示用户，列表示物品，矩阵中的值代表用户对物品的评分。然而，这个矩阵通常是非常稀疏的，因为用户只给少数物品评分。ALS算法就是在这样的不完整评分矩阵上操作，通过矩阵分解来补全缺失值，进而产生推荐。
ALS矩阵分解模型的实现与应用
程序员光剑
09-02 1768
作者：禅与计算机程序设计艺术 1.简介 ALS(Alternating Least Squares)矩阵分解（即隐主题模型）是一种协同过滤推荐系统中的经典模型，其核心思想是找寻用户-物品矩阵（User Item Matrix）中的隐藏因子，使得该矩阵可以同时较好地表达用户偏好、物品特征以及上下文信息。其
深入机器学习系列之：ALS
数据猿
12-24 5126
导读ALS的核心是一个假设：打分矩阵是近似低秩的。换句话说，就是一个m*n的打分矩阵可以由分解的两个小矩阵U（m*k）和V（k*n）的乘积来近似来源： 星环科技丨作者：e...
Spark MLlib中的ALS实现与优化：孟祥瑞解析
"Databricks孟祥瑞探讨了ALS在Spark MLlib中的实现，尤其是在Spark 1.3版本中的改进。ALS是一种交替最小二乘法，常用于协同过滤推荐系统，通过对用户评分矩阵的分析来预测未知评分。" ALS（交替最小二乘法）是一种...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值