矢量量化

在此页面上

关于量化

标量量化
二进制量化
要求
如何启用向量的自动量化
收益分析
用例
步骤
如何摄取预量化向量
用例
收益分析
支持的驱动程序
先决条件
步骤
评估查询结果

注意

Atlas Vector Search对以下功能的支持是作为预览功能的：

摄取 BSON BinDatavector 子类型int1 。
自动标量量化。
自动二进制量化。

Atlas Vector Search支持向量嵌入中双精度或 32 位浮点值的自动量化。它还可以从嵌入提供程序中摄取标量和二进制量化向量并对其进行索引。

关于量化

量化是将全保真向量压缩为更少位数的进程。它减少了在向量搜索索引中存储每个向量所需的主内存量，因为您对减少的表示向量进行了索引，从而允许存储更多向量或具有更高维度的向量。这样，量化就可以减少资源消耗并提高速度。因此，我们建议对具有大量向量（通常超过 10 M 个向量）的应用程序进行量化。

标量量化

标量量化涉及首先识别索引向量每个维度的最小值和最大值，以确定维度的值范围。然后，将该范围划分为大小相等的间隔或分箱。最后，将每个浮点值映射到一个 bin，以将连续浮点值转换为离散整数。在Atlas Vector Search中，这种量化将向量嵌入的RAM费用减少到量化前费用的四分之一1/4 ()。

二进制量化

二进制量化涉及假设每个维度的中点为 0，这通常适用于归一化为长度1 的嵌入，例如 OpenAItext-embedding-3-large 10的。然后，将向量中的每个值与中点进行比较，如果它大于中点，则分配一个二进制值；如果它小于或等于中点，则分配一个二进制值。在Atlas Vector Search中，这种量化将向量嵌入的RAM费用至量化前费用的二十四分之一 ()。它不是1/24 1/32是因为包含与向量值分开的分层可导航小世界图表本身的数据结构未压缩。

当您运行查询时， Atlas Vector Search会使用相同的中点将查询向量中的浮点值转换为二进制向量，以便在查询向量和索引二进制向量之间进行有效比较。然后，它会使用与二进制索引结果相关的原始浮点值，重新评估二进制比较中已识别的候选值，从而进行重新评分，从而进一步完善结果。全保真向量存储在磁盘上自己的数据结构中，仅在重新评分期间配置二进制量化或对二进制或标量量化向量执行精确搜索时引用。

提示

另请参阅：

什么是矢量量化？

要求

下表显示了自动量化和导入量化向量的要求：

要求	对于 `int1` 引入	对于 `int8` 引入	对于自动标量量化	对于自动二进制量化
需要索引定义设置	No	No	是	是
需要BSON`binData` 格式	是	是	No	No
mongod上的存储	`binData(int1)`	`binData(int8)`	`binData(float32)` `array(float32)`	`binData(float32)` `array(float32)`
支持的相似度方法	`euclidean`	`cosine` `euclidean` `dotProduct`	`cosine` `euclidean` `dotProduct`	`cosine` `euclidean` `dotProduct`
支持的维度数	8 的倍数	1 改为 4096	1 改为 4096	8 的倍数
支持新奥搜索	新奥 (ENN) 在上`int1`	新奥 (ENN) 在上`int8`	新奥 (ENN) 在上`float32`	新奥 (ENN) 在上`float32`

如何启用向量的自动量化

您可以配置Atlas Vector Search ，使其自动将向量嵌入中的双精度或 32 位浮点值量化为较小的数字类型，例如 int8（标量）和 binary。

对于大多数嵌入模型，我们建议使用重新评分的二进制量化。如果要使用非 QAT 的较低维度模型，请使用标量量化，因为它的表征损失较小，因此表征容量损失也较小。

收益分析

Atlas Vector Search提供标量量化以及带重新评分的二进制量化的原生功能。自动量化可减少存储和计算资源，从而实现向量的高效处理，从而提高应用程序的可扩展性并费用成本。自动量化会将的RAM减少mongot 3.75x（标量）和24 x（二进制）；向量值分别缩小4 x 和32 x，但“分层可导航小世界”图表本身不会缩小。即使在最高数量和扩展下，这也能提高性能。

用例

如果您有大量全保真向量（通常超过 10 M 个向量），我们建议使用自动量化。量化后，您可以对简化的表示向量进行索引，而不会影响检索向量时的准确性。

步骤

要自动量化您的 double 或 32 位 float 值，请在索引定义中指定您想要作为 fields.quantization 值的量化类型。您可以将以下量化类型之一指定为该值：

