SparkML机器学习(一) TF-IDF的提取

最新推荐文章于 2024-03-02 19:06:33 发布
最新推荐文章于 2024-03-02 19:06:33 发布
阅读量269 收藏 2
点赞数
分类专栏： Spark 算法 SparkML 文章标签： TF-IDF CountVectorizer Tokenizer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44131414/article/details/117201580
版权
Spark 同时被 3 个专栏收录
25 篇文章 0 订阅
订阅专栏
算法
5 篇文章 0 订阅
订阅专栏
SparkML
1 篇文章 0 订阅
订阅专栏
本文介绍了TF-IDF算法的基本原理，包括词频TF和逆文档频率IDF的计算，展示了如何通过Spark MLlib进行分词、词频统计、IDF计算和TF-IDF特征提取，以及如何获取相关词汇的重要程度。通过实例演示了如何在实际项目中应用TF-IDF提升文本分类效果。
摘要由CSDN通过智能技术生成

TF-IDF 含义

TF-IDF（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘的常用加权技术。

  • 主要思想
    如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。
  • TF
    词频（term frequency，TF）指的是某一个给定的词语在该文件中出现的频率;
  • IDF
    逆向文件频率（inverse document frequency，IDF）是一个词语普遍重要性的度量。某一特定词语的IDF，可以由总文件数目除以包含该词语之文件的数目，再将得到的商取以10为底的对数得到：
    单词出现的文章数越少,单词IDF值越大

TF-IDF的提取流程:

1. 分词
2. 计算每篇文档的词频 TF值
3. 计算 IDF 值 : (逆文档词频)
4. 计算TF-IDF值
5. 获取相关词汇的 IDF TF-IDF 值
6. 后续优化: 使用 TextRank ,关联文章上下文语义

package com.xiaolin.ML.start_study

