TF-IDF及相似度计算

一： 基于TF-IDF的关键词提取

TF-IDF：衡量某个词对文章的重要性由TF和IDF组成

TF：词频(因素：某词在同一文章中出现次数)

IDF：反文档频率(因素：某词是否在不同文章中出现)

TF-IDF = TF*IDF

TF ：一个单词在一篇文章出现次数越多越重要

IDF: 每篇文章都出现的单词(如的，你，我，他) ，越不重要

 TFIDF的主要思想：

如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

TFIDF实际上是：TF * IDF， TF词频(Term Frequency)，IDF反文档频率(Inverse Document Frequency)。

TF表示词条在文档d中出现的频率(另一说：TF词频(Term Frequency)指的是某一个给定的词语在该文件中出现的次数)。

IDF的主要思想是：

如果包含词条t的文档越少，也就是n越小，IDF越大(见后续公式)，则说明词条t具有很好的类别区分能力。如果某一类文档C中包含词条t的文档数为m，而其它类包含t的文档总数为k，显然所有包含t的文档数n=m+k，当m大的时候，n也大，按照IDF公式得到的IDF的值会小，就说明该词条t类别区分能力不强。(另一说：IDF反文档频率(Inverse Document Frequency)是指果包含词条的文档越少，IDF越大，则说明词条具有很好的类别区分能力。)但是实际上，有时候，如果一个词条在一个类的文档中频繁出现，则说明该词条能够很好代表这个类的文本的特征，这样的词条应该给它们赋予较高的权重，并选来作为该类文本的特征词以区别与其它类文档。这就是IDF的不足之处.

TF-IDF例子:

词频 (TF) 是一词语出现的次数除以该文件的总词语数。假如一篇文件的总词语数是100个，而词语“母牛”出现了3次，那么“母牛”一词在该文件中的词频就是3/100=0.03。一个计算文件频率 (DF) 的方法是测定有多少份文件出现过“母牛”一词，然后除以文件集里包含的文件总数。所以，如果“母牛”一词在1,000份文件出现过，而文件总数是10,000,000份的话，其逆向文件频率就是 log(10,000,000 / 1,000)=4。最后的TF-IDF的分数为0.03 * 4=0.12。

其他例子：

二： 相似度计算公式

(1)余弦相似度cosine

                举例：A(1,2,3) B(2,3,4)

                cosine(A, B) = 分子 / 分母 = 20 / 20.12 =

                分子：A*B = 1*2 + 2*3 + 3*4 = 20

                分母：    ||A||*    ||B|| = 3.74 * 5.38 = 20.12

                            ||A|| = sqrt(A*A) = sqrt(1*1 + 2*2 + 3* 3) = 3.74

                            ||B|| = sqrt(B*B) = sqrt(4*4 + 2*2 + 3* 3) = 5.38

A表示一个句子，B表示另外一个句子

            cosine(A, B) = 表示两个句子的相似程度

(二)Jaccard 相似度：

A 用户(香蕉、苹果、鸭梨)

B 用户(苹果、橘子、桃子)

A∩B=苹果 1

A∪B=香蕉、苹果、鸭梨、橘子、桃子 5

相似度为1/5=0.2

# Step 1 文件整合 把不同文本整合到一起
import os
import sys
import math
file_path_dir = './data'
raw_path = './raw.data'
idf_path = './idf.data'
def read_file_handler(f):
    fd = open(f, 'r', encoding='utf-8')
    return fd
file_raw_out = open(raw_path, 'w', encoding='utf-8')
# 遍历整个原始数据目录，将零散的文章整合到一个文件中，便于后续数据处理
file_name = 0
for fd in os.listdir(file_path_dir):
    file_path = file_path_dir + '/' + fd
    content_list = []
    file_fd = read_file_handler(file_path)
    for line in file_fd:
        content_list.append(line.strip())
    content = '\t'.join([str(file_name), ' '.join(content_list)]) + '\n'
    file_raw_out.writelines(content)
    file_name += 1
file_raw_out.close()
# Step 2 输出IDF
docs_cnt = file_name
wc_tulist = []
with open(raw_path, 'r', encoding='utf-8') as fd:
    for line in fd:
        # 遍历每一篇文章，文章=line
        ss = line.strip().split('\t')
        if len(ss) != 2:
            continue
        # 对文章的解析，区分出文章的名字和文章的内容
        file_name, file_content = ss
        # 对文章的内容进行切词，因为内容已经按“ ”空格区分好了，所以直接按空格做split就好
        word_list = file_content.strip().split(' ')
        # 去重：对于idf，只关心词有没有出现在文章中，至于出现多少次，并不关心
        word_set = set(word_list)
        for word in word_set:
            # 对于每个关键词，打一个标记“1”，来标识该次出现过
            wc_tulist.append((word, '1'))
# 将内容输出到指定目标文件中去
file_idf_out = open(idf_path, 'w', encoding='utf-8')
# 按照词的字典序，进行排序
wc_sort_tulist = sorted(wc_tulist, key=lambda x: x[0])
current_word = None
sum = 0
for tu in wc_sort_tulist:
    word, val = tu
    if current_word == None:
        current_word = word
    if current_word != word:
        # 通过idf计算公式，得到每个关键词的idf score
        idf = math.log(float(docs_cnt) / (float(sum) + 1.0)) idf公式
        content = '\t'.join([current_word, str(idf)]) + '\n'
        file_idf_out.write(content)
        current_word = word
        sum = 0
    sum += int(val)
idf = math.log(float(docs_cnt) / (float(sum) + 1.0))
content = '\t'.join([current_word, str(idf)]) + '\n'
file_idf_out.write(content)
file_idf_out.close()
# Step 3
input_str = '我们 带来 阿里巴巴 希望 差 我们 我们 我们'
token_idf_dict = {}
# 将idf字典加载到内存
with open(idf_path, 'r', encoding='utf-8') as fd:
    for line in fd:
        ss = line.strip().split('\t')
        if len(ss) != 2:
            continue
        token, idf_score = ss
        token_idf_dict[token] = idf_score
def get_tfidf(input_str):
    token_dict = {}
    # 对输入字符串的每一个词，计算tf
    for t in input_str.strip().split(' '):
        if t not in token_dict:
            token_dict[t] = 1
        else:
            token_dict[t] += 1
    # res_tu_list = []
    for k, v in token_dict.items():
        tf_score = token_dict[k]
        if k not in token_idf_dict:
            continue
        idf_score = token_idf_dict[k]
        tf_idf = tf_score * float(idf_score)
        yield (k, tf_idf)
for k, v in get_tfidf(input_str):
    print(k, v)
求cos
# Step 1: Cosine
input1_str = '我们 带来 阿里巴巴 希望 差 差 差'
# input2_str = '我们 带来 阿里巴巴 好 好 好'
# input2_str = '我们 带来 搜狐 好 好 好'
input2_str = '你们 带来 搜狐 希望 好 好 好'
def cosine(input1_str, input2_str):
    t1_dict = {}
    sum = 0.
    for k, v in get_tfidf(input1_str):
        sum += pow(v, 2)
    sum = math.sqrt(sum)
    for k, v in get_tfidf(input1_str):
        t1_dict[k] = float(v / sum)
    sum = 0.
    for k, v in get_tfidf(input2_str):
        sum += pow(v, 2)
    sum = math.sqrt(sum)
    final_score = 0.
    for k, v in get_tfidf(input2_str):
        if k not in t1_dict:
            continue
        s1 = t1_dict[k]
        s2 = float(v / sum)
        final_score += s1 * s2
    return final_score
print(cosine(input1_str, input2_str))