devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Elasticsearch：检索多向量文档中的原始信息_elasticsearch 从哪个版本支持向量

作者：IT小白 | 2024-05-25 01:57:50

赞

踩

elasticsearch 从哪个版本支持向量

作者：来自 Elastic Gilad Gal

Elasticsearch（从 8.11 版本及更高版本开始）支持单个字段中每个文档具有多个向量。 这样的文档可以通过文档的最相似向量的排名或者通过每个文档具有多个结果（可能在同一结果集中文档包含的每个向量含有一个）来排名。 对于密集向量和稀疏向量（例如，使用 ELSER 时）都是如此，但为了简单起见，博客的其余部分将与密集向量相关。

这似乎是一个罕见的用例，但实际上它经常发生。 当检查密集向量搜索的两个主要用例时，原因就很清楚了：

文本（text） - 元数据文本通常旨在允许有效发现。 这对于主题列表或搜索关键字来说当然是正确的，但对于像标题这样的元数据来说也是如此，它很短并且通常旨在描述文档。 像 BM25 这样基于 token 频率的算法往往在此类内容上表现得非常好，因此它通常不需要引入基于 ML 的算法和密集向量搜索，也不需要从引入中显著受益。 然而，对于大块文本来说，情况并非如此，例如, 即使在搜索几段文本时，像 BM25 这样的算法也很难与 NLP 算法竞争，而向量搜索在这种文本类型上表现出显着的优势。 问题在于，大多数分析文本以生成用于排名的密集向量的 ML 模型仅限于 512 个标记，这大约是单个段落的大小。 换句话说，当向量搜索需要密集向量时，通常会有足够的文本来需要为每个文档生成多个向量。

图像（image） - 在许多情况下，图像描绘了现实世界中的某些事物，并且通常有来自不同角度的图像。 这是一个简单的结果，因为图像是二维的，而现实世界中的事物是三维的，因此二维图像提供了有关它们的非常部分的信息。 在电子商务中演示可能是最简单的，其中通常有一些产品图像，但其他图像搜索用例也是如此。 机器学习模型通常为每个图像生成一个向量，因此如果每个产品有多个图像，则每个产品有多个向量。

显示结果时，通常需要显示文档中导致排名的部分，例如 文本或图像中使文档在结果集中排名靠前的部分。 Elasticsearch 通过嵌套字段支持每个文档多个向量，这种结构非常适合检索生成向量的内容。 为此，只需将原始数据添加为另一个嵌套字段即可。

下面是一个示例：使用以下命令创建具有嵌套向量和文本字段的映射。 你可以在任何无状态（stateless）项目或版本 8.11 或更高版本的 Elasticsearch 部署中使用 Kibana 中的开发控制台。

  1. PUT my-long-text-index
  2. {
  3.   "mappings": {
  4.     "properties": {
  5.       "my_long_text_field": {
  6.         "type": "nested", //because there can be multiple vectors per doc
  7.         "properties": {
  8.           "vector": {
  9.             "type": "dense_vector" //the vector used for ranking
  10.           },
  11.           "text_chunk": {
  12.             "type": "text" //the text from which the vector was created
  13.           }
  14.         }
  15.       }
  16.     }
  17.   }
  18. }
  1. PUT my-long-text-index/_doc/1
  2. {
  3.   "my_long_text_field" : [
  4.     {
  5.       "vector" : [23,14,8],
  6.       "text_chunk" :  "doc 1 chunk 1"
  7.     },
  8.     {
  9.       "vector" : [34,95,17],
  10.       "text_chunk" :  "doc 1 chunk 2"
  11.     }
  12.   ]
  13. }
  1. PUT my-long-text-index/_doc/2
  2. {
  3.   "my_long_text_field" : [
  4.     {
  5.       "vector" : [3,2,890],
  6.       "text_chunk" :  "doc 2 chunk 1"
  7.     },
  8.     {
  9.       "vector" : [129,765,13],
  10.       "text_chunk" :  "doc 2 chunk 2"
  11.     }
  12.   ]
  13. }