scalar 量化以从 32 位输入向量生成字节向量。
binary 量化以从 32 位输入向量生成位向量。

如果您对不是 doubles 或 32 位 float 值的大量的数据指定自动量化， Atlas Vector Search会默默地忽略该向量而不是对其进行索引，并且将跳过这些向量。

如何摄取预量化向量

Atlas Vector Search还支持对来自嵌入提供程序的标量和二进制量化向量进行摄取和索引。如果还没有量化向量，则可以将嵌入转换为BSON BinDatavector 子类型float32 、int1 或int8 向量。

用例

我们建议在以下使用案例中使用BSONbinDatavector 子类型：

您需要对嵌入模型中量化向量输出进行索引。
您有大量浮点向量，但希望减少 mongod 中的存储和 WiredTiger 占用空间（例如磁盘和内存使用量）。

收益分析

与元素数组相比，BinDatavector 格式在集群中所需的磁盘空间大约减少三倍。它允许您使用备用类型（例如int1 或int8 向量）对向量进行索引，从而减少为集合构建Atlas Vector Search索引所需的内存。它将的RAM减少了mongot 3.75x（标量）和24 x（二进制）；向量值分别缩小4 x 和32 x，但“分层可导航小世界”图表本身不会缩小。

如果您还没有 binData 向量，则可在将数据写入集合之前，使用任何支持的驱动程序将嵌入向量转换为此格式。本页将指导您完成将嵌入转换为 BinData vector 子类型的步骤。

支持的驱动程序

BSON BinData vector float32int1int8PyMongo驱动程序v 4.10或更高版本支持子类型、和向量转换。

先决条件

要将您的嵌入数据转换为 BSON BinData vector 子类型，您需要：

运行 MongoDB 6.0.11、7.0.2 或更高版本的 Atlas 集群。
确保您的IP 地址包含在 Atlas 项目的访问列表中。
运行交互式 Python 笔记本（例如 Colab）的环境。
访问支持字节向量输出的嵌入模型。
以下嵌入模型提供程序支持int8 或 int1 binData 向量：
嵌入模型提供者
嵌入模型
Cohere
embed-english-v3.0
Nomic
nomic-embed-text-v1.5
Jina
jina-embeddings-v2-base-en
Mixedbread
mxbai-embed-large-v1
您可以使用任何这些嵌入模型提供程序来生成 binData 向量。标量量化保留了这些模型的召回率，因为这些模型都经过训练具有量化感知能力。因此，即使在这样的较低维度上，这些模型生成的标量量化嵌入的召回率下降也很小。384

步骤

此过程中的示例使用新数据或现有数据和 Cohere 的embed-english-v3.0 模型。新数据的示例使用示例文本字符串，您可以将其替换为自己的数据。现有数据的示例使用了来自listingsAndReviews sample_airbnb数据库中集合的没有任何嵌入的文档子集，您可以将其替换为自己的数据库和集合（带或不带任何嵌入）。根据您是要为新数据还是AtlasbinData 集群中已有的数据创建向量来选择标签页。

通过保存扩展名为 .ipynb 的文件来创建交互式Python笔记本，然后在笔记本中执行以下步骤。要试用该示例，请将占位符替换为有效值。

安装所需的库。

运行以下命令以安装PyMongo驱动程序。如有必要，您还可以安装嵌入模型提供商的库。此操作可能需要几分钟才能完成。

pip install pymongo

您必须安装 PyMongo v4.10 或更高版本的驱动程序。

例子

安装 PyMongo 和 Cohere

pip --quiet install pymongo cohere

在您的笔记本中加载要生成 BSON 向量的数据。

例子

要导入的示例数据

data = [
   "The Great Wall of China is visible from space.",
   "The Eiffel Tower was completed in Paris in 1889.",
   "Mount Everest is the highest peak on Earth at 8,848m.",
   "Shakespeare wrote 37 plays and 154 sonnets during his lifetime.",
   "The Mona Lisa was painted by Leonardo da Vinci.",
]

（条件）从您的数据生成嵌入。

如果您尚未从数据生成嵌入，则需要执行此步骤。如果您已经生成了嵌入，请跳过此步骤。要了解有关从数据生成嵌入的更多信息，请参阅如何创建向量嵌入。

例子

使用 Cohere 从样本数据生成嵌入

占位符	有效值
`<COHERE-API-KEY>`	Cohere 的API密钥。

