Gunakan Kunci Partisi

Kunci Partisi adalah solusi pengoptimalan pencarian berdasarkan partisi. Dengan menetapkan bidang skalar tertentu sebagai Kunci Partisi dan menentukan kondisi pemfilteran berdasarkan Kunci Partisi selama pencarian, cakupan pencarian dapat dipersempit menjadi beberapa partisi, sehingga meningkatkan efisiensi pencarian. Artikel ini akan memperkenalkan cara menggunakan Kunci Partisi dan pertimbangan terkait.

Gambaran Umum

Di Milvus, Anda dapat menggunakan partisi untuk mengimplementasikan pemisahan data dan meningkatkan performa pencarian dengan membatasi cakupan pencarian ke partisi tertentu. Jika Anda memilih untuk mengelola partisi secara manual, Anda dapat membuat maksimal 1.024 partisi dalam koleksi, dan menyisipkan entitas ke dalam partisi-partisi ini berdasarkan aturan tertentu sehingga Anda dapat mempersempit cakupan pencarian dengan membatasi pencarian dalam sejumlah partisi tertentu.

Milvus memperkenalkan Kunci Partisi agar Anda dapat menggunakan kembali partisi dalam pemisahan data untuk mengatasi batas jumlah partisi yang dapat Anda buat dalam koleksi. Ketika membuat koleksi, Anda dapat menggunakan bidang skalar sebagai Kunci Partisi. Setelah koleksi siap, Milvus akan membuat jumlah partisi yang ditentukan di dalam koleksi. Setelah menerima entitas yang dimasukkan, Milvus menghitung nilai hash menggunakan nilai Partition Key dari entitas, mengeksekusi operasi modulo berdasarkan nilai hash dan properti partitions_num dari koleksi untuk mendapatkan ID partisi target, dan menyimpan entitas di partisi target.

Partisi Vs Kunci Partisi

Gambar berikut ini mengilustrasikan bagaimana Milvus memproses permintaan pencarian di dalam koleksi dengan atau tanpa mengaktifkan fitur Kunci Partisi.

• Jika Kunci Partisi dinonaktifkan, Milvus akan mencari entitas yang paling mirip dengan vektor kueri di dalam koleksi. Anda dapat mempersempit cakupan pencarian jika Anda mengetahui partisi mana yang berisi hasil yang paling relevan.

• Jika Kunci Partisi diaktifkan, Milvus menentukan cakupan pencarian berdasarkan nilai Kunci Partisi yang ditentukan dalam filter pencarian dan hanya memindai entitas di dalam partisi yang cocok.

Dengan dan Tanpa Kunci Partisi

Menggunakan Kunci Partisi

Untuk menggunakan Kunci Partisi, Anda perlu

• Mengatur Kunci Partisi,

• Mengatur jumlah partisi yang akan dibuat (Opsional), dan

• Buat kondisi pemfilteran berdasarkan Kunci Partisi.

Mengatur Kunci Partisi

Untuk menetapkan bidang skalar sebagai Kunci Partisi, Anda perlu mengatur atribut is_partition_key ke true saat Anda menambahkan bidang skalar.

from pymilvus import (
    MilvusClient, DataType
)

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

schema = client.create_schema()

schema.add_field(field_name="id",
    datatype=DataType.INT64,
    is_primary=True)
    
schema.add_field(field_name="vector",
    datatype=DataType.FLOAT_VECTOR,
    dim=5)

# Add the partition key
schema.add_field(
    field_name="my_varchar", 
    datatype=DataType.VARCHAR, 
    max_length=512,
    is_partition_key=True,
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());

// Create schema
CreateCollectionReq.CollectionSchema schema = client.createSchema();

schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("vector")
        .dataType(DataType.FloatVector)
        .dimension(5)
        .build());
        
