文本相似度-bm25算法原理及实现

朴灿烈づ我的快乐病毒、 2022-02-23 11:40 237阅读 0赞

转载自[文本相似度-bm25算法原理及实现][-bm25]

## 原理 ##

BM25算法，通常用来作搜索相关性评分。一句话概况其主要思想：对Query进行语素解析，生成语素 q i q\_i qi；然后，对于每个搜索结果D，计算每个语素 q i q\_i qi与D的相关性得分，最后，将 q i q\_i qi相对于D的相关性得分进行加权求和，从而得到Query与D的相关性得分。

BM25算法的一般性公式如下：

S c o r e ( Q , d ) = ∑ i n W i ⋅ R ( q i , d ) Score(Q,d) = \\sum\_\{i\}^nW\_i · R(q\_i, d) Score(Q,d)=i∑nWi⋅R(qi,d)

其中，Q表示Query， q i q\_i qi表示Q解析之后的一个语素（对中文而言，我们可以把对Query的分词作为语素分析，每个词看成语素 q i q\_i qi。）；d表示一个搜索结果文档； W i W\_i Wi表示语素 q i q\_i qi的权重； R ( q i ， d ) R(q\_i，d) R(qi，d)表示语素 q i q\_i qi与文档d的相关性得分。

下面我们来看如何定义 W i W\_i Wi。判断一个词与一个文档的相关性的权重，方法有多种，较常用的是IDF。这里以IDF为例，公式如下：

I D F ( q i ) = l o g N − n ( q i ) + 0.5 n ( q i ) + 0.5 IDF(q\_i)=log\{N-n(q\_i)+0.5\\over n(q\_i)+0.5\} IDF(qi)=logn(qi)\+0.5N−n(qi)\+0.5

其中，N为索引中的全部文档数，n( q i q\_i qi)为包含了 q i q\_i qi的文档数。

根据IDF的定义可以看出，对于给定的文档集合，包含了 q i q\_i qi的文档数越多， q i q\_i qi的权重则越低。也就是说，**当很多文档都包含了 q i q\_i qi时， q i q\_i qi的区分度就不高，因此使用 q i q\_i qi来判断相关性时的重要度就较低。**

我们再来看语素 q i q\_i qi与文档d的相关性得分 R （ q i ， d ） R（q\_i，d） R（qi，d）。首先来看BM25中相关性得分的一般形式：

R ( q i , d ) = f i ⋅ ( k 1 + 1 ) f i + K ⋅ q f i ⋅ ( f 2 + 1 ) q f i + k 2   K = k 1 ⋅ ( 1 − b + b ⋅ d l a v g ( d l ) ) R(q\_i,d)=\{f\_i·(k\_1+1)\\over f\_i+K\}·\{qf\_i·(f\_2+1)\\over qf\_i+k\_2\}\\\\\\ \\\\K=k\_1·(1-b+b·\{dl\\over avg(dl)\}) R(qi,d)=fi\+Kfi⋅(k1\+1)⋅qfi\+k2qfi⋅(f2\+1) K=k1⋅(1−b\+b⋅avg(dl)dl)

其中， k 1 k\_1 k1， k 2 2 k\_22 k22， b b b为调节因子，通常根据经验设置，一般k1=2，b=0.75；fi为 q i q\_i qi在d中的出现频率， q f i qf\_i qfi为 q i q\_i qi在Query中的出现频率。dl为文档d的长度，avgdl为所有文档的平均长度。由于绝大部分情况下， q i q\_i qi在Query中只会出现一次，即 q f i qf\_i qfi=1，因此公式可以简化为：

R ( q i , d ) = f i ⋅ ( k 1 + 1 ) f i + K R(q\_i,d)=\{f\_i·(k\_1+1)\\over f\_i+K\} R(qi,d)=fi\+Kfi⋅(k1\+1)

从K的定义中可以看到，参数b的作用是调整文档长度对相关性影响的大小。b越大，文档长度的对相关性得分的影响越大，反之越小。而文档的相对长度越长，K值将越大，则相关性得分会越小。这可以理解为，当文档较长时，包含 q i q\_i qi的机会越大，因此，同等fi的情况下，长文档与 q i q\_i qi的相关性应该比短文档与 q i q\_i qi的相关性弱。