import cohere
api_key = "<COHERE-API-KEY>"
co = cohere.Client(api_key)
generated_embeddings = co.embed(
   texts=data,
   model="embed-english-v3.0",
   input_type="search_document",
   embedding_types=["float", "int8", "ubinary"]
).embeddings
float32_embeddings = generated_embeddings.float
int8_embeddings = generated_embeddings.int8
int1_embeddings = generated_embeddings.ubinary

从嵌入中生成 BSON 向量。

您可以使用 PyMongo 驱动程序将本地向量嵌入转换为 BSON 向量。

例子

定义并运行函数，生成 BSON 向量

from bson.binary import Binary, BinaryVectorDtype
def generate_bson_vector(vector, vector_dtype):
   return Binary.from_vector(vector, vector_dtype)
# For all vectors in your collection, generate BSON vectors of float32, int8, and int1 embeddings
bson_float32_embeddings = []
bson_int8_embeddings = []
bson_int1_embeddings = []
for i, (f32_emb, int8_emb, int1_emb) in enumerate(zip(float32_embeddings, int8_embeddings, int1_embeddings)):
   bson_float32_embeddings.append(generate_bson_vector(f32_emb, BinaryVectorDtype.FLOAT32))
   bson_int8_embeddings.append(generate_bson_vector(int8_emb, BinaryVectorDtype.INT8))
   bson_int1_embeddings.append(generate_bson_vector(int1_emb, BinaryVectorDtype.PACKED_BIT))

使用 BSON 向量嵌入创建文档。

如果集合中的文档已经包含 BSON 向量嵌入，请跳过此步骤。

例子

从示例数据创建文档

占位符	有效值
`<FIELD-NAME-FOR-FLOAT32-TYPE>`	具有 `float32` 值的字段名称。
`<FIELD-NAME-FOR-INT8-TYPE>`	具有 `int8` 值的字段名称。
`<FIELD-NAME-FOR-INT1-TYPE>`	具有 `int1` 值的字段名称。

def create_docs_with_bson_vector_embeddings(bson_float32_embeddings, bson_int8_embeddings, bson_int1_embeddings, data):
  docs = []
  for i, (bson_f32_emb, bson_int8_emb, bson_int1_emb, text) in enumerate(zip(bson_float32_embeddings, bson_int8_embeddings, bson_int1_embeddings, data)):
     doc = {
          "_id":i,
          "data": text,
          "<FIELD-NAME-FOR-FLOAT32-TYPE>":bson_f32_emb,
          "<FIELD-NAME-FOR-INT8-TYPE>":bson_int8_emb,
          "<FIELD-NAME-FOR-INT1-TYPE>":bson_int1_emb,
     }
     docs.append(doc)
  return docs
documents = create_docs_with_bson_vector_embeddings(bson_float32_embeddings, bson_int8_embeddings, bson_int1_embeddings, data)

将您的数据加载到 Atlas 集群。

您可以从 Atlas UI 加载数据，也可以通过编程方式加载数据。要了解如何从 Atlas UI 加载数据，请参阅插入数据。以下步骤和相关示例演示了如何使用 PyMongo 驱动程序以编程方式加载数据。

连接到您的 Atlas 集群。

占位符	有效值
`<ATLAS-CONNECTION-STRING>`	Atlas连接string 。要了解更多信息，请参阅通过驱动程序连接。

例子

import pymongo
MONGO_URI = "<ATLAS-CONNECTION-STRING>"
def get_mongo_client(mongo_uri):
  # establish the connection
  client = pymongo.MongoClient(mongo_uri)
if not MONGO_URI:
  print("MONGO_URI not set in environment variables")

将数据加载到 Atlas 集群。
占位符
有效值
<DB-NAME>
数据库名称。
<COLLECTION-NAME>
指定数据库中集合的名称。
例子
client = pymongo.MongoClient(MONGO_URI) db = client["<DB-NAME>"] db.create_collection("<COLLECTION-NAME>") col = db["<COLLECTION-NAME>"] col.insert_many(documents)

在集合上创建 Atlas Vector Search 索引。

您可以使用 Atlas UI、Atlas CLI、Atlas Administration API 和 MongoDB 驱动程序创建 Atlas Vector Search 索引。要了解详情，请参阅如何为向量搜索建立字段索引。

例子

为示例集合创建索引

占位符	有效值
`<FIELD-NAME-FOR-FLOAT32-TYPE>`	具有 `float32` 值的字段名称。
`<FIELD-NAME-FOR-INT8-TYPE>`	具有 `int8` 值的字段名称。
`<FIELD-NAME-FOR-INT1-TYPE>`	具有 `int1` 值的字段名称。

