Schema Erklärt

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

Übersicht

In Milvus stellt ein Sammlungsschema eine Tabelle in einer relationalen Datenbank dar, die definiert, wie Milvus die Daten in der Sammlung organisiert.

Ein gut konzipiertes Schema ist von entscheidender Bedeutung, da es das Datenmodell abstrahiert und darüber entscheidet, ob Sie die Geschäftsziele durch eine Suche erreichen können. Da außerdem jede in die Sammlung eingefügte Datenzeile dem Schema entsprechen muss, trägt es zur Aufrechterhaltung der Datenkonsistenz und der langfristigen Qualität bei. Aus technischer Sicht führt ein gut definiertes Schema zu einer gut organisierten Speicherung von Spaltendaten und einer sauberen Indexstruktur, was die Suchleistung erhöht.

Ein Sammlungsschema hat einen Primärschlüssel, mindestens ein Vektorfeld und mehrere skalare Felder. Das folgende Diagramm veranschaulicht, wie ein Artikel einer Liste von Schemafeldern zugeordnet werden kann.

Anatomie des Schemadesigns

Der Entwurf des Datenmodells eines Suchsystems umfasst die Analyse der Geschäftsanforderungen und die Abstraktion der Informationen in ein schemaexprimiertes Datenmodell. So muss beispielsweise die Suche nach einem Textstück "indiziert" werden, indem die wörtliche Zeichenkette durch "Einbettung" in einen Vektor umgewandelt wird und eine Vektorsuche ermöglicht wird. Neben dieser grundlegenden Anforderung kann die Speicherung weiterer Eigenschaften wie Zeitstempel der Veröffentlichung und Autor erforderlich sein. Mit diesen Metadaten kann die semantische Suche durch Filterung verfeinert werden, so dass nur Texte gefunden werden, die nach einem bestimmten Datum oder von einem bestimmten Autor veröffentlicht wurden. Sie können diese Skalare auch mit dem Haupttext abrufen, um das Suchergebnis in der Anwendung darzustellen. Jedem Element sollte ein eindeutiger Bezeichner zugewiesen werden, um diese Textstücke zu organisieren, ausgedrückt als Ganzzahl oder String. Diese Elemente sind für eine ausgefeilte Suchlogik unerlässlich.

Lesen Sie Schema Design Hands-On, um herauszufinden, wie Sie ein gut gestaltetes Schema erstellen.

Schema erstellen

Der folgende Codeschnipsel zeigt, wie man ein Schema erstellt.

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 nur Int64- oder VarChar-Werte. Die folgenden Codeschnipsel zeigen, wie man das Primärfeld hinzufügt.

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 seine is_primary Eigenschaft auf True setzen. Ein Primärfeld akzeptiert standardmäßig Int64-Werte. In diesem Fall sollte der Wert des Primärfelds ein Integer-Wert sein, ähnlich wie 12345. Wenn Sie sich für die Verwendung von VarChar-Werten im Primärfeld entscheiden, sollte der Wert eine Zeichenkette sein, ähnlich wie my_entity_1234.

Sie können auch die Eigenschaften autoId auf True setzen, damit Milvus beim Einfügen von Daten automatisch Primärfeldwerte zuweist.

Details finden Sie unter Primärfeld & AutoId.

Hinzufügen von Vektorfeldern

Vektorfelder akzeptieren verschiedene spärliche und dichte Vektoreinbettungen. In Milvus können Sie vier Vektorfelder zu einer Sammlung hinzufügen. Die folgenden Codeschnipsel zeigen, wie man ein Vektorfeld hinzufügt.

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 Codeschnipseln gibt die Dimensionalität der Vektoreinbettungen an, die in dem Vektorfeld enthalten sein sollen. Der Wert FLOAT_VECTOR zeigt an, dass das Vektorfeld eine Liste von 32-Bit-Gleitkommazahlen enthält, die üblicherweise zur Darstellung von Antilogarithmen verwendet werden.Zusätzlich dazu unterstützt Milvus auch die folgenden Typen von Vektoreinbettungen:

• FLOAT16_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von 16-Bit-Gleitkommazahlen mit halber Genauigkeit und wird in der Regel für Deep-Learning-Szenarien mit eingeschränktem Speicher oder eingeschränkter Bandbreite oder für GPU-basierte Berechnungen verwendet.

• BFLOAT16_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von 16-Bit-Gleitkommazahlen, die eine geringere Genauigkeit, aber denselben Exponentenbereich wie Float32 haben. Dieser Datentyp wird häufig in Deep Learning-Szenarien verwendet, da er die Speichernutzung reduziert, 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 zwischen -128 und 127 liegt. Es ist auf quantisierte Deep Learning-Architekturen wie ResNet und EfficientNet zugeschnitten und verringert die Modellgröße erheblich und steigert die Inferenzgeschwindigkeit, während nur minimale Präzisionsverluste auftreten. Hinweis: Dieser Vektortyp wird nur für HNSW-Indizes unterstützt.

• BINARY_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von 0en und 1en. Sie dienen als kompakte Merkmale zur Darstellung von Daten in Bildverarbeitungs- und Informationsabfrageszenarien.

• SPARSE_FLOAT_VECTOR

  Ein Vektorfeld dieses Typs enthält eine Liste von Nicht-Null-Zahlen und deren Folgenummern zur Darstellung spärlicher Vektoreinbettungen.

Skalare Felder hinzufügen

In häufigen Fällen können Sie skalare Felder verwenden, um die Metadaten der in Milvus gespeicherten Vektoreinbettungen zu speichern und ANN-Suchen mit Metadatenfilterung durchzuführen, um die Korrektheit der Suchergebnisse zu verbessern. Milvus unterstützt mehrere skalare Feldtypen, einschließlich VarChar, Boolean, Int, Float und Double.

String-Felder hinzufügen

In Milvus können Sie VarChar-Felder verwenden, um Zeichenketten zu speichern. Weitere Informationen über das VarChar-Feld finden Sie unter String-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

Die von Milvus unterstützten Zahlentypen sind 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 Codeschnipsel zeigen, wie man ein boolesches Feld hinzufügt.

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 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 halb-strukturierte 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 gleich 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
    ]
}"