Vektor Padat

Vektor padat adalah representasi data numerik yang banyak digunakan dalam pembelajaran mesin dan analisis data. Vektor padat terdiri dari larik dengan bilangan real, di mana sebagian besar atau semua elemennya bukan nol. Dibandingkan dengan vektor jarang, vektor padat mengandung lebih banyak informasi pada tingkat dimensi yang sama, karena setiap dimensi memiliki nilai yang berarti. Representasi ini dapat secara efektif menangkap pola dan hubungan yang kompleks, membuat data lebih mudah dianalisis dan diproses dalam ruang dimensi tinggi. Vektor padat biasanya memiliki jumlah dimensi yang tetap, mulai dari beberapa lusin hingga beberapa ratus atau bahkan ribuan, tergantung pada aplikasi dan persyaratan tertentu.

Vektor padat terutama digunakan dalam skenario yang membutuhkan pemahaman semantik data, seperti pencarian semantik dan sistem rekomendasi. Dalam pencarian semantik, vektor padat membantu menangkap hubungan yang mendasari antara kueri dan dokumen, sehingga meningkatkan relevansi hasil pencarian. Dalam sistem rekomendasi, vektor padat membantu mengidentifikasi kemiripan antara pengguna dan item, menawarkan saran yang lebih personal.

Gambaran Umum

Vektor padat biasanya direpresentasikan sebagai larik angka floating-point dengan panjang tetap, seperti [0.2, 0.7, 0.1, 0.8, 0.3, ..., 0.5]. Dimensi vektor ini biasanya berkisar antara ratusan hingga ribuan, seperti 128, 256, 768, atau 1024. Setiap dimensi menangkap fitur semantik tertentu dari suatu objek, sehingga dapat diterapkan pada berbagai skenario melalui perhitungan kemiripan.

Vektor padat dalam ruang 2D

Gambar di atas mengilustrasikan representasi vektor padat dalam ruang 2D. Meskipun vektor padat dalam aplikasi dunia nyata sering kali memiliki dimensi yang jauh lebih tinggi, ilustrasi 2D ini secara efektif menyampaikan beberapa konsep utama.

• Representasi Multidimensi: Setiap titik mewakili objek konseptual (seperti Milvus, basis data vektor, sistem pencarian, dll.), dengan posisinya ditentukan oleh nilai dimensinya.

• Hubungan Semantik: Jarak antara titik-titik mencerminkan kemiripan semantik antara konsep-konsep. Titik-titik yang lebih dekat menunjukkan konsep-konsep yang lebih terkait secara semantik.

• Efek Pengelompokan: Konsep-konsep yang terkait (seperti Milvus, basis data vektor, dan sistem pencarian) diposisikan berdekatan satu sama lain di dalam ruang, membentuk sebuah klaster semantik.

Di bawah ini adalah contoh vektor padat nyata yang mewakili teks "Milvus is an efficient vector database".

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

Vektor padat dapat dihasilkan dengan menggunakan berbagai model penyematan, seperti model CNN (seperti ResNet, VGG) untuk gambar dan model bahasa (seperti BERT, Word2Vec) untuk teks. Model-model ini mengubah data mentah menjadi titik-titik dalam ruang dimensi tinggi, menangkap fitur semantik data. Selain itu, Milvus menawarkan metode yang mudah digunakan untuk membantu pengguna menghasilkan dan memproses vektor yang padat, seperti yang dijelaskan dalam Embeddings.

Setelah data menjadi vektor, data tersebut dapat disimpan di Milvus untuk pengelolaan dan pengambilan vektor. Diagram di bawah ini menunjukkan proses dasarnya.

Menggunakan vektor padat di Milvus

Menggunakan vektor padat di Milvus

Menambahkan bidang vektor

Untuk menggunakan vektor padat di Milvus, pertama-tama tentukan bidang vektor untuk menyimpan vektor padat saat membuat koleksi. Proses ini meliputi.

1. Mengatur datatype ke tipe data vektor padat yang didukung. Untuk tipe data vektor padat yang didukung, lihat Tipe Data.

2. Menentukan dimensi vektor padat menggunakan parameter dim.

Pada contoh di bawah ini, kami menambahkan bidang vektor bernama dense_vector untuk menyimpan vektor padat. Tipe data field tersebut adalah FLOAT_VECTOR, dengan dimensi 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
    ]
}"

Tipe data yang didukung untuk bidang vektor padat:

Tipe	Deskripsi
FLOAT_VECTOR	Menyimpan bilangan floating-point 32-bit, yang biasa digunakan untuk merepresentasikan bilangan riil dalam komputasi ilmiah dan pembelajaran mesin. Ideal untuk skenario yang membutuhkan presisi tinggi, seperti membedakan vektor yang serupa.
FLOAT16_VECTOR	Menyimpan angka floating-point setengah presisi 16-bit, digunakan untuk pembelajaran mendalam dan perhitungan GPU. Menghemat ruang penyimpanan dalam skenario di mana presisi tidak terlalu penting, seperti pada fase pemanggilan kembali dengan presisi rendah pada sistem rekomendasi.
BFLOAT16_VECTOR	Menyimpan angka Brain Floating Point (bfloat16) 16-bit, menawarkan rentang eksponen yang sama dengan Float32 tetapi dengan presisi yang lebih rendah. Cocok untuk skenario yang perlu memproses vektor dalam jumlah besar dengan cepat, seperti pengambilan gambar berskala besar.

Tetapkan parameter indeks untuk bidang vektor

Untuk mempercepat pencarian semantik, indeks harus dibuat untuk bidang vektor. Pengindeksan dapat secara signifikan meningkatkan efisiensi pengambilan data vektor berskala besar.

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

Pada contoh di atas, sebuah indeks bernama dense_vector_index dibuat untuk bidang dense_vector menggunakan jenis indeks IVF_FLAT. metric_type disetel ke IP, yang menunjukkan bahwa inner product akan digunakan sebagai metrik jarak.

Milvus juga mendukung tipe indeks lainnya. Untuk lebih jelasnya, lihat Floating Vector Indexes. Selain itu, Milvus juga mendukung jenis metrik lainnya. Untuk informasi lebih lanjut, lihat Jenis Metrik.

Membuat koleksi

Setelah pengaturan vektor padat dan param indeks selesai, Anda dapat membuat koleksi yang berisi vektor padat. Contoh di bawah ini menggunakan metode create_collection untuk membuat koleksi bernama my_dense_collection.

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

Memasukkan data

Setelah membuat koleksi, gunakan metode insert untuk menambahkan data yang berisi vektor padat. Pastikan bahwa dimensi vektor padat yang dimasukkan sesuai dengan nilai dim yang ditentukan saat menambahkan bidang vektor padat.

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

Lakukan pencarian kemiripan

Pencarian semantik berdasarkan vektor padat adalah salah satu fitur inti Milvus, memungkinkan Anda untuk dengan cepat menemukan data yang paling mirip dengan vektor kueri berdasarkan jarak antar vektor. Untuk melakukan pencarian kemiripan, siapkan vektor kueri dan parameter pencarian, lalu panggil metode search.

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

Untuk informasi lebih lanjut tentang parameter pencarian kemiripan, lihat Pencarian ANN Dasar.