Explicação do esquema

Um esquema define a estrutura de dados de uma coleção. Antes de criar uma coleção, é necessário definir o desenho do seu esquema. Esta página ajuda-o a compreender o esquema da coleção e a conceber um esquema de exemplo por si próprio.

Visão geral

No Milvus, o esquema de uma coleção corresponde a uma tabela numa base de dados relacional, que define a forma como o Milvus organiza os dados na coleção.

Um esquema bem concebido é essencial, uma vez que abstrai o modelo de dados e determina se é possível atingir os objetivos de negócio através de uma pesquisa. Além disso, como cada linha de dados inserida na coleção deve seguir o esquema, este ajuda a manter a consistência dos dados e a qualidade a longo prazo. De uma perspetiva técnica, um esquema bem definido conduz a um armazenamento de dados em colunas bem organizado e a uma estrutura de índices mais clara, melhorando o desempenho da pesquisa.

Um esquema de coleção tem uma chave primária, pelo menos um campo vetorial e vários campos escalares. O diagrama seguinte ilustra como mapear um artigo para uma lista de campos do esquema.

Anatomia do Design do Esquema

O projeto do modelo de dados de um sistema de pesquisa envolve a análise das necessidades de negócio e a abstração da informação num modelo de dados expresso através de um esquema. Por exemplo, a pesquisa de um trecho de texto deve ser «indexada» através da conversão da cadeia de caracteres literal num vetor por meio de «incorporação» e da ativação da pesquisa vetorial. Para além deste requisito essencial, poderá ser necessário armazenar outras propriedades, tais como a data e hora de publicação e o autor. Estes metadados permitem refinar as pesquisas semânticas através de filtragem, devolvendo apenas textos publicados após uma data específica ou por um autor em particular. Também é possível recuperar estes valores escalares juntamente com o texto principal para apresentar o resultado da pesquisa na aplicação. A cada um deve ser atribuído um identificador único para organizar estes fragmentos de texto, expresso como um número inteiro ou uma cadeia de caracteres. Estes elementos são essenciais para alcançar uma lógica de pesquisa sofisticada.

Consulte o guia prático de conceção de esquemas para descobrir como criar um esquema bem concebido.

Criar esquema

O seguinte trecho de código demonstra como criar um esquema.

from pymilvus import MilvusClient, DataType

schema = MilvusClient.create_schema()

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

CreateCollectionReq.CollectionSchema schema = client.createSchema();

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

const schema = []

import "github.com/milvus-io/milvus/client/v2/entity"

schema := entity.NewSchema()

export schema='{
    "fields": []
}'

Adicionar campo primário

O campo primário numa coleção identifica de forma única uma entidade. Só aceita valores do tipo Int64 ou VARCHAR. Os trechos de código seguintes demonstram como adicionar o campo primário.

schema.add_field(
    field_name="my_id",
    datatype=DataType.INT64,
    is_primary=True,
    auto_id=False,
)

import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq; 

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

schema.push({
    name: "my_id",
    data_type: DataType.Int64,
    is_primary_key: true,
    autoID: false
});

schema.WithField(entity.NewField().WithName("my_id").
    WithDataType(entity.FieldTypeInt64).
    WithIsPrimaryKey(true).
    WithIsAutoID(false),
)

export primaryField='{
    "fieldName": "my_id",
    "dataType": "Int64",
    "isPrimary": true
}'

export schema='{
    \"autoID\": false,
    \"fields\": [
        $primaryField
    ]
}'

Ao adicionar um campo, pode especificá-lo explicitamente como campo primário, definindo a sua propriedade « is_primary » para « True ». Por predefinição, um campo primário aceita valores Int64. Neste caso, o valor do campo primário deve ser um número inteiro semelhante a « 12345 ». Se optar por utilizar valores VARCHAR no campo primário, o valor deve ser uma cadeia de caracteres semelhante a « my_entity_1234 ».

Também pode definir as propriedades autoId para True para que o Milvus atribua automaticamente valores ao campo primário aquando da inserção de dados.

Para mais detalhes, consulte «Campo primário e AutoId».

