本文由簡體中文內容自動轉碼而成。阿里雲不保證此自動轉碼的準確性、完整性及時效性。本文内容請以簡體中文版本為準。

分組檢索Doc

更新時間:2024-07-13 00:20

本文介紹如何通過Java SDK在Collection中按分組進行相似性檢索。

前提條件

介面定義

Java(JSP)
// class DashVectorCollection

// 同步介面
public Response<List<Group>> queryGroupBy(QueryDocGroupByRequest queryDocGroupByRequest);

// 非同步介面
public ListenableFuture<Response<List<Group>>> queryGroupByAsync(QueryDocGroupByRequest queryDocGroupByRequest)

使用樣本

說明
  1. 需要使用您的api-key替換樣本中的YOUR_API_KEY、您的Cluster Endpoint替換樣本中的YOUR_CLUSTER_ENDPOINT,代碼才能正常運行。

根據向量進行分組相似性檢索

Java
package com.aliyun.dashvector;

import com.aliyun.dashvector.models.Doc;
import com.aliyun.dashvector.models.Group;
import com.aliyun.dashvector.models.Vector;
import com.aliyun.dashvector.models.requests.CreateCollectionRequest;
import com.aliyun.dashvector.models.requests.InsertDocRequest;
import com.aliyun.dashvector.models.requests.QueryDocGroupByRequest;
import com.aliyun.dashvector.models.responses.Response;
import com.aliyun.dashvector.proto.CollectionInfo;
import com.aliyun.dashvector.proto.FieldType;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        DashVectorClientConfig config =
                DashVectorClientConfig.builder()
                        .apiKey("YOUR_API_KEY")
                        .endpoint("YOUR_CLUSTER_ENDPOINT")
                        .timeout(30f)
                        .build();
        DashVectorClient client = new DashVectorClient(config);

        CreateCollectionRequest request = CreateCollectionRequest.builder()
                .name("group_demo")
                .dimension(4)
                .metric(CollectionInfo.Metric.dotproduct)
                .dataType(CollectionInfo.DataType.FLOAT)
                .filedSchema("document_id", FieldType.STRING)
                .filedSchema("chunk_id", FieldType.INT)
                .build();

        Response<Void> createResponse = client.create(request);
        assert createResponse.isSuccess();

        DashVectorCollection collection = client.get("group_demo");
        assert collection.isSuccess();

        List<Doc> docs = new ArrayList<>();
        for (int i = 0; i < 6; i++) {
            int finalI = i;
            docs.add(
                    Doc.builder()
                            .id(Integer.toString(i+3))
                            .vector(Vector.builder().value(Collections.nCopies(4, (float) i+3)).build())
                            .fields(
                                    new HashMap<String, Object>() {
                                        {
                                            put("document_id", "paper" + finalI % 3);
                                            put("chunk_id", finalI);
                                        }
                                    }
                            )
                            .build());
        }

        InsertDocRequest insertRequest = InsertDocRequest.builder().docs(docs).build();
        Response<Void> insertResponse = collection.insert(insertRequest);
        assert insertResponse.isSuccess();



        // 構建Vector
        Vector queryVector = Vector.builder().value(Arrays.asList(0.1f, 0.2f, 0.3f, 0.4f)).build();

        // 構建 QueryDocGroupByRequest
        QueryDocGroupByRequest queryDocGroupByRequest =
                QueryDocGroupByRequest.builder().includeVector(true).vector(queryVector)
                        .groupByField("document_id")
                        .groupCount(2)
                        .groupTopk(3)
                        .build();

        // 進行分組Doc檢索
        Response<List<Group>> response = collection.queryGroupBy(queryDocGroupByRequest);

        // 判斷是否成功
        assert response.isSuccess();

        System.out.println(response);
        // example output:
        // {
        //     "code": 0,
        //     "message": "Success",
        //     "requestId": "47404048-6f40-47ad-9d62-2675704afb26",
        //     "output": [
        //         {
        //             "groupId": "paper2",
        //             "docs": [
        //                 {
        //                     "id": "8",
        //                     "vector": {
        //                         "value": [
        //                             8.0,
        //                             8.0,
        //                             8.0,
        //                             8.0
        //                         ]
        //                     },
        //                     "fields": {
        //                         "document_id": "paper2",
        //                         "chunk_id": 5
        //                     },
        //                     "score": 8.0,
        //                     "sparseVector": {
        //
        //                     }
        //                 },
        //                 {
        //                     "id": "5",
        //                     "vector": {
        //                         "value": [
        //                             5.0,
        //                             5.0,
        //                             5.0,
        //                             5.0
        //                         ]
        //                     },
        //                     "fields": {
        //                         "document_id": "paper2",
        //                         "chunk_id": 2
        //                     },
        //                     "score": 5.0,
        //                     "sparseVector": {
        //
        //                     }
        //                 }
        //             ]
        //         },
        //         {
        //             "groupId": "paper1",
        //             "docs": [
        //                 {
        //                     "id": "7",
        //                     "vector": {
        //                         "value": [
        //                             7.0,
        //                             7.0,
        //                             7.0,
        //                             7.0
        //                         ]
        //                     },
        //                     "fields": {
        //                         "document_id": "paper1",
        //                         "chunk_id": 4
        //                     },
        //                     "score": 7.0,
        //                     "sparseVector": {
        //
        //                     }
        //                 },
        //                 {
        //                     "id": "4",
        //                     "vector": {
        //                         "value": [
        //                             4.0,
        //                             4.0,
        //                             4.0,
        //                             4.0
        //                         ]
        //                     },
        //                     "fields": {
        //                         "document_id": "paper1",
        //                         "chunk_id": 1
        //                     },
        //                     "score": 4.0,
        //                     "sparseVector": {
        //
        //                     }
        //                 }
        //             ]
        //         }
        //     ]
        // }
    }
}

