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 Zilliz Cloud stellt ein Kollektionsschema eine Tabelle in einer relationalen Datenbank dar, die definiert, wie Zilliz Cloud die Daten in der Kollektion organisiert.

Ein gut entworfenes Schema ist essentiell, da es das Datenmodell abstrahiert und 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 dazu bei, die Datenkonsistenz und langfristige Qualität zu erhalten. 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, maximal vier Vektorfelder und mehrere skalare Felder. Das folgende Diagramm veranschaulicht, wie ein Artikel auf eine Liste von Schemafeldern abgebildet 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 Zilliz Cloud automatisch Primärfeldwerte bei der Dateneingabe zuweist.

Details finden Sie unter Primärfeld & AutoId.

Vektorfelder hinzufügen

Vektorfelder akzeptieren verschiedene spärliche und dichte Vektoreinbettungen. Auf Zilliz Cloud 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.Darüber hinaus unterstützt Zilliz Cloud auch die folgenden Arten 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-basiertes Computing 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.

• 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. Zilliz Cloud unterstützt mehrere skalare Feldtypen, einschließlich VarChar, Boolean, Int, Float, Double, Array und JSON.

String-Felder hinzufügen

In Milvus können Sie VarChar-Felder verwenden, um Strings 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
    ]
}"

JSON-Felder hinzufügen

Ein JSON-Feld speichert normalerweise 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
    ]
}"