import time
from pymongo.operations import SearchIndexModel
vector_search_index_definition = {
  "fields":[
    {
      "type": "vector",
      "path": "<FIELD-NAME-FOR-FLOAT32-TYPE>",
      "similarity": "dotProduct",
      "numDimensions": 1024,
    },
    {
      "type": "vector",
      "path": "<FIELD-NAME-FOR-INT8-TYPE>",
      "similarity": "dotProduct",
      "numDimensions": 1024,
    },
    {
      "type": "vector",
      "path": "<FIELD-NAME-FOR-INT1-TYPE>",
      "similarity": "euclidean",
      "numDimensions": 1024,
    }
  ]
}
search_index_model = SearchIndexModel(definition=vector_search_index_definition, name="<INDEX-NAME>", type="vectorSearch")
col.create_search_index(model=search_index_model)

定义一个函数，用于运行 Atlas Vector Search 查询。

运行 Atlas Vector Search 查询的函数必须执行以下操作：

将查询文本转换为 BSON 向量。
定义 Atlas Vector Search 查询的管道。

例子

占位符	有效值
`<FIELD-NAME-FOR-FLOAT32-TYPE>`	具有 `float32` 值的字段名称。
`<FIELD-NAME-FOR-INT8-TYPE>`	具有 `int8` 值的字段名称。
`<FIELD-NAME-FOR-INT1-TYPE>`	具有 `int1` 值的字段名称。
`<INDEX-NAME>`	`vector` 类型索引的名称。
`<NUMBER-OF-CANDIDATES-TO-CONSIDER>`	搜索期间要使用的最近邻数量。
`<NUMBER-OF-DOCUMENTS-TO-RETURN>`	结果中要返回的文档数。

def run_vector_search(query_text, collection, path):
  query_text_embeddings = co.embed(
    texts=[query_text],
    model="embed-english-v3.0",
    input_type="search_query",
    embedding_types=["float", "int8", "ubinary"]
  ).embeddings
  if path == "<FIELD-NAME-FOR-FLOAT32-TYPE>":
    query_vector = query_text_embeddings.float[0]
    vector_dtype = BinaryVectorDtype.FLOAT32
  elif path == "<FIELD-NAME-FOR-INT8-TYPE>":
    query_vector = query_text_embeddings.int8[0]
    vector_dtype = BinaryVectorDtype.INT8
  elif path == "<FIELD-NAME-FOR-INT1-TYPE>":
    query_vector = query_text_embeddings.ubinary[0]
    vector_dtype = BinaryVectorDtype.PACKED_BIT
  bson_query_vector = generate_bson_vector(query_vector, vector_dtype)
  pipeline = [
    {
      '$vectorSearch': {
        'index': '<INDEX-NAME>',
        'path': path,
        'queryVector': bson_query_vector,
        'numCandidates': <NUMBER-OF-CANDIDATES-TO-CONSIDER>,
        'limit': <NUMBER-OF-DOCUMENTS-TO-RETURN>
       }
     },
     {
       '$project': {
         '_id': 0,
         'data': 1,
         'score': { '$meta': 'vectorSearchScore' }
        }
     }
  ]
  return collection.aggregate(pipeline)

运行 Atlas Vector Search 查询。

您可以通过编程方式运行 Atlas Vector Search 查询。要了解更多信息，请参阅运行向量搜索查询。

例子

from pprint import pprint
query_text = "tell me a science fact"
float32_results = run_vector_search(query_text, col, "<FIELD-NAME-FOR-FLOAT32-TYPE>")
int8_results = run_vector_search(query_text, col, "<FIELD-NAME-FOR-INT8-TYPE>")
int1_results = run_vector_search(query_text, col, "<FIELD-NAME-FOR-INT1-TYPE>")
print("results from float32 embeddings")
pprint(list(float32_results))
print("--------------------------------------------------------------------------")
print("results from int8 embeddings")
pprint(list(int8_results))
print("--------------------------------------------------------------------------")
print("results from int1 embeddings")
pprint(list(int1_results))

results from float32 embeddings
[{'data': 'Mount Everest is the highest peak on Earth at 8,848m.',
  'score': 0.6578356027603149},
 {'data': 'The Great Wall of China is visible from space.',
  'score': 0.6420407891273499}]
--------------------------------------------------------------------------
results from int8 embeddings
[{'data': 'Mount Everest is the highest peak on Earth at 8,848m.',
  'score': 0.5149182081222534},
 {'data': 'The Great Wall of China is visible from space.',
  'score': 0.5136760473251343}]
--------------------------------------------------------------------------
results from int1 embeddings
[{'data': 'Mount Everest is the highest peak on Earth at 8,848m.',
  'score': 0.62109375},
 {'data': 'The Great Wall of China is visible from space.',
  'score': 0.61328125}]

