Buat Proxima Graph index dan lakukan kueri vektor - Hologres - Alibaba Cloud - Hologres

Fitur pemrosesan vektor di Hologres sangat ideal untuk pencarian kemiripan, pengambilan gambar, dan pengenalan adegan. Fitur ini meningkatkan pemrosesan dan analisis data sehingga memungkinkan pencarian dan rekomendasi yang lebih akurat. Topik ini menjelaskan cara menggunakan Proxima untuk pemrosesan vektor di Hologres serta menyediakan contoh lengkap.

Prosedur

Hubungkan ke instans Hologres.

Gunakan tool pengembangan untuk menghubungkan ke instans Hologres. Untuk informasi selengkapnya, lihat Hubungkan ke tool pengembangan. Jika Anda terhubung menggunakan JDBC, gunakan mode PreparedStatement.
Instal ekstensi Proxima.
Proxima terhubung ke Hologres sebagai ekstensi. Sebelum menggunakan Proxima, superuser harus menjalankan perintah berikut untuk menginstal ekstensi tersebut.
```
--Install the Proxima extension.
CREATE EXTENSION proxima;
```
Ekstensi Proxima diinstal pada tingkat database. Anda hanya perlu menginstalnya sekali untuk setiap database. Untuk menguninstal ekstensi tersebut, jalankan perintah berikut.
```
DROP EXTENSION proxima;
```
Penting
Jangan gunakan perintah DROP EXTENSION <extension_name> CASCADE; untuk menguninstal ekstensi. Opsi CASCADE tidak hanya menghapus ekstensi yang ditentukan, tetapi juga menghapus semua data ekstensi—seperti data PostGIS, RoaringBitmap, Proxima, Binlog, dan BSI—serta objek apa pun yang bergantung pada ekstensi tersebut, termasuk metadata, tabel, view, dan data server.

Buat tabel vektor dan indeks vektor.

Di Hologres, vektor biasanya direpresentasikan sebagai array FLOAT4. Sintaks untuk membuat tabel vektor adalah sebagai berikut.

Catatan

Indeks vektor hanya didukung untuk tabel berorientasi kolom dan tabel hibrida baris-kolom. Tabel berorientasi baris tidak didukung.
Saat mendefinisikan vektor, Anda harus mengatur dimensi array ke 1. Parameter kedua dari array_ndims dan array_length harus diatur ke 1.
Mulai dari Hologres V2.0.11, Anda dapat mengimpor data sebelum membuat indeks vektor. Pendekatan ini mengurangi waktu pembuatan indeks karena tidak perlu membangun indeks selama kompaksi file.

Buat indeks vektor sebelum mengimpor data: Metode ini cocok untuk skenario data real-time.

--Set a single index
BEGIN;
CREATE TABLE feature_tb (
    id BIGINT,
    feature_col FLOAT4[] CHECK(array_ndims(feature_col) = 1 AND array_length(feature_col, 1) = <value>) --Define a vector
);
CALL set_table_property(
'feature_tb', 
'proxima_vectors', 
'{"<feature_col>":{"algorithm":"Graph",
"distance_method":"<value>",
"builder_params":{"min_flush_proxima_row_count" : 1000, 
"min_compaction_proxima_row_count" : 1000, 
"max_total_size_to_merge_mb" : 2000}}}'); --Build a vector index
COMMIT;
--Set multiple indexes
BEGIN;
CREATE TABLE t1 (
    f1 INT PRIMARY KEY,
    f2 FLOAT4[] NOT NULL CHECK(array_ndims(f2) = 1 AND array_length(f2, 1) = 4),
    f3 FLOAT4[] NOT NULL CHECK(array_ndims(f3) = 1 AND array_length(f3, 1) = 4)
);
CALL set_table_property(
't1',  
'proxima_vectors', 
'{"f2":{"algorithm":"Graph",
"distance_method":"InnerProduct",
"builder_params":{"min_flush_proxima_row_count" : 1000, 
"min_compaction_proxima_row_count" : 1000, 
"max_total_size_to_merge_mb" : 2000}},
"f3":{"algorithm":"Graph",
"distance_method":"InnerProduct",
"builder_params":{"min_flush_proxima_row_count" : 1000, 
"min_compaction_proxima_row_count" : 1000, 
"max_total_size_to_merge_mb" : 2000}}}');
COMMIT;