import java.util
import com.xiaolin.RecommenderProgram.util.IKAnalyzer
import org.apache.lucene.analysis.TokenStream
import org.apache.spark.ml.feature.{CountVectorizer, HashingTF, IDF, Tokenizer}
import org.apache.spark.ml.linalg.SparseVector
import org.apache.spark.sql.types.{ArrayType, StringType}
import org.apache.spark.sql.{SparkSession, functions}
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object TFIDFApp {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("TF-IDF Demo").master("local").getOrCreate()
    import spark.implicits._
    spark.sparkContext.setLogLevel("ERROR")
	//初始化demo数据
    val sentenceData = spark.createDataFrame(Seq(
      (0.0, "小林爱爸爸,电影"),
      (1.0, "我爱中国,非常非常的喜欢电影"),
      (2.0, "我爱看普罗米修斯电影,非常的精彩")
    )).toDF("label","text")
	
    sentenceData.show(false)
	+-----+-------------------------------+
	|label|text                           |
	+-----+-------------------------------+
	|0.0  |小林爱爸爸,电影                |
	|1.0  |我爱中国,非常非常的喜欢电影    |
	|2.0  |我爱看普罗米修斯电影,非常的精彩|
	+-----+-------------------------------+
    
    //ik分词器
    import scala.collection.JavaConversions._

    val wordsData = sentenceData.map(x=>{
      val analyzer = new IKAnalyzer()
      val label = x.getAs[Double]("label")
      val text = x.getAs[String]("text")
      val strings = analyzer.segmentation(text)
      (label,text,strings.toSeq.toList)
    }).toDF("label","text","words")
    
      wordsData.show(false)
	+-----+-------------------------------+------------------------------+
	|label|text                           |words                         |
	+-----+-------------------------------+------------------------------+
	|0.0  |小林爱爸爸,电影                |[小林, 爱, 爸爸, 电影]        |
	|1.0  |我爱中国,非常非常的喜欢电影    |[爱, 中国, 喜欢, 电影]        |
	|2.0  |我爱看普罗米修斯电影,非常的精彩|[爱看, 普罗米修斯, 电影, 精彩]|
	+-----+-------------------------------+------------------------------+   
    
    //Tokenizer分词器 将英文句子分成单词
//    val tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words")
//    val wordsData = tokenizer.transform(sentenceData)

    //HashingTF 将每个词转换成Int型，并计算其在文档中的词频（TF） 不可追溯
    //setNumFeatures(200)表示将Hash分桶的数量设置为200个,可以根据你的词语数量来调整,一般来说，这个值越大不同的词被计算为一个Hash值的概率就越小，数据也更准确，但需要消耗更大的内存
//    val hashingTF = new HashingTF()
//      .setInputCol("words")
//      .setOutputCol("TF Features")
//      .setNumFeatures(200)
//
//    val featurizedData = hashingTF.transform(wordsData)

//  CountVectorizer 文档词频 可追溯 每个单词对应的IDF
    val cvModel = new CountVectorizer()
      .setInputCol("words")
      .setOutputCol("TF Features")
      .fit(wordsData)
    
    val featurizedData = cvModel.transform(wordsData)

    featurizedData.show(false)
+-----+-------------------------------+------------------------------+-------------------------------+
|label|text                           |words                         |TF Features                    |
+-----+-------------------------------+------------------------------+-------------------------------+
|0.0  |小林爱爸爸,电影                |[小林, 爱, 爸爸, 电影]        |(9,[0,1,2,8],[1.0,1.0,1.0,1.0])|
|1.0  |我爱中国,非常非常的喜欢电影    |[爱, 中国, 喜欢, 电影]        |(9,[0,1,5,6],[1.0,1.0,1.0,1.0])|
|2.0  |我爱看普罗米修斯电影,非常的精彩|[爱看, 普罗米修斯, 电影, 精彩]|(9,[0,3,4,7],[1.0,1.0,1.0,1.0])|
+-----+-------------------------------+------------------------------+-------------------------------+
    
    //	计算IDF
    val idf = new IDF().setInputCol("TF Features").setOutputCol("TF-IDF features")
    val idfModel = idf.fit(featurizedData)

 //保存model 读取保存的model 数据   idfModel.write.overwrite().save("file:///D:\\IDEAspaces\\bigdata_study\\bigdata_spark\\data\\model\\idf.model")
    spark.read
      .parquet("file:///D:\\IDEAspaces\\bigdata_study\\bigdata_spark\\data\\model\\idf.model\\data")
      .show(false)
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
|idf                                                                                                                                                           |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
|[0.0,0.28768207245178085,0.6931471805599453,0.6931471805599453,0.6931471805599453,0.6931471805599453,0.6931471805599453,0.6931471805599453,0.6931471805599453]|
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+

    //计算TF-IDF
    val rescaledData = idfModel.transform(featurizedData)

    rescaledData.show(false)

+-----+-------------------------------+------------------------------+-------------------------------+-----------------------------------------------------------------------------+
|label|text                           |words                         |TF Features                    |TF-IDF features                                                              |
+-----+-------------------------------+------------------------------+-------------------------------+-----------------------------------------------------------------------------+
|0.0  |小林爱爸爸,电影                |[小林, 爱, 爸爸, 电影]        |(9,[0,1,2,8],[1.0,1.0,1.0,1.0])|(9,[0,1,2,8],[0.0,0.28768207245178085,0.6931471805599453,0.6931471805599453])|
|1.0  |我爱中国,非常非常的喜欢电影    |[爱, 中国, 喜欢, 电影]        |(9,[0,1,5,6],[1.0,1.0,1.0,1.0])|(9,[0,1,5,6],[0.0,0.28768207245178085,0.6931471805599453,0.6931471805599453])|
|2.0  |我爱看普罗米修斯电影,非常的精彩|[爱看, 普罗米修斯, 电影, 精彩]|(9,[0,3,4,7],[1.0,1.0,1.0,1.0])|(9,[0,3,4,7],[0.0,0.6931471805599453,0.6931471805599453,0.6931471805599453]) |
+-----+-------------------------------+------------------------------+-------------------------------+-----------------------------------------------------------------------------+


    val words2 = cvModel.vocabulary
    //获取 词 对应的 idf tf_idf 值
    rescaledData.rdd.mapPartitions(partition=>{
      val rest = new ListBuffer[(Double, Int, Double,String)]
      val topN = 10

      while (partition.hasNext) {

        val row = partition.next()
        var idfVals = row.getAs[SparseVector]("TF-IDF features")
        val tmpList = new ListBuffer[(Int, Double)]

        idfVals.indices.map(i=>{
          tmpList += ((i, idfVals(i)))
        })

        val buffer = tmpList.sortBy(_._2).reverse
        for (item <- buffer.take(topN))
          rest += ((row.getAs[Double]("label"), item._1, item._2,words2(item._1)))
      }
      rest.iterator
    }).toDF("item_id", "index", "tfidf","word").show(false)
    
	|item_id|index|tfidf              |word      |
	+-------+-----+-------------------+----------+
	|0.0    |8    |0.6931471805599453 |爸爸      |
	|0.0    |2    |0.6931471805599453 |小林      |
	|0.0    |1    |0.28768207245178085|爱        |
	|0.0    |0    |0.0                |电影      |
	|1.0    |6    |0.6931471805599453 |中国      |
	|1.0    |5    |0.6931471805599453 |喜欢      |
	|1.0    |1    |0.28768207245178085|爱        |
	|1.0    |0    |0.0                |电影      |
	|2.0    |7    |0.6931471805599453 |爱看      |
	|2.0    |4    |0.6931471805599453 |精彩      |
	|2.0    |3    |0.6931471805599453 |普罗米修斯|
	|2.0    |0    |0.0                |电影      |
	+-------+-----+-------------------+----------+
    spark.close()
  }

}
xiaolin_xinji
关注
专栏目录
Spark MLlib 特征工程系列—特征提取 TF-IDF
08-15 4839
TF-IDF 是文本分类、聚类、信息检索等任务中的一种常见特征提取方法。通过降低常见词汇的权重，TF-IDF 能够更有效地捕捉那些对文档区分度更高的词汇，从而提高模型的效果。IDF 是 TF-IDF 中的重要组成部分，用于调整词频，以减少常见词对文本分析任务的影响。在 Spark 中，可以结合 HashingTF 或 CountVectorizer 来计算 TF-IDF 特征，进而用于各种机器学习任务。
机器学习（十二） 特征提取 TF-IDF
weixin_42438712的博客
01-02 1397
一、概念 **“词频－逆向文件频率”（TF-IDF）**是一种在文本挖掘中广泛使用的特征向量化方法，它可以体现一个文档中词语在语料库中的重要程度。 词语由t表示，文档由d表示，语料库由D表示。词频TF(t,d)是词语t在文档d中出现的次数。文件频率DF(t,D)是包含词语的文档的个数。如果我们只使用词频来衡量重要性，很容易过度强调在文档中经常出现，却没有太多实际信息的词语，比如“a”，“the”...
python实现TF-IDF算法提取关键词
01-11
通过python代码实现TF-IDF算法，并对文本提取关键词，可以自己添加词库以及停用词表。
Spark ML中TF-IDF
chbxw
05-29 433
一、TF-IDF 概念 二、Spark ML 中实现
（3-7）特征提取：TF-IDF特征
最新发布
码农三叔
03-02 1677
TF-IDF是“词频-逆文档频率”（Term Frequency-Inverse Document Frequency）的缩写，是一种用于信息检索和文本挖掘的常用文本特征提取方法。TF-IDF的目标是确定一个文档中词汇的重要性，以便帮助理解文档的主题或进行文本相关性排序。词频（Term Frequency，TF）：词频表示在文档中某个词汇出现的次数。通常，词频越高，该词汇在文档中的重要性越大。
NLP自然语言处理——关键词提取之 TF-IDF 算法（五分钟带你深刻领悟TF-IDF算法的精髓）
荆鹏的博客
09-13 1万+
新手入门保姆级教程!!!自然语言文本预处理、TF-IDF算法详解（三个维度：原理、流程图、代码）、好玩的中文关键词“词云生成”（解决乱码问题）# 获取停用词# 加载文档集，对文档集过滤词性和停用词# 使用TF-IDF提取关键词# 将过滤后的文档集转化为文本列表# 创建TF-IDF向量化器# 计算TF-IDF权重# 获取特征词列表。
sparkmllib算法之操作-第三篇（TF-IDF）
CD
01-14 571
1、定义 在信息检索中，tf-idf（词频-逆文档频率）是一种统计方法，用以评估一个单词在一个文档集合或语料库中的重要程度。经常被用作信息检索、文本挖掘以及用户模型的权重因素。tf-idf的值会随着单词在文档中出现的次数的增加而增大，也会随着单词在语料库中出现的次数的增多而减小。tf-idf是如今最流行的词频加权方案之一。 tf-idf的各种改进版本经常被搜索引擎用作在给定用户查询时对文档的相...
【Spark Mllib】TF-IDF&Word2Vec——文本相似度
热门推荐
06-21 2万+
一个比较通用的例子是使用单词的向量表示基于单词的含义计算两个单词的相似度。特征哈希通过使用哈希方程对特征赋予向量下标,这个向量下标是通过对特征的值做哈希得到的(通常是整数)。使用的哈希方程必须是一致的(就是说,对于一个给定的输入,每次返回相同的输出)。的含义是:在一个文档中出现次数很多的词相比出现次数少的词应该在词向量表示中得到更高的权值。最后的结果就是,稀有的或者重要的词被给予了更高的权值,而更加常用的单词(被认为比较不重要)则在考虑权重的时候有较小的影响。对于我们的任务来说,可以使用。
文本特征提取 java_三种文本特征提取（TF-IDF/Word2Vec/CountVectorizer）及Spark MLlib调用实例（Scala/Java/python）(转)...
weixin_39583521的博客
02-16 392
Spark MLlib 提供三种文本特征提取方法，分别为TF-IDF、Word2Vec以及CountVectorizer其各自原理与调用代码整理如下：TF-IDF算法介绍：词语由t表示，文档由d表示，语料库由D表示。词频TF(t,,d)是词语t在文档d中出现的次数。文件频率DF(t,D)是包含词语的文档的个数。如果我们只使用词频来衡量重要性，很容易过度强调在文档中经常出现而并没有包含太多与文档有关...
基于TF-IDF的关键词提取的实现
qq_37977007的博客
01-17 1953
简单使用TF-IDF提取关键词
spark word2vec 源码_Spark文本特征提取（TF-IDF/Word2Vec/CountVectorizer）
weixin_28797919的博客
01-12 117
importorg.apacheimportorg.apache.sparkimportorg.apache.spark.ml.feature._importorg.apache.spark.mllib.linalg._importorg.apache.spark.mllib.linalg.Vectorsimportorg.apache.spark.mllib.linalg.distributed...
【Spark】TF-IDF
sinat_40431164的博客
06-06 399
TF-IDF Term frequency-inverse document frequency (TF-IDF) is a feature vectorization method widely used in text mining to reflect the importance of a term to a document in the corpus. Denote a term b...
spark mllib机器学习之七 TFIDF
深海小黄鱼
03-14 1061
package com.agm.FeatureExtractors import org.apache.spark.ml.feature.{ HashingTF, IDF, Tokenizer } import org.apache.spark.{ SparkConf, SparkContext } import org.apache.spark.mllib.classification.{
Spark特征提取---TF-IDF
unity_kw_do的博客
05-11 1136
词频（Term Frequency，缩写为TF） 在一篇文档中出现次数最多的词是----"的"、"是"、"在"----这一类最常用的词。它们叫做"停用词"（stop words），表示对找到结果毫无帮助、必须过滤掉的词。 还有长度小于2大于10的，数字也过滤掉，根据词性过滤，留下有实际意义的词。 假设我们把它们都过滤掉了，只考虑剩下的有实际意义的词。这样又会遇到了另一个问题，我们可能
Python3 实现TF-IDF
m0_46507878的博客
07-17 282
Python3 实现tf-idf算法
Spark MLlib TF-IDF算法原理及调用实例（Scala/Java/python）
liulingyuan6的博客
11-28 6970
算法介绍：        词频－逆向文件频率（TF-IDF）是一种在文本挖掘中广泛使用的特征向量化方法，它可以体现一个文档中词语在语料库中的重要程度。         词语由表示，文档由表示，语料库由表示。词频是词语在文档中出现的次数。文件频率是包含词语的文档的个数。如果我们只使用词频来衡量重要性，很容易过度强调在文档中经常出现而并没有包含太多与文档有关的信息的词语，比如“a”，“the”以及
机器学习之使用TF-IDF算法进行文本特征的提取
weixin_43495948的博客
03-08 2997
TF-IDF的主要思想 如果一个词或短语在某一篇文章中出现的概率很高，并且在其它文章中很少出现，则认为该词或短语具有很好的类别区分能力，适合用来分类 TF-IDF的作用 用以评估一个词语对于一个文件或者一个语料库中的其中一份文件的重要程度 TF-IDF公式 词频（term frequency，简称TF），指的是某一个给定的词语在该文件中出现的频率； 逆向文档频率（inverse document frequency，简称IDF）是一个词语普遍重要性的重要度量。某一特定词语idf由总文件数目除以包含该词语文
TF-IDF：自动提取关键词
超级圈的博客
06-20 1万+
目录： 一、TF-IDF基础知识 1.TF-IDF 2.举例介绍 二、TF-IDF调用两个方法 1.CountVectorizer 2.TfidfTransformer 3.别人示例 一、TF-IDF基础知识 1.TF-IDF TF-IDF（Term Frequency-InversDocumentFrequency）是一种常用于信息处理和数...
spark实现tfidf
wshzd的博客
07-11 1012
package xxx import org.apache.log4j.Logger import org.apache.log4j.Level import org.apache.spark.sql.SparkSession import org.apache.spark.ml.feature.{HashingTF, IDF, Tokenizer} object TopicExtracti...
Spark ML Pipeline：构建与理解
Pipline允许用户构建一个包含多个步骤的工作流，其中包括数据预处理、特征提取、模型训练和评估等，以实现端到端的机器学习任务。 1. 数据框（DataFrame） DataFrame是SparkSQL的核心数据结构，它是处理多种类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值