elasticsearch relevance scoring 检索相关性计算

0.047字数 1694阅读 2339

记录一下,elasticsearch/lucene关于文档与query之间相关性的计算方式,目录如下,

  • Lucene/es评分机制
    • Lucene’s Practical Scoring Function
    • Query-Time Boosting
    • Ignoring TF/IDF
    • Pluggable Similarity Algorithms

Lucene/es评分机制

https://www.elastic.co/guide/en/elasticsearch/guide/current/scoring-theory.html
http://mp.weixin.qq.com/s/By340-7g5rDxVKehY1izeQ

es使用Boolean model来匹配文档;使用practical scoring function(tfidf, BM25)来计算文档与query的相关性;使用vector space model来增加额外特征计算(如queryNorm,coord,norm,boost)。

注,一般query为指定在某个field中查询的。即score(field, query);而如果不指定field,且_all字段enable,那么就在该条doc中查询,即score(doc, query)。

Query & Term
query = quick brown fox
term1 = quick 
term2 = brown
term3 = fox
Boolean Model

full AND text AND search AND (elasticsearch OR lucene).

Term Frequency/Inverse Document Frequency (TF/IDF)

词频/逆向文档频率,term的重要性随着它在文档doc中出现的次数成正比增加,但同时会随着它在语料库docs中出现的频率成反比下降。主要包含三部分,

  • tf,该词在一篇文档中出现的次数,tf(t in d) = √frequency
  • idf,该词出现在多少篇文档中(出现一次也算出现),idf(t) = 1+ log((numDocs + 1)/(docFreq + 1))
  • field-length norm,doc/field的文本长度,norm(d) = 1 / √numTermsInDoc
tfidf
//disable field-length norm可以减少index时候的计算量,加快index速度
PUT /my_index
{
  "mappings": {
    "doc": {
      "properties": {
        "text": {
          "type": "string",
          "norms": { "enabled": false } 
        }
      }
    }
  }
}
Vector Space Model

使得query与doc之间的相关性可以比较

query与三文档的对比

上图中,query = "happy hippopotamus",权重分别是2, 5,
doc1 = I am happy in summer.
doc2 = After Christmas I’m a hippopotamus.
doc3 = The happy hippopotamus helped Harry.
文档3与query最相关(夹角最小)。

Lucene’s Practical Scoring Function

lucene的计分函数,对于multiterm查询,lucene将布尔模型(Boolean)、词频/逆向文档频率(tfidf)、向量空间模型(vector space)合并到一个统一的jar包里面,用以收集匹配文档和分数计算。

//原生multiterm query语句
GET /my_index/doc/_search
{
  "query": {
    "match": {
      "text": "quick fox"
    }
  }
}

//布尔模型实现的改写
GET /my_index/doc/_search
{
  "query": {
    "bool": {
      "should": [
        {"term": { "text": "quick" }},
        {"term": { "text": "fox"   }}
      ]
    }
  }
}

只要一个文档与查询匹配,lucene就会对该文档算分,然后合并每个term的得分,用到了practical scoring function

score(q, d)  =  #1
            queryNorm(q)  #2
          · coord(q, d)    #3
          · ∑ (           #4
                   tf(t in d)   #5
                 · idf(t)²      #6
                 · t.getBoost() #7
                 · norm(t, d)    #8
            ) (t in q)    #9
  1. score(q, d),文档d 与查询q 的相关度分数(relevance score)
  2. queryNorm(q),查询正则因子(query normalization factor)
  3. coord(q, d),协调因子(coordination factor)
  4. sum with #9
  5. tf(t in d),term t 在文档d 中的词频
  6. idf(t),term t 的逆向文档频率
  7. t.getBoost(),查询中使用的自定义boost
  8. norm(t, d),文档d的文本长度正则值
  9. sum with #4,查询 q 中每个term t 对于文档d 的权重和
queryNorm

queryNorm试图将查询正则化,以便可以比较两个不同query的结果。(不是很有效)

coord

协调因子,

query = "quick brown fox"

//without coord (the weight for each term is 1.5)
Document with fox → score: 1.5
Document with quick fox → score: 3.0
Document with quick brown fox → score: 4.5

//with coord
Document with fox → score: 1.5 * 1 / 3 = 0.5
Document with quick fox → score: 3.0 * 2 / 3 = 2.0
Document with quick brown fox → score: 4.5 * 3 / 3 = 4.5
{norm

文本长度。文本越短,文本的权重越高。norm(d) = 1 / √numTermsInDoc

boost}

自定义权重。

Query-Time Boosting

查询时权重提升,在搜索时令一个查询语句的自定义权重有别于其他查询语句,会更加符合个性化定制搜索的需求。

GET /_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "title": {
              "query": "quick brown fox",
              "boost": 2 
            }
          }
        },
        {
          "match": { 
            "content": "quick brown fox"
          }
        }
      ]
    }
  }
}

query在title字段的自定义权重比在content字段的大(2>1),默认是1。

Ignoring TF/IDF

有时我们只关心一个term是否在某个doc中出现过,而不在乎它在doc中是否频繁出现,此时可以省去计算tfidf的耗时,加快检索速度。

constant_score

constant_score替代match,不计算tfidf,但是计算其余项的分数。