// Add the partition key
schema.addField(AddFieldReq.builder()
        .fieldName("my_varchar")
        .dataType(DataType.VarChar)
        .maxLength(512)
        .isPartitionKey(true)
        .build());

import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/index"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

milvusAddr := "localhost:19530"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

schema := entity.NewSchema().WithDynamicFieldEnabled(false)
schema.WithField(entity.NewField().
    WithName("id").
    WithDataType(entity.FieldTypeInt64).
    WithIsPrimaryKey(true),
).WithField(entity.NewField().
    WithName("my_varchar").
    WithDataType(entity.FieldTypeVarChar).
    WithIsPartitionKey(true).
    WithMaxLength(512),
).WithField(entity.NewField().
    WithName("vector").
    WithDataType(entity.FieldTypeFloatVector).
    WithDim(5),
)

import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const address = "http://localhost:19530";
const token = "root:Milvus";
const client = new MilvusClient({address, token});

// 3. Create a collection in customized setup mode
// 3.1 Define fields
const fields = [
    {
        name: "my_varchar",
        data_type: DataType.VarChar,
        max_length: 512,
        is_partition_key: true
    }
]

export schema='{
        "autoId": true,
        "enabledDynamicField": false,
        "fields": [
            {
                "fieldName": "id",
                "dataType": "Int64",
                "isPrimary": true
            },
            {
                "fieldName": "vector",
                "dataType": "FloatVector",
                "elementTypeParams": {
                    "dim": "5"
                }
            },
            {
                "fieldName": "my_varchar",
                "dataType": "VarChar",
                "isPartitionKey": true,
                "elementTypeParams": {
                    "max_length": 512
                }
            }
        ]
    }'

Mengatur Nomor Partisi

Ketika Anda menetapkan sebuah bidang skalar dalam koleksi sebagai Kunci Partisi, Milvus secara otomatis membuat 16 partisi dalam koleksi. Setelah menerima sebuah entitas, Milvus memilih partisi berdasarkan nilai Partition Key dari entitas tersebut dan menyimpan entitas di dalam partisi, sehingga beberapa atau semua partisi menyimpan entitas dengan nilai Partition Key yang berbeda.

Anda juga dapat menentukan jumlah partisi yang akan dibuat bersama dengan koleksi. Hal ini hanya berlaku jika Anda memiliki bidang skalar yang ditetapkan sebagai Kunci Partisi.

client.create_collection(
    collection_name="my_collection",
    schema=schema,
    num_partitions=128
)

import io.milvus.v2.service.collection.request.CreateCollectionReq;

CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
                .collectionName("my_collection")
                .collectionSchema(schema)
                .numPartitions(128)
                .build();
        client.createCollection(createCollectionReq);

err = client.CreateCollection(ctx,
    milvusclient.NewCreateCollectionOption("my_collection", schema).
        WithNumPartitions(128))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

await client.create_collection({
    collection_name: "my_collection",
    schema: schema,
    num_partitions: 128
})

export params='{
    "partitionsNum": 128
}'

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"my_collection\",
    \"schema\": $schema,
    \"params\": $params
}"

Membuat Kondisi Pemfilteran

Ketika melakukan pencarian ANN dalam koleksi dengan fitur Partition Key diaktifkan, Anda perlu menyertakan ekspresi pemfilteran yang melibatkan Partition Key dalam permintaan pencarian. Dalam ekspresi pemfilteran, Anda dapat membatasi nilai Kunci Partisi dalam rentang tertentu sehingga Milvus membatasi cakupan pencarian dalam partisi yang sesuai.

Saat melakukan operasi penghapusan, disarankan untuk menyertakan ekspresi penyaringan yang menentukan kunci partisi tunggal untuk mencapai penghapusan yang lebih efisien. Pendekatan ini membatasi operasi penghapusan pada partisi tertentu, mengurangi amplifikasi penulisan selama pemadatan dan menghemat sumber daya untuk pemadatan dan pengindeksan.

