langchain_community.vectorstores.deeplake.DeepLake

class langchain_community.vectorstores.deeplake.DeepLake(dataset_path: str = './deeplake/', token: Optional[str] = None, embedding: Optional[Embeddings] = None, embedding_function: Optional[Embeddings] = None, read_only: bool = False, ingestion_batch_size: int = 1024, num_workers: int = 0, verbose: bool = True, exec_option: Optional[str] = None, runtime: Optional[Dict] = None, index_params: Optional[Dict[str, Union[int, str]]] = None, **kwargs: Any)[source]

Activeloop Deep Lake 向量存储。

我们集成了deeplake的相似性搜索和过滤功能，用于快速原型设计。 现在，它支持用于生产用例的Tensor Query Language (TQL)， 能处理超过十亿行数据。

为什么选择Deep Lake？

  • 不仅存储嵌入向量，还存储具有版本控制的原始数据。

  • 无服务器，不需要另一个服务，并且可以与主要云提供商（如S3、GCS等）一起使用。

  • 不仅仅是一个多模态向量存储。您可以使用数据集来微调自己的LLM模型。

要使用，您应该安装``deeplake`` python包。

示例：
from langchain_community.vectorstores import DeepLake
from langchain_community.embeddings.openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = DeepLake("langchain_store", embeddings.embed_query)

创建一个空的DeepLakeVectorStore或加载一个现有的。

DeepLakeVectorStore位于指定的“path”处。

示例：
>>> # 使用默认张量创建一个向量存储
>>> deeplake_vectorstore = DeepLake(
...        path = <path_for_storing_Data>,
... )
>>>
>>> # 在Deep Lake托管的张量数据库中创建一个向量存储
>>> data = DeepLake(
...        path = "hub://org_id/dataset_name",
...        runtime = {"tensor_db": True},
... )
参数：
dataset_path (str)：用于存储到Deep Lake Vector Store的完整路径。可以是：

  • 形式为“hub://org_id/dataset_name”的Deep Lake云路径。需要在Deep Lake中注册。

  • 形式为“s3://bucketname/path/to/dataset”的s3路径。需要环境中的凭据或传递给creds参数。

  • 形式为“./path/to/dataset”或“~/path/to/dataset”或“path/to/dataset”的本地文件系统路径。

  • 形式为“mem://path/to/dataset”的内存路径，不保存数据集，而是将其保存在内存中。仅用于测试，因为它不会持久保存。默认为_LANGCHAIN_DEFAULT_DEEPLAKE_PATH。

token (str, 可选)：Activeloop令牌，用于获取路径处数据集的凭据，如果是Deep Lake数据集。令牌通常是自动生成的。可选。 embedding (Embeddings, 可选)：用于转换文档或查询的函数。可选。 embedding_function (Embeddings, 可选)：用于转换文档或查询的函数。可选。已弃用：为了向后兼容性而保留此参数。 read_only (bool)：以只读模式打开数据集。默认为False。 ingestion_batch_size (int)：在数据摄取期间，数据被分成批次。批处理大小是每个批次的大小。默认为1024。 num_workers (int)：数据摄取期间要使用的工作程序数量。默认为0。 verbose (bool)：在每次操作后打印数据集摘要。默认为True。 exec_option (str, 可选)：搜索执行的默认方法。可以是“auto”、“python”、“compute_engine”或“tensor_db”。默认为“auto”。如果为None，则设置为“auto”。

  • “auto”- 根据Vector Store的存储位置选择最佳执行方法。这是默认选项。

  • “python” - 在客户端上运行的纯Python实现，可用于存储在任何位置的数据。警告：不建议在大型数据集中使用此选项，因为可能会导致内存问题。

  • “compute_engine” - 在客户端上运行的Deep Lake Compute Engine的高性能C++实现，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能与内存或本地数据集一起使用。

  • “tensor_db” - 高性能且完全托管的Managed Tensor Database，负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。通过在数据集创建期间指定runtime = {“tensor_db”: True}来将数据集存储在此数据库中。

