› › ›

Получатель

Получатель — это спецификация для описания лучших документов, возвращаемых из поиска. Получатель заменяет другие элементы API поиска, которые также возвращают лучшие документы, такие как API поиска, а также query и knn. Получатель может иметь дочерние получатели, и получатель с двумя или более дочерними получателями считается составным получателем. Это позволяет отображать сложное поведение в виде древовидной структуры, называемой деревом получателей, что проясняет порядок операций, выполняемых при поиске.

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

Доступны следующие получатели:

standard: Получатель, который заменяет функциональность традиционного запроса.
knn: Получатель, который заменяет функциональность поиска kNN.
rrf: Получатель, который формирует лучшие документы на основе взаимного ранжирования слияния (RRF).
text_similarity_reranker: Получатель, который улучшает результаты поиска, повторно ранжируя документы на основе семантического сходства с заданным текстом вывода с помощью модели машинного обучения.
rule: Получатель, который применяет контекстные правила поиска для закрепления или исключения документов для определённых запросов.

Стандартный получатель

Стандартный получатель возвращает лучшие документы по традиционному запросу.

Параметры:

query

(Необязательный, объект запроса)

Определяет запрос для получения набора лучших документов.

filter

(Необязательный, объект запроса или список объектов запросов)

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

search_after

(Необязательный, объект поиска после)

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

terminate_after

(Необязательный, целое число) Максимальное количество документов для сбора для каждого фрагмента. Если запрос достигает этого предела, Elasticsearch прерывает запрос преждевременно. Elasticsearch собирает документы до сортировки.

Используйте с осторожностью. Elasticsearch применяет этот параметр к каждому фрагменту, обрабатывающему запрос. Когда это возможно, позвольте Elasticsearch выполнять преждевременное завершение автоматически. Избегайте указания этого параметра для запросов, которые нацелены на потоки данных с базирующимися индексами в нескольких уровнях данных.

sort

(Необязательный, объект сортировки) Объект сортировки, определяющий порядок сопоставленных документов.

min_score

(Необязательный, float)

Минимальный _score для сопоставленных документов. Документы с более низким _score не включаются в лучшие документы.

collapse

(Необязательный, объект сжатия)

Сжимает лучшие документы по указанному ключу в один лучший документ на ключ.

Ограничения

Когда дерево получателей содержит составного получателя (получатель с двумя или более дочерними получателями), параметр поиск после не поддерживается.

Пример

resp = client.search(
    index="restaurants",
    retriever={
        "standard": {
            "query": {
                "bool": {
                    "should": [
                        {
                            "match": {
                                "region": "Austria"
                            }
                        }
                    ],
                    "filter": [
                        {
                            "term": {
                                "year": "2019"
                            }
                        }
                    ]
                }
            }
        }
    },
)
print(resp)

const response = await client.search({
  index: "restaurants",
  retriever: {
    standard: {
      query: {
        bool: {
          should: [
            {
              match: {
                region: "Austria",
              },
            },
          ],
          filter: [
            {
              term: {
                year: "2019",
              },
            },
          ],
        },
      },
    },
  },
});
console.log(response);

GET /restaurants/_search
{
  "retriever": { 
    "standard": { 
      "query": { 
        "bool": { 
          "should": [ 
            {
              "match": { 
                "region": "Austria"
              }
            }
          ],
          "filter": [ 
            {
              "term": { 
                "year": "2019" 
              }
            }
          ]
        }
      }
    }
  }
}

	Открывает объект `retriever`.
	Получатель `standard` используется для определения традиционных запросов Elasticsearch.
	Точка входа для определения запроса поиска.
	Объект `bool` позволяет объединять несколько пунктов запроса логически.
	Массив `should` указывает условия, при которых документ будет соответствовать. Документы, соответствующие этим условиям, будут иметь повышенные релевантные оценки.
	Объект `match` находит документы, где поле `region` содержит слово "Австрия".
	Массив `filter` предоставляет условия фильтрации, которые должны быть выполнены, но не влияют на рейтинг релевантности.
	Объект `term` используется для точных совпадений, в данном случае для фильтрации документов по полю `year`.
	Точное значение для соответствия в поле `year`.

kNN Поисковик

Поисковик kNN возвращает лучшие документы из поиска k-ближайших соседей (kNN).

Параметры

field

(Обязательно, строка)

