Skip to content

Deeplake

DeepLakeVectorStore #

Bases: BasePydanticVectorStore

深湖向量存储。

在这个向量存储中，我们将文本、其嵌入和一些元数据存储在一个深湖数据集中。这个实现允许使用已经存在的深湖数据集，如果它是由这个向量存储创建的。它还支持创建一个新的数据集，如果数据集不存在或者overwrite设置为True。

示例

pip install llama-index-vector-stores-deeplake

from llama_index.vector_stores.deeplake import DeepLakeVectorStore

# 创建一个DeepLakeVectorStore的实例
vector_store = DeepLakeVectorStore(dataset_path=dataset_path, overwrite=True)
Source code in llama_index/vector_stores/deeplake/base.py 
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
class DeepLakeVectorStore(BasePydanticVectorStore):
    """深湖向量存储。

    在这个向量存储中，我们将文本、其嵌入和一些元数据存储在一个深湖数据集中。这个实现允许使用已经存在的深湖数据集，如果它是由这个向量存储创建的。它还支持创建一个新的数据集，如果数据集不存在或者`overwrite`设置为True。

    示例:
        `pip install llama-index-vector-stores-deeplake`

        ```python
        from llama_index.vector_stores.deeplake import DeepLakeVectorStore

        # 创建一个DeepLakeVectorStore的实例
        vector_store = DeepLakeVectorStore(dataset_path=dataset_path, overwrite=True)
        ```"""

    stores_text: bool = True
    flat_metadata: bool = True

    ingestion_batch_size: int
    num_workers: int
    token: Optional[str]
    read_only: Optional[bool]
    dataset_path: str

    _embedding_dimension: int = PrivateAttr()
    _ttl_seconds: Optional[int] = PrivateAttr()
    _deeplake_db: Any = PrivateAttr()
    _deeplake_db_collection: Any = PrivateAttr()
    _vectorstore: "VectorStore" = PrivateAttr()
    _id_tensor_name: str = PrivateAttr()

    def __init__(
        self,
        dataset_path: str = "llama_index",
        token: Optional[str] = None,
        read_only: Optional[bool] = False,
        ingestion_batch_size: int = 1024,
        ingestion_num_workers: int = 4,
        overwrite: bool = False,
        exec_option: Optional[str] = None,
        verbose: bool = True,
        **kwargs: Any,
    ) -> None:
        """Args:
    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”，它不保存数据集，而是将其保存在内存中。仅应用于测试，因为它不会持久保存。
        默认为“llama_index”。
    overwrite（bool，可选）：如果设置为True，则覆盖已存在的向量存储。默认为False。
    token（str，可选）：Activeloop令牌，用于获取用户凭据。这是可选的，令牌通常是自动生成的。默认为None。
    read_only（bool，可选）：如果为True，则以只读模式打开数据集。默认为False。
    ingestion_batch_size（int）：在数据摄入期间，数据被划分为批次。批次大小是每个批次的大小。默认为1024。
    ingestion_num_workers（int）：数据摄入期间要使用的工作程序数量。默认为4。
    exec_option（str）：搜索执行的默认方法。可以是“auto”、“python”、“compute_engine”或“tensor_db”。默认为“auto”。如果为None，则设置为“auto”。
        - “auto”- 根据向量存储的存储位置选择最佳执行方法。这是默认选项。
        - “python” - 在客户端上运行的纯Python实现，可用于存储在任何位置的数据。警告：不建议在大型数据集中使用此选项，因为它可能导致内存问题。
        - “compute_engine” - 在客户端上运行的Deep Lake计算引擎的高性能C++实现，可用于存储在Deep Lake中或连接到Deep Lake的任何数据。不能与内存或本地数据集一起使用。
        - “tensor_db” - 高性能且完全托管的托管张量数据库，负责存储和查询执行。仅适用于存储在Deep Lake托管数据库中的数据。通过在数据集创建期间指定runtime = {"tensor_db": True}来将数据集存储在此数据库中。

Raises:
    ImportError：无法导入`deeplake`。
"""
        super().__init__(
            dataset_path=dataset_path,
            token=token,
            read_only=read_only,
            ingestion_batch_size=ingestion_batch_size,
            num_workers=ingestion_num_workers,
        )

        if not DEEPLAKE_INSTALLED:
            raise ImportError(
                "Could not import deeplake python package. "
                "Please install it with `pip install deeplake`."
            )

        self._vectorstore = VectorStore(
            path=dataset_path,
            ingestion_batch_size=ingestion_batch_size,
            num_workers=ingestion_num_workers,
            token=token,
            read_only=read_only,
            exec_option=exec_option,
            overwrite=overwrite,
            verbose=verbose,
            **kwargs,
        )
        self._id_tensor_name = "ids" if "ids" in self._vectorstore.tensors() else "id"

    @property
    def client(self) -> Any:
        """获取客户端。

返回：
    任何：DeepLake向量存储数据集。
"""
        return self._vectorstore.dataset

    def add(self, nodes: List[BaseNode], **add_kwargs: Any) -> List[str]:
        """将嵌入和它们的节点添加到DeepLake中。

Args:
    nodes（List[BaseNode]）：具有嵌入的节点列表
        要插入的节点。

Returns:
    List[str]：插入的id列表。
"""
        embedding = []
        metadata = []
        id_ = []
        text = []

        for node in nodes:
            embedding.append(node.get_embedding())
            metadata.append(
                node_to_metadata_dict(
                    node, remove_text=False, flat_metadata=self.flat_metadata
                )
            )
            id_.append(node.node_id)
            text.append(node.get_content(metadata_mode=MetadataMode.NONE))

        kwargs = {
            "embedding": embedding,
            "metadata": metadata,
            self._id_tensor_name: id_,
            "text": text,
        }

        return self._vectorstore.add(
            return_ids=True,
            **kwargs,
        )

    def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """使用ref_doc_id删除节点。

Args:
    ref_doc_id（str）：要删除的文档的doc_id。
"""
        self._vectorstore.delete(filter={"metadata": {"doc_id": ref_doc_id}})

    def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
        """查询前k个最相似节点的索引。

Args:
    query (VectorStoreQuery): VectorStoreQuery类的输入，具有以下属性:
        1. query_embedding (List[float]): 查询嵌入
        2. similarity_top_k (int): 前k个最相似节点
    deep_memory (bool): 是否使用深度内存进行查询执行。

Returns:
    VectorStoreQueryResult
"""
        query_embedding = cast(List[float], query.query_embedding)
        exec_option = kwargs.get("exec_option")
        deep_memory = kwargs.get("deep_memory")
        data = self._vectorstore.search(
            embedding=query_embedding,
            exec_option=exec_option,
            k=query.similarity_top_k,
            filter=query.filters,
            deep_memory=deep_memory,
        )

        similarities = data["score"]
        ids = data[self._id_tensor_name]
        metadatas = data["metadata"]
        nodes = []
        for metadata in metadatas:
            nodes.append(metadata_dict_to_node(metadata))

        return VectorStoreQueryResult(nodes=nodes, similarities=similarities, ids=ids)