runtime (Dict, 可选)：在Deep Lake的托管张量数据库中创建Vector Store的参数。加载现有Vector Store时不适用。要在托管张量数据库中创建Vector Store，请设置`runtime = {“tensor_db”: True}`。 index_params (Optional[Dict[str, Union[int, str]]], 可选)：包含将要创建的向量索引信息的字典。默认为None，将利用“deeplake.constants”中的“DEFAULT_VECTORSTORE_INDEX_PARAMS”。

指定的键-值将覆盖默认值。 - threshold: 数据集大小超过此阈值时将为嵌入张量创建索引。当阈值值设置为-1时，将关闭索引创建。默认为-1，关闭索引。 - distance_metric: 此键指定创建向量数据库（VDB）索引时计算向量之间距离的方法。可以是与DistanceType枚举成员对应的字符串，或字符串值本身。

  • 如果未提供值，则默认为“L2”。

  • “L2”对应于DistanceType.L2_NORM。

  • “COS”对应于DistanceType.COSINE_SIMILARITY。

  • additional_params: 用于微调索引的其他参数。

**kwargs：其他可选关键字参数。

Raises

ValueError – 如果不满足某些条件。

Parameters

  • dataset_path (str) –

  • token (Optional[str]) –

  • embedding (Optional[Embeddings]) –

  • embedding_function (Optional[Embeddings]) –

  • read_only (bool) –

  • ingestion_batch_size (int) –

  • num_workers (int) –

  • verbose (bool) –

  • exec_option (Optional[str]) –

  • runtime (Optional[Dict]) –

  • index_params (Optional[Dict[str, Union[int, str]]]) –

  • kwargs (Any) –

Return type

None

Attributes

embeddings

如果可用，访问查询嵌入对象。

Methods

__init__([dataset_path, token, embedding, ...])

创建一个空的DeepLakeVectorStore或加载一个现有的。

aadd_documents(documents, **kwargs)

运行更多的文档通过嵌入并添加到向量存储中。

aadd_texts(texts[, metadatas])

运行更多的文本通过嵌入，并添加到向量存储中。

add_documents(documents, **kwargs)

运行更多的文档通过嵌入并添加到向量存储中。

add_texts(texts[, metadatas, ids])

运行更多文本通过嵌入并添加到向量存储。

adelete([ids])

根据向量ID或其他条件进行删除。

afrom_documents(documents, embedding, **kwargs)

返回从文档和嵌入初始化的VectorStore。

afrom_texts(texts, embedding[, metadatas])

返回从文本和嵌入初始化的VectorStore。

amax_marginal_relevance_search(query[, k, ...])

返回使用最大边际相关性选择的文档。

amax_marginal_relevance_search_by_vector(...)

返回使用最大边际相关性选择的文档。

as_retriever(**kwargs)

返回从此VectorStore初始化的VectorStoreRetriever。

asearch(query, search_type, **kwargs)

返回使用指定搜索类型的查询最相似的文档。

asimilarity_search(query[, k])

返回与查询最相似的文档。

asimilarity_search_by_vector(embedding[, k])

返回与嵌入向量最相似的文档。

asimilarity_search_with_relevance_scores(query)

返回文档和相关性分数在范围[0, 1]内，异步执行。

asimilarity_search_with_score(*args, **kwargs)

使用异步方式运行相似性搜索与距离。

delete([ids])

删除数据集中的实体。

delete_dataset()

删除集合。

ds()

force_delete_by_path(path)

通过路径强制删除数据集。

from_documents(documents, embedding, **kwargs)

返回从文档和嵌入初始化的VectorStore。

from_texts(texts[, embedding, metadatas, ...])

从原始文档中创建一个Deep Lake数据集。

max_marginal_relevance_search(query[, k, ...])

返回使用最大边际相关性选择的文档。

max_marginal_relevance_search_by_vector(...)

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

search(query, search_type, **kwargs)

返回使用指定搜索类型的查询最相似的文档。

similarity_search(query[, k])

返回与查询最相似的文档。

similarity_search_by_vector(embedding[, k])

返回与嵌入向量最相似的文档。

similarity_search_with_relevance_scores(query)

返回文档和相关性得分在[0, 1]范围内。

similarity_search_with_score(query[, k])

