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

redis向量数据库快速开始（三）_redis a vector database

作者：木道寻08 | 2024-07-28 08:57:10

赞

踩

redis a vector database

接：redis向量数据库中文使用手册-快速开始（二）-CSDN博客

具体见：Redis as a vector database quick start guide | Docs

一、创建索引：

  1. 创建索引，使用矢量字段；
  2. 创建一个基于矢量元数据或基于搜索的索引来支持搜索；使用命令create_index;
  1. schema = (
  2.     TextField("$.model", no_stem=True, as_name="model"),
  3.     TextField("$.brand", no_stem=True, as_name="brand"),
  4.     NumericField("$.price", as_name="price"),
  5.     TagField("$.type", as_name="type"),
  6.     TextField("$.description", as_name="description"),
  7.     VectorField(
  8.         "$.description_embeddings",
  9.         "FLAT",
  10.         {
  11.             "TYPE": "FLOAT32",
  12.             "DIM": VECTOR_DIMENSION,
  13.             "DISTANCE_METRIC": "COSINE",
  14.         },
  15.         as_name="vector",
  16.     ),
  17. )
  18. definition = IndexDefinition(prefix=["bikes:"], index_type=IndexType.JSON)
  19. res = client.ft("idx:bikes_vss").create_index(
  20.     fields=schema, definition=definition
  21. )
  22. # >>> 'OK'


  1. import json
  2. import time
  3.  
  4. import numpy as np
  5. import pandas as pd
  6. import redis
  7. import requests
  8. from redis.commands.search.field import (
  9.     NumericField,
  10.     TagField,
  11.     TextField,
  12.     VectorField,
  13. )
  14. from redis.commands.search.indexDefinition import IndexDefinition, IndexType
  15. from redis.commands.search.query import Query
  16. from sentence_transformers import SentenceTransformer
  17.  
  18.  
  19. url = "https://raw.githubusercontent.com/bsbodden/redis_vss_getting_started/main/data/bikes.json"
  20. response = requests.get(url)
  21. bikes = response.json()
  22.  
  23. json.dumps(bikes[0], indent=2)
  24.  
  25. client = redis.Redis(host="localhost", port=6379, decode_responses=True)
  26.  
  27. res = client.ping()
  28. # >>> True
  30. pipeline = client.pipeline()
  31. for i, bike in enumerate(bikes, start=1):
  32.     redis_key = f"bikes:{i:03}"
  33.     pipeline.json().set(redis_key, "$", bike)
  34. res = pipeline.execute()
  35. # >>> [True, True, True, True, True, True, True, True, True, True, True]
  37. res = client.json().get("bikes:010", "$.model")
  38. # >>> ['Summit']
  40. keys = sorted(client.keys("bikes:*"))
  41. # >>> ['bikes:001', 'bikes:002', ..., 'bikes:011']
  43. descriptions = client.json().mget(keys, "$.description")
  44. descriptions = [item for sublist in descriptions for item in sublist]
  45. embedder = SentenceTransformer("msmarco-distilbert-base-v4")
  46. embeddings = embedder.encode(descriptions).astype(np.float32).tolist()
  47. VECTOR_DIMENSION = len(embeddings[0])
  48. # >>> 768
  50. pipeline = client.pipeline()
  51. for key, embedding in zip(keys, embeddings):
  52.     pipeline.json().set(key, "$.description_embeddings", embedding)
  53. pipeline.execute()
  54. # >>> [True, True, True, True, True, True, True, True, True, True, True]
  56. res = client.json().get("bikes:010")
  57. # >>>
  58. # {
  59. #   "model": "Summit",
  60. #   "brand": "nHill",
  61. #   "price": 1200,
  62. #   "type": "Mountain Bike",
  63. #   "specs": {
  64. #     "material": "alloy",
  65. #     "weight": "11.3"
  66. #   },
  67. #   "description": "This budget mountain bike from nHill performs well..."
  68. #   "description_embeddings": [
  69. #     -0.538114607334137,
  70. #     -0.49465855956077576,
  71. #     -0.025176964700222015,
  72. #     ...
  73. #   ]
  74. # }
  75.  
  76. schema = (
  77.     TextField("$.model", no_stem=True, as_name="model"),
  78.     TextField("$.brand", no_stem=True, as_name="brand"),
  79.     NumericField("$.price", as_name="price"),
  80.     TagField("$.type", as_name="type"),
  81.     TextField("$.description", as_name="description"),
  82.     VectorField(
  83.         "$.description_embeddings",
  84.         "FLAT",
  85.         {
  86.             "TYPE": "FLOAT32",
  87.             "DIM": VECTOR_DIMENSION,
  88.             "DISTANCE_METRIC": "COSINE",
  89.         },
  90.         as_name="vector",
  91.     ),
  92. )
  93. definition = IndexDefinition(prefix=["bikes:"], index_type=IndexType.JSON)
  94. res = client.ft("idx:bikes_vss").create_index(
  95.     fields=schema, definition=definition
  96. )
  97. # >>> 'OK'
  99. info = client.ft("idx:bikes_vss").info()
  100. num_docs = info["num_docs"]
  101. indexing_failures = info["hash_indexing_failures"]
  102. # print(f"{num_docs} documents indexed with {indexing_failures} failures")
  103. # >>> 11 documents indexed with 0 failures
  105. query = Query("@brand:Peaknetic")
  106. res = client.ft("idx:bikes_vss").search(query).docs
  107. # print(res)
  108. # >>> [Document {'id': 'bikes:008', 'payload': None, 'brand': 'Peaknetic', 'model': 'Soothe Electric bike', 'price': '1950', 'description_embeddings': ...
  110. query = Query("@brand:Peaknetic").return_fields("id", "brand", "model", "price")
  111. res = client.ft("idx:bikes_vss").search(query).docs
  112. # print(res)
  113. # >>> [Document {'id': 'bikes:008', 'payload': None, 'brand': 'Peaknetic', 'model': 'Soothe Electric bike', 'price': '1950'}, Document {'id': 'bikes:009', 'payload': None, 'brand': 'Peaknetic', 'model': 'Secto', 'price': '430'}]
  115. query = Query("@brand:Peaknetic @price:[0 1000]").return_fields(
  116.     "id", "brand", "model", "price"
  117. )
  118. res = client.ft("idx:bikes_vss").search(query).docs
  119. # print(res)
  120. # >>> [Document {'id': 'bikes:009', 'payload': None, 'brand': 'Peaknetic', 'model': 'Secto', 'price': '430'}]
  122. queries = [
  123.     "Bike for small kids",
  124.     "Best Mountain bikes for kids",
  125.     "Cheap Mountain bike for kids",
  126.     "Female specific mountain bike",
  127.     "Road bike for beginners",
  128.     "Commuter bike for people over 60",
  129.     "Comfortable commuter bike",
  130.     "Good bike for college students",
  131.     "Mountain bike for beginners",
  132.     "Vintage bike",
  133.     "Comfortable city bike",
  134. ]
  135.  
  136. encoded_queries = embedder.encode(queries)
  137. len(encoded_queries)
  138. # >>> 11
  140.  
  141. def create_query_table(query, queries, encoded_queries, extra_params={}):
  142.     results_list = []
  143.     for i, encoded_query in enumerate(encoded_queries):
  144.         result_docs = (
  145.             client.ft("idx:bikes_vss")
  146.             .search(
  147.                 query,
  148.                 {
  149.                     "query_vector": np.array(
  150.                         encoded_query, dtype=np.float32
  151.                     ).tobytes()
  152.                 }
  153.                 | extra_params,
  154.             )
  155.             .docs
  156.         )
  157.         for doc in result_docs:
  158.             vector_score = round(1 - float(doc.vector_score), 2)
  159.             results_list.append(
  160.                 {
  161.                     "query": queries[i],
  162.                     "score": vector_score,
  163.                     "id": doc.id,
  164.                     "brand": doc.brand,
  165.                     "model": doc.model,
  166.                     "description": doc.description,
  167.                 }
  168.             )
  169.  
  170.     # Optional: convert the table to Markdown using Pandas
  171.     queries_table = pd.DataFrame(results_list)
  172.     queries_table.sort_values(
  173.         by=["query", "score"], ascending=[True, False], inplace=True
  174.     )
  175.     queries_table["query"] = queries_table.groupby("query")["query"].transform(
  176.         lambda x: [x.iloc[0]] + [""] * (len(x) - 1)
  177.     )
  178.     queries_table["description"] = queries_table["description"].apply(
  179.         lambda x: (x[:497] + "...") if len(x) > 500 else x
  180.     )
  181.     queries_table.to_markdown(index=False)
  182.  
  183.  
  184.  
  185. query = (
  186.     Query("(*)=>[KNN 3 @vector $query_vector AS vector_score]")
  187.     .sort_by("vector_score")
  188.     .return_fields("vector_score", "id", "brand", "model", "description")
  189.     .dialect(2)
  190. )
  191.  
  192. create_query_table(query, queries, encoded_queries)
  193. # >>> | Best Mountain bikes for kids     |    0.54 | bikes:003... (+ 32 more results)
  195. hybrid_query = (
  196.     Query("(@brand:Peaknetic)=>[KNN 3 @vector $query_vector AS vector_score]")
  197.     .sort_by("vector_score")
  198.     .return_fields("vector_score", "id", "brand", "model", "description")
  199.     .dialect(2)
  200. )
  201. create_query_table(hybrid_query, queries, encoded_queries)
  202. # >>> | Best Mountain bikes for kids     |    0.3  | bikes:008... (+22 more results)
  204. range_query = (
  205.     Query(
  206.         "@vector:[VECTOR_RANGE $range $query_vector]=>{$YIELD_DISTANCE_AS: vector_score}"
  207.     )
  208.     .sort_by("vector_score")
  209.     .return_fields("vector_score", "id", "brand", "model", "description")
  210.     .paging(0, 4)
  211.     .dialect(2)
  212. )
  213. create_query_table(
  214.     range_query, queries[:1], encoded_queries[:1], {"range": 0.55}
  215. )
  216. # >>> | Bike for small kids |    0.52 | bikes:001 | Velorim    |... (+1 more result)

