🚀 Prueba Zilliz Cloud, el Milvus completamente gestionado, gratis—¡experimenta un rendimiento 10 veces más rápido! Prueba Ahora>>

milvus-logo
LFAI
  • Home
  • Blog
  • Milvus admite la importación de archivos Apache Parquet para mejorar la eficacia del procesamiento de datos

Milvus admite la importación de archivos Apache Parquet para mejorar la eficacia del procesamiento de datos

  • Engineering
March 08, 2024
Cai Zhang, Fendy Feng

Milvus, la base de datos vectorial altamente escalable y famosa por su capacidad para manejar grandes conjuntos de datos, da un importante paso adelante al introducir la compatibilidad con archivos Parquet en la versión 2.3.4. Al adoptar Apache Parquet, los usuarios pueden agilizar sus procesos de importación de datos y disfrutar de un ahorro sustancial en costes de almacenamiento y computación.

En nuestro último post, exploramos las ventajas de Parquet y los beneficios que aporta a los usuarios de Milvus. Discutimos la motivación que hay detrás de la integración de esta función y proporcionamos una guía paso a paso para importar sin problemas archivos Parquet en Milvus, desbloqueando nuevas posibilidades para una gestión y análisis eficientes de los datos.

¿Qué es Apache Parquet?

Apache Parquet es un popular formato de archivo de datos orientado a columnas de código abierto diseñado para mejorar la eficiencia del almacenamiento y procesamiento de conjuntos de datos a gran escala. A diferencia de los formatos de datos tradicionales orientados a filas, como CSV o JSON, Parquet almacena los datos por columnas, ofreciendo esquemas de compresión y codificación de datos más eficientes. Este enfoque se traduce en un mejor rendimiento, menores requisitos de almacenamiento y una mayor capacidad de procesamiento, lo que lo hace ideal para manejar datos complejos en masa.

Cómo se benefician los usuarios de Milvus de la compatibilidad con la importación de archivos Parquet

Milvus amplía la compatibilidad con las importaciones de archivos Parquet, proporcionando a los usuarios experiencias optimizadas y diversas ventajas, entre las que se incluyen la reducción de los gastos de almacenamiento y computación, la racionalización de la gestión de datos y la simplificación del proceso de importación.

Eficiencia de almacenamiento optimizada y gestión de datos racionalizada

Parquet ofrece opciones de compresión flexibles y esquemas de codificación eficientes que se adaptan a diferentes tipos de datos, garantizando una eficiencia de almacenamiento óptima. Esta flexibilidad es especialmente valiosa en entornos de nube, donde cada gramo de ahorro de almacenamiento se correlaciona directamente con una reducción tangible de los costes. Con esta nueva función de Milvus, los usuarios pueden consolidar sin esfuerzo todos sus datos diversos en un único archivo, agilizando la gestión de datos y mejorando la experiencia general del usuario. Esta función es especialmente beneficiosa para los usuarios que trabajan con tipos de datos Array de longitud variable, que ahora pueden disfrutar de un proceso de importación de datos simplificado.

Mejora del rendimiento de las consultas

El diseño de almacenamiento en columnas de Parquet y los métodos de compresión avanzados mejoran significativamente el rendimiento de las consultas. A la hora de realizar consultas, los usuarios pueden centrarse únicamente en los datos pertinentes sin tener que escanear los datos irrelevantes. Esta lectura selectiva de columnas minimiza el uso de la CPU, lo que se traduce en tiempos de consulta más rápidos.

Amplia compatibilidad lingüística

Parquet está disponible en varios lenguajes, como Java, C++ y Python, y es compatible con un gran número de herramientas de procesamiento de datos. Con el soporte de archivos Parquet, los usuarios de Milvus que utilizan diferentes SDKs pueden generar sin problemas archivos Parquet para analizarlos dentro de la base de datos.

Cómo importar archivos Parquet a Milvus

Si sus datos ya están en formato de archivo Parquet, la importación es fácil. Suba el archivo Parquet a un sistema de almacenamiento de objetos como MinIO, y ya está listo para importar.

El siguiente fragmento de código es un ejemplo de importación de ficheros Parquet a 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

Si sus datos no son archivos Parquet o tienen campos dinámicos, puede aprovechar BulkWriter, nuestra herramienta de conversión de formatos de datos, para ayudarle a generar archivos Parquet. BulkWriter ha adoptado ahora Parquet como su formato de datos de salida por defecto, asegurando una experiencia más intuitiva para los desarrolladores.

El siguiente fragmento de código es un ejemplo del uso de BulkWriter para generar archivos 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

A continuación, puede empezar a importar sus archivos Parquet en 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

Ahora, sus datos están perfectamente integrados en Milvus.

¿Y ahora qué?

A medida que Milvus continúa soportando volúmenes de datos cada vez mayores, surge el reto de gestionar importaciones de gran tamaño, especialmente cuando los archivos Parquet superan los 10 GB. Para hacer frente a este reto, tenemos previsto segregar los datos de importación en columnas escalares y vectoriales, creando dos archivos Parquet por importación para aliviar la presión de E/S. Para conjuntos de datos que superen varios cientos de gigabytes, recomendamos importar los datos varias veces.

Like the article? Spread the word

Sigue Leyendo