🚀 Prova Zilliz Cloud, la versione completamente gestita di Milvus, gratuitamente—sperimenta prestazioni 10 volte più veloci! Prova Ora>>

milvus-logo
LFAI
  • Home
  • Blog
  • Milvus supporta l'importazione di file Apache Parquet per una maggiore efficienza nell'elaborazione dei dati

Milvus supporta l'importazione di file Apache Parquet per una maggiore efficienza nell'elaborazione dei dati

  • Engineering
March 08, 2024
Cai Zhang, Fendy Feng

Milvus, il database vettoriale altamente scalabile e rinomato per la sua capacità di gestire vasti insiemi di dati, compie un significativo passo avanti introducendo il supporto per i file Parquet nella versione 2.3.4. Grazie all'adozione di Apache Parquet, gli utenti possono snellire i processi di importazione dei dati e risparmiare notevolmente sui costi di archiviazione e di calcolo.

Nel nostro ultimo post, esploriamo i vantaggi di Parquet e i benefici che porta agli utenti di Milvus. Discutiamo le motivazioni alla base dell'integrazione di questa funzione e forniamo una guida passo passo per importare senza problemi i file Parquet in Milvus, aprendo nuove possibilità per una gestione e un'analisi efficienti dei dati.

Cos'è Apache Parquet?

Apache Parquet è un popolare formato di file di dati open-source orientato alle colonne, progettato per migliorare l'efficienza dell'archiviazione e dell'elaborazione di insiemi di dati su larga scala. A differenza dei tradizionali formati di dati orientati alle righe, come CSV o JSON, Parquet memorizza i dati per colonna, offrendo schemi di compressione e codifica dei dati più efficienti. Questo approccio si traduce in un miglioramento delle prestazioni, in una riduzione dei requisiti di archiviazione e in una maggiore potenza di elaborazione, che lo rendono ideale per la gestione di dati complessi in blocco.

Come gli utenti di Milvus beneficiano del supporto per le importazioni di file Parquet

Milvus estende il supporto per l'importazione di file Parquet, offrendo agli utenti un'esperienza ottimizzata e vari vantaggi, tra cui la riduzione dei costi di archiviazione e di calcolo, la semplificazione della gestione dei dati e la semplificazione del processo di importazione.

Efficienza di archiviazione ottimizzata e gestione dei dati semplificata

Parquet offre opzioni di compressione flessibili e schemi di codifica efficienti che si adattano a diversi tipi di dati, garantendo un'efficienza di archiviazione ottimale. Questa flessibilità è particolarmente preziosa negli ambienti cloud, dove ogni grammo di risparmio sullo storage è direttamente correlato a una riduzione tangibile dei costi. Grazie a questa nuova funzione di Milvus, gli utenti possono consolidare senza problemi tutti i loro dati diversi in un unico file, semplificando la gestione dei dati e migliorando l'esperienza complessiva dell'utente. Questa funzione è particolarmente vantaggiosa per gli utenti che lavorano con tipi di dati Array di lunghezza variabile, che ora possono godere di un processo di importazione dei dati semplificato.

Migliori prestazioni delle query

Il design dello storage colonnare di Parquet e i metodi di compressione avanzati migliorano significativamente le prestazioni delle query. Quando si eseguono le query, gli utenti possono concentrarsi solo sui dati pertinenti senza scorrere i dati irrilevanti. Questa lettura selettiva delle colonne riduce al minimo l'utilizzo della CPU, con conseguenti tempi di interrogazione più rapidi.

Ampia compatibilità linguistica

Parquet è disponibile in diversi linguaggi come Java, C++ e Python ed è compatibile con un gran numero di strumenti di elaborazione dati. Grazie al supporto dei file Parquet, gli utenti di Milvus che utilizzano diversi SDK possono generare senza problemi file Parquet da analizzare all'interno del database.

Come importare i file Parquet in Milvus

Se i dati sono già in formato Parquet, l'importazione è semplice. Caricate il file Parquet in un sistema di archiviazione a oggetti come MinIO e siete pronti per l'importazione.

Il frammento di codice che segue è un esempio di importazione di file Parquet in Milvus.

