› › ›

稀疏向量查询

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

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

然后，这些令牌-权重对用于针对稀疏向量进行查询。在查询时，使用与创建令牌相同的推理模型计算查询向量。查询时，这些查询向量与其各自的权重一起进行 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)来实现，方法是通过具有多个standard检索器的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 查询语义查询 »

稀疏向量查询