Имя поля вектора для поиска. Должно быть полем dense_vector с включенным индексированием.

query_vector

(Обязательно, если query_vector_builder не определено, массив float)

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

query_vector_builder

(Обязательно, если query_vector не определено, объект-построитель вектора запроса)

Определяет модель для построения вектора запроса.

k

(Обязательно, целое число)

Количество ближайших соседей для возврата в качестве лучших результатов. Это значение должно быть меньше или равно num_candidates.

num_candidates

(Обязательно, целое число)

Количество кандидатов на ближайших соседей для рассмотрения на каждый фрагмент. Должно быть больше k или size, если k опущено, и не может превышать 10 000. Elasticsearch собирает num_candidates результатов с каждого фрагмента, а затем объединяет их, чтобы найти лучшие k результаты. Увеличение num_candidates, как правило, повышает точность окончательных k результатов. По умолчанию равно Math.min(1.5 * k, 10_000).

filter

(Необязательно, объект запроса или список объектов запросов)

Запрос для фильтрации документов, которые могут соответствовать. Поиск kNN вернет лучшие k документов, которые также соответствуют этому фильтру. Значение может быть единственным запросом или списком запросов. Если filter не предоставлен, все документы могут соответствовать.

similarity

(Необязательно, число с плавающей точкой)

Минимальная близость, необходимая для того, чтобы документ считался соответствием. Значение близости рассчитывается на основе исходного similarity. А не оценки документа. Сопоставленные документы затем оцениваются в соответствии с similarity, и применяется предоставленное значение boost.

Параметр similarity - это прямое вычисление векторной близости.

l2_norm: также известный как евклидов, будет включать документы, где вектор находится в dims гиперсфере с радиусом similarity с центром в query_vector.
cosine, dot_product и max_inner_product: Возвращаются только векторы, где косинусная близость или скалярное произведение не меньше указанного similarity.

Подробнее см.: поиск близости kNN

Ограничения

Параметры query_vector и query_vector_builder не могут использоваться вместе.

Пример

resp = client.search(
    index="restaurants",
    retriever={
        "knn": {
            "field": "vector",
            "query_vector": [
                10,
                22,
                77
            ],
            "k": 10,
            "num_candidates": 10
        }
    },
)
print(resp)

const response = await client.search({
  index: "restaurants",
  retriever: {
    knn: {
      field: "vector",
      query_vector: [10, 22, 77],
      k: 10,
      num_candidates: 10,
    },
  },
});
console.log(response);

GET /restaurants/_search
{
  "retriever": {
    "knn": { 
      "field": "vector", 
      "query_vector": [10, 22, 77], 
      "k": 10, 
      "num_candidates": 10 
    }
  }
}

	Настройка поиска k-ближайших соседей (knn), основанного на близости векторов.
	Указывает имя поля, содержащего векторы.
	Вектор запроса, с которым сравниваются векторные данные документа в поиске `knn`.
	Количество ближайших соседей для возврата в качестве лучших результатов. Это значение должно быть меньше или равно `num_candidates`.
	Размер начального набора кандидатов, из которого выбираются окончательные `k` ближайших соседей.

Поисковик RRF

Поисковик RRF возвращает лучшие документы на основе формулы RRF, равномерно взвешивая два или более дочерних поисковика. Слияние обратных рангов (RRF) — это метод объединения нескольких наборов результатов с различными показателями релевантности в единый набор результатов.

Параметры

retrievers

(Обязательно, массив объектов поисковиков)

Список дочерних поисковиков, которые определяют наборы возвращаемых лучших документов, к которым будет применена формула RRF. Каждый дочерний поисковик имеет равный вес в рамках формулы RRF. Требуются два или более дочерних поисковиков.

rank_constant

(Необязательно, целое число)

Это значение определяет, насколько сильно документы в отдельных наборах результатов для каждого запроса влияют на окончательный ранжированный набор результатов. Большее значение указывает, что документы с более низким рангом имеют большее влияние. Это значение должно быть больше или равно 1. По умолчанию равно 60.

rank_window_size

(Необязательно, целое число)

Это значение определяет размер отдельных наборов результатов для каждого запроса. Большее значение улучшит релевантность результатов за счет производительности. Окончательный ранжированный набор результатов усекается до значения размера запроса. rank_window_size должно быть больше или равно size и больше или равно 1. По умолчанию равно параметру size.

filter