Impor data sebelum membuat indeks vektor: Metode ini cocok untuk skenario analitik offline.

Catatan

Mulai dari Hologres V2.1.17, Serverless Computing didukung. Untuk skenario seperti impor offline dataset vektor besar atau kueri vektor berskala besar, Anda dapat menggunakan Serverless Computing untuk memanfaatkan sumber daya arsitektur tanpa server tambahan. Pendekatan ini menghindari penggunaan sumber daya instans sendiri, yang secara signifikan meningkatkan stabilitas instans dan mengurangi risiko error kehabisan memori (OOM). Anda hanya dikenai biaya berdasarkan tugas tersebut. Untuk informasi selengkapnya tentang Serverless Computing, lihat Serverless Computing. Untuk mempelajari cara menggunakan fitur ini, lihat Use Serverless Computing.

--Set a single index
BEGIN;
CREATE TABLE feature_tb (
    id BIGINT,
    feature_col FLOAT4[] CHECK(array_ndims(feature_col) = 1 AND array_length(feature_col, 1) = <value>) --Define a vector
);
COMMIT;
-- (Optional) We recommend using Serverless Computing for large-scale offline imports and ETL.
SET hg_computing_resource = 'serverless';
-- Import data
INSERT INTO feature_tb ...;
VACUUM feature_tb;
-- Build the vector index
CALL set_table_property(
'feature_tb', 
'proxima_vectors', 
'{"<feature_col>":{"algorithm":"Graph",
"distance_method":"<value>",
"builder_params":{"min_flush_proxima_row_count" : 1000, 
"min_compaction_proxima_row_count" : 1000, 
"max_total_size_to_merge_mb" : 2000}}}'); 
-- Reset the configuration to ensure that non-essential SQL statements do not use serverless resources.
RESET hg_computing_resource;

Tabel berikut menjelaskan parameter-parameter tersebut.

Kategori	Parameter	Deskripsi	Contoh
Properti vektor dasar	feature_col	Nama kolom vektor.	feature
	array_ndims	Dimensi vektor. Hanya vektor satu dimensi yang didukung.	Contoh berikut menunjukkan cara membuat vektor satu dimensi dengan panjang 4. `feature float4[] check(array_ndims(feature) = 1 and array_length(feature, 1) = 4)`
	array_length	Panjang vektor. Nilai maksimum adalah 1.000.000.
Pengaturan indeks vektor	proxima_vectors	Menentukan properti indeks vektor. Ini adalah string JSON yang berisi parameter berikut: algorithm: Algoritma yang digunakan untuk membangun indeks vektor. Saat ini, hanya `Graph` yang didukung. distance_method: Fungsi jarak yang digunakan untuk membangun indeks vektor. Fungsi jarak berikut didukung: (Direkomendasikan) `SquaredEuclidean`: Menghitung jarak Euclidean kuadrat. Fungsi ini menawarkan performa kueri tertinggi dan cocok untuk kueri yang menggunakan fungsi `pm_approx_squared_euclidean_distance`. `Euclidean`: Menghitung jarak Euclidean. Fungsi ini hanya cocok untuk kueri yang menggunakan fungsi `pm_approx_euclidean_distance`. (Gunakan dengan hati-hati) `InnerProduct`: Menghitung jarak hasil kali dalam. Secara internal, perhitungan ini dikonversi menjadi perhitungan jarak Euclidean yang melibatkan akar kuadrat. Konversi ini menambah beban komputasi baik saat pembuatan indeks maupun kueri, sehingga mengurangi efisiensi. Hindari penggunaan fungsi ini kecuali bisnis Anda memerlukannya. Fungsi ini hanya cocok untuk kueri yang menggunakan fungsi `pm_approx_inner_product_distance`. `builder_params`: String berformat JSON yang menentukan parameter untuk mengontrol proses pembuatan indeks. Termasuk parameter berikut: `min_flush_proxima_row_count`: Jumlah minimum baris yang diperlukan untuk membangun indeks saat data di-flush ke disk. Nilai yang direkomendasikan adalah 1.000. `min_compaction_proxima_row_count`: Jumlah minimum baris yang diperlukan untuk membangun indeks saat data dikompaksi di disk. Nilai yang direkomendasikan adalah 1.000. `max_total_size_to_merge_mb`: Ukuran maksimum file yang akan digabung selama kompaksi data, dalam megabyte (MB). Nilai yang direkomendasikan adalah 2.000. `proxima_builder_thread_count`: Jumlah thread yang digunakan untuk membangun indeks vektor selama penulisan data. Nilai default adalah 4. Biasanya Anda tidak perlu mengubah nilai ini. Catatan	Contoh berikut menunjukkan cara membangun indeks vektor untuk kueri yang menggunakan jarak Euclidean kuadrat. `call set_table_property( 'feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph", "distance_method":"SquaredEuclidean", "builder_params":{"min_flush_proxima_row_count" : 1000, "min_compaction_proxima_row_count" : 1000, "max_total_size_to_merge_mb" : 2000}}}');`

