Schema erklärt

Ein Schema definiert die Datenstruktur einer Sammlung. Bevor Sie eine Sammlung erstellen, müssen Sie ein Schema dafür entwerfen. Diese Seite hilft Ihnen, das Schema einer Sammlung zu verstehen und selbst ein Beispielschema zu entwerfen.

Übersicht

Bei Milvus entspricht ein Sammlungsschema einer Tabelle in einer relationalen Datenbank, die festlegt, wie Milvus die Daten in der Sammlung organisiert.

Ein gut durchdachtes Schema ist unerlässlich, da es das Datenmodell abstrahiert und darüber entscheidet, ob Sie Ihre Geschäftsziele durch eine Suche erreichen können. Da zudem jede in die Sammlung eingefügte Datenzeile dem Schema entsprechen muss, trägt es zur Aufrechterhaltung der Datenkonsistenz und der langfristigen Datenqualität bei. Aus technischer Sicht führt ein klar definiertes Schema zu einer gut organisierten Speicherung der Spaltendaten und einer übersichtlicheren Indexstruktur, was die Suchleistung steigert.

Ein Sammlungsschema verfügt über einen Primärschlüssel, mindestens ein Vektorfeld und mehrere Skalarfelder. Das folgende Diagramm veranschaulicht, wie ein Artikel einer Liste von Schemafeldern zugeordnet wird.

Aufbau des Schema-Designs

Das Design des Datenmodells eines Suchsystems umfasst die Analyse der geschäftlichen Anforderungen und die Abstraktion von Informationen in ein schemabasiertes Datenmodell. So muss beispielsweise die Suche nach einem Textabschnitt „indiziert“ werden, indem die literale Zeichenkette durch „Einbettung“ in einen Vektor umgewandelt und die Vektorsuche ermöglicht wird. Über diese grundlegende Anforderung hinaus kann es erforderlich sein, weitere Eigenschaften wie den Veröffentlichungszeitstempel und den Autor zu speichern. Diese Metadaten ermöglichen es, semantische Suchen durch Filterung zu verfeinern, sodass nur Texte zurückgegeben werden, die nach einem bestimmten Datum oder von einem bestimmten Autor veröffentlicht wurden. Sie können diese Skalare auch zusammen mit dem Haupttext abrufen, um das Suchergebnis in der Anwendung darzustellen. Jedem sollte eine eindeutige Kennung zugewiesen werden, um diese Textteile zu organisieren; diese wird als Ganzzahl oder Zeichenkette ausgedrückt. Diese Elemente sind für die Realisierung einer ausgefeilten Suchlogik unerlässlich.

Lesen Sie den Artikel „Schema Design Hands-On“, um zu erfahren, wie Sie ein gut durchdachtes Schema erstellen.

Schema erstellen

Der folgende Codeausschnitt veranschaulicht, wie ein Schema erstellt wird.

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": []
}'

Primärfeld hinzufügen

Das Primärfeld in einer Sammlung identifiziert eine Entität eindeutig. Es akzeptiert ausschließlich Werte vom Typ „Int64“ oder „VARCHAR “. Die folgenden Codeausschnitte zeigen, wie das Primärfeld hinzugefügt wird.

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

Beim Hinzufügen eines Feldes können Sie das Feld explizit als Primärfeld kennzeichnen, indem Sie dessen Eigenschaft „ is_primary “ auf „ True “ setzen. Ein Primärfeld akzeptiert standardmäßig Int64-Werte. In diesem Fall sollte der Wert des Primärfeldes aus Ganzzahlen bestehen, ähnlich wie in 12345. Wenn Sie sich dafür entscheiden, VARCHAR-Werte im Primärfeld zu verwenden, sollte der Wert aus Zeichenketten bestehen, ähnlich wie in my_entity_1234.

Sie können außerdem die Eigenschaften „ autoId “ auf „ True “ setzen, damit Milvus die Werte für das Primärfeld beim Einfügen von Daten automatisch zuweist.

Weitere Informationen finden Sie unter „Primärfeld & AutoId“.

Vektorfelder hinzufügen

