› › ›

稀疏向量查询

稀疏向量查询执行一个由稀疏向量组成的查询，例如由学习的稀疏检索模型构建的查询。这可以通过两种策略之一实现

使用自然语言处理模型将查询文本转换为标记-权重对列表
将预先计算的标记-权重对作为查询向量发送

然后，这些标记-权重对用于针对稀疏向量的查询中。在查询时，使用与创建标记时相同的推理模型来计算查询向量。查询时，这些查询向量与其各自的权重进行 OR 运算，这意味着评分实际上是存储维度和查询维度之间的点积计算。

例如，存储的向量 {"feature_0": 0.12, "feature_1": 1.2, "feature_2": 3.0} 和查询向量 {"feature_0": 2.5, "feature_2": 0.2} 将使文档得分为 _score = 0.12*2.5 + 3.0*0.2 = 0.9

使用自然语言处理模型的示例请求

编辑

resp = client.search(
    query={
        "sparse_vector": {
            "field": "ml.tokens",
            "inference_id": "the inference ID to produce the token weights",
            "query": "the query string"
        }
    },
)
print(resp)

const response = await client.search({
  query: {
    sparse_vector: {
      field: "ml.tokens",
      inference_id: "the inference ID to produce the token weights",
      query: "the query string",
    },
  },
});
console.log(response);

GET _search
{
   "query":{
      "sparse_vector": {
        "field": "ml.tokens",
        "inference_id": "the inference ID to produce the token weights",
        "query": "the query string"
      }
   }
}

使用预计算向量的示例请求

编辑

resp = client.search(
    query={
        "sparse_vector": {
            "field": "ml.tokens",
            "query_vector": {
                "token1": 0.5,
                "token2": 0.3,
                "token3": 0.2
            }
        }
    },
)
print(resp)

const response = await client.search({
  query: {
    sparse_vector: {
      field: "ml.tokens",
      query_vector: {
        token1: 0.5,
        token2: 0.3,
        token3: 0.2,
      },
    },
  },
});
console.log(response);

GET _search
{
   "query":{
      "sparse_vector": {
        "field": "ml.tokens",
        "query_vector": { "token1": 0.5, "token2": 0.3, "token3": 0.2 }
      }
   }
}

`sparse_vector` 的顶层参数

编辑

field

（必需，字符串）包含要搜索的标记-权重对的字段的名称。

inference_id

（可选，字符串）用于将查询文本转换为标记-权重对的推理 ID。它必须是用于从输入文本创建标记的相同推理 ID。只允许使用 inference_id 和 query_vector 中的一个。如果指定了 inference_id，则还必须指定 query。

query

（可选，字符串）要用于搜索的查询文本。如果指定了 inference_id，则还必须指定 query。如果指定了 query_vector，则不得指定 query。

query_vector

（可选，字典）表示要搜索的预计算查询向量的标记-权重对字典。使用此查询向量进行搜索将绕过额外的推理。只允许使用 inference_id 和 query_vector 中的一个。

prune

（可选，布尔值） [预览] 此功能处于技术预览阶段，可能会在未来的版本中更改或删除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。是否执行修剪，从查询中省略不重要的标记以提高查询性能。如果 prune 为 true 但未指定 pruning_config，则将进行修剪，但将使用默认值。默认值：false。

pruning_config

（可选，对象） [预览] 此功能处于技术预览阶段，可能会在未来的版本中更改或删除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。可选的修剪配置。如果启用，这将从查询中省略不重要的标记，以提高查询性能。仅当 prune 设置为 true 时才使用此项。如果 prune 设置为 true 但未指定 pruning_config，则将使用默认值。

pruning_config 的参数为

tokens_freq_ratio_threshold: （可选，整数） [预览] 此功能处于技术预览阶段，可能会在未来的版本中更改或删除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。频率高于指定字段中所有标记的平均频率的 tokens_freq_ratio_threshold 倍的标记被视为异常值并进行修剪。此值必须介于 1 和 100 之间。默认值：5。
tokens_weight_threshold: （可选，浮点数） [预览] 此功能处于技术预览阶段，可能会在未来的版本中更改或删除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。权重小于 tokens_weight_threshold 的标记被认为是不重要的并进行修剪。此值必须介于 0 和 1 之间。默认值：0.4。
only_score_pruned_tokens: （可选，布尔值） [预览] 此功能处于技术预览阶段，可能会在未来的版本中更改或删除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。如果 true，我们仅将修剪后的标记输入评分，并丢弃未修剪的标记。强烈建议将此值设置为主查询的 false，但可以将其设置为重新评分查询的 true，以获得更相关的结果。默认值：false。