Impor data vektor.
Anda dapat mengimpor data ke tabel vektor dalam mode offline atau real-time. Setelah impor batch, Anda harus menjalankan perintah VACUUM dan ANALYZE untuk meningkatkan performa kueri.
- Perintah VACUUM meningkatkan efisiensi kueri dengan mengompaksi file backend menjadi file yang lebih besar. Proses ini mengonsumsi sumber daya CPU, dan durasinya meningkat seiring ukuran tabel. Jika proses VACUUM sedang berjalan, tunggu hingga selesai.
```
VACUUM <tablename>;
```
- Perintah ANALYZE mengumpulkan statistik yang digunakan Query Optimizer (QO) untuk menghasilkan rencana eksekusi yang lebih efisien.
```
analyze <tablename>;
```
Kueri data vektor.
Hologres mendukung kueri pencocokan eksak dan kueri pencocokan perkiraan. Fungsi yang ditentukan pengguna (UDF) dengan awalan pm_ melakukan kueri pencocokan eksak, sedangkan UDF dengan awalan pm_approx_ melakukan kueri pencocokan perkiraan. Hanya kueri pencocokan perkiraan yang dapat menggunakan indeks vektor. Untuk skenario di mana indeks vektor telah dibuat, kami merekomendasikan penggunaan kueri pencocokan perkiraan untuk performa yang lebih baik. Indeks vektor hanya dapat digunakan dalam kueri tabel tunggal. Utamakan kueri vektor tabel tunggal dan hindari operasi join.
- Kueri pencocokan perkiraan (menggunakan indeks vektor)
  
  Kueri perkiraan dapat mengenai indeks vektor dan lebih cocok untuk skenario yang memerlukan pemindaian data dalam jumlah besar dengan efisiensi eksekusi tinggi. Secara default, akurasi recall adalah 99% atau lebih tinggi. Untuk menggunakan indeks vektor, Anda hanya perlu menambahkan awalan approx_ ke fungsi perhitungan jarak yang sesuai. Fungsi perhitungan jarak yang sesuai adalah sebagai berikut:
  Catatan
  
  Untuk kueri pencocokan perkiraan menggunakan jarak Euclidean kuadrat dan jarak Euclidean, indeks vektor hanya digunakan ketika ORDER BY distance ASC ditentukan. Urutan menurun tidak didukung.
  
  Untuk kueri pencocokan perkiraan menggunakan jarak hasil kali dalam, indeks vektor hanya digunakan ketika ORDER BY distance DESC ditentukan. Urutan menaik tidak didukung.