(Необязательно, объект запроса или список объектов запросов)

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

Пример: Гибридный поиск

Простой пример гибридного поиска (лексический поиск + поиск по плотным векторам), объединяющий поисковик standard с поисковиком knn с использованием RRF:

resp = client.search(
    index="restaurants",
    retriever={
        "rrf": {
            "retrievers": [
                {
                    "standard": {
                        "query": {
                            "multi_match": {
                                "query": "Austria",
                                "fields": [
                                    "city",
                                    "region"
                                ]
                            }
                        }
                    }
                },
                {
                    "knn": {
                        "field": "vector",
                        "query_vector": [
                            10,
                            22,
                            77
                        ],
                        "k": 10,
                        "num_candidates": 10
                    }
                }
            ],
            "rank_constant": 1,
            "rank_window_size": 50
        }
    },
)
print(resp)

const response = await client.search({
  index: "restaurants",
  retriever: {
    rrf: {
      retrievers: [
        {
          standard: {
            query: {
              multi_match: {
                query: "Austria",
                fields: ["city", "region"],
              },
            },
          },
        },
        {
          knn: {
            field: "vector",
            query_vector: [10, 22, 77],
            k: 10,
            num_candidates: 10,
          },
        },
      ],
      rank_constant: 1,
      rank_window_size: 50,
    },
  },
});
console.log(response);

GET /restaurants/_search
{
  "retriever": {
    "rrf": { 
      "retrievers": [ 
        {
          "standard": { 
            "query": {
              "multi_match": {
                "query": "Austria",
                "fields": [
                  "city",
                  "region"
                ]
              }
            }
          }
        },
        {
          "knn": { 
            "field": "vector",
            "query_vector": [10, 22, 77],
            "k": 10,
            "num_candidates": 10
          }
        }
      ],
      "rank_constant": 1, 
      "rank_window_size": 50  
    }
  }
}

	Определяет дерево поисковиков с поисковиком RRF.
	Массив подпоисковиков.
	Первый подпоисковик — поисковик `standard`.
	Второй подпоисковик — поисковик `knn`.
	Постоянная ранжирования для поисковика RRF.
	Размер окна ранжирования для поисковика RRF.

Пример: Гибридный поиск с разреженными векторами

Более сложный пример гибридного поиска (лексический поиск + поиск по разреженным векторам ELSER + поиск по плотным векторам) с использованием RRF:

resp = client.search(
    index="movies",
    retriever={
        "rrf": {
            "retrievers": [
                {
                    "standard": {
                        "query": {
                            "sparse_vector": {
                                "field": "plot_embedding",
                                "inference_id": "my-elser-model",
                                "query": "films that explore psychological depths"
                            }
                        }
                    }
                },
                {
                    "standard": {
                        "query": {
                            "multi_match": {
                                "query": "crime",
                                "fields": [
                                    "plot",
                                    "title"
                                ]
                            }
                        }
                    }
                },
                {
                    "knn": {
                        "field": "vector",
                        "query_vector": [
                            10,
                            22,
                            77
                        ],
                        "k": 10,
                        "num_candidates": 10
                    }
                }
            ]
        }
    },
)
print(resp)

const response = await client.search({
  index: "movies",
  retriever: {
    rrf: {
      retrievers: [
        {
          standard: {
            query: {
              sparse_vector: {
                field: "plot_embedding",
                inference_id: "my-elser-model",
                query: "films that explore psychological depths",
              },
            },
          },
        },
        {
          standard: {
            query: {
              multi_match: {
                query: "crime",
                fields: ["plot", "title"],
              },
            },
          },
        },
        {
          knn: {
            field: "vector",
            query_vector: [10, 22, 77],
            k: 10,
            num_candidates: 10,
          },
        },
      ],
    },
  },
});
console.log(response);

GET movies/_search
{
  "retriever": {
    "rrf": {
      "retrievers": [
        {
          "standard": {
            "query": {
              "sparse_vector": {
                "field": "plot_embedding",
                "inference_id": "my-elser-model",
                "query": "films that explore psychological depths"
              }
            }
          }
        },
        {
          "standard": {
            "query": {
              "multi_match": {
                "query": "crime",
                "fields": [
                  "plot",
                  "title"
                ]
              }
            }
          }
        },
        {
          "knn": {
            "field": "vector",
            "query_vector": [10, 22, 77],
            "k": 10,
            "num_candidates": 10
          }
        }
      ]
    }
  }
}