Adicionar campos vetoriais

Os campos vetoriais aceitam várias incorporações vetoriais esparsas e densas. No Milvus, pode adicionar quatro campos vetoriais a uma coleção. Os trechos de código seguintes demonstram como adicionar um campo vetorial.

schema.add_field(
    field_name="my_vector",
    datatype=DataType.FLOAT_VECTOR,
    dim=5
)

schema.addField(AddFieldReq.builder()
        .fieldName("my_vector")
        .dataType(DataType.FloatVector)
        .dimension(5)
        .build());

schema.push({
    name: "my_vector",
    data_type: DataType.FloatVector,
    dim: 5
});

schema.WithField(entity.NewField().WithName("my_vector").
    WithDataType(entity.FieldTypeFloatVector).
    WithDim(5),
)

export vectorField='{
    "fieldName": "my_vector",
    "dataType": "FloatVector",
    "elementTypeParams": {
        "dim": 5
    }
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $primaryField,
        $vectorField
    ]
}"

O parâmetro ` dim ` nos trechos de código acima indica a dimensionalidade das representações vetoriais a serem mantidas no campo vetorial. O valor ` FLOAT_VECTOR ` indica que o campo vetorial contém uma lista de números de ponto flutuante de 32 bits, que são normalmente utilizados para representar antilogaritmos. Além disso, o Milvus também suporta os seguintes tipos de representações vetoriais:

• FLOAT16_VECTOR

  Um campo vetorial deste tipo contém uma lista de números de ponto flutuante de meia precisão de 16 bits e aplica-se normalmente a cenários de aprendizagem profunda com restrições de memória ou largura de banda, ou a cenários de computação baseados em GPU.

• BFLOAT16_VECTOR

  Um campo vetorial deste tipo contém uma lista de números de ponto flutuante de 16 bits que têm precisão reduzida, mas o mesmo intervalo de expoentes que o Float32. Este tipo de dados é frequentemente utilizado em cenários de aprendizagem profunda, uma vez que reduz o consumo de memória sem afetar significativamente a precisão.

• INT8_VECTOR

  Um campo vetorial deste tipo armazena vetores compostos por inteiros assinados de 8 bits (int8), com cada componente variando entre –128 e 127. Concebido para arquiteturas de aprendizagem profunda quantizadas — tais como ResNet e EfficientNet —, reduz substancialmente o tamanho do modelo e aumenta a velocidade de inferência, tudo isto com uma perda de precisão mínima. Nota: Este tipo de vetor é suportado apenas para índices HNSW.

• BINARY_VECTOR

  Um campo vetorial deste tipo contém uma lista de 0s e 1s. Estes servem como características compactas para representar dados em cenários de processamento de imagens e recuperação de informação.

• SPARSE_FLOAT_VECTOR

  Um campo vetorial deste tipo contém uma lista de números diferentes de zero e os respetivos números de sequência para representar incorporações vetoriais esparsas.

Adicionar campos escalares

Em casos comuns, pode utilizar campos escalares para armazenar os metadados das incorporações vetoriais guardadas no Milvus e realizar pesquisas ANN com filtragem de metadados para melhorar a exatidão dos resultados da pesquisa. O Milvus suporta vários tipos de campos escalares, incluindo VARCHAR, Booleano, Int, Float e Double.

Adicionar campos VARCHAR

No Milvus, pode utilizar campos « VARCHAR » para armazenar cadeias de caracteres. Para mais informações sobre o campo « VARCHAR », consulte Campo VarChar.

schema.add_field(
    field_name="my_varchar",
    datatype=DataType.VARCHAR,
    max_length=512
)

schema.addField(AddFieldReq.builder()
        .fieldName("my_varchar")
        .dataType(DataType.VarChar)
        .maxLength(512)
        .build());

schema.push({
    name: "my_varchar",
    data_type: DataType.VarChar,
    max_length: 512
});

schema.WithField(entity.NewField().WithName("my_varchar").
    WithDataType(entity.FieldTypeVarChar).
    WithMaxLength(512),
)