关于字段的详细描述：

1）$.description_embeddings AS vector: 矢量字段的json路径和其别名；

2）FLAT：指定索引方法

3）TYPE FLOAT32：设置矢量分量的类型；

4）DIM 768：确定嵌入式方式的长度或者维度；

5）DISTANCE_METRIC COSINE： 距离函数：余弦；

Vectors | Docs

  • 检查索引状态

一旦执行FT.CREATE命令，索引过程就会在后台运行。在很短的时间内，所有JSON文档都应该被索引并准备好被查询。要验证这一点，可以使用FT.INFO命令，该命令提供有关索引的详细信息和统计信息。特别令人感兴趣的是成功索引的文档数量和失败的数量：

  1. info = client.ft("idx:bikes_vss").info()
  2. num_docs = info["num_docs"]
  3. indexing_failures = info["hash_indexing_failures"]
  4. # print(f"{num_docs} documents indexed with {indexing_failures} failures")
  5. # >>> 11 documents indexed with 0 failures

二、搜索和查询；

  1. 嵌入提示
  1. queries = [
  2.     "Bike for small kids",
  3.     "Best Mountain bikes for kids",
  4.     "Cheap Mountain bike for kids",
  5.     "Female specific mountain bike",
  6.     "Road bike for beginners",
  7.     "Commuter bike for people over 60",
  8.     "Comfortable commuter bike",
  9.     "Good bike for college students",
  10.     "Mountain bike for beginners",
  11.     "Vintage bike",
  12.     "Comfortable city bike",
  13. ]
  1. 首先需要使用相同的句子转换器模型对查询提示进行编码，那样：
  1. encoded_queries = embedder.encode(queries)
  2. len(encoded_queries)
  3. # >>> 11