运行带有返回距离的Deep Lake相似性搜索。
__init__(dataset_path: str = './deeplake/', token: Optional[str] = None, embedding: Optional[Embeddings] = None, embedding_function: Optional[Embeddings] = None, read_only: bool = False, ingestion_batch_size: int = 1024, num_workers: int = 0, verbose: bool = True, exec_option: Optional[str] = None, runtime: Optional[Dict] = None, index_params: Optional[Dict[str, Union[int, str]]] = None, **kwargs: Any) → None[source]

创建一个空的DeepLakeVectorStore或加载一个现有的。

DeepLakeVectorStore位于指定的“path”处。

示例：
>>> # 使用默认张量创建一个向量存储
>>> deeplake_vectorstore = DeepLake(
...        path = <path_for_storing_Data>,
... )
>>>
>>> # 在Deep Lake托管的张量数据库中创建一个向量存储
>>> data = DeepLake(
...        path = "hub://org_id/dataset_name",
...        runtime = {"tensor_db": True},
... )
参数：
dataset_path (str)：用于存储到Deep Lake Vector Store的完整路径。可以是：

  • 形式为“hub://org_id/dataset_name”的Deep Lake云路径。需要在Deep Lake中注册。

  • 形式为“s3://bucketname/path/to/dataset”的s3路径。需要环境中的凭据或传递给creds参数。

  • 形式为“./path/to/dataset”或“~/path/to/dataset”或“path/to/dataset”的本地文件系统路径。

  • 形式为“mem://path/to/dataset”的内存路径，不保存数据集，而是将其保存在内存中。仅用于测试，因为它不会持久保存。默认为_LANGCHAIN_DEFAULT_DEEPLAKE_PATH。

token (str, 可选)：Activeloop令牌，用于获取路径处数据集的凭据，如果是Deep Lake数据集。令牌通常是自动生成的。可选。 embedding (Embeddings, 可选)：用于转换文档或查询的函数。可选。 embedding_function (Embeddings, 可选)：用于转换文档或查询的函数。可选。已弃用：为了向后兼容性而保留此参数。 read_only (bool)：以只读模式打开数据集。默认为False。 ingestion_batch_size (int)：在数据摄取期间，数据被分成批次。批处理大小是每个批次的大小。默认为1024。 num_workers (int)：数据摄取期间要使用的工作程序数量。默认为0。 verbose (bool)：在每次操作后打印数据集摘要。默认为True。 exec_option (str, 可选)：搜索执行的默认方法。可以是“auto”、“python”、“compute_engine”或“tensor_db”。默认为“auto”。如果为None，则设置为“auto”。

  • “auto”- 根据Vector Store的存储位置选择最佳执行方法。这是默认选项。

  • “python” - 在客户端上运行的纯Python实现，可用于存储在任何位置的数据。警告：不建议在大型数据集中使用此选项，因为可能会导致内存问题。

  • “compute_engine” - 在客户端上运行的Deep Lake Compute Engine的高性能C++实现，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能与内存或本地数据集一起使用。

  • “tensor_db” - 高性能且完全托管的Managed Tensor Database，负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。通过在数据集创建期间指定runtime = {“tensor_db”: True}来将数据集存储在此数据库中。

runtime (Dict, 可选)：在Deep Lake的托管张量数据库中创建Vector Store的参数。加载现有Vector Store时不适用。要在托管张量数据库中创建Vector Store，请设置`runtime = {“tensor_db”: True}`。 index_params (Optional[Dict[str, Union[int, str]]], 可选)：包含将要创建的向量索引信息的字典。默认为None，将利用“deeplake.constants”中的“DEFAULT_VECTORSTORE_INDEX_PARAMS”。

指定的键-值将覆盖默认值。 - threshold: 数据集大小超过此阈值时将为嵌入张量创建索引。当阈值值设置为-1时，将关闭索引创建。默认为-1，关闭索引。 - distance_metric: 此键指定创建向量数据库（VDB）索引时计算向量之间距离的方法。可以是与DistanceType枚举成员对应的字符串，或字符串值本身。

  • 如果未提供值，则默认为“L2”。

  • “L2”对应于DistanceType.L2_NORM。

  • “COS”对应于DistanceType.COSINE_SIMILARITY。

  • additional_params: 用于微调索引的其他参数。

**kwargs：其他可选关键字参数。

Raises

ValueError – 如果不满足某些条件。

