在Spark1.2之后,Spark自带实现TF-IDF接口,只要直接调用就可以,但实际上,Spark自带的词典大小设置较于古板,如果设置小了,则导致无法计算,如果设置大了,Driver端回收数据的时候,容易发生OOM,所以更多时候都是自己根据实际情况手动实现TF-IDF。不过,在本篇文章中,两种方式都会介绍。
数据准备:
val df = ss.sql("select * from bigdatas.news_seg")
//如果hive表的数据没有切词,则先对数据进行切词操作(hive里面每一行是用空格将各个词连接的字符串,或者说是一篇文章,结尾使用##@@##标识),得到一个数组类型数据
val df_seg = df.selectExpr("split(split(sentence,'##@@##')[0],' ') as seg")
一、Spark自带TF-IDF
1、Spark自带TF实现
首先需要实例化HashingTF,这个类用于根据给传入的各篇已经分好词的文章,对里面的每个词进行hashing计算,每个hashing值对应词表的一个位置,以及对每个词在每篇文章中的一个统计;
这个类有一个方法setBinaty()可以设置其统计时的计算方式:多项式分布计算和伯努利分布计算:
- setBinary(false):多项式分布计算,一个词在一篇文章中出现多少次,计算多少次;
- setBinary(true):伯努利分布计算,一个词在一篇文章中,不管多少次,只要出现了,就为1,否则为0
还有一个重要方法setNumFeatures(),用于设置词表的大小,默认是2^18。
实例化HashingTF之后,使用transform就可以计算词频(TF)。
TF代码实现:
// 多项式分布计算
val hashingTF = new HashingTF()
.setBinary(false)
.setInputCol("seg")
.setOutputCol("feature_tf")
.setNumFeatures(1<<18)
// 伯努利分布计算
val hashingTF_BN = new HashingTF()
.setBinary(true)
.setInputCol("seg")
.setOutputCol("feature_tf")
.setNumFeatures(1<<18)
/**
* hashingTF.transform(df_seg):转换之后会在原来基础上增加一列,就是setOutputCol("feature_tf")设置的列
* 新增列的数据结构为:(词表大小,[该行数据的每个词对应词表的hashCode],[该行数据的每个词在该行数据出现的次数,即多项式统计词频])
*/
val df_tf = hashingTF.transform(df_seg).select("feature_tf")
最后列“feature_tf”的数据结构为(词典大小, [hashingCode], [term freq])。
2、Spark自带实现TF-IDF
对word进行idf加权(完成tf计算的基础上)
实现原理跟上一步的TF类似,但多出一步,这一步是用于扫描一次上一步计算出来的tf数据。
代码如下:
val idf = new IDF()
.setInputCol("feature_tf")
.setOutputCol("feature_tfidf")
.setMinDocFreq(2)
//fit():内部对df_tf进行遍历,统计doc Freq,这个操作是在tf完成后才做的
val idfModel = idf.fit(df_tf)
val df_tfidf = idfModel.transform(df_tf).select("feature_tfidf")
二、自己实现TF-IDF
手动实现,有计算的先后问题,必须先算DocFreq(DF),再算TermFreq(TF)。
1、doc Freq 文档频率计算 -> 同时可以得到所有文章的单词集合(词典)
df的数据是每一行代表一篇文章,那么在计算某个词出现的文章次数,那么转化为某个词的统计。即将一篇文章切好词之后,放在一个set集合里面,表示这个set集合的每个词出现1次;那么将所有文章的词都切好,放在set集合里面,每篇文章拥有一个set集合,然后再根据词groupBy,Count,就可以得到每个词的DocFreq。
val setUDF = udf((str:String)=>str.split(" ").distinct)
// 1.1、对每篇文章的词进行去重操作,即set集合
val df_set = df.withColumn("words_set",setUDF(df("sentence")))
// 1.2、行转列,groupby、count,顺带可以求出词典大小,以及每个词对应在词典的位置index
val docFreq_map = df_set.select(explode(df_set("words_set")).as("word"))
.groupBy("word")
.count()
.rdd
.map(x=>(x(0).toString,x(1).toString))
.collectAsMap() //collect有一个重要特性,就是会将数据回收到Driver端,方便分发
上面计算出来的数据格式为:Map(word->wordCount),或理解为:Map(word->DocFreq)
除了计算出DF外,还要顺便计算词典大小,因为词典大小代表了向量的大小,以及每个词对应词典的位置。
val dictSize = docFreq_map.size
// 对单词进行编码,得到索引,类型为int,每个词对应于[0,dictSize-1]区间的一个位置
val wordEncode = docFreq_map.keys.zipWithIndex.toMap
2、term Freq 词频计算 -> 同时计算tf-idf
词频计算其实就是做wordCount,这里重点还需要顺带计算TF-IDF。
val docCount = df_seg.count()
val mapUDF = udf { str: String =>
//每一行处理就是处理一篇文章
// wordCOunt
val tfMap = str.split("##@##")(0).split(" ")
.map((_,1L))
.groupBy(_._1)
.mapValues(_.length)
// tfMap{term->termCount}
// docFreq_map{term->termDocCount}
// wordEncode{term->index}
// 处理后的tfIDFMap数据结果为:[(index:int,tf_idf:Double)] //必须要处理成这种形式
val tfIDFMap = tfMap.map{x=>
val idf_v = math.log10(docCount.toDouble/(docFreq_map.getOrElse(x._1,"0.0").toDouble+1))
(wordEncode.getOrElse(x._1,0),x._2.toDouble * idf_v)
}
// 做成向量:第一个参数为向量大小(词典大小);第二个参数用于给指定的index赋值为tf-idf
Vectors.sparse(dictSize,tfIDFMap.toSeq)
}
val dfTF = df.withColumn("tf_idf",mapUDF(df("sentence")))
三、完整Demo代码
package com.cjs
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.ml.feature.HashingTF
import org.apache.spark.ml.feature.IDF
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions._
object TFIDFTransform {
def main(args: Array[String]): Unit = {
Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
val conf = new SparkConf()
.set("spark.some.config.option","some-value")
val ss = SparkSession
.builder()
.config(conf)
.enableHiveSupport()
.appName("test_tf-idf")
//.master("local[2]") //单机版配置,集群情况下,可以去掉
.getOrCreate()
val df = ss.sql("select * from bigdatas.news_seg")
//如果hive表的数据没有切词,则先对数据进行切词操作(hive里面每一行是用空格将各个词连接的字符串,或者说是一篇文章,结尾使用##@@##标识),得到一个数组类型数据
val df_seg = df.selectExpr("split(split(sentence,'##@@##')[0],' ') as seg")
val docCount = df_seg.count()
//一、spark自带tf-idf实现
//词典默认是2^20,先给一个词的一个hashCode,对应于词典的一个位置
//词典空间过大,Driver进行数据回收时,容易出现OOM
// 1、spark自带TF实现
/**
setBinary:
false:多项式分布 -> 一个词在一篇文章中出现多少次,计算多少次
true:伯努利分布 -> 一个词在一篇文章中,不管多少次,只要出现了,就为1,否则为0
**/
/**
* setInputCol("seg") :输入参数(DF)的列名
* setOutputCol("feature_tf"):输出结果(结果)的列名
* setNumFeatures(1<<18):设置词表大小,默认是1<<18
*/
// 多项式分布计算
val hashingTF = new HashingTF()
.setBinary(false)
.setInputCol("seg")
.setOutputCol("feature_tf")
.setNumFeatures(1<<18)
// 伯努利分布计算
val hashingTF_BN = new HashingTF()
.setBinary(true)
.setInputCol("seg")
.setOutputCol("feature_tf")
.setNumFeatures(1<<18)
/**
* hashingTF.transform(df_seg):转换之后会在原来基础上增加一列,就是setOutputCol("feature_tf")设置的列
* 新增列的数据结构为:(词表大小,[该行数据的每个词对应词表的hashCode],[该行数据的每个词在该行数据出现的次数,即多项式统计词频])
*/
val df_tf = hashingTF.transform(df_seg).select("feature_tf")
// 2、spark自带IDF实现, 对word进行idf加权(完成tf计算的基础上)
val idf = new IDF()
.setInputCol("feature_tf")
.setOutputCol("feature_tfidf")
.setMinDocFreq(2)
//fit():内部对df_tf进行遍历,统计doc Freq,这个操作是在tf完成后才做的
val idfModel = idf.fit(df_tf)
val df_tfidf = idfModel.transform(df_tf).select("feature_tfidf")
//二、自己实现tf-idf,有顺序的实现
//1、doc Freq 文档频率计算 -> 同时可以得到所有文章的单词集合(词典)
val setUDF = udf((str:String)=>str.split(" ").distinct)
// 1.1、对每篇文章的词进行去重操作,即set集合
val df_set = df.withColumn("words_set",setUDF(df("sentence")))
// 1.2、行转列,groupby、count,顺带可以求出词典大小,以及每个词对应在词典的位置index
val docFreq_map = df_set.select(explode(df_set("words_set")).as("word"))
.groupBy("word")
.count()
.rdd
// .map(x=>(x(0).toString,x(1).toString))
.map(x=>(x(0).toString,math.log10(docCount.toDouble/(x(1).toString.toDouble+1)))) //顺带计算idf
.collectAsMap() //collect有一个重要特性,就是会将数据回收到Driver端,方便分发
val dictSize = docFreq_map.size
// 对单词进行编码,得到索引,类型为int,每个词对应于[0,dictSize-1]区间的一个位置
val wordEncode = docFreq_map.keys.zipWithIndex.toMap
//2、term Freq 词频计算
// 返回数据结构:
val mapUDF = udf { str: String =>
//每一行处理就是处理一篇文章
// wordCOunt
val tfMap = str.split("##@##")(0).split(" ")
.map((_,1L))
.groupBy(_._1)
.mapValues(_.length)
// tfMap{term->termCount}
// docFreq_map{term->termDocCount}
// wordEncode{term->index}
// 处理后的tfIDFMap数据结果为:[(index:int,tf_idf:Double)] //必须要处理成这种形式
val tfIDFMap = tfMap.map{x=>
// val idf_v = math.log10(docCount.toDouble/(docFreq_map.getOrElse(x._1,"0.0").toDouble+1))
// (wordEncode.getOrElse(x._1,0),x._2.toDouble * idf_v)
val idf_v = docFreq_map.getOrElse(x._1,0.0)
(wordEncode.getOrElse(x._1,0),x._2.toDouble * idf_v) //已经在第1步算出idf情况下使用
}
// 做成向量:第一个参数为向量大小(词典大小);第二个参数用于给指定的index赋值为tf-idf
Vectors.sparse(dictSize,tfIDFMap.toSeq)
}
val dfTF = df.withColumn("tf_idf",mapUDF(df("sentence")))
}
}