DeepLake#

class langchain_community.vectorstores.deeplake.DeepLake(dataset_path: str = './deeplake/', token: str | None = None, embedding: Embeddings | None = None, embedding_function: Embeddings | None = None, read_only: bool = False, ingestion_batch_size: int = 1024, num_workers: int = 0, verbose: bool = True, exec_option: str | None = None, runtime: Dict | None = None, index_params: Dict[str, int | str] | None = 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。

示例

>>> # Create a vector store with default tensors
>>> deeplake_vectorstore = DeepLake(
...        path = <path_for_storing_Data>,
... )
>>>
>>> # Create a vector store in the Deep Lake Managed Tensor Database
>>> data = DeepLake(
...        path = "hub://org_id/dataset_name",
...        runtime = {"tensor_db": True},
... )

Parameters:

dataset_path (str) –
用于存储到Deep Lake向量存储的完整路径。它可以是： - Deep Lake云路径，形式为hub://org_id/dataset_name。

需要注册Deep Lake。
- s3路径，形式为s3://bucketname/path/to/dataset。
  需要在环境或传递给creds参数中提供凭证。
- 本地文件系统路径，形式为./path/to/dataset
  或~/path/to/dataset或path/to/dataset。
- 内存路径，形式为mem://path/to/dataset，它不会
  保存数据集，而是将其保存在内存中。仅用于测试，因为它不会持久化。默认为_LANGCHAIN_DEFAULT_DEEPLAKE_PATH。
token (str, optional) – Activeloop 令牌，用于获取路径下数据集的凭据，如果它是一个 Deep Lake 数据集。令牌通常是自动生成的。可选。
embedding (Embeddings, optional) – 用于转换文档或查询的函数。可选。
embedding_function (Embeddings, optional) – 用于转换文档或查询的函数。可选。已弃用：保留此参数以保持向后兼容性。
read_only (bool) – 以只读模式打开数据集。默认值为 False。
ingestion_batch_size (int) – 在数据摄取过程中，数据被分成批次。批次大小是每个批次的大小。默认值为1024。
num_workers (int) – 数据摄取期间使用的工作线程数。默认值为0。
verbose (bool) – 每次操作后打印数据集摘要。默认值为 True。
exec_option (str, optional) –
搜索执行的默认方法。它可以是 "auto", "python", "compute_engine" 或 "tensor_db"。默认为 "auto"。如果为 None，则设置为“auto”。 - auto- 根据存储位置选择最佳执行方法

向量存储的位置。这是默认选项。
- python - 纯 Python 实现，运行在客户端上，
  可用于存储在任何地方的数据。警告：不建议将此选项用于大数据集，因为它可能导致内存问题。
- compute_engine - 高性能的 C++ 实现，运行在客户端上，
  可用于存储在或连接到 Deep Lake 的任何数据。不能用于内存或本地数据集。
- tensor_db - 高性能且完全托管的托管张量数据库，
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。通过在数据集创建时指定 runtime = {“tensor_db”: True} 将数据集存储在此数据库中。
runtime (Dict, optional) – 用于在Deep Lake的托管张量数据库中创建向量存储的参数。加载现有向量存储时不适用。要在托管张量数据库中创建向量存储，请设置 runtime = {“tensor_db”: True}。
index_params (可选[Dict[str, Union[int, str]]], 可选) –
包含有关将创建的向量索引信息的字典。默认为None，将使用deeplake.constants中的DEFAULT_VECTORSTORE_INDEX_PARAMS。指定的键值将覆盖默认值。 - threshold: 数据集大小的阈值，超过该阈值将为嵌入张量创建索引。当阈值设置为-1时，索引创建将被关闭。默认为-1，即关闭索引。

当阈值设置为-1时，索引创建将被关闭。默认为-1，即关闭索引。
- distance_metric: 此键指定在创建向量数据库（VDB）索引时计算向量之间距离的方法。它可以是对应于DistanceType枚举成员的字符串，也可以是字符串值本身。
  如果未提供值，则默认为“L2”。 - “L2”对应于DistanceType.L2_NORM。 - “COS”对应于DistanceType.COSINE_SIMILARITY。
- additional_params: 用于微调索引的附加参数。
**kwargs – 其他可选的关键字参数。

Raises:

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

属性

embeddings

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

方法

`__init__`([dataset_path, token, embedding, ...])	创建一个空的DeepLakeVectorStore或加载一个已存在的。
`aadd_documents`(documents, **kwargs)	异步运行更多文档通过嵌入并添加到向量存储中。
`aadd_texts`(texts[, metadatas, ids])	异步运行更多文本通过嵌入并添加到向量存储中。
`add_documents`(documents, **kwargs)	在向量存储中添加或更新文档。
`add_texts`(texts[, metadatas, ids])	通过嵌入运行更多文本并将其添加到向量存储中。
`adelete`([ids])	异步删除通过向量ID或其他条件。
`afrom_documents`(documents, embedding, **kwargs)	异步返回从文档和嵌入初始化的VectorStore。
`afrom_texts`(texts, embedding[, metadatas, ids])	异步返回从文本和嵌入初始化的VectorStore。
`aget_by_ids`(ids, /)	异步通过ID获取文档。
`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数据集。
`get_by_ids`(ids, /)	通过ID获取文档。
`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: str | None = None, embedding: Embeddings | None = None, embedding_function: Embeddings | None = None, read_only: bool = False, ingestion_batch_size: int = 1024, num_workers: int = 0, verbose: bool = True, exec_option: str | None = None, runtime: Dict | None = None, index_params: Dict[str, int | str] | None = None, **kwargs: Any) → None[source]#

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