remote_files = []
try:
    print("Prepare upload files")
    minio_client = Minio(endpoint=MINIO_ADDRESS, access_key=MINIO_ACCESS_KEY, secret_key=MINIO_SECRET_KEY,
                         secure=False)
    found = minio_client.bucket_exists(bucket_name)
    if not found:
        minio_client.make_bucket(bucket_name)
        print("MinIO bucket '{}' doesn't exist".format(bucket_name))
        return False, []

    # set your remote data path
    remote_data_path = "milvus_bulkinsert"

    def upload_file(f: str):
        file_name = os.path.basename(f)
        minio_file_path = os.path.join(remote_data_path, "parquet", file_name)
        minio_client.fput_object(bucket_name, minio_file_path, f)
        print("Upload file '{}' to '{}'".format(f, minio_file_path))
        remote_files.append(minio_file_path)

    upload_file(data_file)

except S3Error as e:
    print("Failed to connect MinIO server {}, error: {}".format(MINIO_ADDRESS, e))
    return False, []

print("Successfully upload files: {}".format(remote_files))
return True, remote_files

Se i vostri dati non sono file Parquet o hanno campi dinamici, potete utilizzare BulkWriter, il nostro strumento di conversione del formato dei dati, per aiutarvi a generare file Parquet. BulkWriter ha ora adottato Parquet come formato di output predefinito, garantendo un'esperienza più intuitiva per gli sviluppatori.

Lo snippet di codice qui sotto è un esempio di utilizzo di BulkWriter per generare file Parquet.

import numpy as np
import json

from pymilvus import (
    RemoteBulkWriter,
    BulkFileType,
)

remote_writer = RemoteBulkWriter(
        schema=your_collection_schema,
        remote_path="your_remote_data_path",
        connect_param=RemoteBulkWriter.ConnectParam(
            endpoint=YOUR_MINIO_ADDRESS,
            access_key=YOUR_MINIO_ACCESS_KEY,
            secret_key=YOUR_MINIO_SECRET_KEY,
            bucket_name="a-bucket",
        ),
        file_type=BulkFileType.PARQUET,
)

# append your data
batch_count = 10000
for i in range(batch_count):
    row = {
        "id": i,
        "bool": True if i % 5 == 0 else False,
        "int8": i % 128,
        "int16": i % 1000,
        "int32": i % 100000,
        "int64": i,
        "float": i / 3,
        "double": i / 7,
        "varchar": f"varchar_{i}",
        "json": {"dummy": i, "ok": f"name_{i}"},
        "vector": gen_binary_vector() if bin_vec else gen_float_vector(),
        f"dynamic_{i}": i,
    }
    remote_writer.append_row(row)

# append rows by numpy type
for i in range(batch_count):
    remote_writer.append_row({
        "id": np.int64(i + batch_count),
        "bool": True if i % 3 == 0 else False,
        "int8": np.int8(i % 128),
        "int16": np.int16(i % 1000),
        "int32": np.int32(i % 100000),
        "int64": np.int64(i),
        "float": np.float32(i / 3),
        "double": np.float64(i / 7),
        "varchar": f"varchar_{i}",
        "json": json.dumps({"dummy": i, "ok": f"name_{i}"}),
        "vector": gen_binary_vector() if bin_vec else gen_float_vector(),
        f"dynamic_{i}": i,
    })

print(f"{remote_writer.total_row_count} rows appends")
print(f"{remote_writer.buffer_row_count} rows in buffer not flushed")
print("Generate data files...")
remote_writer.commit()
print(f"Data files have been uploaded: {remote_writer.batch_files}")
remote_files = remote_writer.batch_files

Quindi, è possibile iniziare a importare i file Parquet in Milvus.

remote_files = [remote_file_path]
task_id = utility.do_bulk_insert(collection_name=collection_name,
                                 files=remote_files)

task_ids = [task_id]         
states = wait_tasks_to_state(task_ids, BulkInsertState.ImportCompleted)
complete_count = 0
for state in states:
    if state.state == BulkInsertState.ImportCompleted:
        complete_count = complete_count + 1

Ora i vostri dati sono perfettamente integrati in Milvus.

Cosa succederà in futuro?

Poiché Milvus continua a supportare volumi di dati sempre crescenti, si pone la sfida di gestire importazioni di grandi dimensioni, in particolare quando i file Parquet superano i 10 GB. Per affrontare questa sfida, abbiamo in programma di segregare i dati importati in colonne scalari e vettoriali, creando due file Parquet per ogni importazione per alleggerire la pressione I/O. Per i set di dati che superano le centinaia di gigabyte, si consiglia di importare i dati più volte.

Like the article? Spread the word

Continua a Leggere