//match
GET /_search
{
    "query": {
        "match": {
            "description": "wifi garden pool"
        }
    }
}

//constant_score
GET /_search
{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "user" : "kimchy"}
            },
            "boost" : 1.2
        }
    }
}
function_score query

https://www.elastic.co/guide/en/elasticsearch/reference/6.0/query-dsl-function-score-query.html#function-decay

es检索时默认会以文档的相关性进行排序,而如果想要改变默认的排序规则,可以通过sort指定一个或多个排序字段。

GET /_search
{
    "query" : {
        "bool" : {
            "filter" : { "term" : { "user_id" : 1 }}
        }
    },
    "sort": { "date": { "order": "desc" }}
}

但是直接指定sort排序过于直接,可能效果不好(除非sort字段index前已经计算好)。此时就需要对多个字段进行综合评估,用到function_score,它允许我们为每个与query查询匹配的doc应用一个scoring函数,以达到改变默认规则的目的。es已有的function_score,如下,

  • weight,为每个doc应用一个直接而不被正则化的权重提升值:当 weight=2 时,最终结果为 2 * _score(与constant_score的boost=2不同,constant_score的boost参与到_score的正则化计算中,只是constant_score没有计算tfidf,其余项quertNorm, coord, norm, boost都要参与到正则化计算中)
  • random_score,根据seed随机种子,返回一个0到1的分数;seed相同,随机分相同。多用于个性化推荐
  • field_value_factor,通过doc中指定filed从而计算出一个排序分
    • field,指定的字段名
    • factor,缩放系数,默认为1
    • modifier,字段加工方式
      • none,不处理
      • log,对数
      • log1p,字段值+1后取对数
      • square,平方
      • sqrt,开方
      • reciprocal,倒数,etc.
  • decay_function,linear线性,exp指数,gauss高斯,入参如下,
    • orgin,原点
    • scale,衰减点
    • offset,非零偏移量,默认0
    • decay,从原点衰减到scale点的所得分,默认0.5,即scale点的文档得分是0.5
  • script_score,通过脚本自定义不同字段的不同得分逻辑
//weight & random_score & score_mode & boost_mode
GET /_search
{
  "query": {
    "function_score": {
      "filter": {
        "term": { "city": "Barcelona" }
      },
      "functions": [
        {
          "filter": { "term": { "features": "wifi" }},
          "weight": 1
        },
        {
          "filter": { "term": { "features": "garden" }},
          "weight": 1
        },
        {
          "filter": { "term": { "features": "pool" }},
          "weight": 2
        },
        {
          "random_score": { 
            "seed":  "the_users_session_id" 
          }
        }
      ],
      "score_mode": "sum",
      "boost_mode": "multiply"
    }
  }
}

//field_value_factor
GET /_search
{
    "query": {
        "function_score": {
            "field_value_factor": {
                "field": "likes",
                "factor": 1.2,
                "modifier": "sqrt",
                "missing": 1
            }
        }
    }
}

//delay function(d = day)
GET /_search
{
    "query": {
        "function_score": {
            "gauss": {
                "date": {
                      "origin": "2013-09-17", 
                      "scale": "10d",
                      "offset": "5d", 
                      "decay" : 0.5 
                }
            }
        }
    }
}
decay_function
score combination
  • score_mode,function_score与function_score之间的相处方式,
    • multiply,默认
    • sum
    • avg
    • max/min
    • first
  • boost_mode,function_score与_score之间的相处方式,
    • multiply,默认
    • sum
    • avg
    • max/min
    • replace

Pluggable Similarity Algorithms

es配置了多种检索相关性算法可供选择,

  • tfidf,默认
  • BM25
  • DFR, DFI, IB, etc.

其中,lucene自6.0起使用BM25代替了之前的tfidf。

//configure BM25 in mapping setting
PUT /my_index
{
  "mappings": {
    "doc": {
      "properties": {
        "title": {
          "type":       "string",
          "similarity": "BM25" 
        },
        "body": {
          "type":       "string",
          "similarity": "default" 
        }
      }
  }
}
BM25

http://fjdu.github.io/coding/2017/03/16/bm25-elasticsearch-lucene.html
http://www.jianshu.com/p/0b372804ff45
https://en.wikipedia.org/wiki/Okapi_BM25

Best Match 25,发布于1994年,是调整相关性计算的第25次迭代。
引入了Term frequency saturation(词频饱和度),计算如下,

BM25.png

其中,

  • |D|:文档长度
  • avgdl:所有文档的平均文档长度
  • k1,b是自由参数,lucene默认k1=1.2,b=0.75
  • IDF = log((#Docs - #DocsHit + 0.5)/(#DocsHit + 0.5))
  • TF = query count in one doc
词频饱和度snapshot (blue)
Term frequency saturation for TF/IDF and BM25
BM25F

http://www.cnblogs.com/bentuwuying/p/6730891.html

BM25F是BM25的改进版本,BM25在计算文档与query的相关性时将文档当做整体来考虑;但是随着advanced search的发展,文档的结构化(即每个文档都可以切分成多个独立的域field,比如title,abstract,keyword,body text等)需要被考虑,不同的域对相关性的贡献应该要更精细地处理,而BM25F就是query在文档的各个field中分值的加权求和。


推荐阅读更多精彩内容