DeepLakeVectorStore 位于指定的 path。

示例

>>> # Create a vector store with default tensors
>>> deeplake_vectorstore = DeepLake(
...        path = <path_for_storing_Data>,
... )
>>>
>>> # Create a vector store in the Deep Lake Managed Tensor Database
>>> data = DeepLake(
...        path = "hub://org_id/dataset_name",
...        runtime = {"tensor_db": True},
... )

Parameters:

dataset_path (str) –
用于存储到Deep Lake向量存储的完整路径。它可以是： - Deep Lake云路径，形式为hub://org_id/dataset_name。

需要注册Deep Lake。
- s3路径，形式为s3://bucketname/path/to/dataset。
  需要在环境或传递给creds参数中提供凭证。
- 本地文件系统路径，形式为./path/to/dataset
  或~/path/to/dataset或path/to/dataset。
- 内存路径，形式为mem://path/to/dataset，它不会
  保存数据集，而是将其保存在内存中。仅用于测试，因为它不会持久化。默认为_LANGCHAIN_DEFAULT_DEEPLAKE_PATH。
token (str, optional) – Activeloop 令牌，用于获取路径下数据集的凭据，如果它是一个 Deep Lake 数据集。令牌通常是自动生成的。可选。
embedding (Embeddings, optional) – 用于转换文档或查询的函数。可选。
embedding_function (Embeddings, optional) – 用于转换文档或查询的函数。可选。已弃用：保留此参数以保持向后兼容性。
read_only (bool) – 以只读模式打开数据集。默认值为 False。
ingestion_batch_size (int) – 在数据摄取过程中，数据被分成批次。批次大小是每个批次的大小。默认值为1024。
num_workers (int) – 数据摄取期间使用的工作线程数。默认值为0。
verbose (bool) – 每次操作后打印数据集摘要。默认值为 True。
exec_option (str, optional) –
搜索执行的默认方法。它可以是 "auto", "python", "compute_engine" 或 "tensor_db"。默认为 "auto"。如果为 None，则设置为“auto”。 - auto- 根据存储位置选择最佳执行方法

向量存储的位置。这是默认选项。
- python - 纯 Python 实现，运行在客户端上，
  可用于存储在任何地方的数据。警告：不建议将此选项用于大数据集，因为它可能导致内存问题。
- compute_engine - 高性能的 C++ 实现，运行在客户端上，
  可用于存储在或连接到 Deep Lake 的任何数据。不能用于内存或本地数据集。
