11，基于pySpark的TF-IDF算法实现

from pyspark import SparkConf, SparkContext

import math

#以下为计算过程中需要用到的几个函数

# 该函数主要是统计一个文档中包含哪些单词

def word_contains(words_list):

      words_set=set(words_list)#将列表转为set,去除重复的单词

      return list(words_set)#再将set转为列表返回

# 计算每个单词的逆文档频率idf

def computeIDF(word_df_tuple,num_document):

      word=word_df_tuple[0]

      df=word_df_tuple[1]

      #根据逆文档频率计算公式计算idf值

      word_idf = math.log(float(num_document+1) / float(df+1), 2)

      return (word, word_idf)#以一个元组tuple的形式返回一个单词的dif值

# 计算每个文档中单词的tf值，并将文档转成向量

def computeTF(words_list, all_words_list):

      words_num=len(words_list)#获取文档中出现的单词的个数

      words_dic={}

      for word in words_list:#统计文档中每个单词出现的次数

            if word in words_dic.keys():

                  words_dic[word]+=1

            else:

                  words_dic[word]=1

      tf_vector=[]

      for word in all_words_list:#将文档转为一个tf值向量并返回

            if word in words_dic.keys():

                  tf=float(words_dic[word])/words_num

                  tf_vector.append(tf)

            else:

                  tf_vector.append(0)

      return tf_vector

# 计算每个文档向量中每个单词的tfidf值

def computeTFIDF(tf_vector, words_idf_dic,all_words_list):

      i=0

      tfidf_vector=[]

      for word in all_words_list:#将每个单词的tf值和idf值相乘

            tfidf=tf_vector[i]*words_idf_dic[word]

            tfidf_vector.append(tfidf)

            i+=1

      return tfidf_vector

# 对每个tfidf向量进行归一化

def nomoralize(tfidf_vector):

      new_vector=[]

      sum=0

      for item in tfidf_vector:

            sum+=math.pow(item,2)

      sqrt_sum=math.sqrt(sum)

      for item in tfidf_vector:

            new_item=item/sqrt_sum

            new_vector.append(new_item)

return new_vector

#主程序

if __name__ == "__main__":

conf = SparkConf().setAppName("tfidf")

sc = SparkContext(conf=conf)

#示例文档数据，每个文档是一个单词列表

documents_list=[["hello","world","china","good","spark","good"],

                ["hello","china","china","great","love","china"],

                ["love","spark","spark","good","hello","spark"]]

#创建RDD并进行缓存

tokenized_document_rdd=sc.parallelize(documents_list).cache()

print "*************************** compute idf************************************"

#这个阶段的主要操作是计算单词的idf值

#获取文档的个数用来计算逆文档频率

num_document=tokenized_document_rdd.count()

#计算每个单词的文档支持度

#实现思路是，针对每个文本文档，通过将单词列表转成set来获取每个文档中出现的单词，然后

#通过flatMap操作，将每个文档出现的单词合并成一个新的集合。在新的集合中，一个单词出现

#的次数即是其文档支持度。因此，我们可以在flatMap操作之后应用map和reducebykey操作来统

#计每个单词的文档支持度。

words_df_rdd=tokenized_document_rdd.flatMap(lambda words_list:word_contains(words_list)) \

                                   .map(lambda word:(word,1)) \

                                   .reduceByKey(lambda a,b:a+b)

#根据单词的文档频率和文档的总数计算每个单词的idf

# computeIDF函数实现的是具体计算idf的值

words_idf_rdd=words_df_rdd.map(lambda word_df_tuple:

                               computeIDF(word_df_tuple, num_document))

print "*********************************** compute tf *******************************"

#计算每个文本中每个单词出现的频次，进而计算tf值

#返回包含所有单词的列表

#flatMap是将所有文档中的单词合并成一个大的列表，distinct是将列表中重复的单词去除

all_words_list= tokenized_document_rdd.flatMap(lambda words_list:words_list) \

                                   .distinct() \

                                   .collect()

#考虑到单词可能很多，我们将包含所有单词的all_words_list变量做出广播变量，使得一个executor

#上的多个Task可以共享该变量

all_words_broadcast=sc.broadcast(all_words_list)

#计算单词的tf,得到文档的tf向量

document_tf_rdd= tokenized_document_rdd.map(lambda words_list:

                                            computeTF(words_list, all_words_broadcast.value))

print "******************************* compute tfidf*********************************"

#提取从rdd中提取每个单词的idf值，并将提取的列表变量转成字典变量，进而转成广播变量，以

#供发送给各个executor计算每个文档中每个单词的tfidf值

words_idf_list= words_idf_rdd.collect()

words_idf_dic={}

for item in words_idf_list:#将单词的idf值列表转为字典易于获取每个单词的idf值

       words_idf_dic[item[0]]=item[1]

words_idf_broadcast=sc.broadcast(words_idf_dic)

#计算每个文本中每个单词的tfidf值

document_tfidf_rdd= document_tf_rdd.map(lambda words_tf_list:computeTFIDF(words_tf_list,

 words_idf_broadcast.value,all_words_broadcast.value))

#将每个文本对应的列表向量进行归一化

normalized_document_tfidf_rdd= document_tfidf_rdd.map(lambda tfidf_vector:

 nomoralize(tfidf_vector))

print "************************** print tfidf vectors*********************************"

#打印输出每个tfidf向量

tfidf_vectors= normalized_document_tfidf_rdd.collect()

for item in tfidf_vectors:

           print item