安装所需的库。

运行以下命令以安装PyMongo驱动程序。如有必要，您还可以安装嵌入模型提供商的库。此操作可能需要几分钟才能完成。

pip install pymongo

您必须安装 PyMongo v4.10 或更高版本的驱动程序。

例子

安装 PyMongo 和 Cohere

pip --quiet install pymongo cohere

定义函数以生成向量嵌入并将嵌入转换为BSON兼容格式。

您必须使用嵌入模型定义执行以下操作的函数：

如果现有数据没有任何嵌入，请从现有数据生成嵌入。
将嵌入转换为BSON向量。

例子

生成和转换嵌入的函数

占位符	有效值
`<COHERE-API-KEY>`	Cohere 的API密钥。

1 import os
2 import pymongo
3 import cohere
4 from bson.binary import Binary, BinaryVectorDtype
5 
6 # Specify your OpenAI API key and embedding model
7 os.environ["COHERE_API_KEY"] = "<COHERE-API-KEY>"
8 cohere_client = cohere.Client(os.environ["COHERE_API_KEY"])
9 
10 # Function to generate embeddings using Cohere
11 def get_embedding(text):
12     response = cohere_client.embed(
13       texts=[text],
14       model='embed-english-v3.0',
15       input_type='search_document',
16       embedding_types=["float"]
17     )
18     embedding = response.embeddings.float[0]
19     return embedding
20 
21 # Function to convert embeddings to BSON-compatible format
22 def generate_bson_vector(vector, vector_dtype):
23     return Binary.from_vector(vector, vector_dtype)

1 import os
2 import pymongo
3 import cohere
4 from bson.binary import Binary, BinaryVectorDtype
5 
6 # Specify your OpenAI API key and embedding model
7 os.environ["COHERE_API_KEY"] = "<COHERE-API-KEY>"
8 cohere_client = cohere.Client(os.environ["COHERE_API_KEY"])
9 
10 # Function to generate embeddings using Cohere
11 def get_embedding(text):
12     response = cohere_client.embed(
13       texts=[text],
14       model='embed-english-v3.0',
15       input_type='search_document',
16       embedding_types=["int8"]
17     )
18     embedding = response.embeddings.int8[0]
19     return embedding
20 
21 # Function to convert embeddings to BSON-compatible format
22 def generate_bson_vector(vector, vector_dtype):
23     return Binary.from_vector(vector, vector_dtype)

1 import os
2 import pymongo
3 import cohere
4 from bson.binary import Binary, BinaryVectorDtype
5 
6 # Specify your OpenAI API key and embedding model
7 os.environ["COHERE_API_KEY"] = "<COHERE-API-KEY>"
8 cohere_client = cohere.Client(os.environ["COHERE_API_KEY"])
9 
10 # Function to generate embeddings using Cohere
11 def get_embedding(text):
12     response = cohere_client.embed(
13       texts=[text],
14       model='embed-english-v3.0',
15       input_type='search_document',
16       embedding_types=["ubinary"]
17     )
18     embedding = response.embeddings.ubinary[0]
19     return embedding
20 
21 # Function to convert embeddings to BSON-compatible format
22 def generate_bson_vector(vector, vector_dtype):
23     return Binary.from_vector(vector, vector_dtype)

连接到Atlas 集群并检索现有数据。

您必须提供以下信息：

用于连接Atlas 集群的连接字符串，该集群包含要为其生成嵌入的数据库和集合。
数据库名称，该数据库包含要为其生成嵌入的集合。
要为其生成嵌入的集合的名称。

例子

连接到Atlas集群以访问数据

占位符	有效值
`<ATLAS-CONNECTION-STRING>`	Atlas连接string 。要了解更多信息，请参阅通过驱动程序连接。

1 # Connect to your Atlas cluster
2 mongo_client = pymongo.MongoClient("<ATLAS-CONNECTION-STRING>")
3 db = mongo_client["sample_airbnb"]
4 collection = db["listingsAndReviews"]
5 
6 # Filter to exclude null or empty summary fields
7 filter = { "summary": {"$nin": [None, ""]} }
8 
9 # Get a subset of documents in the collection
10 documents = collection.find(filter).limit(50)
11 
12 # Initialize the count of updated documents
13 updated_doc_count = 0

生成、转换嵌入并将其加载到您的集合中。