Parameters

  • dataset_path (str) –

  • token (Optional[str]) –

  • embedding (Optional[Embeddings]) –

  • embedding_function (Optional[Embeddings]) –

  • read_only (bool) –

  • ingestion_batch_size (int) –

  • num_workers (int) –

  • verbose (bool) –

  • exec_option (Optional[str]) –

  • runtime (Optional[Dict]) –

  • index_params (Optional[Dict[str, Union[int, str]]]) –

  • kwargs (Any) –

Return type

None

async aadd_documents(documents: List[Document], **kwargs: Any) → List[str]

运行更多的文档通过嵌入并添加到向量存储中。

参数:

documents (List[Document]): 要添加到向量存储中的文档。

返回:

List[str]: 添加的文本的ID列表。

Parameters

  • documents (List[Document]) –

  • kwargs (Any) –

Return type

List[str]

async aadd_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, **kwargs: Any) → List[str]

运行更多的文本通过嵌入，并添加到向量存储中。

Parameters

  • texts (Iterable[str]) –

  • metadatas (Optional[List[dict]]) –

  • kwargs (Any) –

Return type

List[str]

add_documents(documents: List[Document], **kwargs: Any) → List[str]

运行更多的文档通过嵌入并添加到向量存储中。

参数:

documents (List[Document]): 要添加到向量存储中的文档。

返回:

List[str]: 添加的文本的ID列表。

Parameters

  • documents (List[Document]) –

  • kwargs (Any) –

Return type

List[str]

add_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, **kwargs: Any) → List[str][source]

运行更多文本通过嵌入并添加到向量存储。

示例：
>>> ids = deeplake_vectorstore.add_texts(
...     texts = <list_of_texts>,
...     metadatas = <list_of_metadata_jsons>,
...     ids = <list_of_ids>,
... )
参数：

texts (Iterable[str]): 要添加到向量存储的文本。 metadatas (Optional[List[dict]], optional): 可选的元数据列表。 ids (Optional[List[str]], optional): 可选的ID列表。 embedding_function (Optional[Embeddings], optional): 用于将文本转换为嵌入的嵌入函数。 **kwargs (Any): 通过此方法传递的任何其他关键字参数不受支持。

返回：

List[str]: 添加的文本的ID列表。

Parameters

  • texts (Iterable[str]) –

  • metadatas (Optional[List[dict]]) –

  • ids (Optional[List[str]]) –

  • kwargs (Any) –

Return type

List[str]

async adelete(ids: Optional[List[str]] = None, **kwargs: Any) → Optional[bool]

根据向量ID或其他条件进行删除。

参数：

ids：要删除的ID列表。 **kwargs：子类可能使用的其他关键字参数。

返回：

Optional[bool]：如果删除成功则为True，否则为False，如果未实现则为None。

Parameters

  • ids (Optional[List[str]]) –

  • kwargs (Any) –

Return type

Optional[bool]

async classmethod afrom_documents(documents: List[Document], embedding: Embeddings, **kwargs: Any) → VST

返回从文档和嵌入初始化的VectorStore。

Parameters
Return type

VST

async classmethod afrom_texts(texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]] = None, **kwargs: Any) → VST

返回从文本和嵌入初始化的VectorStore。

Parameters

  • texts (List[str]) –

  • embedding (Embeddings) –

  • metadatas (Optional[List[dict]]) –

  • kwargs (Any) –

Return type

VST

返回使用最大边际相关性选择的文档。

最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

参数：

query：要查找类似文档的文本。 k：要返回的文档数量。默认为4。 fetch_k：要获取以传递给MMR算法的文档数量。 lambda_mult：0到1之间的数字，确定结果之间多样性的程度，0对应最大多样性，1对应最小多样性。默认为0.5。

返回：

由最大边际相关性选择的文档列表。

Parameters

  • query (str) –

  • k (int) –

  • fetch_k (int) –

  • lambda_mult (float) –

  • kwargs (Any) –

Return type

List[Document]