根據主鍵(對應的向量)進行分組相似性檢索

Java
        // 構建QueryDocGroupByRequest
        QueryDocGroupByRequest request = QueryDocGroupByRequest.builder()
                .groupByField("age")          
                .id("1")
                .groupCount(10)  // 返回10個分組
                .groupTopk(10)   // 每個分組最多返回10個doc
                .outputFields(Arrays.asList("name", "age")) // 僅返回name、age這2個Field
                .includeVector(true)
                .build();

        // 根據主鍵(對應的向量)進行分組相似性檢索
        Response<List<Group>> response2 = collection.queryGroupBy(request);

        // 判斷檢索是否成功
        assert response2.isSuccess();

帶過濾條件的分組相似性檢索

Java
        Vector vector = Vector.builder().value(Arrays.asList(0.1f, 0.2f, 0.3f, 0.4f)).build();

        // 構建QueryDocGroupByRequest
        QueryDocGroupByRequest request = QueryDocGroupByRequest.builder()
                .groupByField("age")          
                .vector(vector)
                .filter("age > 18") // 條件過濾,僅對age > 18的Doc進行相似性檢索
                .outputFields(Arrays.asList("name", "age")) // 僅返回name、age這2個Field
                .includeVector(true)
                .build();

        // 根據向量或者主鍵進行分組相似性檢索 + 條件過濾
        Response<List<Group>> response = collection.queryGroupBy(request);

        // 判斷檢索是否成功
        assert response.isSuccess();

帶有Sparse Vector的分組向量檢索

說明

Sparse Vector(稀疏向量)可用於關鍵詞權重表示,實現帶關鍵詞感知能力的向量檢索

Java
        Vector vector = Vector.builder().value(Arrays.asList(0.1f, 0.2f, 0.3f, 0.4f)).build();

        // 構建QueryDocGroupByRequest
        QueryDocGroupByRequest request = QueryDocGroupByRequest.builder()
                .groupByField("age")          
                .vector(vector)
                .sparseVector(
                        new Map<Integer, Float>() {
                            {
                                put(1, 0.4f);
                                put(10000, 0.6f);
                                put(222222, 0.8f);
                            }
                        }) // 稀疏向量
                .build();

        //根據向量進行分組相似性檢索 + 稀疏向量
        Response<List<Group>> response = collection.queryGroupBy(request);

        // 判斷檢索是否成功
        assert response.isSuccess();

入參描述

可通過QueryDocGroupByRequest.builder()構造QueryDocGroupByRequest對象,其可用方法如下表所示:

說明

vectorid兩個入參需要二選一使用,並保證其中一個不為空白。

方法

必填

預設值

描述

groupByField( String groupByField )

-

按指定欄位的值來分組檢索,目前不支援schema-free欄位。

groupCount(int groupCount)

10

最多返回的分組個數,儘力而為參數,一般可以返回groupCount個分組。

groupTopk(int groupTopk)

1

每個分組返回groupTopk條相似性結果,儘力而為參數,優先順序低於groupCount。

vector(Vector vector)

-

向量資料

sparseVector(Map(Integer, Float))

-

稀疏向量

id(String id)

-

主鍵,表示根據主鍵對應的向量進行相似性檢索

filter(String filter)

-

過濾條件,需滿足SQL where子句規範,詳見

includeVector(bool includeVector)

false

是否返迴向量資料

partition(String partition)

default

分區名稱

outputFields(List<String> outputFields)

-

返迴文檔欄位列表,預設返回所有文檔欄位

outputField(String field)

-

build()

-

-

構造QueryDocRequest對象

出參描述

說明

返回結果為Response<List<Group>>對象,其中可擷取本次操作結果資訊,如下表所示。

方法

傳回型別

描述

樣本

getCode()

int

傳回值,參考返回狀態代碼說明

0

getMessage()

String

返回訊息

success

getRequestId()

String

請求唯一id

19215409-ea66-4db9-8764-26ce2eb5bb99

getOutput()

List<Group>

返回分組相似性檢索結果

        {
            "groupId": "20",
            "docs": [
                {
                    "id": "2",
                    "vector": {
                        "value": [
                            0.475044,
                            0.906511,
                            0.60797,
                            0.573515
                        ]
                    },
                    "fields": {
                        "name": "lisi",
                        "weight": 45.0,
                        "male": false,
                        "age": 20
                    },
                    "score": 0.6406033,
                    "sparseVector": {

                    }
                }
            ]
        }

isSuccess()

Boolean

判斷請求是否成功

true

  • 本頁導讀 (1, M)
  • 前提條件
  • 介面定義
  • 使用樣本
  • 根據向量進行分組相似性檢索
  • 根據主鍵(對應的向量)進行分組相似性檢索
  • 帶過濾條件的分組相似性檢索
  • 帶有Sparse Vector的分組向量檢索
  • 入參描述
  • 出參描述
文檔反饋