export varCharField='{
    "fieldName": "my_varchar",
    "dataType": "VarChar",
    "elementTypeParams": {
        "max_length": 512
    }
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $primaryField,
        $vectorField,
        $varCharField
    ]
}"

Adicionar campos numéricos

Os tipos de números suportados pelo Milvus são Int8, Int16, Int32, Int64, Float e Double. Para mais informações sobre os campos numéricos, consulte Campo numérico.

schema.add_field(
    field_name="my_int64",
    datatype=DataType.INT64,
)

schema.addField(AddFieldReq.builder()
        .fieldName("my_int64")
        .dataType(DataType.Int64)
        .build());

schema.push({
    name: "my_int64",
    data_type: DataType.Int64,
});

schema.WithField(entity.NewField().WithName("my_int64").
    WithDataType(entity.FieldTypeInt64),
)

export int64Field='{
    "fieldName": "my_int64",
    "dataType": "Int64"
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $primaryField,
        $vectorField,
        $varCharField,
        $int64Field
    ]
}"

Adicionar campos booleanos

O Milvus suporta campos booleanos. Os trechos de código seguintes demonstram como adicionar um campo booleano.

schema.add_field(
    field_name="my_bool",
    datatype=DataType.BOOL,
)

schema.addField(AddFieldReq.builder()
        .fieldName("my_bool")
        .dataType(DataType.Bool)
        .build());

schema.push({
    name: "my_bool",
    data_type: DataType.Boolean,
});

schema.WithField(entity.NewField().WithName("my_bool").
    WithDataType(entity.FieldTypeBool),
)

export boolField='{
    "fieldName": "my_bool",
    "dataType": "Boolean"
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $primaryField,
        $vectorField,
        $varCharField,
        $int64Field,
        $boolField
    ]
}"

Adicionar campos compostos

No Milvus, um campo composto é um campo que pode ser dividido em subcampos mais pequenos, tais como as chaves num campo JSON ou os índices num campo Array.

Adicionar campos JSON

Um campo JSON armazena normalmente dados JSON semiestruturados. Para mais informações sobre os campos JSON, consulte Campo JSON.

schema.add_field(
    field_name="my_json",
    datatype=DataType.JSON,
)

schema.addField(AddFieldReq.builder()
        .fieldName("my_json")
        .dataType(DataType.JSON)
        .build());

schema.push({
    name: "my_json",
    data_type: DataType.JSON,
});

schema.WithField(entity.NewField().WithName("my_json").
    WithDataType(entity.FieldTypeJSON),
)

export jsonField='{
    "fieldName": "my_json",
    "dataType": "JSON"
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $primaryField,
        $vectorField,
        $varCharField,
        $int64Field,
        $boolField,
        $jsonField
    ]
}"

Adicionar campos de matriz

Um campo de matriz armazena uma lista de elementos. Os tipos de dados de todos os elementos num campo de matriz devem ser os mesmos. Para mais informações sobre os campos de matriz, consulte Campo de Matriz.

schema.add_field(
    field_name="my_array",
    datatype=DataType.ARRAY,
    element_type=DataType.VARCHAR,
    max_capacity=5,
    max_length=512,
)

schema.addField(AddFieldReq.builder()
        .fieldName("my_array")
        .dataType(DataType.Array)
        .elementType(DataType.VarChar)
        .maxCapacity(5)
        .maxLength(512)
        .build());

schema.push({
    name: "my_array",
    data_type: DataType.Array,
    element_type: DataType.VarChar,
    max_capacity: 5,
    max_length: 512
});

schema.WithField(entity.NewField().WithName("my_array").
    WithDataType(entity.FieldTypeArray).
    WithElementType(entity.FieldTypeInt64).
    WithMaxLength(512).
    WithMaxCapacity(5),
)

export arrayField='{
    "fieldName": "my_array",
    "dataType": "Array",
    "elementDataType": "VarChar",
    "elementTypeParams": {
        "max_length": 512
    }
}'

export schema="{
    \"autoID\": false,
    \"fields\": [
        $primaryField,
        $vectorField,
        $varCharField,
        $int64Field,
        $boolField,
        $jsonField,
        $arrayField
    ]
}"