如果您的数据还没有嵌入，请使用任何嵌入模型从数据生成嵌入。要学习；了解有关从数据生成嵌入的更多信息，请参阅如何创建向量嵌入。
将嵌入转换为BSON向量（如以下示例中的第 7行所示）。
将嵌入上传到Atlas 集群上的集合。

这些操作可能需要几分钟才能完成。

例子

生成、转换嵌入并将其加载到集合中

1 for doc in documents:
2     # Generate embeddings based on the summary
3     summary = doc["summary"]
4     embedding = get_embedding(summary)  # Get float32 embedding
5 
6     # Convert the float32 embedding to BSON format
7     bson_float32 = generate_bson_vector(embedding, BinaryVectorDtype.FLOAT32)
8 
9     # Update the document with the BSON embedding
10     collection.update_one(
11         {"_id": doc["_id"]},
12         {"$set": {"embedding": bson_float32}}
13     )
14     updated_doc_count += 1
15 
16 print(f"Updated {updated_doc_count} documents with BSON embeddings.")

1 for doc in documents:
2     # Generate embeddings based on the summary
3     summary = doc["summary"]
4     embedding = get_embedding(summary)  # Get int8 embedding
5 
6     # Convert the float32 embedding to BSON format
7     bson_int8 = generate_bson_vector(embedding, BinaryVectorDtype.INT8)
8 
9     # Update the document with the BSON embedding
10     collection.update_one(
11         {"_id": doc["_id"]},
12         {"$set": {"embedding": bson_int8}}
13     )
14     updated_doc_count += 1
15 
16 print(f"Updated {updated_doc_count} documents with BSON embeddings.")

1 for doc in documents:
2     # Generate embeddings based on the summary
3     summary = doc["summary"]
4     embedding = get_embedding(summary)  # Get int1 embedding
5 
6     # Convert the float32 embedding to BSON format
7     bson_int1 = generate_bson_vector(embedding, BinaryVectorDtype.PACKED_BIT)
8 
9     # Update the document with the BSON embedding
10     collection.update_one(
11         {"_id": doc["_id"]},
12         {"$set": {"embedding": bson_int1}}
13     )
14     updated_doc_count += 1
15 
16 print(f"Updated {updated_doc_count} documents with BSON embeddings.")

在集合上创建 Atlas Vector Search 索引。

您可以使用Atlas用户界面、 Atlas CLI、 Atlas管理API和MongoDB驱动程序以您的首选语言创建Atlas Vector Search索引。要学习；了解更多信息，请参阅如何为向量搜索的字段编制索引。

例子

为集合创建索引

占位符	有效值
`<INDEX-NAME>`	`vector` 类型索引的名称。

1 from pymongo.operations import SearchIndexModel
2 
3 vector_search_index_definition = {
4   "fields":[
5     {
6       "type": "vector",
7       "path": "embedding",
8       "similarity": "euclidean",
9       "numDimensions": 1024,
10     }
11   ]
12 }
13 
14 search_index_model = SearchIndexModel(definition=vector_search_index_definition, name="<INDEX-NAME>", type="vectorSearch")
15 
16 collection.create_search_index(model=search_index_model)

构建索引大约需要一分钟时间。在建立索引时，索引处于初始同步状态。构建完成后，您可以开始查询集合中的数据。

定义一个函数，用于运行 Atlas Vector Search 查询。

运行 Atlas Vector Search 查询的函数必须执行以下操作：

为查询文本生成嵌入。
将查询文本转换为 BSON 向量。
定义 Atlas Vector Search 查询的管道。

例子

用于运行Atlas Vector Search查询的函数

占位符	有效值
`<INDEX-NAME>`	`vector` 类型索引的名称。
`<NUMBER-OF-CANDIDATES-TO-CONSIDER>`	搜索期间要使用的最近邻数量。
`<NUMBER-OF-DOCUMENTS-TO-RETURN>`	结果中要返回的文档数。

1 def run_vector_search(query_text, collection, path):
2   query_embedding = get_embedding("query_text")
3   bson_query_vector = generate_bson_vector(query_embedding, BinaryVectorDtype.FLOAT32)
4 
5   pipeline = [
6     {
7       '$vectorSearch': {
8         'index': '<INDEX-NAME>',
9         'path': path,
10         'queryVector': bson_query_vector,
11         'numCandidates': <NUMBER-OF-CANDIDATES-TO-CONSIDER>, # for example, 20
12         'limit': <NUMBER-OF-DOCUMENTS-TO-RETURN> # for example, 5
13        }
14      },
15      {
16        '$project': {
17          '_id': 0,
18          'name': 1,
19          'summary': 1,
20          'score': { '$meta': 'vectorSearchScore' }
21         }
22      }
23   ]
24 
25   return collection.aggregate(pipeline)

