Utilizar Partition Key

La clave de partición es una solución de optimización de la búsqueda basada en particiones. Al designar un campo escalar específico como Clave de Partición y especificar condiciones de filtrado basadas en la Clave de Partición durante la búsqueda, el ámbito de búsqueda puede reducirse a varias particiones, mejorando así la eficiencia de la búsqueda. Este artículo presenta cómo utilizar la Clave de Partición y las consideraciones relacionadas.

Visión general

En Milvus, puede utilizar particiones para implementar la segregación de datos y mejorar el rendimiento de la búsqueda restringiendo el alcance de la búsqueda a particiones específicas. Si elige gestionar las particiones manualmente, puede crear un máximo de 1.024 particiones en una colección, e insertar entidades en estas particiones basándose en una regla específica para que pueda limitar el alcance de la búsqueda restringiendo las búsquedas dentro de un número específico de particiones.

Milvus introduce la Clave de partición para que pueda reutilizar particiones en la segregación de datos para superar el límite en el número de particiones que puede crear en una colección. Al crear una colección, puede utilizar un campo escalar como clave de partición. Una vez que la colección está lista, Milvus crea el número especificado de particiones dentro de la colección con cada partición correspondiente a un rango de los valores en la Clave de Partición. Al recibir las entidades insertadas, Milvus las almacena en diferentes particiones basándose en sus valores de Clave de Partición.

Partición v.s. Clave de Partición

La siguiente figura ilustra cómo Milvus procesa las peticiones de búsqueda en una colección con o sin la función Partition Key activada.

• Si la Clave de partición está desactivada, Milvus busca las entidades más similares al vector de consulta dentro de la colección. Puede limitar el alcance de la búsqueda si sabe qué partición contiene los resultados más relevantes.

• Si la Clave de Partición está activada, Milvus determina el ámbito de búsqueda basándose en el valor de la Clave de Partición especificado en un filtro de búsqueda y explora sólo las entidades dentro de las particiones que coinciden.

Con o Sin Clave de Partición

Usar Clave de Partición

Para utilizar la Clave de Partición, debe

• Establecer la Clave de Partición.

• Establecer el número de particiones a crear (Opcional), y

• Crear una condición de filtrado basada en la Clave de Partición.

Establecer la Clave de Partición

Para designar un campo escalar como la Clave de Partición, necesitas establecer su atributo is_partition_key a true cuando añadas el campo escalar.

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
                }
            }
        ]
    }'

Establecer números de partición

Cuando designa un campo escalar en una colección como Clave de Partición, Milvus crea automáticamente 16 particiones en la colección. Al recibir una entidad, Milvus elige una partición basándose en el valor de la Clave de Partición de esta entidad y almacena la entidad en la partición, dando como resultado que algunas o todas las particiones contengan entidades con diferentes valores de Clave de Partición.

También puede determinar el número de particiones a crear junto con la colección. Esto sólo es válido si tienes un campo escalar designado como Clave de Partición.

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

Crear condición de filtrado

Al realizar búsquedas RNA en una colección con la función Clave de partición activada, debe incluir una expresión de filtrado que incluya la Clave de partición en la solicitud de búsqueda. En la expresión de filtrado, puede restringir el valor de la Clave de Partición dentro de un rango específico para que Milvus restrinja el ámbito de búsqueda dentro de las particiones correspondientes.

Los siguientes ejemplos demuestran el filtrado basado en Clave de Partición basado en un valor específico de Clave de Partición y un conjunto de valores de Clave de Partición.

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