Повторный ранжировщик сходства текстов

Повторный ранжировщик использует модель NLP для улучшения результатов поиска, переупорядочивая верхние k документов на основе их семантического сходства с запросом.

Обратитесь к Семантическому повторному ранжированию для обзора семантического повторного ранжирования высокого уровня.

Предварительные условия

Для использования повторного ранжировщика сходства текстов необходимо сначала настроить конечную точку вывода для задачи rerank с помощью Создание API вывода. Конечная точка должна быть настроена с моделью машинного обучения, которая может вычислять сходство текстов. Обратитесь к справочнику моделей Elastic NLP для списка поддерживаемых сторонними разработчиками моделей сходства текстов Elasticsearch.

У вас есть следующие варианты:

Используйте встроенную Elastic Rerank модель кросс-кодирования через сервис Elasticsearch API вывода.
Используйте конечную точку вывода Cohere Rerank с типом задачи rerank.
Используйте конечную точку вывода Google Vertex AI с типом задачи rerank.
Загрузите модель в Elasticsearch с помощью Eland с помощью типа задачи NLP text_similarity.
- Затем настройте конечную точку вывода сервиса Elasticsearch с типом задачи rerank.
- Обратитесь к примеру на этой странице для пошагового руководства.

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

score = max(score, 0) + min(exp(score), 1)

Используя вышеприведенное, все первоначально отрицательные оценки будут проецироваться на (0, 1), а положительные — на [1, бесконечность). Для отмены, при необходимости, можно использовать:

score = score - 1, if score >= 0
score = ln(score), if score < 0

Параметры

retriever

(Обязательно, повторный ранжировщик)

Дочерний повторный ранжировщик, генерирующий начальный набор верхних документов для повторного ранжирования.

field

(Обязательно, string)

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

inference_id

(Обязательно, string)

Уникальный идентификатор конечной точки вывода, созданной с помощью API вывода.

inference_text

(Обязательно, string)

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

rank_window_size

(Необязательно, int)

Количество верхних документов для рассмотрения в процессе повторного ранжирования. По умолчанию 10.

min_score

(Необязательно, float)

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

filter

(Необязательно, объект запроса или список объектов запроса)

Применяет указанный фильтр boolean запроса к дочернему повторному ранжировщику. Если дочерний повторный ранжировщик уже определяет какие-либо фильтры, то этот фильтр верхнего уровня применяется совместно с фильтром, определенным в дочернем повторном ранжировщике.

Пример: Elastic Rerank

Этот пример демонстрирует, как развернуть модель Elastic Rerank и использовать её для повторного ранжирования результатов поиска, используя повторный ранжировщик text_similarity_reranker.

Выполните следующие шаги:

Создайте конечную точку вывода для задачи rerank, используя Создание API вывода.

resp = client.inference.put(
    task_type="rerank",
    inference_id="my-elastic-rerank",
    inference_config={
        "service": "elasticsearch",
        "service_settings": {
            "model_id": ".rerank-v1",
            "num_threads": 1,
            "adaptive_allocations": {
                "enabled": True,
                "min_number_of_allocations": 1,
                "max_number_of_allocations": 10
            }
        }
    },
)
print(resp)

const response = await client.inference.put({
  task_type: "rerank",
  inference_id: "my-elastic-rerank",
  inference_config: {
    service: "elasticsearch",
    service_settings: {
      model_id: ".rerank-v1",
      num_threads: 1,
      adaptive_allocations: {
        enabled: true,
        min_number_of_allocations: 1,
        max_number_of_allocations: 10,
      },
    },
  },
});
console.log(response);

PUT _inference/rerank/my-elastic-rerank
{
  "service": "elasticsearch",
  "service_settings": {
    "model_id": ".rerank-v1",
    "num_threads": 1,
    "adaptive_allocations": { 
      "enabled": true,
      "min_number_of_allocations": 1,
      "max_number_of_allocations": 10
    }
  }
}

Адаптивные выделения будут включены с минимумом 1 и максимумом 10 выделений.

Определите повторный ранжировщик text_similarity_rerank:

resp = client.search(
    retriever={
        "text_similarity_reranker": {
            "retriever": {
                "standard": {
                    "query": {
                        "match": {
                            "text": "How often does the moon hide the sun?"
                        }
                    }
                }
            },
            "field": "text",
            "inference_id": "my-elastic-rerank",
            "inference_text": "How often does the moon hide the sun?",
            "rank_window_size": 100,
            "min_score": 0.5
        }
    },
)
print(resp)

