Dichter Vektor

Dichte Vektoren sind numerische Datendarstellungen, die häufig beim maschinellen Lernen und bei der Datenanalyse verwendet werden. Sie bestehen aus Arrays mit reellen Zahlen, bei denen die meisten oder alle Elemente ungleich Null sind. Im Vergleich zu spärlichen Vektoren enthalten dichte Vektoren mehr Informationen auf der gleichen Dimensionsebene, da jede Dimension sinnvolle Werte enthält. Mit dieser Darstellung können komplexe Muster und Beziehungen effektiv erfasst werden, was die Analyse und Verarbeitung von Daten in hochdimensionalen Räumen erleichtert. Dichte Vektoren haben in der Regel eine feste Anzahl von Dimensionen, die je nach Anwendung und Anforderungen von einigen Dutzend bis zu mehreren Hundert oder sogar Tausend reichen.

Dichte Vektoren werden hauptsächlich in Szenarien verwendet, die ein Verständnis der Semantik von Daten erfordern, wie z. B. bei der semantischen Suche und bei Empfehlungssystemen. Bei der semantischen Suche helfen dichte Vektoren, die zugrundeliegenden Verbindungen zwischen Abfragen und Dokumenten zu erfassen und so die Relevanz der Suchergebnisse zu verbessern. In Empfehlungssystemen helfen sie bei der Erkennung von Ähnlichkeiten zwischen Nutzern und Objekten und bieten so personalisierte Vorschläge.

Überblick

Dichte Vektoren werden in der Regel als Arrays von Fließkommazahlen mit einer festen Länge dargestellt, z. B. [0.2, 0.7, 0.1, 0.8, 0.3, ..., 0.5]. Die Dimensionalität dieser Vektoren reicht in der Regel von Hunderten bis Tausenden, z. B. 128, 256, 768 oder 1024. Jede Dimension erfasst spezifische semantische Merkmale eines Objekts und macht es durch Ähnlichkeitsberechnungen für verschiedene Szenarien anwendbar.

Dichte Vektoren im 2D-Raum

Das obige Bild veranschaulicht die Darstellung dichter Vektoren in einem 2D-Raum. Obwohl dichte Vektoren in realen Anwendungen oft viel höhere Dimensionen haben, vermittelt diese 2D-Darstellung effektiv mehrere Schlüsselkonzepte.

• Mehrdimensionale Darstellung: Jeder Punkt repräsentiert ein konzeptionelles Objekt (wie Milvus, eine Vektordatenbank, ein Retrievalsystem usw.), wobei seine Position durch die Werte seiner Dimensionen bestimmt wird.

• Semantische Beziehungen: Die Abstände zwischen den Punkten spiegeln die semantische Ähnlichkeit zwischen den Konzepten wider. Näher beieinander liegende Punkte weisen auf Konzepte hin, die semantisch enger miteinander verwandt sind.

• Clustering-Effekt: Verwandte Konzepte (wie Milvus, Vektordatenbank und Retrievalsystem) werden im Raum nahe beieinander positioniert und bilden einen semantischen Cluster.

Unten sehen Sie ein Beispiel für einen echten dichten Vektor, der den Text "Milvus is an efficient vector database" darstellt.

[
    -0.013052909,
    0.020387933,
    -0.007869,
    -0.11111383,
    -0.030188112,
    -0.0053388323,
    0.0010654867,
    0.072027855,
    // ... more dimensions
]

Dichte Vektoren können mit verschiedenen Einbettungsmodellen erzeugt werden, z. B. CNN-Modelle (wie ResNet, VGG) für Bilder und Sprachmodelle (wie BERT, Word2Vec) für Text. Diese Modelle wandeln Rohdaten in Punkte im hochdimensionalen Raum um und erfassen die semantischen Merkmale der Daten. Darüber hinaus bietet Milvus bequeme Methoden zur Erzeugung und Verarbeitung dichter Vektoren, wie unter Einbettungen beschrieben.

Sobald die Daten vektorisiert sind, können sie in Milvus zur Verwaltung und zum Abruf der Vektoren gespeichert werden. Das folgende Diagramm zeigt den grundlegenden Prozess.

Verwendung von dichten Vektoren in Milvus

Dichte Vektoren in Milvus verwenden

Vektorfeld hinzufügen

Um dichte Vektoren in Milvus zu verwenden, definieren Sie zunächst ein Vektorfeld zum Speichern von dichten Vektoren, wenn Sie eine Sammlung erstellen. Dieser Prozess beinhaltet.

1. Einstellen von datatype auf einen unterstützten dichten Vektordatentyp. Unterstützte Datentypen für dichte Vektoren finden Sie unter Datentypen.

2. Angeben der Dimensionen des dichten Vektors mit dem Parameter dim.

Im folgenden Beispiel fügen wir ein Vektorfeld mit dem Namen dense_vector hinzu, um dichte Vektoren zu speichern. Der Datentyp des Felds ist FLOAT_VECTOR mit einer Dimension von 4.