async amax_marginal_relevance_search_by_vector(embedding: List[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → List[Document]

返回使用最大边际相关性选择的文档。

Parameters

  • embedding (List[float]) –

  • k (int) –

  • fetch_k (int) –

  • lambda_mult (float) –

  • kwargs (Any) –

Return type

List[Document]

as_retriever(**kwargs: Any) → VectorStoreRetriever

返回从此VectorStore初始化的VectorStoreRetriever。

参数：
search_type（可选[str]）：定义Retriever应执行的搜索类型。

可以是”similarity”（默认值）、”mmr”或”similarity_score_threshold”。

search_kwargs（可选[Dict]）：传递给搜索函数的关键字参数。可以包括：

k：要返回的文档数量（默认值：4） score_threshold：用于similarity_score_threshold的最小相关性阈值 fetch_k：传递给MMR算法的文档数量（默认值：20） lambda_mult：MMR返回结果的多样性；1表示最小多样性，0表示最大多样性（默认值：0.5） filter：按文档元数据筛选

返回：

VectorStoreRetriever：VectorStore的Retriever类。

示例：

# 检索更多具有更高多样性的文档
# 如果数据集中有许多相似的文档，则很有用
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 6, 'lambda_mult': 0.25}
)

# 为MMR算法考虑更多文档
# 但只返回前5个
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 5, 'fetch_k': 50}
)

# 仅检索具有特定阈值以上相关性分数的文档
docsearch.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={'score_threshold': 0.8}
)

# 仅从数据集中获取最相似的单个文档
docsearch.as_retriever(search_kwargs={'k': 1})

# 使用筛选器仅从特定论文中检索文档
docsearch.as_retriever(
    search_kwargs={'filter': {'paper_title':'GPT-4 Technical Report'}}
)
Parameters

kwargs (Any) –

Return type

VectorStoreRetriever

async asearch(query: str, search_type: str, **kwargs: Any) → List[Document]

返回使用指定搜索类型的查询最相似的文档。

Parameters

  • query (str) –

  • search_type (str) –

  • kwargs (Any) –

Return type

List[Document]

返回与查询最相似的文档。

Parameters

  • query (str) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Document]

async asimilarity_search_by_vector(embedding: List[float], k: int = 4, **kwargs: Any) → List[Document]

返回与嵌入向量最相似的文档。

Parameters

  • embedding (List[float]) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Document]

async asimilarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]

返回文档和相关性分数在范围[0, 1]内，异步执行。

0表示不相似，1表示最相似。

参数：

query：输入文本 k：要返回的文档数量。默认为4。 **kwargs：要传递给相似性搜索的kwargs。应包括：

score_threshold：可选，介于0到1之间的浮点值，用于过滤检索到的文档集

返回：

元组列表（doc，相似度分数）的列表

Parameters

  • query (str) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Tuple[Document, float]]

async asimilarity_search_with_score(*args: Any, **kwargs: Any) → List[Tuple[Document, float]]

使用异步方式运行相似性搜索与距离。

Parameters

  • args (Any) –

  • kwargs (Any) –

Return type

List[Tuple[Document, float]]

delete(ids: Optional[List[str]] = None, **kwargs: Any) → bool[source]

删除数据集中的实体。

参数：
ids（可选[List[str] ]，可选）：要删除的document_ids。

默认为None。

**kwargs：子类可能使用的其他关键字参数。

  • filter（可选[Dict[str, str] ]，可选）：要删除的筛选条件。

  • delete_all（可选[bool]，可选）：是否删除整个数据集。

返回：

bool：删除操作是否成功。

Parameters

  • ids (Optional[List[str]]) –

  • kwargs (Any) –

Return type

bool

delete_dataset() → None[source]

删除集合。

Return type

None

ds() → Any[source]
Return type

Any

classmethod force_delete_by_path(path: str) → None[source]

通过路径强制删除数据集。

参数：

path（str）：要删除的数据集的路径。

引发：

ValueError：如果未安装deeplake。

Parameters

path (str) –

Return type

None

classmethod from_documents(documents: List[Document], embedding: Embeddings, **kwargs: Any) → VST

返回从文档和嵌入初始化的VectorStore。

Parameters
Return type

VST

classmethod from_texts(texts: List[str], embedding: Optional[Embeddings] = None, metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, dataset_path: str = './deeplake/', **kwargs: Any) → DeepLake[source]

从原始文档中创建一个Deep Lake数据集。

如果指定了dataset_path，则数据集将持久化在该位置，否则默认在`./deeplake`。

