Milvus suporta a importação de ficheiros Apache Parquet para uma maior eficiência no processamento de dados
Milvus, a base de dados vetorial altamente escalável conhecida pela sua capacidade de lidar com vastos conjuntos de dados, dá um passo em frente significativo ao introduzir o suporte de ficheiros Parquet na versão 2.3.4. Ao adotar o Apache Parquet, os utilizadores podem simplificar os seus processos de importação de dados e beneficiar de poupanças substanciais nos custos de armazenamento e de cálculo.
No nosso último post, exploramos as vantagens do Parquet e os benefícios que traz aos utilizadores do Milvus. Discutimos a motivação por detrás da integração desta funcionalidade e fornecemos um guia passo-a-passo sobre a importação de ficheiros Parquet para o Milvus, abrindo novas possibilidades para uma gestão e análise de dados eficiente.
O que é o Apache Parquet?
O Apache Parquet é um popular formato de ficheiro de dados orientado para colunas, de código aberto, concebido para aumentar a eficiência do armazenamento e processamento de conjuntos de dados em grande escala. Em contraste com os formatos de dados tradicionais orientados para linhas, como CSV ou JSON, o Parquet armazena dados por coluna, oferecendo esquemas de compressão e codificação de dados mais eficientes. Esta abordagem traduz-se num melhor desempenho, em requisitos de armazenamento reduzidos e numa maior capacidade de processamento, tornando-o ideal para o tratamento de dados complexos em massa.
Como os usuários do Milvus se beneficiam do suporte para importação de arquivos Parquet
O Milvus amplia o suporte para a importação de ficheiros Parquet, proporcionando aos utilizadores experiências optimizadas e várias vantagens, incluindo despesas de armazenamento e computação reduzidas, gestão de dados optimizada e um processo de importação simplificado.
Eficiência de armazenamento optimizada e gestão de dados simplificada
O Parquet oferece opções de compressão flexíveis e esquemas de codificação eficientes que atendem a diferentes tipos de dados, garantindo uma eficiência de armazenamento optimizada. Esta flexibilidade é particularmente valiosa em ambientes de nuvem, onde cada grama de poupança de armazenamento está diretamente relacionada com reduções de custos tangíveis. Com esta nova funcionalidade do Milvus, os utilizadores podem consolidar sem esforço todos os seus dados diversos num único ficheiro, simplificando a gestão de dados e melhorando a experiência geral do utilizador. Esta funcionalidade é particularmente vantajosa para os utilizadores que trabalham com tipos de dados Array de comprimento variável, que podem agora desfrutar de um processo de importação de dados simplificado.
Desempenho de consulta melhorado
O design de armazenamento em colunas do Parquet e os métodos avançados de compressão melhoram significativamente o desempenho das consultas. Quando realizam consultas, os utilizadores podem concentrar-se apenas nos dados pertinentes, sem percorrer os dados irrelevantes. Esta leitura selectiva de colunas minimiza a utilização da CPU, resultando em tempos de consulta mais rápidos.
Ampla compatibilidade de idiomas
O Parquet está disponível em várias linguagens, como Java, C++ e Python, e é compatível com um grande número de ferramentas de processamento de dados. Com o suporte de ficheiros Parquet, os utilizadores do Milvus que utilizam diferentes SDKs podem gerar facilmente ficheiros Parquet para análise na base de dados.
Como importar ficheiros Parquet para o Milvus
Se os seus dados já estiverem no formato de ficheiro Parquet, a importação é fácil. Carregue o ficheiro Parquet para um sistema de armazenamento de objectos, como o MinIO, e está pronto para importar.
O trecho de código abaixo é um exemplo de importação de ficheiros Parquet para o 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 os seus dados não forem ficheiros Parquet ou tiverem campos dinâmicos, pode utilizar o BulkWriter, a nossa ferramenta de conversão de formatos de dados, para o ajudar a gerar ficheiros Parquet. O BulkWriter adoptou agora o Parquet como formato de dados de saída predefinido, garantindo uma experiência mais intuitiva para os programadores.
O fragmento de código abaixo é um exemplo de utilização do BulkWriter para gerar ficheiros 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
Depois, pode começar a importar os seus ficheiros Parquet para o 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
Agora, os seus dados estão perfeitamente integrados no Milvus.
O que vem a seguir?
À medida que o Milvus continua a suportar volumes de dados cada vez maiores, surge o desafio de gerir importações de grandes dimensões, particularmente quando os ficheiros Parquet ultrapassam os 10GB. Para enfrentar este desafio, planeamos separar os dados de importação em colunas escalares e vectoriais, criando dois ficheiros Parquet por importação para aliviar a pressão de I/O. Para conjuntos de dados que excedam várias centenas de gigabytes, recomendamos a importação dos dados várias vezes.
- O que é o Apache Parquet?
- Como os usuários do Milvus se beneficiam do suporte para importação de arquivos Parquet
- Como importar ficheiros Parquet para o Milvus
- O que vem a seguir?
On This Page
Try Managed Milvus for Free
Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.
Get StartedLike the article? Spread the word