- tensor_db - 高性能且完全托管的托管张量数据库，
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。通过在数据集创建时指定 runtime = {“tensor_db”: True} 将数据集存储在此数据库中。
runtime (Dict, optional) – 用于在Deep Lake的托管张量数据库中创建向量存储的参数。加载现有向量存储时不适用。要在托管张量数据库中创建向量存储，请设置 runtime = {“tensor_db”: True}。
index_params (可选[Dict[str, Union[int, str]]], 可选) –
包含有关将创建的向量索引信息的字典。默认为None，将使用deeplake.constants中的DEFAULT_VECTORSTORE_INDEX_PARAMS。指定的键值将覆盖默认值。 - threshold: 数据集大小的阈值，超过该阈值将为嵌入张量创建索引。当阈值设置为-1时，索引创建将被关闭。默认为-1，即关闭索引。

当阈值设置为-1时，索引创建将被关闭。默认为-1，即关闭索引。
- distance_metric: 此键指定在创建向量数据库（VDB）索引时计算向量之间距离的方法。它可以是对应于DistanceType枚举成员的字符串，也可以是字符串值本身。
  如果未提供值，则默认为“L2”。 - “L2”对应于DistanceType.L2_NORM。 - “COS”对应于DistanceType.COSINE_SIMILARITY。
- additional_params: 用于微调索引的附加参数。
**kwargs – 其他可选的关键字参数。

Raises:

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

Return type:

无

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

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

Parameters:

documents (list[Document]) – 要添加到向量存储中的文档。
kwargs (Any) – 额外的关键字参数。

Returns:

已添加文本的ID列表。

Raises:

ValueError – 如果ID的数量与文档的数量不匹配。

Return type:

列表[字符串]

async aadd_texts(texts: Iterable[str], metadatas: list[dict] | None = None, *, ids: list[str] | None = None, **kwargs: Any) → list[str]#

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

Parameters:

texts (Iterable[str]) – 要添加到向量存储中的字符串的可迭代对象。
metadatas (list[dict] | None) – 可选的与文本关联的元数据列表。默认值为 None。
ids (list[str] | None) – 可选的列表
**kwargs (Any) – 向量存储特定参数。

Returns:

将文本添加到向量存储中后的ID列表。

Raises:

ValueError – 如果元数据的数量与文本的数量不匹配。
ValueError – 如果id的数量与文本的数量不匹配。

Return type:

列表[字符串]

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

在向量存储中添加或更新文档。

Parameters:

documents (list[Document]) – 要添加到向量存储中的文档。
kwargs (Any) – 额外的关键字参数。如果 kwargs 包含 ids 并且 documents 也包含 ids， kwargs 中的 ids 将优先。

Returns:

已添加文本的ID列表。

Raises:

ValueError – 如果id的数量与文档的数量不匹配。

Return type:

列表[字符串]

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

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

示例

>>> ids = deeplake_vectorstore.add_texts(
...     texts = <list_of_texts>,
...     metadatas = <list_of_metadata_jsons>,
...     ids = <list_of_ids>,
... )

Parameters:

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

Returns:

已添加文本的ID列表。

Return type:

列表[str]

async adelete(ids: list[str] | None = None, **kwargs: Any) → bool | None#

通过向量ID或其他条件异步删除。

Parameters:

ids (list[str] | None) – 要删除的id列表。如果为None，则删除所有。默认值为None。
**kwargs (Any) – 子类可能使用的其他关键字参数。

Returns:

如果删除成功则为真，否则为假，如果未实现则为无。

Return type:

可选[布尔]

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

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

Parameters:

documents (list[Document]) – 要添加到向量存储中的文档列表。
embedding (Embeddings) – 使用的嵌入函数。
kwargs (Any) – 额外的关键字参数。

Returns:

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

Return type:

VectorStore

async classmethod afrom_texts(texts: list[str], embedding: Embeddings, metadatas: list[dict] | None = None, *, ids: list[str] | None = None, **kwargs: Any) → VST#

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