三、执行K近邻查询

KNN是一种基础算法，旨在找到与给定输入最相似的项目。KNN算法基于所选择的距离函数来计算查询向量与数据库中每个向量之间的距离。然后，它返回到查询向量的距离最小的K个项目。这些是最相似的项目。

以下示例显示了一个不应用预过滤器的查询。预筛选表达式（*）表示全部，但您可以将其替换为按其他元数据进行筛选的查询表达式。

然后查询的KNN部分搜索三个最近的邻居。到查询向量的距离返回为vector_score。结果按此分数排序。最后，它返回结果集中的字段vector_score、id、$.brand、$.model和$.description。

  1. query = (
  2.     Query('(*)=>[KNN 3 @vector $query_vector AS vector_score]')
  3.      .sort_by('vector_score')
  4.      .return_fields('vector_score', 'id', 'brand', 'model', 'description')
  5.      .dialect(2)
  6. )

必须将矢量化查询作为$query_vector作为字节数组传递。以下代码显示了从矢量化查询提示符（encoded_query）创建Python NumPy数组作为单精度浮点数组的示例，并将其转换为紧凑的字节级表示，该表示可以作为参数传递给查询：

client.ft(INDEX_NAME).search(query, { 'query_vector': np.array(encoded_query, dtype=np.float32).tobytes() }).docs