```
FLOAT4 pm_approx_squared_euclidean_distance(FLOAT4[], FLOAT4[])
FLOAT4 pm_approx_euclidean_distance(FLOAT4[], FLOAT4[])
FLOAT4 pm_approx_inner_product_distance(FLOAT4[], FLOAT4[])
```
  Fungsi yang digunakan dalam kueri harus sesuai dengan parameter proxima_vector distance_method yang ditentukan saat pembuatan tabel. Contoh berikut menunjukkan cara mengkueri hasil Top N. Dalam kueri pencocokan perkiraan, parameter kedua harus berupa nilai konstan.
  
  Catatan
  Kueri berbasis indeks bersifat lossy, yang dapat menyebabkan kehilangan presisi tertentu. Tingkat recall default biasanya di atas 99%.
```
-- Calculate the top K results based on the squared Euclidean distance. The distance_method parameter in the proxima_vector property of the table must be set to SquaredEuclidean.
SELECT pm_approx_squared_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
-- Calculate the top K results based on the Euclidean distance. The distance_method parameter in the proxima_vector property of the table must be set to Euclidean.
SELECT pm_approx_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
-- Calculate the top K results based on the inner product distance. The distance_method parameter in the proxima_vector property of the table must be set to InnerProduct.
SELECT pm_approx_inner_product_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance DESC limit 10 ;
```
- Kueri pencocokan eksak (tanpa menggunakan indeks vektor)
  
  Kueri pencocokan eksak cocok untuk dataset kecil atau ketika tingkat recall 100% diperlukan. Tiga metode perhitungan jarak—jarak Euclidean, jarak Euclidean kuadrat, dan jarak hasil kali dalam—berkorespondensi dengan tiga fungsi jarak berikut.
```
FLOAT4 pm_squared_euclidean_distance(FLOAT4[], FLOAT4[])
FLOAT4 pm_euclidean_distance(FLOAT4[], FLOAT4[])
FLOAT4 pm_inner_product_distance(FLOAT4[], FLOAT4[])
```
  Untuk menemukan K tetangga terdekat ke vektor target, Anda dapat menggunakan kueri SQL berikut.
  
  Catatan
  Contoh berikut menunjukkan kueri SQL untuk perhitungan pencocokan eksak. Selama eksekusi, sistem memindai semua vektor di kolom fitur, menghitung jarak untuk masing-masing, mengurutkan hasilnya, dan mengembalikan 10 teratas. Pendekatan ini cocok untuk dataset kecil atau ketika tingkat recall sempurna diperlukan.
```
-- Find the 10 nearest neighbors based on squared Euclidean distance.
SELECT pm_squared_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
-- Find the 10 nearest neighbors based on Euclidean distance.
SELECT pm_euclidean_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance ASC limit 10 ;
-- Find the 10 neighbors with the greatest inner product distance.
SELECT pm_inner_product_distance(feature, '{0.1,0.2,0.3,0.4}') AS distance FROM feature_tb ORDER BY distance DESC limit 10 ;
```

Contoh lengkap

Contoh berikut menunjukkan cara menggunakan indeks Proxima Graph untuk menemukan 40 tetangga terdekat dalam tabel vektor 4 dimensi dengan 100.000 entri, berdasarkan jarak Euclidean kuadrat.

Buat tabel vektor.

CREATE EXTENSION proxima;
BEGIN;
-- Create a table group with a shard count of 4.
CALL HG_CREATE_TABLE_GROUP ('test_tg_shard_4', 4);
CREATE TABLE feature_tb (
    id BIGINT,
    feature FLOAT4[] CHECK (array_ndims(feature) = 1 AND array_length(feature, 1) = 4)
);
CALL set_table_property ('feature_tb', 'table_group', 'test_tg_shard_4');
CALL set_table_property ('feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph","distance_method":"SquaredEuclidean","builder_params":
												{"min_flush_proxima_row_count" : 1000, "min_compaction_proxima_row_count" : 1000, "max_total_size_to_merge_mb" : 2000}}}');
COMMIT;

Impor data.

-- (Optional) We recommend using Serverless Computing for large-scale offline imports and ETL.
SET hg_computing_resource = 'serverless';
INSERT INTO feature_tb
SELECT
    i,
    ARRAY[random(), random(), random(), random()]::FLOAT4[]
FROM
    generate_series(1, 100000) i;