const response = await client.search({
  retriever: {
    text_similarity_reranker: {
      retriever: {
        standard: {
          query: {
            match: {
              text: "How often does the moon hide the sun?",
            },
          },
        },
      },
      field: "text",
      inference_id: "my-elastic-rerank",
      inference_text: "How often does the moon hide the sun?",
      rank_window_size: 100,
      min_score: 0.5,
    },
  },
});
console.log(response);

POST _search
{
  "retriever": {
    "text_similarity_reranker": {
      "retriever": {
        "standard": {
          "query": {
            "match": {
              "text": "How often does the moon hide the sun?"
            }
          }
        }
      },
      "field": "text",
      "inference_id": "my-elastic-rerank",
      "inference_text": "How often does the moon hide the sun?",
      "rank_window_size": 100,
      "min_score": 0.5
    }
  }
}

Пример: Cohere Rerank

Этот пример позволяет использовать семантический поиск "из коробки" путем повторного ранжирования верхних документов с использованием API Cohere Rerank. Этот подход исключает необходимость генерации и хранения вложений для всех индексированных документов. Для этого требуется конечная точка вывода Cohere Rerank, настроенная для задачи rerank.

resp = client.search(
    index="index",
    retriever={
        "text_similarity_reranker": {
            "retriever": {
                "standard": {
                    "query": {
                        "match_phrase": {
                            "text": "landmark in Paris"
                        }
                    }
                }
            },
            "field": "text",
            "inference_id": "my-cohere-rerank-model",
            "inference_text": "Most famous landmark in Paris",
            "rank_window_size": 100,
            "min_score": 0.5
        }
    },
)
print(resp)

const response = await client.search({
  index: "index",
  retriever: {
    text_similarity_reranker: {
      retriever: {
        standard: {
          query: {
            match_phrase: {
              text: "landmark in Paris",
            },
          },
        },
      },
      field: "text",
      inference_id: "my-cohere-rerank-model",
      inference_text: "Most famous landmark in Paris",
      rank_window_size: 100,
      min_score: 0.5,
    },
  },
});
console.log(response);

GET /index/_search
{
   "retriever": {
      "text_similarity_reranker": {
         "retriever": {
            "standard": {
               "query": {
                  "match_phrase": {
                     "text": "landmark in Paris"
                  }
               }
            }
         },
         "field": "text",
         "inference_id": "my-cohere-rerank-model",
         "inference_text": "Most famous landmark in Paris",
         "rank_window_size": 100,
         "min_score": 0.5
      }
   }
}

Пример: Семантическое повторное ранжирование с моделью Hugging Face

Следующий пример использует модель cross-encoder/ms-marco-MiniLM-L-6-v2 из Hugging Face для повторного ранжирования результатов поиска на основе семантического сходства. Модель должна быть загружена в Elasticsearch с помощью Eland.

Обратитесь к справочнику моделей Elastic NLP для списка поддерживаемых сторонними разработчиками моделей сходства текстов Elasticsearch.

Выполните следующие действия для загрузки модели и создания семантического повторного ранжировщика.

Установите Eland с помощью pip
```
python -m pip install eland[pytorch]
```
Загрузите модель в Elasticsearch с помощью Eland. В этом примере предполагается, что у вас есть развертывание Elastic Cloud и API-ключ. Обратитесь к документации Eland для получения дополнительных вариантов аутентификации.
```
eland_import_hub_model \
  --cloud-id $CLOUD_ID \
  --es-api-key $ES_API_KEY \
  --hub-model-id cross-encoder/ms-marco-MiniLM-L-6-v2 \
  --task-type text_similarity \
  --clear-previous \
  --start
```

Создайте конечную точку вывода для задачи rerank

resp = client.inference.put(
    task_type="rerank",
    inference_id="my-msmarco-minilm-model",
    inference_config={
        "service": "elasticsearch",
        "service_settings": {
            "num_allocations": 1,
            "num_threads": 1,
            "model_id": "cross-encoder__ms-marco-minilm-l-6-v2"
        }
    },
)
print(resp)