from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")

schema = client.create_schema(
    auto_id=True,
    enable_dynamic_fields=True,
)

schema.add_field(field_name="pk", datatype=DataType.VARCHAR, is_primary=True, max_length=100)
schema.add_field(field_name="dense_vector", datatype=DataType.FLOAT_VECTOR, dim=4)

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")
        .build());

CreateCollectionReq.CollectionSchema schema = client.createSchema();
schema.setEnableDynamicField(true);
schema.addField(AddFieldReq.builder()
        .fieldName("pk")
        .dataType(DataType.VarChar)
        .isPrimaryKey(true)
        .autoID(true)
        .maxLength(100)
        .build());

schema.addField(AddFieldReq.builder()
        .fieldName("dense_vector")
        .dataType(DataType.FloatVector)
        .dimension(4)
        .build());

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

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

export primaryField='{
    "fieldName": "pk",
    "dataType": "VarChar",
    "isPrimary": true,
    "elementTypeParams": {
        "max_length": 100
    }
}'

export vectorField='{
    "fieldName": "dense_vector",
    "dataType": "FloatVector",
    "elementTypeParams": {
        "dim": 4
    }
}'

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

Unterstützte Datentypen für dichte Vektorfelder:

Typ	Beschreibung
FLOAT_VECTOR	Speichert 32-Bit-Gleitkommazahlen, die üblicherweise zur Darstellung von reellen Zahlen bei wissenschaftlichen Berechnungen und maschinellem Lernen verwendet werden. Ideal für Szenarien, die eine hohe Präzision erfordern, z. B. zur Unterscheidung ähnlicher Vektoren.
FLOAT16_VECTOR	Speichert 16-Bit-Gleitkommazahlen mit halber Genauigkeit, die für Deep Learning und GPU-Berechnungen verwendet werden. Es spart Speicherplatz in Szenarien, in denen die Genauigkeit weniger kritisch ist, wie z. B. in der Recall-Phase von Empfehlungssystemen mit geringer Genauigkeit.
BFLOAT16_VECTOR	Speichert 16-Bit-Gehirn-Fließkommazahlen (bfloat16), die denselben Exponentenbereich wie Float32 bieten, aber eine geringere Genauigkeit aufweisen. Geeignet für Szenarien, in denen große Mengen von Vektoren schnell verarbeitet werden müssen, wie z. B. bei der Suche nach Bildern in großem Maßstab.

Index-Parameter für Vektorfeld festlegen

Um die semantische Suche zu beschleunigen, muss ein Index für das Vektorfeld erstellt werden. Die Indizierung kann die Abfrageeffizienz von großen Vektordaten erheblich verbessern.

index_params = client.prepare_index_params()

index_params.add_index(
    field_name="dense_vector",
    index_name="dense_vector_index",
    index_type="IVF_FLAT",
    metric_type="IP",
    params={"nlist": 128}
)

import io.milvus.v2.common.IndexParam;
import java.util.*;

List<IndexParam> indexes = new ArrayList<>();
Map<String,Object> extraParams = new HashMap<>();
extraParams.put("nlist",128);
indexes.add(IndexParam.builder()
        .fieldName("dense_vector")
        .indexType(IndexParam.IndexType.IVF_FLAT)
        .metricType(IndexParam.MetricType.IP)
        .extraParams(extraParams)
        .build());

import { MetricType, IndexType } from "@zilliz/milvus2-sdk-node";

const indexParams = {
    index_name: 'dense_vector_index',
    field_name: 'dense_vector',
    metric_type: MetricType.IP,
    index_type: IndexType.IVF_FLAT,
    params: {
      nlist: 128
    },
};

export indexParams='[
        {
            "fieldName": "dense_vector",
            "metricType": "IP",
            "indexName": "dense_vector_index",
            "indexType": "IVF_FLAT",
            "params":{"nlist": 128}
        }
    ]'

Im obigen Beispiel wird ein Index namens dense_vector_index für das Feld dense_vector unter Verwendung des Index-Typs IVF_FLAT erstellt. metric_type wird auf IP gesetzt, was anzeigt, dass das innere Produkt als Abstandsmetrik verwendet wird.

Milvus unterstützt auch andere Indextypen. Weitere Einzelheiten finden Sie unter Fließende Vektorindizes. Zusätzlich unterstützt Milvus auch andere metrische Typen. Weitere Informationen finden Sie unter Metrische Typen.

Sammlung erstellen

Sobald die Einstellungen für dichte Vektoren und Index-Parameter abgeschlossen sind, können Sie eine Sammlung erstellen, die dichte Vektoren enthält. Das folgende Beispiel verwendet die Methode create_collection, um eine Sammlung namens my_dense_collection zu erstellen.

client.create_collection(
    collection_name="my_dense_collection",
    schema=schema,
    index_params=index_params
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());

CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("my_dense_collection")
        .collectionSchema(schema)
        .indexParams(indexes)
        .build();
client.createCollection(requestCreate);

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

const client = new MilvusClient({
    address: 'http://localhost:19530'
});

await client.createCollection({
    collection_name: 'my_dense_collection',
    schema: schema,
    index_params: indexParams
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
    \"collectionName\": \"my_dense_collection\",
    \"schema\": $schema,
    \"indexParams\": $indexParams
}"

Daten einfügen

Nachdem Sie die Sammlung erstellt haben, fügen Sie mit der Methode insert Daten mit dichten Vektoren hinzu. Stellen Sie sicher, dass die Dimensionalität der eingefügten dichten Vektoren mit dem Wert dim übereinstimmt, der beim Hinzufügen des dichten Vektorfeldes definiert wurde.

data = [
    {"dense_vector": [0.1, 0.2, 0.3, 0.7]},
    {"dense_vector": [0.2, 0.3, 0.4, 0.8]},
]

client.insert(
    collection_name="my_dense_collection",
    data=data
)

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.InsertResp;

List<JsonObject> rows = new ArrayList<>();
Gson gson = new Gson();
rows.add(gson.fromJson("{\"dense_vector\": [0.1, 0.2, 0.3, 0.4]}", JsonObject.class));
rows.add(gson.fromJson("{\"dense_vector\": [0.2, 0.3, 0.4, 0.5]}", JsonObject.class));

InsertResp insertR = client.insert(InsertReq.builder()
        .collectionName("my_dense_collection")
        .data(rows)
        .build());

const data = [
  { dense_vector: [0.1, 0.2, 0.3, 0.7] },
  { dense_vector: [0.2, 0.3, 0.4, 0.8] },
];

client.insert({
  collection_name: "my_dense_collection",
  data: data,
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "data": [
        {"dense_vector": [0.1, 0.2, 0.3, 0.4]},
        {"dense_vector": [0.2, 0.3, 0.4, 0.5]}        
    ],
    "collectionName": "my_dense_collection"
}'

## {"code":0,"cost":0,"data":{"insertCount":2,"insertIds":["453577185629572531","453577185629572532"]}}

Ähnlichkeitssuche durchführen

Die semantische Suche auf der Basis von dichten Vektoren ist eine der Kernfunktionen von Milvus, die es Ihnen ermöglicht, schnell Daten zu finden, die einem Abfragevektor auf der Grundlage des Abstands zwischen Vektoren am ähnlichsten sind. Um eine Ähnlichkeitssuche durchzuführen, bereiten Sie den Abfragevektor und die Suchparameter vor und rufen dann die Methode search auf.

search_params = {
    "params": {"nprobe": 10}
}

query_vector = [0.1, 0.2, 0.3, 0.7]

res = client.search(
    collection_name="my_dense_collection",
    data=[query_vector],
    anns_field="dense_vector",
    search_params=search_params,
    limit=5,
    output_fields=["pk"]
)

print(res)

# Output
# data: ["[{'id': '453718927992172271', 'distance': 0.7599999904632568, 'entity': {'pk': '453718927992172271'}}, {'id': '453718927992172270', 'distance': 0.6299999952316284, 'entity': {'pk': '453718927992172270'}}]"]

import io.milvus.v2.service.vector.request.data.FloatVec;

Map<String,Object> searchParams = new HashMap<>();
searchParams.put("nprobe",10);

FloatVec queryVector = new FloatVec(new float[]{0.1f, 0.3f, 0.3f, 0.4f});

SearchResp searchR = client.search(SearchReq.builder()
        .collectionName("my_dense_collection")
        .data(Collections.singletonList(queryVector))
        .annsField("dense_vector")
        .searchParams(searchParams)
        .topK(5)
        .outputFields(Collections.singletonList("pk"))
        .build());
        
System.out.println(searchR.getSearchResults());

// Output
//
// [[SearchResp.SearchResult(entity={pk=453444327741536779}, score=0.65, id=453444327741536779), SearchResp.SearchResult(entity={pk=453444327741536778}, score=0.65, id=453444327741536778)]]

query_vector = [0.1, 0.2, 0.3, 0.7];

client.search({
    collection_name: my_dense_collection,
    data: query_vector,
    limit: 5,
    output_fields: ['pk'],
    params: {
        nprobe: 10
    }
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "my_dense_collection",
    "data": [
        [0.1, 0.2, 0.3, 0.7]
    ],
    "annsField": "dense_vector",
    "limit": 5,
    "searchParams":{
        "params":{"nprobe":10}
    },
    "outputFields": ["pk"]
}'

## {"code":0,"cost":0,"data":[{"distance":0.55,"id":"453577185629572532","pk":"453577185629572532"},{"distance":0.42,"id":"453577185629572531","pk":"453577185629572531"}]}

Weitere Informationen zu Parametern für die Ähnlichkeitssuche finden Sie unter Grundlegende ANN-Suche.