文档

分组检索Doc

更新时间:

本文介绍如何通过Java SDK在Collection中按分组进行相似性检索。

前提条件

接口定义

// 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,代码才能正常运行。

根据向量进行分组相似性检索

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": {
        //
        //                     }
        //                 }
        //             ]
        //         }
        //     ]
        // }
    }
}

根据主键(对应的向量)进行分组相似性检索

        // 构建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();

带过滤条件的分组相似性检索

        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(稀疏向量)可用于关键词权重表示,实现带关键词感知能力的向量检索

        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