Parameters:

texts (list[str]) – 要添加到向量存储中的文本。
embedding (Embeddings) – 使用的嵌入函数。
metadatas (list[dict] | None) – 可选的与文本关联的元数据列表。默认值为 None。
ids (list[str] | None) – 可选的与文本关联的ID列表。
kwargs (Any) – 额外的关键字参数。

Returns:

VectorStore 从文本和嵌入初始化。

Return type:

VectorStore

async aget_by_ids(ids: Sequence[str], /) → list[Document]#

通过ID异步获取文档。

返回的文档预计将具有ID字段，该字段设置为向量存储中文档的ID。

如果某些ID未找到或存在重复的ID，返回的文档数量可能少于请求的数量。

用户不应假设返回文档的顺序与输入ID的顺序相匹配。相反，用户应依赖返回文档的ID字段。

如果没有找到某些ID的文档，此方法不应引发异常。

Parameters:: ids (Sequence[str]) – 要检索的ID列表。
Returns:: 文档列表。
Return type:: 列表[Document]

在版本0.2.11中添加。

async amax_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → list[Document]#

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

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
fetch_k (int) – 要传递给MMR算法的文档数量。默认值为20。
lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。
kwargs (Any)

Returns:

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

Return type:

列表[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) – 返回的文档数量。默认为4。
fetch_k (int) – 要传递给MMR算法的文档数量。默认值为20。
lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。
**kwargs (Any) – 传递给搜索方法的参数。

Returns:

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

Return type:

列表[Document]

as_retriever(**kwargs: Any) → VectorStoreRetriever#

返回从此VectorStore初始化的VectorStoreRetriever。

Parameters:

**kwargs (Any) –

传递给搜索函数的关键字参数。可以包括： search_type (Optional[str]): 定义检索器应执行的搜索类型。可以是“similarity”（默认）、“mmr”或“similarity_score_threshold”。

检索器应执行的搜索类型。可以是“similarity”（默认）、“mmr”或“similarity_score_threshold”。

search_kwargs (Optional[Dict]): 传递给搜索函数的关键字参数。

可以包括以下内容：

k: 返回的文档数量（默认：4） score_threshold: 最小相关性阈值

用于similarity_score_threshold

fetch_k: 传递给MMR算法的文档数量: （默认：20）
lambda_mult: MMR返回结果的多样性；: 1表示最小多样性，0表示最大多样性。（默认：0.5）

filter: 按文档元数据过滤

Returns:

VectorStore的检索器类。

Return type:

VectorStoreRetriever

示例：

# Retrieve more documents with higher diversity
# Useful if your dataset has many similar documents
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 6, 'lambda_mult': 0.25}
)

# Fetch more documents for the MMR algorithm to consider
# But only return the top 5
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 5, 'fetch_k': 50}
)

# Only retrieve documents that have a relevance score
# Above a certain threshold
docsearch.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={'score_threshold': 0.8}
)

# Only get the single most similar document from the dataset
docsearch.as_retriever(search_kwargs={'k': 1})

# Use a filter to only retrieve documents from a specific paper
docsearch.as_retriever(
    search_kwargs={'filter': {'paper_title':'GPT-4 Technical Report'}}
)

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

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

Parameters:

query (str) – 输入文本。
search_type (str) – 要执行的搜索类型。可以是“similarity”、“mmr”或“similarity_score_threshold”。
**kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询最相似的文档列表。

Raises:

ValueError – 如果 search_type 不是 “similarity”、“mmr” 或 “similarity_score_threshold” 之一。

Return type:

列表[Document]

async asimilarity_search(query: str, k: int = 4, **kwargs: Any) → list[Document]#

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

Parameters:

query (str) – 输入文本。
k (int) – 返回的文档数量。默认为4。
**kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询最相似的文档列表。

Return type:

列表[Document]

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

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

Parameters:

embedding (list[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
**kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询向量最相似的文档列表。

Return type:

列表[Document]

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

异步返回文档和相关度分数，范围在[0, 1]之间。

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

Parameters:

query (str) – 输入文本。
k (int) – 返回的文档数量。默认为4。
**kwargs (Any) –
传递给相似性搜索的kwargs。应包括： score_threshold: 可选，一个介于0到1之间的浮点值

过滤检索到的文档集

Returns:

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

Return type:

列表[元组[Document, 浮点数]]

async asimilarity_search_with_score(*args: Any, **kwargs: Any) → list[tuple[Document, float]]#

异步运行带有距离的相似性搜索。

Parameters:

*args (Any) – 传递给搜索方法的参数。
**kwargs (Any) – 传递给搜索方法的参数。

Returns:

(文档, 相似度分数) 的元组列表。

Return type:

列表[元组[Document, 浮点数]]

delete(ids: List[str] | None = None, **kwargs: Any) → bool[来源]#

删除数据集中的实体。

Parameters:

ids (Optional[List[str]], optional) – 要删除的文档ID。默认为 None。
**kwargs – 子类可能使用的其他关键字参数。 - filter (Optional[Dict[str, str]], optional): 用于删除的过滤器。 - delete_all (Optional[bool], optional): 是否删除整个数据集。

Returns:

删除操作是否成功。

Return type:

布尔

delete_dataset() → None[source]#

删除集合。

Return type:: 无

ds() → Any[source]#

Return type:: 任何

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

强制删除路径下的数据集。

Parameters:: path (str) – 要删除的数据集的路径。
Raises:: ValueError – 如果未安装deeplake。
Return type:: 无

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

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

Parameters:

documents (list[Document]) – 要添加到向量存储中的文档列表。
embedding (Embeddings) – 使用的嵌入函数。
kwargs (Any) – 额外的关键字参数。

Returns:

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

Return type:

VectorStore

classmethod from_texts(texts: List[str], embedding: Embeddings | None = None, metadatas: List[dict] | None = None, ids: List[str] | None = 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 = , … )

Parameters:

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 (可选[Embeddings]) – 嵌入函数。默认为 None。注意，在其他地方，它被称为 embedding_function。
metadatas (可选[列表[字典]]) – 元数据列表。默认为 None。
ids (可选[列表[字符串]]) – 文档ID列表。默认为None。
kwargs (Any) – 额外的关键字参数。

Returns:

Deep Lake 数据集。

Return type:

DeepLake

get_by_ids(ids: Sequence[str], /) → list[Document]#

通过ID获取文档。

返回的文档预计将具有ID字段，该字段设置为向量存储中文档的ID。

如果某些ID未找到或存在重复的ID，返回的文档数量可能少于请求的数量。

用户不应假设返回文档的顺序与输入ID的顺序相匹配。相反，用户应依赖返回文档的ID字段。

如果没有找到某些ID的文档，此方法不应引发异常。

Parameters:: ids (Sequence[str]) – 要检索的ID列表。
Returns:: 文档列表。
Return type:: 列表[Document]

在版本0.2.11中添加。

max_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, exec_option: str | None = None, **kwargs: Any) → List[Document][source]#

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

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

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
fetch_k (int) – MMR算法所需的文档数量。
lambda_mult (float) – 值介于0和1之间。0对应于最大多样性，1对应于最小多样性。默认值为0.5。
exec_option (str) –
支持3种执行搜索的方式。 - “python” - 在客户端上运行的纯Python实现。
可以用于存储在任何地方的数据。警告：不建议将此选项用于大数据集，因为可能会导致内存问题。
- ”compute_engine” - 高效的C++实现的Deep Lake计算引擎。
  在客户端上运行，可以用于存储在或连接到Deep Lake的任何数据。不能用于内存或本地数据集。
- ”tensor_db” - 高效的、完全托管的Tensor数据库。
  负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。要在此数据库中存储数据集，请在创建数据集时指定runtime = {“db_engine”: True}。
deep_memory (bool) – 是否使用深度记忆模型来改进搜索结果。如果在向量存储初始化时未指定deep_memory，则默认为False。如果为True，则距离度量设置为“deepmemory_distance”，这表示模型训练时使用的度量。搜索将使用深度记忆模型进行。如果为False，则距离度量设置为“COS”或用户指定的任何距离度量。
kwargs (Any) – 额外的关键字参数

Returns:

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

Raises:

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

Return type:

列表[文档]

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

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

示例： >>> data = vector_store.max_marginal_relevance_search_by_vector( … embedding=, … fetch_k=, … k=, … exec_option=, … )

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
fetch_k (int) – 为MMR算法获取的文档数量。
lambda_mult (float) – 介于0和1之间的数字，决定多样性程度。 0对应最大多样性，1对应最小多样性。默认值为0.5。
exec_option (str) –
DeepLakeVectorStore 支持3种搜索方式。可以是“python”、“compute_engine”或“tensor_db”。默认为 “python”。 - “python” - 在客户端上运行的纯Python实现。

可以用于存储在任何地方的数据。警告：不建议在大型数据集上使用此选项，因为可能会导致内存问题。
- ”compute_engine” - 高性能的C++实现的Deep
  Lake计算引擎。在客户端上运行，可以用于存储在或连接到Deep Lake的任何数据。不能用于内存或本地数据集。
- ”tensor_db” - 高性能、完全托管的Tensor数据库。
  负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。要将数据集存储在此数据库中，请在创建数据集时指定runtime = {“db_engine”: True}。
deep_memory (bool) – 是否使用深度记忆模型来改进搜索结果。如果在向量存储初始化时未指定deep_memory，则默认为False。如果为True，则距离度量设置为“deepmemory_distance”，这表示模型训练时使用的度量。搜索将使用深度记忆模型进行。如果为False，则距离度量设置为“COS”或用户指定的任何距离度量。
kwargs (Any) – 额外的关键字参数。

Returns:

List[Documents] - 文档列表。

Return type:

列表[文档]

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

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

Parameters:

query (str) – 输入文本
search_type (str) – 要执行的搜索类型。可以是“similarity”、“mmr”或“similarity_score_threshold”。
**kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询最相似的文档列表。

Raises:

ValueError – 如果 search_type 不是 “similarity”、“mmr” 或 “similarity_score_threshold” 之一。

Return type:

列表[Document]

similarity_search(query: str, k: int = 4, **kwargs: Any) → List[Document][来源]#

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

示例

>>> # Search using an embedding
>>> data = vector_store.similarity_search(
...     query=<your_query>,
...     k=<num_items>,
...     exec_option=<preferred_exec_option>,
... )
>>> # Run tql search:
>>> data = vector_store.similarity_search(
...     query=None,
...     tql="SELECT * WHERE id == <id>",
...     exec_option="compute_engine",
... )

Parameters:

k (int) – 返回的文档数量。默认为4。
query (str) – 用于查找相似文档的文本。
kwargs (Any) –
额外的关键字参数包括： 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’: 客户端的 Compute Engine 的 C++ 实现。
  不适用于内存或本地数据集。
- ’tensor_db’: 用于存储和查询的托管张量数据库。
  仅适用于 Deep Lake 托管数据库中的数据。在数据集创建期间使用 runtime = {“db_engine”: True}。
deep_memory (bool): 是否使用 Deep Memory 模型来改进
搜索结果。如果在向量存储初始化中未指定 deep_memory，则默认为 False。如果为 True，则距离度量设置为 “deepmemory_distance”，表示模型训练时使用的度量。搜索使用 Deep Memory 模型执行。如果为 False，则距离度量设置为 “COS” 或用户指定的任何距离度量。

Returns:

与查询向量最相似的文档列表。

Return type:

列表[Document]

similarity_search_by_vector(embedding: List[float] | ndarray, k: int = 4, **kwargs: Any) → List[Document][来源]#

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

示例

>>> # Search using an embedding
>>> data = vector_store.similarity_search_by_vector(
...    embedding=<your_embedding>,
...    k=<num_items_to_return>,
...    exec_option=<preferred_exec_option>,
... )

Parameters:

embedding (Union[List[float], np.ndarray]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
kwargs (Any) –
Additional keyword arguments including: filter (Union[Dict, Callable], optional):
Additional filter before embedding search. - Dict - Key-value search on tensors of htype json. True

if all key-value filters are satisfied. Dict = {“tensor_name_1”: {“key”: value},

”tensor_name_2”: {“key”: value}}
- Function - Any function compatible with
  deeplake.filter.
Defaults to None.
exec_option (str): Options for search execution include
”python”, “compute_engine”, or “tensor_db”. Defaults to “python”. - “python” - Pure-python implementation running on the client.

Can be used for data stored anywhere. WARNING: using this option with big datasets is discouraged due to potential memory issues.
- ”compute_engine” - Performant C++ implementation of the Deep
  Lake Compute Engine. Runs on the client and can be used for any data stored in or connected to Deep Lake. It cannot be used with in-memory or local datasets.
- ”tensor_db” - Performant, fully-hosted Managed Tensor Database.
  Responsible for storage and query execution. Only available for data stored in the Deep Lake Managed Database. To store datasets in this database, specify runtime = {“db_engine”: True} during dataset creation.
distance_metric (str): L2 for Euclidean, L1 for Nuclear,
max for L-infinity distance, cos for cosine similarity, ‘dot’ for dot product. Defaults to L2.

deep_memory (bool): Whether to use the Deep Memory model for improving
search results. Defaults to False if deep_memory is not specified in the Vector Store initialization. If True, the distance metric is set to “deepmemory_distance”, which represents the metric with which the model was trained. The search is performed using the Deep Memory model. If False, the distance metric is set to “COS” or whatever distance metric user specifies.

Returns:

与查询向量最相似的文档列表。

Return type:

列表[Document]

similarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → list[tuple[Document, float]]#

返回文档和相关度分数，范围在[0, 1]之间。

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

Parameters:

query (str) – 输入文本。
k (int) – 返回的文档数量。默认为4。
**kwargs (Any) –
传递给相似性搜索的kwargs。应包括： score_threshold: 可选，一个介于0到1之间的浮点值

用于过滤检索到的文档集。

Returns:

(文档, 相似度分数) 的元组列表。

Return type:

列表[元组[Document, 浮点数]]

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=, … embedding= … k=, … exec_option=, … )

Parameters:

query (str) – 要搜索的查询文本。
k (int) – 返回的结果数量。默认为4。
kwargs (Any) –
Additional keyword arguments. Some of these arguments are: distance_metric: L2 for Euclidean, L1 for Nuclear, max L-infinity

distance, cos for cosine similarity, ‘dot’ for dot product. Defaults to L2.
filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
embedding_function (Callable): Embedding function to use. Defaults to None.

exec_option (str): DeepLakeVectorStore supports 3 ways to perform
searching. It could be either “python”, “compute_engine” or “tensor_db”. Defaults to “python”. - “python” - Pure-python implementation running on the client.

Can be used for data stored anywhere. WARNING: using this option with big datasets is discouraged due to potential memory issues.
- ”compute_engine” - Performant C++ implementation of the Deep
  Lake Compute Engine. Runs on the client and can be used for any data stored in or connected to Deep Lake. It cannot be used with in-memory or local datasets.
- ”tensor_db” - Performant, fully-hosted Managed Tensor Database.
  Responsible for storage and query execution. Only available for data stored in the Deep Lake Managed Database. To store datasets in this database, specify runtime = {“db_engine”: True} during dataset creation.
deep_memory (bool): Whether to use the Deep Memory model for improving
search results. Defaults to False if deep_memory is not specified in the Vector Store initialization. If True, the distance metric is set to “deepmemory_distance”, which represents the metric with which the model was trained. The search is performed using the Deep Memory model. If False, the distance metric is set to “COS” or whatever distance metric user specifies.

Returns:

与查询最相似的文档列表: 带有浮点距离的文本。

Return type:

列表[元组[Document, 浮点数]]

使用 DeepLake 的示例