Vektorfelder unterstützen verschiedene spärliche und dichte Vektor-Embeddings. In Milvus können Sie einer Sammlung vier Vektorfelder hinzufügen. Die folgenden Codeausschnitte veranschaulichen, wie ein Vektorfeld hinzugefügt wird.

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

Der Parameter ` dim ` in den obigen Codeausschnitten gibt die Dimensionalität der Vektoreinbettungen an, die im Vektorfeld gespeichert werden sollen. Der Wert ` FLOAT_VECTOR ` bedeutet, dass das Vektorfeld eine Liste von 32-Bit-Gleitkommazahlen enthält, die üblicherweise zur Darstellung von Antilogarithmen verwendet werden. Darüber hinaus unterstützt Milvus auch die folgenden Arten von Vektoreinbettungen:

• FLOAT16_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von 16-Bit-Gleitkommazahlen mit halber Genauigkeit und kommt in der Regel in Deep-Learning- oder GPU-basierten Rechenszenarien zum Einsatz, bei denen Speicher oder Bandbreite begrenzt sind.

• BFLOAT16_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von 16-Bit-Gleitkommazahlen, die zwar eine reduzierte Genauigkeit, aber denselben Exponentenbereich wie Float32 aufweisen. Dieser Datentyp wird häufig in Deep-Learning-Szenarien verwendet, da er den Speicherbedarf senkt, ohne die Genauigkeit wesentlich zu beeinträchtigen.

• INT8_VECTOR

  Ein Vektorfeld dieses Typs speichert Vektoren, die aus 8-Bit-Ganzzahlen mit Vorzeichen (int8) bestehen, wobei jede Komponente im Bereich von –128 bis 127 liegt. Speziell auf quantisierte Deep-Learning-Architekturen – wie ResNet und EfficientNet – zugeschnitten, reduziert er die Modellgröße erheblich und steigert die Inferenzgeschwindigkeit, wobei nur ein minimaler Genauigkeitsverlust entsteht. Hinweis: Dieser Vektortyp wird nur für HNSW-Indizes unterstützt.

• BINARY_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste aus Nullen und Einsen. Diese dienen als kompakte Merkmale zur Darstellung von Daten in Szenarien der Bildverarbeitung und der Informationsgewinnung.

• SPARSE_FLOAT_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von Zahlen ungleich Null sowie deren Sequenznummern, um spärliche Vektoreinbettungen darzustellen.

Skalarfelder hinzufügen

In gängigen Fällen können Sie Skalarfelder verwenden, um die Metadaten der in Milvus gespeicherten Vektoreinbettungen abzulegen und ANN-Suchen mit Metadatenfilterung durchzuführen, um die Genauigkeit der Suchergebnisse zu verbessern. Milvus unterstützt mehrere Skalarfeldtypen, darunter VARCHAR, Boolean, Int, Float und Double.

VARCHAR-Felder hinzufügen

In Milvus können Sie „ VARCHAR “-Felder zum Speichern von Zeichenketten verwenden. Weitere Informationen zum Feld „ VARCHAR “ finden Sie unter „VarChar-Feld“.

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

Zahlenfelder hinzufügen

Milvus unterstützt folgende Zahlentypen: „ Int8 “, „ Int16 “, „ Int32 “, „ Int64 “, „ Float “ und „ Double “. Weitere Informationen zu den Zahlenfeldern finden Sie unter „Zahlenfeld“.

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

Boolesche Felder hinzufügen

Milvus unterstützt boolesche Felder. Die folgenden Codeausschnitte veranschaulichen, wie ein boolesches Feld hinzugefügt wird.

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

Zusammengesetzte Felder hinzufügen

In Milvus ist ein zusammengesetztes Feld ein Feld, das in kleinere Unterfelder unterteilt werden kann, wie beispielsweise die Schlüssel in einem JSON-Feld oder die Indizes in einem Array-Feld.

JSON-Felder hinzufügen

Ein JSON-Feld speichert in der Regel halbstrukturierte JSON-Daten. Weitere Informationen zu JSON-Feldern finden Sie unter „JSON-Feld“.

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

Array-Felder hinzufügen

Ein Array-Feld speichert eine Liste von Elementen. Die Datentypen aller Elemente in einem Array-Feld sollten identisch sein. Weitere Informationen zu Array-Feldern finden Sie unter „Array-Feld“.

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