client property #

client: Any

获取客户端。

返回： 任何：DeepLake向量存储数据集。

add #

add(nodes: List[BaseNode], **add_kwargs: Any) -> List[str]

将嵌入和它们的节点添加到DeepLake中。

Returns:

Type Description
List[str]

List[str]：插入的id列表。
Source code in llama_index/vector_stores/deeplake/base.py 
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
    def add(self, nodes: List[BaseNode], **add_kwargs: Any) -> List[str]:
        """将嵌入和它们的节点添加到DeepLake中。

Args:
    nodes（List[BaseNode]）：具有嵌入的节点列表
        要插入的节点。

Returns:
    List[str]：插入的id列表。
"""
        embedding = []
        metadata = []
        id_ = []
        text = []

        for node in nodes:
            embedding.append(node.get_embedding())
            metadata.append(
                node_to_metadata_dict(
                    node, remove_text=False, flat_metadata=self.flat_metadata
                )
            )
            id_.append(node.node_id)
            text.append(node.get_content(metadata_mode=MetadataMode.NONE))

        kwargs = {
            "embedding": embedding,
            "metadata": metadata,
            self._id_tensor_name: id_,
            "text": text,
        }

        return self._vectorstore.add(
            return_ids=True,
            **kwargs,
        )

delete #

delete(ref_doc_id: str, **delete_kwargs: Any) -> None

使用ref_doc_id删除节点。

Source code in llama_index/vector_stores/deeplake/base.py 
169
170
171
172
173
174
175
    def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """使用ref_doc_id删除节点。

Args:
    ref_doc_id（str）：要删除的文档的doc_id。
"""
        self._vectorstore.delete(filter={"metadata": {"doc_id": ref_doc_id}})

query #

query(
    query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult

查询前k个最相似节点的索引。

Parameters:

Name Type Description Default
query VectorStoreQuery

VectorStoreQuery类的输入，具有以下属性: 1. query_embedding (List[float]): 查询嵌入 2. similarity_top_k (int): 前k个最相似节点

 required
deep_memory bool

是否使用深度内存进行查询执行。

 required

Returns:

Type Description
VectorStoreQueryResult

VectorStoreQueryResult
Source code in llama_index/vector_stores/deeplake/base.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
    def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
        """查询前k个最相似节点的索引。

Args:
    query (VectorStoreQuery): VectorStoreQuery类的输入，具有以下属性:
        1. query_embedding (List[float]): 查询嵌入
        2. similarity_top_k (int): 前k个最相似节点
    deep_memory (bool): 是否使用深度内存进行查询执行。

Returns:
    VectorStoreQueryResult
"""
        query_embedding = cast(List[float], query.query_embedding)
        exec_option = kwargs.get("exec_option")
        deep_memory = kwargs.get("deep_memory")
        data = self._vectorstore.search(
            embedding=query_embedding,
            exec_option=exec_option,
            k=query.similarity_top_k,
            filter=query.filters,
            deep_memory=deep_memory,
        )

        similarities = data["score"]
        ids = data[self._id_tensor_name]
        metadatas = data["metadata"]
        nodes = []
        for metadata in metadatas:
            nodes.append(metadata_dict_to_node(metadata))

        return VectorStoreQueryResult(nodes=nodes, similarities=similarities, ids=ids)