ANALYZE feature_tb;
VACUUM feature_tb;
-- Reset the configuration to ensure that non-essential SQL statements do not use serverless resources.
RESET hg_computing_resource;

Jalankan kueri.

-- (Optional) Use Serverless Computing to run large-scale vector query jobs.
SET hg_computing_resource = 'serverless';
SELECT
    pm_approx_squared_euclidean_distance (feature, '{0.1,0.2,0.3,0.4}') AS distance
FROM
    feature_tb
ORDER BY
    distance
LIMIT 40;
-- Reset the configuration to ensure that non-essential SQL statements do not use serverless resources.
RESET hg_computing_resource;

Penyetelan performa

Skenario penggunaan indeks vektor
Untuk dataset kecil (misalnya puluhan ribu entri) atau kueri volume rendah pada instans dengan sumber daya memadai, perhitungan langsung tanpa indeks sering kali sudah cukup. Pertimbangkan penggunaan indeks Proxima Graph hanya jika perhitungan langsung tidak memenuhi persyaratan latensi dan throughput Anda. Perhatikan poin-poin berikut:
- Indeks Proxima bersifat lossy dan tidak menjamin keakuratan hasil. Jarak yang dihitung mungkin tidak tepat.
- Indeks Proxima Graph mungkin mengembalikan hasil lebih sedikit dari yang diminta. Misalnya, kueri dengan LIMIT 1000 mungkin hanya mengembalikan 500 entri.
- Penggunaan indeks Proxima Graph bisa kompleks.

Tentukan jumlah shard yang sesuai

Jumlah shard yang lebih tinggi menghasilkan lebih banyak file yang dibuat untuk indeks Proxima Graph, yang dapat menurunkan throughput kueri. Kami merekomendasikan menetapkan jumlah shard yang wajar berdasarkan sumber daya instans Anda. Pedoman umum adalah menetapkan jumlah shard sama dengan jumlah node pekerja. Misalnya, untuk instans 64-core, jumlah shard 4 direkomendasikan. Untuk mengurangi latensi kueri tunggal, Anda dapat mengurangi jumlah shard, tetapi hal ini akan menurunkan performa penulisan.

-- Create a vector table and place it in a table group with a shard count of 4.
BEGIN;
CALL HG_CREATE_TABLE_GROUP ('test_tg_shard_4', 4);
CREATE TABLE proxima_test (
    id BIGINT NOT NULL,
    vectors FLOAT4[] CHECK (array_ndims(vectors) = 1 AND array_length(vectors, 1) = 128),
    PRIMARY KEY (id)
);
CALL set_table_property ('proxima_test', 'proxima_vectors', '{"vectors":{"algorithm":"Graph","distance_method":"SquaredEuclidean","builder_params":{}, "searcher_init_params":{}}}');
CALL set_table_property ('proxima_test', 'table_group', 'test_tg_shard_4');
COMMIT;

(Direkomendasikan) Kueri tanpa kondisi filter

Penggunaan klausa WHERE dapat berdampak negatif pada penggunaan indeks dan mungkin menghasilkan performa yang lebih buruk. Oleh karena itu, kami merekomendasikan menjalankan kueri tanpa kondisi filter. Untuk pencarian vektor tanpa filter, kondisi ideal adalah memiliki hanya satu file indeks vektor per shard. Hal ini meminimalkan I/O dan meningkatkan performa kueri dalam setiap shard.

Untuk skenario ini, gunakan pernyataan pembuatan tabel yang mirip dengan berikut:
```
BEGIN;
CREATE TABLE feature_tb (
    uuid text,
    feature FLOAT4[] NOT NULL CHECK (array_ndims(feature) = 1 AND array_length(feature, 1) = N) --Define a vector
);
CALL set_table_property ('feature_tb', 'shard_count', '?'); --Specify the shard count based on your business needs. You can omit this if not needed.
CALL set_table_property ('feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph","distance_method":"InnerProduct"}}'); --Build a vector index
END;                 
```
Kueri dengan kondisi filter
Untuk pencarian vektor dengan kondisi filter, pertimbangkan skenario umum berikut.
- Skenario 1: Filter berdasarkan kolom string
  Kasus penggunaan umum adalah mencari data vektor dalam kelompok tertentu, seperti menemukan data wajah dalam suatu kelas. Contoh kueri adalah sebagai berikut:
```
SELECT pm_xx_distance(feature, '{1,2,3,4}') AS d FROM feature_tb WHERE uuid = 'x' ORDER BY d limit 10;
```
  Kami merekomendasikan optimasi berikut:
  - Tetapkan uuid sebagai kunci distribusi. Hal ini memastikan bahwa data dengan nilai filter yang sama disimpan pada shard yang sama, sehingga kueri diarahkan hanya ke satu shard.
  - Tetapkan uuid sebagai kunci pengelompokan untuk tabel. Hal ini mengurutkan data dalam setiap file berdasarkan kunci pengelompokan.
- Skenario 2: Filter berdasarkan bidang waktu
  Anda biasanya memfilter data vektor berdasarkan bidang waktu. Kami merekomendasikan menetapkan bidang waktu time_field sebagai kunci segmen tabel untuk dengan cepat menemukan file tempat data disimpan. Contoh kueri adalah sebagai berikut:
```
SELECT pm_xx_distance(feature, '{1,2,3,4}') AS d FROM feature_tb WHERE time_field BETWEEN '2020-08-30 00:00:00' AND '2020-08-30 12:00:00' ORDER BY d limit 10;
```
Untuk pencarian vektor dengan kondisi filter, pernyataan pembuatan tabel biasanya sebagai berikut:
```
BEGIN;
CREATE TABLE feature_tb (
    time_field timestamptz NOT NULL,
    uuid text,
    feature FLOAT4[] NOT NULL CHECK (array_ndims(feature) = 1 AND array_length(feature, 1) = N)
);
CALL set_table_property ('feature_tb', 'distribution_key', 'uuid');
CALL set_table_property ('feature_tb', 'segment_key', 'time_field');
CALL set_table_property ('feature_tb', 'clustering_key', 'uuid');
CALL set_table_property ('feature_tb', 'proxima_vectors', '{"feature":{"algorithm":"Graph","distance_method":"InnerProduct"}}');
COMMIT;
-- If you do not filter by time, you can remove the indexes related to time_field.
```

FAQ

Apa yang harus saya lakukan jika muncul error ERROR: function pm_approx_inner_product_distance(real[], unknown) does not exist?

Penyebab: Error ini biasanya terjadi karena pernyataan CREATE EXTENSION proxima; belum dijalankan di database untuk menginisialisasi ekstensi Proxima.

Solusi: Jalankan pernyataan CREATE EXTENSION proxima; untuk menginisialisasi ekstensi Proxima.
Apa yang harus saya lakukan jika muncul error Writing column: feature with array size: 5 violates fixed size list (4) constraint declared in schema?

Penyebab: Dimensi data yang ditulis ke kolom vektor tidak sesuai dengan dimensi yang didefinisikan dalam skema tabel.

Solusi: Periksa data masukan Anda untuk vektor dengan dimensi yang salah.
Apa yang harus saya lakukan jika muncul error The size of two arrays must be the same in DistanceFunction, size of left array: 4, size of right array:?

Penyebab: Dalam fungsi pm_xx_distance(left, right), dimensi array left tidak sesuai dengan dimensi array right.

Solusi: Pastikan dimensi array left dan right dalam fungsi pm_xx_distance(left, right) sama.
Apa yang harus saya lakukan jika muncul error BackPressure Exceed Reject Limit ctxId: XXXXXXXX, tableId: YY, shardId: ZZ selama penulisan real-time?

Penyebab: Tugas penulisan real-time mengalami bottleneck dan menghasilkan exception tekanan balik. Hal ini menunjukkan bahwa tugas penulisan memiliki overhead tinggi dan lambat. Masalah ini biasanya disebabkan oleh nilai kecil untuk parameter min_flush_proxima_row_count dikombinasikan dengan kecepatan penulisan real-time yang tinggi. Konfigurasi ini menghasilkan overhead tinggi untuk pembuatan indeks real-time, yang pada gilirannya menghambat proses penulisan.