Contoh berikut ini mendemonstrasikan pemfilteran berbasis Kunci Partisi berdasarkan nilai Kunci Partisi tertentu dan sekumpulan nilai Kunci Partisi.

# Filter based on a single partition key value, or
filter='partition_key == "x" && <other conditions>'

# Filter based on multiple partition key values
filter='partition_key in ["x", "y", "z"] && <other conditions>'

// Filter based on a single partition key value, or
String filter = "partition_key == 'x' && <other conditions>";

// Filter based on multiple partition key values
String filter = "partition_key in ['x', 'y', 'z'] && <other conditions>";

// Filter based on a single partition key value, or
filter = "partition_key == 'x' && <other conditions>"

// Filter based on multiple partition key values
filter = "partition_key in ['x', 'y', 'z'] && <other conditions>"

// Filter based on a single partition key value, or
const filter = 'partition_key == "x" && <other conditions>'

// Filter based on multiple partition key values
const filter = 'partition_key in ["x", "y", "z"] && <other conditions>'

# Filter based on a single partition key value, or
export filter='partition_key == "x" && <other conditions>'

# Filter based on multiple partition key values
export filter='partition_key in ["x", "y", "z"] && <other conditions>'

Menggunakan Isolasi Kunci Partisi

Dalam skenario multi-penyewaan, Anda dapat menetapkan bidang skalar yang terkait dengan identitas penyewa sebagai kunci partisi dan membuat filter berdasarkan nilai tertentu dalam bidang skalar ini. Untuk lebih meningkatkan kinerja pencarian dalam skenario serupa, Milvus memperkenalkan fitur Isolasi Kunci Partisi.

Isolasi Kunci Partisi

Seperti yang ditunjukkan pada gambar di atas, Milvus mengelompokkan entitas berdasarkan nilai Kunci Partisi dan membuat indeks terpisah untuk masing-masing kelompok ini. Setelah menerima permintaan pencarian, Milvus menempatkan indeks berdasarkan nilai Kunci Partisi yang ditentukan dalam kondisi pemfilteran dan membatasi cakupan pencarian di dalam entitas yang termasuk di dalam indeks, sehingga menghindari pemindaian entitas yang tidak relevan selama pencarian dan meningkatkan kinerja pencarian.

Setelah Anda mengaktifkan Isolasi Kunci Partisi, Anda harus menyertakan hanya satu nilai spesifik dalam filter berbasis kunci partisi sehingga Milvus dapat membatasi cakupan pencarian dalam entitas yang termasuk dalam indeks yang cocok.

Mengaktifkan Isolasi Kunci Partisi

Contoh kode berikut ini menunjukkan cara mengaktifkan Isolasi Kunci Partisi.

client.create_collection(
    collection_name="my_collection",
    schema=schema,
    properties={"partitionkey.isolation": True}
)

import io.milvus.v2.service.collection.request.CreateCollectionReq;

Map<String, String> properties = new HashMap<>();
properties.put("partitionkey.isolation", "true");

CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
        .collectionName("my_collection")
        .collectionSchema(schema)
        .properties(properties)
        .build();
client.createCollection(createCollectionReq);

err = client.CreateCollection(ctx,
    milvusclient.NewCreateCollectionOption("my_collection", schema).
        WithProperty("partitionkey.isolation", true))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

res = await client.alterCollection({
    collection_name: "my_collection",
    properties: {
        "partitionkey.isolation": true
    }
})

export params='{
    "partitionKeyIsolation": true
}'

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"my_collection\",
    \"schema\": $schema,
    \"params\": $params
}"

Setelah Anda mengaktifkan Isolasi Kunci Partisi, Anda masih dapat mengatur Kunci Partisi dan jumlah partisi seperti yang dijelaskan dalam Mengatur Nomor Partisi. Perhatikan bahwa filter berbasis Kunci-Partisi harus menyertakan hanya nilai Kunci Partisi tertentu.