日本熟妇hd丰满老熟妇,中文字幕一区二区三区在线不卡 ,亚洲成片在线观看,免费女同在线一区二区

分組檢索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,代碼才能正常運行。

根據(jù)向量進行分組相似性檢索

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();



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

        // 構(gòu)建 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": {
        //
        //                     }
        //                 }
        //             ]
        //         }
        //     ]
        // }
    }
}

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

        // 構(gòu)建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();

        // 根據(jù)主鍵(對應的向量)進行分組相似性檢索
        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();

        // 構(gòu)建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();

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

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

帶有Sparse Vector的分組向量檢索

說明

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

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

        // 構(gòu)建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();

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

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

入?yún)⒚枋?/b>

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

說明

vectorid兩個入?yún)⑿枰x一使用,并保證其中一個不為空。

方法

必填

默認值

描述

groupByField( String groupByField )

-

按指定字段的值來分組檢索,目前不支持schema-free字段。

groupCount(int groupCount)

10

最多返回的分組個數(shù),盡力而為參數(shù),一般可以返回groupCount個分組。

groupTopk(int groupTopk)

1

每個分組返回groupTopk條相似性結(jié)果,盡力而為參數(shù),優(yōu)先級低于groupCount。

vector(Vector vector)

-

向量數(shù)據(jù)

sparseVector(Map(Integer, Float))

-

稀疏向量

id(String id)

-

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

filter(String filter)

-

過濾條件,需滿足SQL where子句規(guī)范,詳見

includeVector(bool includeVector)

false

是否返回向量數(shù)據(jù)

partition(String partition)

default

分區(qū)名稱

outputFields(List<String> outputFields)

-

返回文檔字段列表,默認返回所有文檔字段

outputField(String field)

-

vectorField(String)

-

使用多向量檢索的一個向量執(zhí)行分組檢索。

build()

-

-

構(gòu)造QueryDocRequest對象

出參描述

說明

返回結(jié)果為Response<List<Group>>對象,其中可獲取本次操作結(jié)果信息,如下表所示。

方法

返回類型

描述

示例

getCode()

int

返回值,參考返回狀態(tài)碼說明

0

getMessage()

String

返回消息

success

getRequestId()

String

請求唯一id

19215409-ea66-4db9-8764-26ce2eb5bb99

getOutput()

List<Group>

返回分組相似性檢索結(jié)果

        {
            "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