Solusi: Tetapkan min_flush_proxima_row_count ke nilai yang lebih besar.

Bagaimana cara menulis data vektor menggunakan Java?

Contoh berikut menunjukkan cara menulis data vektor menggunakan Java.

private static void insertIntoVector(Connection conn) throws Exception {
    try (PreparedStatement stmt = conn.prepareStatement("insert into feature_tb values(?,?);")) {
        for (int i = 0; i < 100; ++i) {
           stmt.setInt(1, i);
           Float[] featureVector = {0.1f,0.2f,0.3f,0.4f};
           Array array = conn.createArrayOf("FLOAT4", featureVector);
           stmt.setArray(2, array);
           stmt.execute();
        }
    }
}

Bagaimana cara memeriksa apakah indeks Proxima Graph digunakan dari rencana eksekusi?

Anda dapat memeriksa rencana eksekusi untuk memverifikasi bahwa indeks Proxima Graph digunakan. Jalankan pernyataan EXPLAIN ANALYZE. Jika output mencakup Proxima Filter: ProximaCond, hal ini mengonfirmasi bahwa kueri menggunakan indeks Proxima Graph. Jika Anda tidak melihat filter ini, indeks tidak digunakan, yang biasanya menunjukkan ketidaksesuaian antara definisi tabel dan pernyataan kueri Anda. Berikut adalah contoh rencana eksekusi yang menggunakan indeks Proxima Graph:

test=# explain analyze select  pm_approx_squared_euclidean_distance(feature, array[0.1,0.1,0.1,0.1,0.2]::float4[]) from test_get_ordered_array_according_to_docs order by 1 limit 10;
                                                              QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=0.00..27.64 rows=0 width=4)
  ->  Sort  (cost=0.00..27.56 rows=10 width=4)
        Sort Key: (ProximaDistanceRef)
        [node_id=7; Row_count=10; Avg_Open_Time=0ms; Max_Open_Time=0ms; Min_Open_Time=0ms; Avg_Get_Next_Time=0ms; Max_Get_Next_Time=0ms; Min_Get_Next_Time=0ms]
        ->  Exchange (Gather Exchange)  (cost=0.00..1.68 rows=10 width=4)
              [node_id=6; Row_count=10; Avg_Open_Time=0ms; Max_Open_Time=0ms; Min_Open_Time=0ms; Avg_Get_Next_Time=0ms; Max_Get_Next_Time=0ms; Min_Get_Next_Time=0ms]
              ->  Decode  (cost=0.00..1.68 rows=10 width=4)
                    [node_id=4; Row_count=10; Avg_Open_Time=0ms; Max_Open_Time=0ms; Min_Open_Time=0ms; Avg_Get_Next_Time=0ms; Max_Get_Next_Time=0ms; Min_Get_Next_Time=0ms]
                    ->  Result  (cost=0.00..1.58 rows=10 width=4)
                          ->  Index Scan using holo_index:[1] on test_get_ordered_array_according_to_docs  (cost=0.00..0.53 rows=10 width=1)
                                Proxima Filter: ProximaCond  -> KNN: $5 distance_method: pm_approx_squared_euclidean_distance search_params: {NULL} args: {featureARRAY[$1, $2, $3, $4]}

Fungsi jarak

Hologres mendukung tiga fungsi jarak vektor berikut:

Jarak Euclidean kuadrat (SquaredEuclidean). Rumusnya sebagai berikut.
Jarak Euclidean (Euclidean). Rumusnya sebagai berikut.
Jarak hasil kali dalam (InnerProduct). Rumusnya sebagai berikut.

Catatan

Saat menggunakan jarak berbasis Euclidean, jarak Euclidean kuadrat lebih performan daripada jarak Euclidean karena menghindari operasi akar kuadrat yang mahal, namun tetap menghasilkan peringkat top-K yang sama. Oleh karena itu, kami merekomendasikan penggunaan jarak Euclidean kuadrat kapan pun sesuai dengan kasus penggunaan Anda.