Запрос с функцией оценки

Функция скрипт-оценки позволяет обернуть другой запрос и настроить оценку с помощью вычислений, полученных из других числовых значений полей документа с помощью выражения скрипта. Вот простой пример:

resp = client.search(
    query={
        "function_score": {
            "query": {
                "match": {
                    "message": "elasticsearch"
                }
            },
            "script_score": {
                "script": {
                    "source": "Math.log(2 + doc['my-int'].value)"
                }
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      function_score: {
        query: {
          match: {
            message: 'elasticsearch'
          }
        },
        script_score: {
          script: {
            source: "Math.log(2 + doc['my-int'].value)"
          }
        }
      }
    }
  }
)
puts response

const response = await client.search({
  query: {
    function_score: {
      query: {
        match: {
          message: "elasticsearch",
        },
      },
      script_score: {
        script: {
          source: "Math.log(2 + doc['my-int'].value)",
        },
      },
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "function_score": {
      "query": {
        "match": { "message": "elasticsearch" }
      },
      "script_score": {
        "script": {
          "source": "Math.log(2 + doc['my-int'].value)"
        }
      }
    }
  }
}

Помимо различных значений и выражений полей скрипта, параметр скрипта _score может быть использован для получения оценки на основе обернутого запроса.

Компиляция скриптов кэшируется для более быстрого выполнения. Если скрипт должен принимать параметры, предпочтительнее повторно использовать один и тот же скрипт и предоставить ему параметры:

resp = client.search(
    query={
        "function_score": {
            "query": {
                "match": {
                    "message": "elasticsearch"
                }
            },
            "script_score": {
                "script": {
                    "params": {
                        "a": 5,
                        "b": 1.2
                    },
                    "source": "params.a / Math.pow(params.b, doc['my-int'].value)"
                }
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      function_score: {
        query: {
          match: {
            message: 'elasticsearch'
          }
        },
        script_score: {
          script: {
            params: {
              a: 5,
              b: 1.2
            },
            source: "params.a / Math.pow(params.b, doc['my-int'].value)"
          }
        }
      }
    }
  }
)
puts response

const response = await client.search({
  query: {
    function_score: {
      query: {
        match: {
          message: "elasticsearch",
        },
      },
      script_score: {
        script: {
          params: {
            a: 5,
            b: 1.2,
          },
          source: "params.a / Math.pow(params.b, doc['my-int'].value)",
        },
      },
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "function_score": {
      "query": {
        "match": { "message": "elasticsearch" }
      },
      "script_score": {
        "script": {
          "params": {
            "a": 5,
            "b": 1.2
          },
          "source": "params.a / Math.pow(params.b, doc['my-int'].value)"
        }
      }
    }
  }
}

Обратите внимание, что в отличие от запроса custom_score, оценка запроса умножается на результат оценки скрипта. Если вы хотите этого избежать, установите "boost_mode": "replace".

Оценка по весу позволяет умножить оценку на предоставленный weight. Иногда это желательно, так как значения усиления, заданные для определённых запросов, нормализуются, в то время как для этой функции оценки это не так. Числовое значение имеет тип float.

"weight" : number

Функция random_score генерирует случайные числа, равномерно распределенные от 0 до 1 (не включая 1). По умолчанию, она использует внутренние идентификаторы документов Lucene в качестве источника случайности, что очень эффективно, но, к сожалению, не воспроизводимо, так как документы могут быть переименованы при слиянии.

Если вам нужно, чтобы результаты были воспроизводимыми, можно предоставить seed и field. Конечное значение затем будет рассчитано на основе этого значения, минимального значения field для рассматриваемого документа и соли, рассчитанной на основе имени индекса и идентификатора фрагмента, чтобы документы с одинаковым значением, но хранящиеся в разных индексах, получали разные оценки. Обратите внимание, что документы в одном фрагменте и с одинаковым значением для field будут, тем не менее, получать одинаковые оценки, поэтому обычно желательно использовать поле с уникальными значениями для всех документов. Хорошим вариантом по умолчанию может быть использование поля _seq_no, единственным недостатком которого является то, что оценки изменятся, если документ будет обновлён, так как операции обновления также обновляют значение поля _seq_no.

resp = client.search(
    query={
        "function_score": {
            "random_score": {
                "seed": 10,
                "field": "_seq_no"
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      function_score: {
        random_score: {
          seed: 10,
          field: '_seq_no'
        }
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "function_score": {
	      "random_score": {
	        "seed": 10,
	        "field": "_seq_no"
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    function_score: {
      random_score: {
        seed: 10,
        field: "_seq_no",
      },
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "function_score": {
      "random_score": {
        "seed": 10,
        "field": "_seq_no"
      }
    }
  }
}

Функция field_value_factor позволяет использовать поле из документа для влияния на оценку. Она похожа на использование функции script_score, но избегает накладных расходов на скрипты. Если используется для многозначного поля, в расчётах используется только первое значение поля.

Например, представьте, что у вас есть документ, индексированный с числовым полем my-int, и вы хотите повлиять на оценку документа с помощью этого поля. Пример реализации:

resp = client.search(
    query={
        "function_score": {
            "field_value_factor": {
                "field": "my-int",
                "factor": 1.2,
                "modifier": "sqrt",
                "missing": 1
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      function_score: {
        field_value_factor: {
          field: 'my-int',
          factor: 1.2,
          modifier: 'sqrt',
          missing: 1
        }
      }
    }
  }
)
puts response

const response = await client.search({
  query: {
    function_score: {
      field_value_factor: {
        field: "my-int",
        factor: 1.2,
        modifier: "sqrt",
        missing: 1,
      },
    },
  },
});
console.log(response);

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

Что переведётся в следующую формулу для оценки:

sqrt(1.2 * doc['my-int'].value)

Существует ряд опций для функции field_value_factor:

Функции затухания оценивают документ с помощью функции, которая затухает в зависимости от расстояния числового значения поля документа от заданного пользователем начала отсчета. Это похоже на запрос по диапазону, но с плавными краями вместо прямоугольных.

Чтобы использовать оценку по расстоянию для запроса, содержащего числовые поля, пользователь должен определить origin и scale для каждого поля. origin необходимо для определения «центральной точки», от которой вычисляется расстояние, а scale — для определения скорости затухания. Функция затухания задается как

"DECAY_FUNCTION": { 
    "FIELD_NAME": { 
          "origin": "11, 12",
          "scale": "2km",
          "offset": "0km",
          "decay": 0.33
    }
}

В приведенном выше примере поле является geo_point, а начало отсчета может быть задано в формате геокоординат. scale и offset в этом случае должны быть указаны с единицей измерения. Если ваше поле — поле даты, вы можете установить scale и offset как дни, недели и так далее. Пример:

resp = client.search(
    query={
        "function_score": {
            "gauss": {
                "@timestamp": {
                    "origin": "2013-09-17",
                    "scale": "10d",
                    "offset": "5d",
                    "decay": 0.5
                }
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      function_score: {
        gauss: {
          "@timestamp": {
            origin: '2013-09-17',
            scale: '10d',
            offset: '5d',
            decay: 0.5
          }
        }
      }
    }
  }
)
puts response

const response = await client.search({
  query: {
    function_score: {
      gauss: {
        "@timestamp": {
          origin: "2013-09-17",
          scale: "10d",
          offset: "5d",
          decay: 0.5,
        },
      },
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "function_score": {
      "gauss": {
        "@timestamp": {
          "origin": "2013-09-17", 
          "scale": "10d",
          "offset": "5d",         
          "decay": 0.5            
        }
      }
    }
  }
}

В первом примере ваши документы могут представлять отели и содержать поле с геолокацией. Вы хотите вычислить функцию затухания в зависимости от того, как далеко находится отель от заданного местоположения. Вы можете не сразу увидеть, какую шкалу выбрать для функции Гаусса, но вы можете сказать что-то вроде: «На расстоянии 2 км от желаемого местоположения оценка должна быть уменьшена до одной трети». Параметр «масштаб» затем будет автоматически скорректирован, чтобы гарантировать, что функция оценки вычисляет оценку 0,33 для отелей, находящихся в 2 км от желаемого местоположения.

Во втором примере документы со значением поля между 2013-09-12 и 2013-09-22 получат вес 1,0, а документы, которые находятся в 15 днях от этой даты, получат вес 0,5.

    "DECAY_FUNCTION": {
        "FIELD_NAME": {
              "origin": ...,
              "scale": ...
        },
        "multi_value_mode": "avg"
    }

Предположим, вы ищете отель в определенном городе. Ваш бюджет ограничен. Также вы хотите, чтобы отель был недалеко от центра города, поэтому чем дальше отель от желаемого места, тем меньше вероятность, что вы забронируете его.

Вы хотите, чтобы результаты запроса, соответствующие вашим критериям (например, "отель, Нанси, некурящий"), были оценены с учетом расстояния до центра города и цены.

Интуитивно вы хотите определить центр города как начало отсчета и, возможно, вы готовы пройти 2 км до центра города от отеля.
В этом случае вашим началом отсчета для поля местоположения является центр города, а масштаб составляет ~2 км.

Если у вас ограниченный бюджет, то вы, вероятно, предпочтете что-то дешевое, а не дорогое. Для поля цены начало отсчета будет 0 евро, а масштаб зависит от того, сколько вы готовы заплатить, например, 20 евро.

В этом примере поля могут называться "цена" для цены отеля и "местоположение" для координат этого отеля.

Функция для price в этом случае будет

"gauss": { 
    "price": {
          "origin": "0",
          "scale": "20"
    }
}

и для location:

"gauss": { 
    "location": {
          "origin": "11, 12",
          "scale": "2km"
    }
}

Предположим, вы хотите умножить эти две функции на исходный рейтинг. Запрос будет выглядеть следующим образом:

resp = client.search(
    query={
        "function_score": {
            "functions": [
                {
                    "gauss": {
                        "price": {
                            "origin": "0",
                            "scale": "20"
                        }
                    }
                },
                {
                    "gauss": {
                        "location": {
                            "origin": "11, 12",
                            "scale": "2km"
                        }
                    }
                }
            ],
            "query": {
                "match": {
                    "properties": "balcony"
                }
            },
            "score_mode": "multiply"
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      function_score: {
        functions: [
          {
            gauss: {
              price: {
                origin: '0',
                scale: '20'
              }
            }
          },
          {
            gauss: {
              location: {
                origin: '11, 12',
                scale: '2km'
              }
            }
          }
        ],
        query: {
          match: {
            properties: 'balcony'
          }
        },
        score_mode: 'multiply'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "function_score": {
	      "functions": [
	        {
	          "gauss": {
	            "price": {
	              "origin": "0",
	              "scale": "20"
	            }
	          }
	        },
	        {
	          "gauss": {
	            "location": {
	              "origin": "11, 12",
	              "scale": "2km"
	            }
	          }
	        }
	      ],
	      "query": {
	        "match": {
	          "properties": "balcony"
	        }
	      },
	      "score_mode": "multiply"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    function_score: {
      functions: [
        {
          gauss: {
            price: {
              origin: "0",
              scale: "20",
            },
          },
        },
        {
          gauss: {
            location: {
              origin: "11, 12",
              scale: "2km",
            },
          },
        },
      ],
      query: {
        match: {
          properties: "balcony",
        },
      },
      score_mode: "multiply",
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "function_score": {
      "functions": [
        {
          "gauss": {
            "price": {
              "origin": "0",
              "scale": "20"
            }
          }
        },
        {
          "gauss": {
            "location": {
              "origin": "11, 12",
              "scale": "2km"
            }
          }
        }
      ],
      "query": {
        "match": {
          "properties": "balcony"
        }
      },
      "score_mode": "multiply"
    }
  }
}

Далее мы покажем, как выглядит вычисленная оценка для каждой из трех возможных функций затухания.

Нормальное затухание, ключевое слово gauss

При выборе gauss в качестве функции затухания в приведенном выше примере контур и поверхность графика множителя выглядят следующим образом:

Предположим, что результаты вашего исходного поиска соответствуют трем отелям:

• "Backback Nap"
• "Drink n Drive"
• "BnB Bellevue".

"Drink n Drive" находится довольно далеко от вашего определенного местоположения (почти 2 км) и не слишком дешевый (около 13 евро), поэтому он получает низкий множитель - 0,56. "BnB Bellevue" и "Backback Nap" находятся довольно близко к определенному местоположению, но "BnB Bellevue" дешевле, поэтому он получает множитель 0,86, а "Backpack Nap" - 0,66.

Экспоненциальное затухание, ключевое слово exp

При выборе exp в качестве функции затухания в приведенном выше примере контур и поверхность графика множителя выглядят следующим образом:

Линейное затухание, ключевое слово linear

При выборе linear в качестве функции затухания в приведенном выше примере контур и поверхность графика множителя выглядят следующим образом:

Поддерживаются только числовые, датированные и геокоординатные поля.

Если числовое поле отсутствует в документе, функция вернет 1.