从BM25的公式可以看到，通过使用不同的语素分析方法、语素权重判定方法，以及语素与文档的相关性判定方法，我们可以衍生出不同的搜索相关性得分计算方法，这就为我们设计算法提供了较大的灵活性。

## 代码 ##

import math
    import jieba
    from utils import utils
    
    # 测试文本
    text = ''' 自然语言处理是计算机科学领域与人工智能领域中的一个重要方向。 它研究能实现人与计算机之间用自然语言进行有效通信的各种理论和方法。 自然语言处理是一门融语言学、计算机科学、数学于一体的科学。 因此，这一领域的研究将涉及自然语言，即人们日常使用的语言， 所以它与语言学的研究有着密切的联系，但又有重要的区别。 自然语言处理并不是一般地研究自然语言， 而在于研制能有效地实现自然语言通信的计算机系统， 特别是其中的软件系统。因而它是计算机科学的一部分。 '''
    
    class BM25(object):
    
        def __init__(self, docs):
            self.D = len(docs)
            self.avgdl = sum([len(doc)+0.0 for doc in docs]) / self.D
            self.docs = docs
            self.f = []  # 列表的每一个元素是一个dict，dict存储着一个文档中每个词的出现次数
            self.df = { } # 存储每个词及出现了该词的文档数量
            self.idf = { } # 存储每个词的idf值
            self.k1 = 1.5
            self.b = 0.75
            self.init()
    
        def init(self):
            for doc in self.docs:
                tmp = { }
                for word in doc:
                    tmp[word] = tmp.get(word, 0) + 1  # 存储每个文档中每个词的出现次数
                self.f.append(tmp)
                for k in tmp.keys():
                    self.df[k] = self.df.get(k, 0) + 1
            for k, v in self.df.items():
                self.idf[k] = math.log(self.D-v+0.5)-math.log(v+0.5)
    
        def sim(self, doc, index):
            score = 0
            for word in doc:
                if word not in self.f[index]:
                    continue
                d = len(self.docs[index])
                score += (self.idf[word]*self.f[index][word]*(self.k1+1)
                          / (self.f[index][word]+self.k1*(1-self.b+self.b*d
                                                          / self.avgdl)))
            return score
    
        def simall(self, doc):
            scores = []
            for index in range(self.D):
                score = self.sim(doc, index)
                scores.append(score)
            return scores
    
    if __name__ == '__main__':
        sents = utils.get_sentences(text)
        doc = []
        for sent in sents:
            words = list(jieba.cut(sent))
            words = utils.filter_stop(words)
            doc.append(words)
        print(doc)
        s = BM25(doc)
        print(s.f)
        print(s.idf)
        print(s.simall(['自然语言', '计算机科学', '领域', '人工智能', '领域']))

分段再分词结果

[['自然语言', '计算机科学', '领域', '人工智能', '领域', '中', '一个', '方向'], 
    ['研究', '人', '计算机', '之间', '自然语言', '通信', '理论', '方法'], 
    ['自然语言', '一门', '融', '语言学', '计算机科学', '数学', '一体', '科学'], 
    [],
    ['这一', '领域', '研究', '涉及', '自然语言'], 
    ['日常', '语言'], 
    ['语言学', '研究'], 
    ['区别'], 
    ['自然语言', '研究', '自然语言'], 
    ['在于', '研制', '自然语言', '通信', '计算机系统'], 
    ['特别', '软件系统'], 
    ['计算机科学', '一部分']]

s.f  
列表的每一个元素是一个dict，dict存储着一个文档中每个词的出现次数