示例： >>> # 使用嵌入进行搜索 >>> vector_store = DeepLake.from_texts( … texts = <要嵌入的文本>, … embedding_function = <用于查询的嵌入函数>, … k = <要返回的项目数量>, … exec_option = <首选执行选项>, )

参数：
dataset_path (str): - 数据集的完整路径。可以是：
  • Deep Lake云路径的形式为``hub://username/dataset_name``。

    要写入Deep Lake云数据集， 确保您已登录到Deep Lake （从命令行使用’activeloop login’）

  • AWS S3路径的形式为``s3://bucketname/path/to/dataset``。

    环境中需要凭据

  • Google Cloud Storage路径的形式为

    gcs://bucketname/path/to/dataset 环境中需要凭据

  • 本地文件系统路径的形式为``./path/to/dataset``或

    ~/path/to/dataset``或``path/to/dataset。

  • 内存路径的形式为``mem://path/to/dataset``，不会

    保存数据集，而是将其保存在内存中。 仅应用于测试，因为它不会持久化。

texts (List[Document]): 要添加的文档列表。 embedding (Optional[Embeddings]): 嵌入函数。默认为None。

注意，在其他地方，它被称为embedding_function。

metadatas (Optional[List[dict]]): 元数据列表。默认为None。 ids (Optional[List[str]]): 文档ID列表。默认为None。 **kwargs: 附加关键字参数。

返回：

DeepLake: Deep Lake数据集。

Parameters

  • texts (List[str]) –

  • embedding (Optional[Embeddings]) –

  • metadatas (Optional[List[dict]]) –

  • ids (Optional[List[str]]) –

  • dataset_path (str) –

  • kwargs (Any) –

Return type

DeepLake

返回使用最大边际相关性选择的文档。

最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

示例： >>> # 使用嵌入进行搜索 >>> data = vector_store.max_marginal_relevance_search( … query = <query_to_search>, … embedding_function = <embedding_function_for_query>, … k = <number_of_items_to_return>, … exec_option = <preferred_exec_option>, … )

参数：

query：要查找相似文档的文本。 k：要返回的文档数量。默认为4。 fetch_k：MMR算法的文档数量。 lambda_mult：介于0和1之间的值。0对应于最大多样性，1对应于最小多样性。默认为0.5。 exec_option（str）：支持3种执行搜索的方式。

  • “python” - 在客户端上运行的纯Python实现。可用于存储在任何位置的数据。警告：不建议在大型数据集上使用此选项，可能会出现内存问题。

  • “compute_engine” - Deep Lake Compute Engine的高性能C++实现。在客户端上运行，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能与内存中或本地数据集一起使用。

  • “tensor_db” - 高性能的完全托管的Managed Tensor Database。负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建期间指定`runtime = {“db_engine”: True}`。

deep_memory（bool）：是否使用Deep Memory模型来改善搜索结果。如果在Vector Store初始化中未指定deep_memory，则默认为False。如果为True，则距离度量设置为”deepmemory_distance”，表示使用模型训练的度量。使用Deep Memory模型执行搜索。如果为False，则距离度量设置为”COS”或用户指定的任何距离度量。 **kwargs：其他关键字参数

返回：

通过最大边际相关性选择的文档列表。

引发：

ValueError：当MRR搜索开启但未指定嵌入函数时。

Parameters

  • query (str) –

  • k (int) –

  • fetch_k (int) –

  • lambda_mult (float) –

  • exec_option (Optional[str]) –

  • kwargs (Any) –

Return type

List[Document]