使用 inner_hits 查询索引并返回相关文本块：

  1. GET my-long-text-index/_search
  2. {
  3.   "knn": {
  4.     "field": "my_long_text_field.vector",
  5.     "query_vector": [23,14,9],
  6.     "k": 1,
  7.     "num_candidates": 10,
  8.     "inner_hits":{
  9.       "_source": false,
  10.       "fields": [ "my_long_text_field.text_chunk"
  11.         ],
  12.         "size": 1
  13.     }
  14.   }
  15. }

你的结果应如下所示：

  1. Result:
  2. {
  3.   "took": 4,
  4.   "timed_out": false,
  5.   "_shards": {
  6.     "total": 1,
  7.     "successful": 1,
  8.     "skipped": 0,
  9.     "failed": 0
  10.   },
  11.   "hits": {
  12.     "total": {
  13.       "value": 1,
  14.       "relation": "eq"
  15.     },
  16.     "max_score": 0.999715,
  17.     "hits": [
  18.       {
  19.         "_index": "my-long-text-index",
  20.         "_id": "1",
  21.         "_score": 0.999715,
  22.         "_source": {
  23.           "my_long_text_field": [
  24.             {
  25.               "vector": [
  26.                 23,
  27.                 14,
  28.                 8
  29.               ],
  30.               "text_chunk": "doc 1 chunk 1"
  31.             },
  32.             {
  33.               "vector": [
  34.                 34,
  35.                 95,
  36.                 17
  37.               ],
  38.               "text_chunk": "doc 1 chunk 2"
  39.             }
  40.           ]
  41.         },
  42.         "inner_hits": {
  43.           "my_long_text_field": {
  44.             "hits": {
  45.               "total": {
  46.                 "value": 2,
  47.                 "relation": "eq"
  48.               },
  49.               "max_score": 0.999715,
  50.               "hits": [
  51.                 {
  52.                   "_index": "my-long-text-index",
  53.                   "_id": "1",
  54.                   "_nested": {
  55.                     "field": "my_long_text_field",
  56.                     "offset": 0
  57.                   },
  58.                   "_score": 0.999715,
  59.                   "fields": {
  60.                     "my_long_text_field": [
  61.                       {
  62.                         "text_chunk": [
  63.                           "doc 1 chunk 1"
  64.                         ]
  65.                       }
  66.                     ]
  67.                   }
  68.                 }
  69.               ]
  70.             }
  71.           }
  72.         }
  73.       }
  74.     ]
  75.   }
  76. }

如果希望显示同一文档的多个结果，例如 如果文档是教科书，并且向 RAG 提供同一本书中的几个相关章节（每本书都索引为单个文档）很有用，则查询可以如下所示：

  1. GET my-long-text-index/_search
  2. {
  3.   "knn": {
  4.     "field": "my_long_text_field.vector",
  5.     "query_vector": [23,14,9],
  6.     "k": 3,
  7.     "num_candidates": 10,
  8.     "inner_hits":{
  9.       "size": 3,
  10.       "_source": false,
  11.       "fields": [ "my_long_text_field.text_chunk"
  12.         ]
  13.     }
  14.   }
  15. }