1 def run_vector_search(query_text, collection, path):
2   query_embedding = get_embedding("query_text")
3   bson_query_vector = generate_bson_vector(query_embedding, BinaryVectorDtype.INT8)
4 
5   pipeline = [
6     {
7       '$vectorSearch': {
8         'index': '<INDEX-NAME>',
9         'path': path,
10         'queryVector': bson_query_vector,
11         'numCandidates': <NUMBER-OF-CANDIDATES-TO-CONSIDER>, # for example, 20
12         'limit': <NUMBER-OF-DOCUMENTS-TO-RETURN> # for example, 5
13        }
14      },
15      {
16        '$project': {
17          '_id': 0,
18          'name': 1,
19          'summary': 1,
20          'score': { '$meta': 'vectorSearchScore' }
21         }
22      }
23   ]
24 
25   return collection.aggregate(pipeline)

1 def run_vector_search(query_text, collection, path):
2   query_embedding = get_embedding("query_text")
3   bson_query_vector = generate_bson_vector(query_embedding, BinaryVectorDtype.PACKED_BIT)
4 
5   pipeline = [
6     {
7       '$vectorSearch': {
8         'index': '<INDEX-NAME>',
9         'path': path,
10         'queryVector': bson_query_vector,
11         'numCandidates': <NUMBER-OF-CANDIDATES-TO-CONSIDER>, # for example, 20
12         'limit': <NUMBER-OF-DOCUMENTS-TO-RETURN> # for example, 5
13        }
14      },
15      {
16        '$project': {
17          '_id': 0,
18          'name': 1,
19          'summary': 1,
20          'score': { '$meta': 'vectorSearchScore' }
21         }
22      }
23   ]
24 
25   return collection.aggregate(pipeline)

运行 Atlas Vector Search 查询。

您可以通过编程方式运行 Atlas Vector Search 查询。要了解更多信息，请参阅运行向量搜索查询。

例子

运行示例Atlas Vector Search查询

1 from pprint import pprint
2 
3 query_text = "ocean view"
4 query_results = run_vector_search(query_text, collection, "embedding")
5 
6 print("results from your embeddings")
7 pprint(list(query_results))

results from your embeddings
[{'name': 'Your spot in Copacabana',
  'score': 0.5468248128890991,
  'summary': 'Having a large airy living room. The apartment is well divided. '
             'Fully furnished and cozy. The building has a 24h doorman and '
             'camera services in the corridors. It is very well located, close '
             'to the beach, restaurants, pubs and several shops and '
             'supermarkets. And it offers a good mobility being close to the '
             'subway.'},
 {'name': 'Twin Bed room+MTR Mongkok shopping&My',
  'score': 0.527062714099884,
  'summary': 'Dining shopping conveniently located Mongkok subway E1, airport '
             'shuttle bus stops A21. Three live two beds, separate WC, 24-hour '
             'hot water. Free WIFI.'},
{'name': 'Quarto inteiro na Tijuca',
  'score': 0.5222363471984863,
  'summary': 'O quarto disponível tem uma cama de solteiro, sofá e computador '
             'tipo desktop para acomodação.'},
 {'name': 'Makaha Valley Paradise with OceanView',
  'score': 0.5175154805183411,
  'summary': 'A beautiful and comfortable 1 Bedroom Air Conditioned Condo in '
             'Makaha Valley - stunning Ocean & Mountain views All the '
             'amenities of home, suited for longer stays. Full kitchen & large '
             "bathroom.  Several gas BBQ's for all guests to use & a large "
             'heated pool surrounded by reclining chairs to sunbathe.  The '
             'Ocean you see in the pictures is not even a mile away, known as '
             'the famous Makaha Surfing Beach. Golfing, hiking,snorkeling  '
             'paddle boarding, surfing are all just minutes from the front '
             'door.'},
 {'name': 'Cozy double bed room 東涌鄉村雅緻雙人房',
  'score': 0.5149975419044495,
  'summary': 'A comfortable double bed room at G/F. Independent entrance. High '
             'privacy. The room size is around 100 sq.ft. with a 48"x72" '
             'double bed. The village house is close to the Hong Kong Airport, '
             'AsiaWorld-Expo, HongKong-Zhuhai-Macau Bridge, Disneyland, '
             'Citygate outlets, 360 Cable car, shopping centre, main tourist '
             'attractions......'}]

结果可能会有所不同，因为您在步骤 3 中从 sample_airbnb.listingsAndReviews命名空间中随机选择了 50 个文档。在您的环境中，所选文档和生成的嵌入可能会有所不同。