max_marginal_relevance_search_by_vector(embedding: List[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, exec_option: Optional[str] = None, **kwargs: Any) → List[Document][source]

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

示例： >>> data = vector_store.max_marginal_relevance_search_by_vector( … embedding=<your_embedding>, … fetch_k=<elements_to_fetch_before_mmr_search>, … k=<number_of_items_to_return>, … exec_option=<preferred_exec_option>, … )

参数：

embedding: 要查找类似文档的嵌入。 k: 要返回的文档数量。默认为4。 fetch_k: MMR算法中要获取的文档数量。 lambda_mult: 0到1之间的数字，确定多样性程度。

0表示最大多样性，1表示最小多样性。默认为0.5。

exec_option (str): DeepLakeVectorStore支持3种搜索方式。

可以是”python”、”compute_engine”或”tensor_db”。默认为”python”。 - “python” - 在客户端上运行的纯Python实现。

可用于存储在任何位置的数据。警告：不建议在大型数据集上使用此选项，可能会出现内存问题。

  • “compute_engine” - Deep Lake Compute Engine的高性能C++实现。

    在客户端上运行，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能用于内存中或本地数据集。

  • “tensor_db” - 高性能、完全托管的Managed Tensor Database。

    负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建时指定`runtime = {“db_engine”: True}`。

deep_memory (bool): 是否使用Deep Memory模型来改善搜索结果。如果在Vector Store初始化中未指定deep_memory，则默认为False。

如果为True，则将距离度量设置为”deepmemory_distance”，表示使用模型训练的度量。使用Deep Memory模型进行搜索。 如果为False，则将距离度量设置为”COS”或用户指定的任何距离度量。

**kwargs: 其他关键字参数。

返回：

List[Documents] - 文档列表。

Parameters

  • embedding (List[float]) –

  • k (int) –

  • fetch_k (int) –

  • lambda_mult (float) –

  • exec_option (Optional[str]) –

  • kwargs (Any) –

Return type

List[Document]

search(query: str, search_type: str, **kwargs: Any) → List[Document]

返回使用指定搜索类型的查询最相似的文档。

Parameters

  • query (str) –

  • search_type (str) –

  • kwargs (Any) –

Return type

List[Document]

返回与查询最相似的文档。

示例：
>>> # 使用嵌入进行搜索
>>> data = vector_store.similarity_search(
...     query=<your_query>,
...     k=<num_items>,
...     exec_option=<preferred_exec_option>,
... )
>>> # 运行tql搜索：
>>> data = vector_store.similarity_search(
...     query=None,
...     tql="SELECT * WHERE id == <id>",
...     exec_option="compute_engine",
... )
参数：

k (int): 要返回的文档数量。默认为4。 query (str): 要查找相似文档的文本。 **kwargs: 其他关键字参数包括：

embedding (Callable): 要使用的嵌入函数。默认为None。 distance_metric (str): ‘L2’表示欧几里德距离，’L1’表示核范数，’max’

表示L-无穷范数，’cos’表示余弦相似度，’dot’表示点积。 默认为’L2’。

filter (Union[Dict, Callable], optional): 在嵌入搜索之前的额外过滤器。
  • Dict: 在htype json张量上进行键-值搜索，

    （样本必须满足所有键-值过滤器） Dict = {“tensor_1”: {“key”: value}, “tensor_2”: {“key”: value}}

  • Function: 与`deeplake.filter`兼容。

默认为None。

exec_option (str): 支持3种执行搜索的方式。

‘python’、’compute_engine’或’tensor_db’。默认为’python’。 - ‘python’: 用于客户端的纯Python实现。

警告：不推荐用于大型数据集。

  • ‘compute_engine’: 用于客户端的计算引擎的C++实现。不适用于内存中或本地数据集。

  • ‘tensor_db’: 用于存储和查询的托管张量数据库。

    仅适用于Deep Lake托管数据库中的数据。 在数据集创建期间使用`runtime = {“db_engine”: True}`。

deep_memory (bool): 是否使用Deep Memory模型来改善搜索结果。

如果在Vector Store初始化中未指定deep_memory，则默认为False。 如果为True，则距离度量设置为”deepmemory_distance”，表示模型训练时使用的度量。 使用Deep Memory模型执行搜索。如果为False，则距离度量设置为”COS”或 用户指定的任何距离度量。

返回：

List[Document]: 与查询向量最相似的文档列表。

Parameters

  • query (str) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Document]

similarity_search_by_vector(embedding: Union[List[float], ndarray], k: int = 4, **kwargs: Any) → List[Document][source]

返回与嵌入向量最相似的文档。

示例：
>>> # 使用嵌入进行搜索
>>> data = vector_store.similarity_search_by_vector(
...    embedding=<your_embedding>,
...    k=<num_items_to_return>,
...    exec_option=<preferred_exec_option>,
... )
参数：
embedding (Union[List[float], np.ndarray]):

要查找相似文档的嵌入。

