Parquet Content-Defined Chunking con Xet Storage en Hugging Face Hub

Visión general

Parquet Content-Defined Chunking (CDC) está disponible para PyArrow y Pandas, permitiendo una deduplicación eficiente de archivos Parquet sobre la capa de almacenamiento Xet de Hugging Face. CDC deduplica datos a nivel de páginas o bloques de contenido definidos, de modo que al subir o descargar Parquet solo se transfieren los datos modificados. Esto puede reducir drásticamente el tráfico y los costos de almacenamiento, especialmente para grandes conjuntos de datos alojados en el Hub. Xet es una capa de almacenamiento diseñada para deduplicar bloques entre repos y archivos. La disposición de Parquet — bloques de columnas y páginas de datos con compresión — puede producir representaciones byte-level diferentes para cambios pequeños. CDC resuelve esto creando bloques basados en el contenido, alineando la deduplicación con los datos lógicos. Para desarrolladores, puedes habilitar CDC pasando use_content_defined_chunking=True a la función write_parquet (PyArrow). Pandas también soporta la característica. Con PyArrow, puedes leer y escribir datos Parquet en Hugging Face Hub a través de las URIs hf:// cuando pyarrow>=21.0.0 está instalado. El Hub recopila estadísticas de almacenamiento y demuestra que los datos subidos pueden ser considerablemente más pequeños cuando se usa CDC. El blog ilustra escenarios como añadir o eliminar columnas, cambiar tipos de columnas y añadir filas. Muestra deduplicación entre repos y entre archivos, así como el impacto de distintos tamaños de row-group. En resumen, Parquet CDC, combinado con Xet, permite flujos de trabajo de datos más eficientes y escalables en el Hub.

Características clave

El chunking definido por el contenido opera a nivel de páginas de datos Parquet (bloques de columnas) para mejorar la granularidad de la deduplicación.
Funciona con PyArrow y Pandas, permitiendo CDC en escrituras Parquet.
Deduplicación entre repos y entre archivos, no solo dentro de un único archivo.
Integración con la capa de almacenamiento Hugging Face Xet para reducir los bytes transferidos y la huella de almacenamiento.
Soporte para ediciones comunes de Parquet (agregar/eliminar columnas, cambiar tipos) con menos movimiento de datos.
Compatibilidad con hf:// URIs, permitiendo lectura/escritura directa al Hub cuando se instala pyarrow>=21.0.0.
El rendimiento de deduplicación depende de cómo se distribuyen los cambios en los datos y de las restricciones del lector/escritor; el tamaño de row-group puede influir.
Señala que las descargas también se benefician de CDC al usar las APIs del Hub (hf_hub_download, datasets.load_dataset).

Casos de uso comunes

Grandes conjuntos Parquet almacenados en Xet donde los datos evolucionan con el tiempo y se quiere evitar reenviar datos no modificados.
Flujos de trabajo colaborativos entre varios repos, compartiendo columnas o filas actualizadas con transferencias mínimas.
Escenarios de evolución de esquemas (agregar/eliminar columnas, cambiar tipos) donde solo las partes afectadas se transfieren.
Pipelines de datos que dependen de la organización por columnas de Parquet y buscan optimizar el almacenamiento y el ancho de banda entre backends estilo nube.

Setup & instalación

Para usar Parquet CDC, necesitarás PyArrow 21.0.0 o superior y el ecosistema Pandas. Instala los paquetes requeridos y luego ejecuta escrituras con CDC.

# Instalar dependencias principales con soporte CDC
pip install "pyarrow>=21.0.0" pandas

# Opcional: instalar herramientas adicionales de Hugging Face para acceder a datasets
pip install huggingface_hub datasets

# Ejemplo PyArrow: escribir una tabla con CDC activado
import pyarrow as pa
import pyarrow.parquet as pq
# tabla simple
tbl = pa.Table.from_pydict({"id": [1, 2, 3], "valor": [100, 200, 300]})
# activar chunking definido por el contenido
pq.write_table(tbl, "hf://mi-repo/data.parquet", use_content_defined_chunking=True)

# Ejemplo Pandas: escribir un DataFrame con CDC activado
import pandas as pd
df = pd.DataFrame({"id": [1, 2, 3], "valor": [100, 200, 300]})
df.to_parquet("hf://mi-repo/data.parquet", use_content_defined_chunking=True)

Nota: CDC requiere pyarrow>=21.0.0 para habilitar I/O hf:// directos al Hub.

Quick start

El flujo mínimo siguiente demuestra escritura con CDC y lectura posterior para ver la deduplicación y el rendimiento del Hub.

import pyarrow as pa
import pyarrow.parquet as pq
# 1) Crear y escribir datos iniciales
tbl1 = pa.Table.from_pydict({"id": [1, 2, 3], "valor": [100, 200, 300]})
pq.write_table(tbl1, "hf://mi-repo/data.parquet", use_content_defined_chunking=True)
# 2) Leer
print(pq.read_table("hf://mi-repo/data.parquet"))
# 3) Modificar datos (p. ej., añadir columna)
tbl2 = tbl1.append_column("extra", pa.array([1, 1, 1]))
pq.write_table(tbl2, "hf://mi-repo/data.parquet", use_content_defined_chunking=True)
# 4) Leer datos actualizados
print(pq.read_table("hf://mi-repo/data.parquet"))

Este flujo muestra cómo CDC permite escribir con menos datos transferidos y leer de vuelta desde el Hub.

Ventajas y desventajas

Ventajas
Reducción significativa del tamaño de uploads/downloads para Parquet cuando los cambios son incrementales.
Deduplicación entre repos y entre archivos, facilitando el intercambio eficiente de datos.
Funciona con flujos Parquet estándar vía PyArrow y Pandas, con acceso directo al Hub mediante hf://.
Soporta ediciones de Parquet con menos movimiento de datos.
Desventajas
El rendimiento de deduplicación depende de cómo se traducen los cambios en las páginas de Parquet; algunas modificaciones pueden reducir los beneficios.
El rendimiento óptimo puede requerir ajustar el tamaño de row-group según la carga de trabajo.
Requiere que los escritores de Parquet soporten CDC.

Alternativas (comparaciones breves)

| Enfoque | Deduplicación entre repos | Soporte CDC | Notas |---|---|---|---| | Parquet sin CDC en Xet | No | No | Transfiere los datos completos en reenvíos. |Parquet CDC con Xet (Hub) | Sí | Sí | Reduce la transferencia de datos; depende de escritores con CDC. |Almacenamiento en la nube tradicional sin Xet | No | No | Transfiere datos más grandes con mayor frecuencia. |