有关使用 Cohere 的 embed-english-v3.0 嵌入模型在样本数据上对这一程序的高级演示，请参阅本笔记本。

评估查询结果

您可以通过评估 ANN搜索结果与针对量化向量的 ENN搜索结果的匹配程度来衡量Atlas Vector Search查询的准确性。也就是说，您可以将相同查询条件的 ANN搜索结果与 ENN搜索结果进行比较，并测量 ANN搜索结果在 ENN搜索结果中包含最近邻的频率。

有关评估查询结果的演示，请参阅如何衡量查询结果的准确性。

后退

创建和运行查询

来年

检索增强生成 (RAG)

嵌入模型提供者	嵌入模型
Cohere	`embed-english-v3.0`
Nomic	`nomic-embed-text-v1.5`
Jina	`jina-embeddings-v2-base-en`
Mixedbread	`mxbai-embed-large-v1`

占位符	有效值
`<DB-NAME>`	数据库名称。
`<COLLECTION-NAME>`	指定数据库中集合的名称。

1	import os
2	import pymongo
3	import cohere
4	from bson.binary import Binary, BinaryVectorDtype
5
6	# Specify your OpenAI API key and embedding model
7	os.environ["COHERE_API_KEY"] = "<COHERE-API-KEY>"
8	cohere_client = cohere.Client(os.environ["COHERE_API_KEY"])
9
10	# Function to generate embeddings using Cohere
11	def get_embedding(text):
12	response = cohere_client.embed(
13	texts=[text],
14	model='embed-english-v3.0',
15	input_type='search_document',
16	embedding_types=["float"]
17	)
18	embedding = response.embeddings.float[0]
19	return embedding
20
21	# Function to convert embeddings to BSON-compatible format
22	def generate_bson_vector(vector, vector_dtype):
23	return Binary.from_vector(vector, vector_dtype)

1	# Connect to your Atlas cluster
2	mongo_client = pymongo.MongoClient("<ATLAS-CONNECTION-STRING>")
3	db = mongo_client["sample_airbnb"]
4	collection = db["listingsAndReviews"]
5
6	# Filter to exclude null or empty summary fields
7	filter = { "summary": {"$nin": [None, ""]} }
8
9	# Get a subset of documents in the collection
10	documents = collection.find(filter).limit(50)
11
12	# Initialize the count of updated documents
13	updated_doc_count = 0

1	for doc in documents:
2	# Generate embeddings based on the summary
3	summary = doc["summary"]
4	embedding = get_embedding(summary) # Get float32 embedding
5
6	# Convert the float32 embedding to BSON format
7	bson_float32 = generate_bson_vector(embedding, BinaryVectorDtype.FLOAT32)
8
9	# Update the document with the BSON embedding
10	collection.update_one(
11	{"_id": doc["_id"]},
12	{"$set": {"embedding": bson_float32}}
13	)
14	updated_doc_count += 1
15
16	print(f"Updated {updated_doc_count} documents with BSON embeddings.")

1	from pymongo.operations import SearchIndexModel
2
3	vector_search_index_definition = {
4	"fields":[
5	{
6	"type": "vector",
7	"path": "embedding",
8	"similarity": "euclidean",
9	"numDimensions": 1024,
10	}
11	]
12	}
13
14	search_index_model = SearchIndexModel(definition=vector_search_index_definition, name="<INDEX-NAME>", type="vectorSearch")
15
16	collection.create_search_index(model=search_index_model)

1	def run_vector_search(query_text, collection, path):
2	query_embedding = get_embedding("query_text")
3	bson_query_vector = generate_bson_vector(query_embedding, BinaryVectorDtype.FLOAT32)
4
5	pipeline = [
6	{
7	'$vectorSearch': {
8	'index': '<INDEX-NAME>',
9	'path': path,
10	'queryVector': bson_query_vector,
11	'numCandidates': <NUMBER-OF-CANDIDATES-TO-CONSIDER>, # for example, 20
12	'limit': <NUMBER-OF-DOCUMENTS-TO-RETURN> # for example, 5
13	}
14	},
15	{
16	'$project': {
17	'_id': 0,
18	'name': 1,
19	'summary': 1,
20	'score': { '$meta': 'vectorSearchScore' }
21	}
22	}
23	]
24
25	return collection.aggregate(pipeline)

1	from pprint import pprint
2
3	query_text = "ocean view"
4	query_results = run_vector_search(query_text, collection, "embedding")
5
6	print("results from your embeddings")
7	pprint(list(query_results))