[{'中': 1, '计算机科学': 1, '领域': 2, '一个': 1, '人工智能': 1, '方向': 1, '自然语言': 1}, 
    {'之间': 1, '方法': 1, '理论': 1, '通信': 1, '计算机': 1, '人': 1, '研究': 1, '自然语言': 1}, 
    {'融': 1, '一门': 1, '一体': 1, '数学': 1, '科学': 1, '计算机科学': 1, '语言学': 1, '自然语言': 1}, 
    {}, 
    {'领域': 1, '这一': 1, '涉及': 1, '研究': 1, '自然语言': 1}, 
    {'日常': 1, '语言': 1}, 
    {'语言学': 1, '研究': 1}, 
    {'区别': 1}, 
    {'研究': 1, '自然语言': 2}, 
    {'通信': 1, '计算机系统': 1, '研制': 1, '在于': 1, '自然语言': 1}, 
    {'软件系统': 1, '特别': 1}, 
    {'一部分': 1, '计算机科学': 1}]

s.df  
存储每个词及出现了该词的文档数量

{
        '在于': 1,  
        '人工智能': 1,  
        '语言': 1,  
        '领域': 2,  
        '融': 1, 
        '日常': 1, 
        '人': 1, 
        '这一': 1, 
        '软件系统': 1, 
        '特别': 1, 
        '数学': 1, 
        '通信': 2, 
        '区别': 1, 
        '之间': 1, 
        '计算机科学': 3, 
        '科学': 1, 
        '一体': 1, 
        '方向': 1, 
        '中': 1, 
        '理论': 1, 
        '计算机': 1, 
        '涉及': 1, 
        '研制': 1, 
        '一门': 1, 
        '研究': 4, 
        '语言学': 2, 
        '计算机系统': 1, 
        '自然语言': 6, 
        '一部分': 1, 
        '一个': 1, 
        '方法': 1
    }

s.idf  
存储每个词的idf值

{
        '在于': 2.0368819272610397, 
        '一部分': 2.0368819272610397, 
        '一个': 2.0368819272610397, 
        '语言': 2.0368819272610397, 
        '领域': 1.4350845252893225, 
        '融': 2.0368819272610397, 
        '日常': 2.0368819272610397, 
        '人': 2.0368819272610397, 
        '这一': 2.0368819272610397, 
        '软件系统': 2.0368819272610397, 
        '特别': 2.0368819272610397, 
        '数学': 2.0368819272610397, 
        '通信': 1.4350845252893225, 
        '区别': 2.0368819272610397, 
        '之间': 2.0368819272610397, 
        '一门': 2.0368819272610397, 
        '科学': 2.0368819272610397, 
        '一体': 2.0368819272610397, 
        '方向': 2.0368819272610397, 
        '中': 2.0368819272610397, 
        '理论': 2.0368819272610397, 
        '计算机': 2.0368819272610397, 
        '涉及': 2.0368819272610397, 
        '研制': 2.0368819272610397, 
        '计算机科学': 0.9985288301111273, 
        '研究': 0.6359887667199966, 
        '语言学': 1.4350845252893225, 
        '计算机系统': 2.0368819272610397, 
        '自然语言': 0.0, 
        '人工智能': 2.0368819272610397, 
        '方法': 2.0368819272610397
    }

s.simall(\[‘自然语言’, ‘计算机科学’, ‘领域’, ‘人工智能’, ‘领域’\])  
\[‘自然语言’, ‘计算机科学’, ‘领域’, ‘人工智能’, ‘领域’\]与每一句的相似度

[5.0769919814311475, 0.0, 0.6705449078118518, 0, 2.5244316697250033, 0, 0, 0, 0.0, 0.0, 0, 1.2723636062357853]

### 详细代码 ###

[https://github.com/jllan/jannlp/blob/master/similarity/bm25.py][https_github.com_jllan_jannlp_blob_master_similarity_bm25.py]

## 参考 ##

[http://www.cnblogs.com/hdflzh/p/4034602.html][http_www.cnblogs.com_hdflzh_p_4034602.html]  
[http://www.aiuxian.com/article/p-2690039.html][http_www.aiuxian.com_article_p-2690039.html]

[-bm25]: https://www.jianshu.com/p/1e498888f505
[https_github.com_jllan_jannlp_blob_master_similarity_bm25.py]: https://github.com/jllan/jannlp/blob/master/similarity/bm25.py
[http_www.cnblogs.com_hdflzh_p_4034602.html]: http://www.cnblogs.com/hdflzh/p/4034602.html
[http_www.aiuxian.com_article_p-2690039.html]: http://www.aiuxian.com/article/p-2690039.html