结果如下：

  1. {
  2.   "took": 5,
  3.   "timed_out": false,
  4.   "_shards": {
  5.     "total": 1,
  6.     "successful": 1,
  7.     "skipped": 0,
  8.     "failed": 0
  9.   },
  10.   "hits": {
  11.     "total": {
  12.       "value": 2,
  13.       "relation": "eq"
  14.     },
  15.     "max_score": 0.999715,
  16.     "hits": [
  17.       {
  18.         "_index": "my-long-text-index",
  19.         "_id": "1",
  20.         "_score": 0.999715,
  21.         "_source": {
  22.           "my_long_text_field": [
  23.             {
  24.               "vector": [
  25.                 23,
  26.                 14,
  27.                 8
  28.               ],
  29.               "text_chunk": "doc 1 chunk 1"
  30.             },
  31.             {
  32.               "vector": [
  33.                 34,
  34.                 95,
  35.                 17
  36.               ],
  37.               "text_chunk": "doc 1 chunk 2"
  38.             }
  39.           ]
  40.         },
  41.         "inner_hits": {
  42.           "my_long_text_field": {
  43.             "hits": {
  44.               "total": {
  45.                 "value": 2,
  46.                 "relation": "eq"
  47.               },
  48.               "max_score": 0.999715,
  49.               "hits": [
  50.                 {
  51.                   "_index": "my-long-text-index",
  52.                   "_id": "1",
  53.                   "_nested": {
  54.                     "field": "my_long_text_field",
  55.                     "offset": 0
  56.                   },
  57.                   "_score": 0.999715,
  58.                   "fields": {
  59.                     "my_long_text_field": [
  60.                       {
  61.                         "text_chunk": [
  62.                           "doc 1 chunk 1"
  63.                         ]
  64.                       }
  65.                     ]
  66.                   }
  67.                 },
  68.                 {
  69.                   "_index": "my-long-text-index",
  70.                   "_id": "1",
  71.                   "_nested": {
  72.                     "field": "my_long_text_field",
  73.                     "offset": 1
  74.                   },
  75.                   "_score": 0.88984984,
  76.                   "fields": {
  77.                     "my_long_text_field": [
  78.                       {
  79.                         "text_chunk": [
  80.                           "doc 1 chunk 2"
  81.                         ]
  82.                       }
  83.                     ]
  84.                   }
  85.                 }
  86.               ]
  87.             }
  88.           }
  89.         }
  90.       },
  91.       {
  92.         "_index": "my-long-text-index",
  93.         "_id": "2",
  94.         "_score": 0.81309915,
  95.         "_source": {
  96.           "my_long_text_field": [
  97.             {
  98.               "vector": [
  99.                 3,
  100.                 2,
  101.                 890
  102.               ],
  103.               "text_chunk": "doc 2 chunk 1"
  104.             },
  105.             {
  106.               "vector": [
  107.                 129,
  108.                 765,
  109.                 13
  110.               ],
  111.               "text_chunk": "doc 2 chunk 2"
  112.             }
  113.           ]
  114.         },
  115.         "inner_hits": {
  116.           "my_long_text_field": {
  117.             "hits": {
  118.               "total": {
  119.                 "value": 2,
  120.                 "relation": "eq"
  121.               },
  122.               "max_score": 0.81309915,
  123.               "hits": [
  124.                 {
  125.                   "_index": "my-long-text-index",
  126.                   "_id": "2",
  127.                   "_nested": {
  128.                     "field": "my_long_text_field",
  129.                     "offset": 1
  130.                   },
  131.                   "_score": 0.81309915,
  132.                   "fields": {
  133.                     "my_long_text_field": [
  134.                       {
  135.                         "text_chunk": [
  136.                           "doc 2 chunk 2"
  137.                         ]
  138.                       }
  139.                     ]
  140.                   }
  141.                 },
  142.                 {
  143.                   "_index": "my-long-text-index",
  144.                   "_id": "2",
  145.                   "_nested": {
  146.                     "field": "my_long_text_field",
  147.                     "offset": 0
  148.                   },
  149.                   "_score": 0.6604239,
  150.                   "fields": {
  151.                     "my_long_text_field": [
  152.                       {
  153.                         "text_chunk": [
  154.                           "doc 2 chunk 1"
  155.                         ]
  156.                       }
  157.                     ]
  158.                   }
  159.                 }
  160.               ]
  161.             }
  162.           }
  163.         }
  164.       }
  165.     ]
  166.   }
  167. }

准备好将 RAG 构建到你的应用程序中了吗？ 想要尝试使用向量数据库的不同 LLMs？
在 Github 上查看我们的 LangChain、Cohere 等示例笔记本，并参加即将开始的 Elasticsearch 工程师培训！

原文：Retrieval of originating information in multi-vector documents — Elastic Search Labs

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/620103
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号