Decay functions - Elasticsearch 权威指南中文版

返回介绍

Decay functions

发布于 2019-07-04 字数 6328 浏览 823 评论 0

[[decay-functions]]
=== The Closer, The Better

Many variables could influence the user’s choice of vacation
home.(((“relevance”, “controlling”, “using decay functions”))) Maybe she would like to be close to the center of town, but perhaps
would be willing to settle for a place that is a bit farther from the
center if the price is low enough. Perhaps the reverse is true: she would be
willing to pay more for the best location.

If we were to add a filter that excluded any vacation homes farther than 1
kilometer from the center, or any vacation homes that cost more than £100 a
night, we might exclude results that the user would consider to be a good
compromise.

The function_score query gives (((“function_score query”, “decay functions”)))(((“decay functions”)))us the ability to trade off one sliding scale
(like location) against another sliding scale (like price), with a group of
functions known as the decay functions.

The three decay functions–called linear, exp, and gauss—operate on numeric fields, date fields, or lat/lon geo-points.(((“linear function”)))(((“exp (exponential) function”)))(((“gauss (Gaussian) function”))) All three take
the same parameters:

origin::
The central point, or the best possible value for the field.
Documents that fall at the origin will get a full _score of 1.0.

scale::
The rate of decay–how quickly the _score should drop the further from
the origin that a document lies (for example, every £10 or every 100 meters).

decay::
The _score that a document at scale distance from the origin should
receive. Defaults to 0.5.

offset::
Setting a nonzero offset expands the central point to cover a range
of values instead of just the single point specified by the origin. All
values in the range -offset <= origin <= +offset will receive the full
_score of 1.0.

The only difference between these three functions is the shape of the decay
curve. The difference is most easily illustrated with a graph (see <>).

[[img-decay-functions]]
.Decay function curves
image::images/elas_1705.png[“The curves of the decay functions”]

The curves shown in <> all have their origin—the
central point–set to 40. The offset is 5, meaning that all values in
the range 40 - 5 <= value <= 40 + 5 are treated as though they were at the
origin—they all get the full score of 1.0.

Outside this range, the score starts to decay. The rate of decay is
determined by the scale (which in this example is set to 5), and the
decay (which is set to the default of 0.5). The result is that all three
curves return a score of 0.5 at origin +/- (offset + scale), or at points
30 and 50.

The difference between linear, exp, and gauss is the shape of the curve at other points in the range:

  • The linear funtion is just a straight line. Once the line hits zero,
    all values outside the line will return a score of 0.0.
  • The exp (exponential) function decays rapidly, then slows down.
  • The gauss (Gaussian) function is bell-shaped–it decays slowly, then
    rapidly, then slows down again.

Which curve you choose depends entirely on how quickly you want the _score
to decay, the further a value is from the origin.

To return to our example: our user would prefer to rent a vacation home close
to the center of London ({ "lat": 51.50, "lon": 0.12}) and to pay no more
than £100 a night, but our user considers price to be more important than
distance. (((“gauss (Gaussian) function”, “in function_score query”))) We could write this query as follows:

[source,json]

GET /_search { “query”: { “function_score”: { “functions”: [ { “gauss”: { “location”: { “origin”: { “lat”: 51.5, “lon”: 0.12 }, “offset”: “2km”, “scale”: “3km” } } }, { “gauss”: { “price”: { “origin”: “50”, “offset”: “50”, “scale”: “20” } }, “weight”: 2 } ] } } }

The `location` field is mapped as a `geo_point`.
The `price` field is numeric.
See <> for the reason that `origin` is `50` instead of `100`.
The `price` clause has twice the weight of the `location` clause.

The location clause is(((“location clause, Gaussian function example”))) easy to understand:

  • We have specified an origin that corresponds to the center of London.
  • Any location within 2km of the origin receives the full score of 1.0.
  • Locations 5km (offset + scale) from the centre receive a score
    of 0.5.

[[Understanding-the-price-Clause]]
=== Understanding the price Clause

The price clause is a little trickier.(((“price clause (Gaussian function example)”))) The user’s preferred price is
anything up to £100, but this example sets the origin to £50. Prices can’t be
negative, but the lower they are, the better. Really, any price between £0 and
£100 should be considered optimal.

If we were to set the origin to £100, then prices below £100 would receive a
lower score. Instead, we set both the origin and the offset to £50. That
way, the score decays only for any prices above £100 (origin + offset).

The weight parameter can be used to increase or decrease the contribution of
individual clauses. (((“weight parameter (in function_score query)”))) The weight, which defaults to 1.0, is multiplied by
the score from each clause before the scores are combined with the specified
score_mode.

==================================================

上一篇:Random scoring

下一篇:Pluggable similarities

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

目前还没有任何评论,快来抢沙发吧!