Partitionsschlüssel verwenden

Der Partitionsschlüssel ist eine Lösung zur Suchoptimierung auf der Grundlage von Partitionen. Indem man ein bestimmtes skalares Feld als Partitionsschlüssel bestimmt und während der Suche Filterbedingungen auf der Grundlage des Partitionsschlüssels festlegt, kann der Suchbereich auf mehrere Partitionen eingegrenzt werden, wodurch die Sucheffizienz verbessert wird. In diesem Artikel werden die Verwendung des Partitionsschlüssels und damit verbundene Überlegungen vorgestellt.

Überblick

In Milvus können Sie Partitionen verwenden, um eine Datentrennung zu implementieren und die Suchleistung zu verbessern, indem Sie den Suchbereich auf bestimmte Partitionen beschränken. Wenn Sie sich für die manuelle Verwaltung von Partitionen entscheiden, können Sie maximal 1.024 Partitionen in einer Sammlung erstellen und Entitäten auf der Grundlage einer bestimmten Regel in diese Partitionen einfügen, so dass Sie den Suchbereich einschränken können, indem Sie die Suche auf eine bestimmte Anzahl von Partitionen beschränken.

Milvus führt den Partitionsschlüssel ein, mit dem Sie Partitionen in der Datentrennung wiederverwenden können, um die Begrenzung der Anzahl der Partitionen zu überwinden, die Sie in einer Sammlung erstellen können. Bei der Erstellung einer Sammlung können Sie ein skalares Feld als Partitionsschlüssel verwenden. Sobald die Sammlung fertig ist, erstellt Milvus die angegebene Anzahl von Unterteilungen innerhalb der Sammlung, wobei jede Unterteilung einem Bereich der Werte im Unterteilungsschlüssel entspricht. Nach dem Empfang der eingefügten Entitäten speichert Milvus diese in verschiedenen Partitionen auf der Grundlage ihrer Partitionsschlüsselwerte.

Partition vs. Partitionsschlüssel

Die folgende Abbildung zeigt, wie Milvus die Suchanfragen in einer Sammlung mit und ohne aktivierter Partitionsschlüssel-Funktion verarbeitet.

• Wenn der Partitionsschlüssel deaktiviert ist, sucht Milvus nach Entitäten, die dem Abfragevektor innerhalb der Sammlung am ähnlichsten sind. Sie können den Suchbereich eingrenzen, wenn Sie wissen, welche Partition die relevantesten Ergebnisse enthält.

• Wenn der Partitionsschlüssel aktiviert ist, bestimmt Milvus den Suchbereich auf der Grundlage des in einem Suchfilter angegebenen Partitionsschlüsselwertes und durchsucht nur die Entitäten innerhalb der Partitionen, die übereinstimmen.

Mit oder ohne Partitionsschlüssel

Partitionsschlüssel verwenden

Um den Partitionsschlüssel zu verwenden, müssen Sie

• Legen Sie den Partitionsschlüssel fest.

• die Anzahl der zu erstellenden Partitionen festlegen (optional), und

• eine Filterbedingung auf der Grundlage des Partitionsschlüssels erstellen.

Partitionsschlüssel festlegen

Um ein skalares Feld als Partitionsschlüssel zu bestimmen, müssen Sie sein is_partition_key Attribut auf true setzen, wenn Sie das skalare Feld hinzufügen.

from pymilvus import (
    MilvusClient, DataType
)

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

schema = client.create_schema()

# Add the partition key
schema.add_field(
    field_name="my_varchar", 
    datatype=DataType.VARCHAR, 
    max_length=512,
    # highlight-next-line
    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();

// Add the partition key
schema.addField(AddFieldReq.builder()
        .fieldName("my_varchar")
        .dataType(DataType.VarChar)
        .maxLength(512)
        // highlight-next-line
        .isPartitionKey(true)
        .build());

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,
        // highlight-next-line
        is_partition_key: true
    }
]

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

Partitionsnummern festlegen

Wenn Sie ein skalares Feld in einer Sammlung als Partitionsschlüssel festlegen, erstellt Milvus automatisch 16 Partitionen in der Sammlung. Beim Empfang einer Entität wählt Milvus eine Partition basierend auf dem Partitionsschlüsselwert dieser Entität aus und speichert die Entität in der Partition, was dazu führt, dass einige oder alle Partitionen Entitäten mit unterschiedlichen Partitionsschlüsselwerten enthalten.

Sie können auch die Anzahl der Partitionen bestimmen, die zusammen mit der Sammlung erstellt werden sollen. Dies gilt nur, wenn Sie ein skalares Feld als Partitionsschlüssel festgelegt haben.

client.create_collection(
    collection_name="my_collection",
    schema=schema,
    # highlight-next-line
    num_partitions=1024
)

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

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

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

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

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\": \"myCollection\",
    \"schema\": $schema,
    \"params\": $params
}"

Filterungsbedingung erstellen

Wenn Sie ANN-Suchen in einer Sammlung mit aktivierter Partitionsschlüssel-Funktion durchführen, müssen Sie einen Filterausdruck mit dem Partitionsschlüssel in die Suchanfrage aufnehmen. In dem Filterausdruck können Sie den Wert des Partitionsschlüssels innerhalb eines bestimmten Bereichs einschränken, so dass Milvus den Suchbereich auf die entsprechenden Partitionen beschränkt.

Die folgenden Beispiele demonstrieren die Partition-Key-basierte Filterung basierend auf einem bestimmten Partition-Key-Wert und einem Satz von Partition-Key-Werten.

# 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
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>'