const response = await client.inference.put({
  task_type: "rerank",
  inference_id: "my-msmarco-minilm-model",
  inference_config: {
    service: "elasticsearch",
    service_settings: {
      num_allocations: 1,
      num_threads: 1,
      model_id: "cross-encoder__ms-marco-minilm-l-6-v2",
    },
  },
});
console.log(response);

PUT _inference/rerank/my-msmarco-minilm-model
{
  "service": "elasticsearch",
  "service_settings": {
    "num_allocations": 1,
    "num_threads": 1,
    "model_id": "cross-encoder__ms-marco-minilm-l-6-v2"
  }
}

Определите повторный ранжировщик text_similarity_rerank.

resp = client.search(
    index="movies",
    retriever={
        "text_similarity_reranker": {
            "retriever": {
                "standard": {
                    "query": {
                        "match": {
                            "genre": "drama"
                        }
                    }
                }
            },
            "field": "plot",
            "inference_id": "my-msmarco-minilm-model",
            "inference_text": "films that explore psychological depths"
        }
    },
)
print(resp)

const response = await client.search({
  index: "movies",
  retriever: {
    text_similarity_reranker: {
      retriever: {
        standard: {
          query: {
            match: {
              genre: "drama",
            },
          },
        },
      },
      field: "plot",
      inference_id: "my-msmarco-minilm-model",
      inference_text: "films that explore psychological depths",
    },
  },
});
console.log(response);

POST movies/_search
{
  "retriever": {
    "text_similarity_reranker": {
      "retriever": {
        "standard": {
          "query": {
            "match": {
              "genre": "drama"
            }
          }
        }
      },
      "field": "plot",
      "inference_id": "my-msmarco-minilm-model",
      "inference_text": "films that explore psychological depths"
    }
  }
}

Этот повторный ранжировщик использует стандартный запрос match для поиска в индексе movie фильмов с тегом "драма". Затем он повторно ранжирует результаты на основе семантического сходства с текстом в параметре inference_text, используя модель, которую мы загрузили в Elasticsearch.

Получатель правил запросов

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

Предварительные условия

Для использования получателя необходимо предварительно создать один или несколько наборов правил запросов с помощью API управления правилами запросов.

Параметры

retriever

(Обязательно, получатель)

Вложенный получатель, возвращающий результаты для применения правил запросов поверх них. Это может быть автономный получатель, например, стандартный или kNN получатель, или составной получатель.

ruleset_ids

(Обязательно, array)

Массив из одного или нескольких уникальных идентификаторов наборов правил запросов с правилами, основанными на запросах, для сопоставления и применения по мере необходимости. Наборы правил и связанные с ними правила оцениваются в порядке их указания в запросе и наборе правил. Максимальное количество наборов правил для указания — 10.

match_criteria

(Обязательно, object)

Определяет критерии сопоставления для применения к правилам в заданном наборе(ах) правил запросов. Критерии сопоставления должны соответствовать ключам, определённым в поле criteria.metadata правила.

rank_window_size

(Необязательно, int)

Количество верхних документов, которые нужно вернуть из получателя rule. По умолчанию 10.

Пример: Получатель правил

Этот пример демонстрирует работу получателя правил без дополнительных получателей. Он выполняет запрос, определённый в retriever, и применяет правила из my-ruleset к полученным результатам.

resp = client.search(
    index="movies",
    retriever={
        "rule": {
            "match_criteria": {
                "query_string": "harry potter"
            },
            "ruleset_ids": [
                "my-ruleset"
            ],
            "retriever": {
                "standard": {
                    "query": {
                        "query_string": {
                            "query": "harry potter"
                        }
                    }
                }
            }
        }
    },
)
print(resp)

const response = await client.search({
  index: "movies",
  retriever: {
    rule: {
      match_criteria: {
        query_string: "harry potter",
      },
      ruleset_ids: ["my-ruleset"],
      retriever: {
        standard: {
          query: {
            query_string: {
              query: "harry potter",
            },
          },
        },
      },
    },
  },
});
console.log(response);

GET movies/_search
{
  "retriever": {
    "rule": {
      "match_criteria": {
        "query_string": "harry potter"
      },
      "ruleset_ids": [
        "my-ruleset"
      ],
      "retriever": {
        "standard": {
          "query": {
            "query_string": {
              "query": "harry potter"
            }
          }
        }
      }
    }
  }
}

Пример: Получатель правил в сочетании с RRF