tokens_freq_ratio_threshold 和 tokens_weight_threshold 的默认值是基于使用 ELSERv2 进行的测试选择的，该测试提供了最佳结果。

ELSER 查询示例

编辑

以下是引用 ELSER 模型执行语义搜索的 sparse_vector 查询的示例。有关如何使用 ELSER 和 sparse_vector 查询执行语义搜索的更详细描述，请参阅本教程。

resp = client.search(
    index="my-index",
    query={
        "sparse_vector": {
            "field": "ml.tokens",
            "inference_id": "my-elser-model",
            "query": "How is the weather in Jamaica?"
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-index",
  query: {
    sparse_vector: {
      field: "ml.tokens",
      inference_id: "my-elser-model",
      query: "How is the weather in Jamaica?",
    },
  },
});
console.log(response);

GET my-index/_search
{
   "query":{
      "sparse_vector": {
         "field": "ml.tokens",
         "inference_id": "my-elser-model",
         "query": "How is the weather in Jamaica?"
      }
   }
}

多个 sparse_vector 查询可以相互组合或与其他查询类型组合。这可以通过将它们包装在布尔查询子句中并使用线性增强来实现

resp = client.search(
    index="my-index",
    query={
        "bool": {
            "should": [
                {
                    "sparse_vector": {
                        "field": "ml.inference.title_expanded.predicted_value",
                        "inference_id": "my-elser-model",
                        "query": "How is the weather in Jamaica?",
                        "boost": 1
                    }
                },
                {
                    "sparse_vector": {
                        "field": "ml.inference.description_expanded.predicted_value",
                        "inference_id": "my-elser-model",
                        "query": "How is the weather in Jamaica?",
                        "boost": 1
                    }
                },
                {
                    "multi_match": {
                        "query": "How is the weather in Jamaica?",
                        "fields": [
                            "title",
                            "description"
                        ],
                        "boost": 4
                    }
                }
            ]
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-index",
  query: {
    bool: {
      should: [
        {
          sparse_vector: {
            field: "ml.inference.title_expanded.predicted_value",
            inference_id: "my-elser-model",
            query: "How is the weather in Jamaica?",
            boost: 1,
          },
        },
        {
          sparse_vector: {
            field: "ml.inference.description_expanded.predicted_value",
            inference_id: "my-elser-model",
            query: "How is the weather in Jamaica?",
            boost: 1,
          },
        },
        {
          multi_match: {
            query: "How is the weather in Jamaica?",
            fields: ["title", "description"],
            boost: 4,
          },
        },
      ],
    },
  },
});
console.log(response);

GET my-index/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "sparse_vector": {
            "field": "ml.inference.title_expanded.predicted_value",
            "inference_id": "my-elser-model",
            "query": "How is the weather in Jamaica?",
            "boost": 1
          }
        },
        {
          "sparse_vector": {
            "field": "ml.inference.description_expanded.predicted_value",
            "inference_id": "my-elser-model",
            "query": "How is the weather in Jamaica?",
            "boost": 1
          }
        },
        {
          "multi_match": {
            "query": "How is the weather in Jamaica?",
            "fields": [
              "title",
              "description"
            ],
            "boost": 4
          }
        }
      ]
    }
  }
}

这也可以通过倒数排名融合 (RRF)来实现，通过具有多个标准检索器的rrf检索器来实现。