有了查询模板，就可以通过传递矢量化的查询提示来执行循环中的所有查询提示。请注意，脚本将每个结果的vector_score计算为1-doc.vector_score。因为使用余弦距离作为度量，所以距离最小的项目更接近，因此更类似于查询。

然后，在匹配的文档上循环，并创建一个结果列表，该列表可以转换为Pandas表以可视化结果：

  1. def create_query_table(query, queries, encoded_queries, extra_params={}):
  2.     results_list = []
  3.     for i, encoded_query in enumerate(encoded_queries):
  4.         result_docs = (
  5.             client.ft("idx:bikes_vss")
  6.             .search(
  7.                 query,
  8.                 {
  9.                     "query_vector": np.array(
  10.                         encoded_query, dtype=np.float32
  11.                     ).tobytes()
  12.                 }
  13.                 | extra_params,
  14.             )
  15.             .docs
  16.         )
  17.         for doc in result_docs:
  18.             vector_score = round(1 - float(doc.vector_score), 2)
  19.             results_list.append(
  20.                 {
  21.                     "query": queries[i],
  22.                     "score": vector_score,
  23.                     "id": doc.id,
  24.                     "brand": doc.brand,
  25.                     "model": doc.model,
  26.                     "description": doc.description,
  27.                 }
  28.             )
  29.  
  30.     # Optional: convert the table to Markdown using Pandas
  31.     queries_table = pd.DataFrame(results_list)
  32.     queries_table.sort_values(
  33.         by=["query", "score"], ascending=[True, False], inplace=True
  34.     )
  35.     queries_table["query"] = queries_table.groupby("query")["query"].transform(
  36.         lambda x: [x.iloc[0]] + [""] * (len(x) - 1)
  37.     )
  38.     queries_table["description"] = queries_table["description"].apply(
  39.         lambda x: (x[:497] + "...") if len(x) > 500 else x
  40.     )
  41.     queries_table.to_markdown(index=False)

查询结果显示了各个查询的前三个匹配项（我们的K参数），以及每个查询的自行车id、品牌和型号。例如，对于查询“儿童最佳山地自行车”，相似度最高（0.54），因此最接近的匹配是“Nord”品牌的“Chook air 5”自行车型号，描述为：

Chook Air 5为六岁及以上的孩子们提供了一辆耐用且轻便的山地自行车，让他们第一次体验在赛道上的骑行，并轻松穿越森林和田野。顶部较低的管子使您在任何情况下都能轻松装卸，让您的孩子在小径上更安全。Chook Air 5是山地自行车的完美入门。

从描述来看，这辆自行车非常适合年幼的孩子，所使用的嵌入准确地捕捉到了描述的语义。

  1. query = (
  2.     Query("(*)=>[KNN 3 @vector $query_vector AS vector_score]")
  3.     .sort_by("vector_score")
  4.     .return_fields("vector_score", "id", "brand", "model", "description")
  5.     .dialect(2)
  6. )
  7. create_query_table(query, queries, encoded_queries)
  8. # >>> | Best Mountain bikes for kids     |    0.54 | bikes:003... (+ 32 more results)
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/893515
推荐阅读
相关标签

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

  

闽ICP备14008679号