Этот пример показывает, как объединить получатель rule с другими получателями переупорядочивания, такими как rrf или text_similarity_reranker.

Получатель rule будет применять правила к любым документам, возвращённым из его определённого retriever или любого из его подполучателей. Это означает, что для наилучших результатов получатель rule должен быть внешним определённым получателем. Вложение получателя rule в качестве подполучателя под переупорядочивателем, таким как rrf или text_similarity_reranker, может не привести к ожидаемым результатам.

resp = client.search(
    index="movies",
    retriever={
        "rule": {
            "match_criteria": {
                "query_string": "harry potter"
            },
            "ruleset_ids": [
                "my-ruleset"
            ],
            "retriever": {
                "rrf": {
                    "retrievers": [
                        {
                            "standard": {
                                "query": {
                                    "query_string": {
                                        "query": "sorcerer's stone"
                                    }
                                }
                            }
                        },
                        {
                            "standard": {
                                "query": {
                                    "query_string": {
                                        "query": "chamber of secrets"
                                    }
                                }
                            }
                        }
                    ]
                }
            }
        }
    },
)
print(resp)

const response = await client.search({
  index: "movies",
  retriever: {
    rule: {
      match_criteria: {
        query_string: "harry potter",
      },
      ruleset_ids: ["my-ruleset"],
      retriever: {
        rrf: {
          retrievers: [
            {
              standard: {
                query: {
                  query_string: {
                    query: "sorcerer's stone",
                  },
                },
              },
            },
            {
              standard: {
                query: {
                  query_string: {
                    query: "chamber of secrets",
                  },
                },
              },
            },
          ],
        },
      },
    },
  },
});
console.log(response);

GET movies/_search
{
  "retriever": {
    "rule": { 
      "match_criteria": {
        "query_string": "harry potter"
      },
      "ruleset_ids": [
        "my-ruleset"
      ],
      "retriever": {
        "rrf": { 
          "retrievers": [
            {
              "standard": {
                "query": {
                  "query_string": {
                    "query": "sorcerer's stone"
                  }
                }
              }
            },
            {
              "standard": {
                "query": {
                  "query_string": {
                    "query": "chamber of secrets"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}

	Получатель `rule` является внешним получателем, применяющим правила к результатам поиска, которые были предварительно переупорядочены с помощью получателя `rrf`.
	Получатель `rrf` возвращает результаты от всех его подполучателей, а вывод получателя `rrf` используется в качестве входных данных для получателя `rule`.

Общие рекомендации по использованию

Использование `from` и `size` с деревом получателей

Параметры from и size предоставляются глобально в рамках общего API поиска. Они применяются ко всем получателям в дереве получателей, если конкретный получатель не переопределяет параметр size с помощью другого параметра, такого как rank_window_size. Однако окончательные результаты поиска всегда ограничиваются size.

Использование агрегаций с деревом получателей

Агрегации указываются глобально в рамках запроса поиска. Запрос, используемый для агрегации, представляет собой комбинацию всех лист-получателей в качестве should-клаузов в булевом запросе.

Ограничения на параметры поиска при указании получателя

Когда получатель указан в рамках поиска, следующие элементы недопустимы на верхнем уровне:

© 2023-2025 Elasticsearch
As of September 2024, Elasticsearch is available under a choice of three licenses: the Server Side Public License (SSPL), the Elastic License, or the AGPLv3 (OSI approved).
Elasticsearch and the Elasticsearch logo are trademarks of Elasticsearch B.V., registered in the U.S. and in other countries.
https://www.elastic.co/guide/en/elasticsearch/reference/8.17/retriever.html

Получатель

Стандартный получатель

Параметры:

Ограничения

Пример

kNN Поисковик

Параметры

Ограничения

Пример

Поисковик RRF

Параметры

Пример: Гибридный поиск

Пример: Гибридный поиск с разреженными векторами

Повторный ранжировщик сходства текстов

Предварительные условия

Параметры

Пример: Elastic Rerank

Пример: Cohere Rerank

Пример: Семантическое повторное ранжирование с моделью Hugging Face

Получатель правил запросов

Предварительные условия

Параметры

Пример: Получатель правил

Пример: Получатель правил в сочетании с RRF

Общие рекомендации по использованию

Использование from и size с деревом получателей

Использование агрегаций с деревом получателей

Ограничения на параметры поиска при указании получателя

Использование `from` и `size` с деревом получателей