resp = client.search(
    index="my-index",
    retriever={
        "rrf": {
            "retrievers": [
                {
                    "standard": {
                        "query": {
                            "multi_match": {
                                "query": "How is the weather in Jamaica?",
                                "fields": [
                                    "title",
                                    "description"
                                ]
                            }
                        }
                    }
                },
                {
                    "standard": {
                        "query": {
                            "sparse_vector": {
                                "field": "ml.inference.title_expanded.predicted_value",
                                "inference_id": "my-elser-model",
                                "query": "How is the weather in Jamaica?",
                                "boost": 1
                            }
                        }
                    }
                },
                {
                    "standard": {
                        "query": {
                            "sparse_vector": {
                                "field": "ml.inference.description_expanded.predicted_value",
                                "inference_id": "my-elser-model",
                                "query": "How is the weather in Jamaica?",
                                "boost": 1
                            }
                        }
                    }
                }
            ],
            "window_size": 10,
            "rank_constant": 20
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-index",
  retriever: {
    rrf: {
      retrievers: [
        {
          standard: {
            query: {
              multi_match: {
                query: "How is the weather in Jamaica?",
                fields: ["title", "description"],
              },
            },
          },
        },
        {
          standard: {
            query: {
              sparse_vector: {
                field: "ml.inference.title_expanded.predicted_value",
                inference_id: "my-elser-model",
                query: "How is the weather in Jamaica?",
                boost: 1,
              },
            },
          },
        },
        {
          standard: {
            query: {
              sparse_vector: {
                field: "ml.inference.description_expanded.predicted_value",
                inference_id: "my-elser-model",
                query: "How is the weather in Jamaica?",
                boost: 1,
              },
            },
          },
        },
      ],
      window_size: 10,
      rank_constant: 20,
    },
  },
});
console.log(response);

GET my-index/_search
{
  "retriever": {
    "rrf": {
      "retrievers": [
        {
          "standard": {
            "query": {
              "multi_match": {
                "query": "How is the weather in Jamaica?",
                "fields": [
                  "title",
                  "description"
                ]
              }
            }
          }
        },
        {
          "standard": {
            "query": {
              "sparse_vector": {
                "field": "ml.inference.title_expanded.predicted_value",
                "inference_id": "my-elser-model",
                "query": "How is the weather in Jamaica?",
                "boost": 1
              }
            }
          }
        },
        {
          "standard": {
            "query": {
              "sparse_vector": {
                "field": "ml.inference.description_expanded.predicted_value",
                "inference_id": "my-elser-model",
                "query": "How is the weather in Jamaica?",
                "boost": 1
              }
            }
          }
        }
      ],
      "window_size": 10,
      "rank_constant": 20
    }
  }
}

带有修剪配置和重新评分的 ELSER 查询示例

编辑

以下是上述示例的扩展，它向 sparse_vector 查询添加了 [预览] 此功能处于技术预览阶段，可能会在未来的版本中更改或删除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能的支持 SLA 的约束。修剪配置。修剪配置会识别要从查询中修剪的不重要标记，以提高查询性能。

标记修剪发生在分片级别。虽然这应该导致相同的标记在各个分片中被标记为不重要，但这并不能保证，因为它取决于每个分片的组成。因此，如果您在多分片索引上使用 pruning_config 运行 sparse_vector，我们强烈建议添加一个重新评分筛选的搜索结果函数，其中包含最初从查询中修剪的标记。这将有助于缓解任何分片级别的不一致性与修剪的标记，并提供更好的整体相关性。

resp = client.search(
    index="my-index",
    query={
        "sparse_vector": {
            "field": "ml.tokens",
            "inference_id": "my-elser-model",
            "query": "How is the weather in Jamaica?",
            "prune": True,
            "pruning_config": {
                "tokens_freq_ratio_threshold": 5,
                "tokens_weight_threshold": 0.4,
                "only_score_pruned_tokens": False
            }
        }
    },
    rescore={
        "window_size": 100,
        "query": {
            "rescore_query": {
                "sparse_vector": {
                    "field": "ml.tokens",
                    "inference_id": "my-elser-model",
                    "query": "How is the weather in Jamaica?",
                    "prune": True,
                    "pruning_config": {
                        "tokens_freq_ratio_threshold": 5,
                        "tokens_weight_threshold": 0.4,
                        "only_score_pruned_tokens": True
                    }
                }
            }
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-index",
  query: {
    sparse_vector: {
      field: "ml.tokens",
      inference_id: "my-elser-model",
      query: "How is the weather in Jamaica?",
      prune: true,
      pruning_config: {
        tokens_freq_ratio_threshold: 5,
        tokens_weight_threshold: 0.4,
        only_score_pruned_tokens: false,
      },
    },
  },
  rescore: {
    window_size: 100,
    query: {
      rescore_query: {
        sparse_vector: {
          field: "ml.tokens",
          inference_id: "my-elser-model",
          query: "How is the weather in Jamaica?",
          prune: true,
          pruning_config: {
            tokens_freq_ratio_threshold: 5,
            tokens_weight_threshold: 0.4,
            only_score_pruned_tokens: true,
          },
        },
      },
    },
  },
});
console.log(response);

GET my-index/_search
{
   "query":{
      "sparse_vector":{
         "field": "ml.tokens",
         "inference_id": "my-elser-model",
         "query":"How is the weather in Jamaica?",
         "prune": true,
         "pruning_config": {
           "tokens_freq_ratio_threshold": 5,
           "tokens_weight_threshold": 0.4,
           "only_score_pruned_tokens": false
         }
      }
   },
   "rescore": {
      "window_size": 100,
      "query": {
         "rescore_query": {
            "sparse_vector": {
               "field": "ml.tokens",
               "inference_id": "my-elser-model",
               "query": "How is the weather in Jamaica?",
               "prune": true,
               "pruning_config": {
                   "tokens_freq_ratio_threshold": 5,
                   "tokens_weight_threshold": 0.4,
                   "only_score_pruned_tokens": true
               }
            }
         }
      }
   }
}

当执行跨集群搜索时，推理是在本地集群上执行的。

« Knn 查询语义查询 »

稀疏向量查询