k (int): 要返回的文档数量。默认为4。 **kwargs: 包括以下附加关键字参数：

filter (Union[Dict, Callable], optional):

在嵌入搜索之前的额外过滤器。 - Dict - 在htype json张量上进行键-值搜索。如果所有键-值过滤器都满足，则为True。

Dict = {“tensor_name_1”: {“key”: value},

“tensor_name_2”: {“key”: value}}

  • Function - 与`deeplake.filter`兼容的任何函数。

默认为None。

exec_option (str): 搜索执行选项包括

“python”、”compute_engine”或”tensor_db”。默认为”python”。 - “python” - 在客户端上运行的纯Python实现。可用于存储在任何位置的数据。警告：不建议在大型数据集上使用此选项，可能会出现内存问题。 - “compute_engine” - 高性能的Deep Lake Compute Engine的C++实现。在客户端上运行，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能与内存中或本地数据集一起使用。 - “tensor_db” - 高性能、完全托管的托管张量数据库。负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。

要将数据集存储在此数据库中，请在数据集创建时指定`runtime = {“db_engine”: True}`。

distance_metric (str): L2`表示欧几里德距离，`L1`表示核范数，`max`表示L-无穷距离，`cos`表示余弦相似度，’dot’表示点积。默认为`L2。 deep_memory (bool): 是否使用Deep Memory模型来改善搜索结果。如果在Vector Store初始化中未指定deep_memory，则默认为False。如果为True，则距离度量设置为”deepmemory_distance”，表示模型训练时使用的度量。使用Deep Memory模型执行搜索。如果为False，则距离度量设置为”COS”或用户指定的任何距离度量。

返回：

List[Document]: 与查询向量最相似的文档列表。

Parameters

  • embedding (Union[List[float], ndarray]) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Document]

similarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]

返回文档和相关性得分在[0, 1]范围内。

0表示不相似，1表示最相似。

参数：

query：输入文本 k：要返回的文档数量。默认为4。 **kwargs：要传递给相似性搜索的kwargs。应包括：

score_threshold：可选，介于0到1之间的浮点值，用于过滤检索到的文档集

返回：

元组列表（doc，相似性得分）

Parameters

  • query (str) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Tuple[Document, float]]

similarity_search_with_score(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]][source]

运行带有返回距离的Deep Lake相似性搜索。

示例： >>> data = vector_store.similarity_search_with_score( … query=<your_query>, … embedding=<your_embedding_function> … k=<number_of_items_to_return>, … exec_option=<preferred_exec_option>, … )

参数：

query (str)：要搜索的查询文本。 k (int)：要返回的结果数量。默认为4。 **kwargs：其他关键字参数。其中一些参数包括：

distance_metric：L2`表示欧氏距离，`L1`表示核范数，`max`表示极限距离，`cos`表示余弦相似度，’dot’表示点积。默认为`L2。 filter (Optional[Dict[str, str]])：按元数据进行过滤。默认为None。 embedding_function (Callable)：要使用的嵌入函数。默认为None。 exec_option (str)：DeepLakeVectorStore支持3种执行搜索的方式。可以是”python”、”compute_engine”或”tensor_db”。默认为”python”。

  • “python” - 在客户端上运行的纯Python实现。可用于存储在任何位置的数据。警告：不建议在大型数据集上使用此选项，因为可能会出现内存问题。

  • “compute_engine” - Deep Lake Compute Engine的高性能C++实现。在客户端上运行，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能与内存中或本地数据集一起使用。

  • “tensor_db” - 高性能、完全托管的管理型张量数据库。负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建时指定 runtime = {“db_engine”: True}。

deep_memory (bool)：是否使用Deep Memory模型来改善搜索结果。如果在Vector Store初始化中未指定deep_memory，则默认为False。如果为True，则距离度量设置为”deepmemory_distance”，表示模型训练时使用的度量。使用Deep Memory模型执行搜索。如果为False，则距离度量设置为”COS”或用户指定的任何距离度量。

返回：

List[Tuple[Document, float]]：与查询文本最相似的文档列表，带有浮点数距离。

Parameters

  • query (str) –

  • k (int) –

  • kwargs (Any) –

Return type

List[Tuple[Document, float]]

Examples using DeepLake