Integraciones de Bucket

La mayoría de las herramientas ya pueden usar un bucket, de una de las dos formas siguientes:

• Las bibliotecas de Python basadas en fsspec (pandas, Dask, PyArrow y otras) leen y escriben rutas hf://buckets/ a través de la interfaz de sistema de archivos de huggingface_hub.
• Las herramientas que se comunican con S3 (boto3, la CLI de AWS, rclone, DVC y otras) funcionan contra la API compatible con S3.

Esta página cubre las bibliotecas con soporte de buckets integrado, además de ejemplos para bibliotecas de datos comunes. Para montajes y montajes de volúmenes, consulte Patrones de acceso.

pandas

import pandas as pd

df = pd.read_parquet("hf://buckets/username/my-bucket/data.parquet")
df.to_parquet("hf://buckets/username/my-bucket/output.parquet")

Dask

Dask lee y escribe de forma perezosa, una partición por archivo, por lo que puede procesar conjuntos de datos más grandes que la memoria directamente desde un bucket:

import dask.dataframe as dd

df = dd.read_parquet("hf://buckets/username/my-bucket/data/")
df.to_parquet("hf://buckets/username/my-bucket/output/")

Consulte Dask en el Hub para obtener más información.

Daft

Daft admite de forma nativa las rutas hf://buckets/, con lecturas aceleradas por Xet habilitadas de forma predeterminada:

import daft
from daft.io import IOConfig, HuggingFaceConfig
from huggingface_hub import get_token

io_config = IOConfig(hf=HuggingFaceConfig(token=get_token()))
df = daft.read_parquet("hf://buckets/username/my-bucket/data.parquet", io_config=io_config)

PyArrow

import pyarrow.parquet as pq

table = pq.read_table("hf://buckets/username/my-bucket/data.parquet")

PySpark

Con pyspark_huggingface instalado:

df = (
    spark.read.format("huggingface")
    .option("data_files", '["data.parquet"]')
    .load("buckets/username/my-bucket")
)

Consulte PySpark en el Hub para obtener más información.

🤗 Datasets

from datasets import load_dataset

ds = load_dataset("buckets/username/my-bucket", data_files=["data.parquet"])

datatrove

Los lectores y escritores de datatrove aceptan rutas hf://buckets/. HuggingFaceBucketWriter sube salidas grandes con Xet:

from datatrove.pipeline.readers import ParquetReader
from datatrove.pipeline.writers import HuggingFaceBucketWriter

reader = ParquetReader(data_folder="hf://buckets/username/my-bucket/raw/")
writer = HuggingFaceBucketWriter(bucket="username/my-bucket", prefix="filtered")

Consulte el README de datatrove para obtener más información.

LeRobot

LeRobot puede transmitir un conjunto de datos de entrenamiento desde un bucket. El bucket debe contener el conjunto de datos completo (meta/, archivos Parquet y de video) en su raíz:

lerobot-train \
  --dataset.repo_id=username/my-bucket \
  --dataset.repo_type=bucket \
  --dataset.streaming=true \
  --policy.type=act

Diffusers

diffusers-cli run sube sus salidas a un bucket con --push-to. El bucket se crea si no existe:

diffusers-cli run --model black-forest-labs/FLUX.1-dev --dtype bf16 \
  --pipeline-kwargs '{"prompt": "an astronaut riding a horse"}' \
  --push-to hf://buckets/username/my-bucket/outputs

Consulte la guía de la CLI de Diffusers para obtener más información.

Trackio

Cuando Trackio registra en un Space, almacena los datos de ejecución en un bucket creado a partir del ID del Space. Pasa bucket_id a trackio.init() para usar un bucket que elijas.

Inspect AI

Inspect AI puede escribir registros de evaluación directamente en un bucket: dirija su directorio de registros a una ruta hf://buckets/ (requiere huggingface_hub>=1.6.0). Cree el bucket y autentifíquese primero (Inspect no lo creará por usted):

hf auth login
hf buckets create username/my-bucket --private

export INSPECT_LOG_DIR=hf://buckets/username/my-bucket/eval-logs
inspect eval popularity.py --model openai/gpt-4
inspect view

Consulte la guía de registros de evaluación de Inspect para obtener más detalles.

SkyPilot

SkyPilot ejecuta cargas de trabajo de IA en más de 20 nubes, Kubernetes y en entornos on-prem, y puede usar el almacenamiento de Hugging Face como backend: así, un solo bucket es legible desde cualquier nube sin copias por nube. Establece store: hf en una entrada de file_mounts para montar un bucket en modo lectura-escritura o un repositorio en modo solo lectura:

# qwen-sft.yaml — launch anywhere: sky launch qwen-sft.yaml --infra aws|gcp|...
resources:
  accelerators: H100:1

file_mounts:
  /base-model:
    source: hf://Qwen/Qwen2.5-3B           # model repo, read-only
    store: hf
    mode: MOUNT
  /data:
    source: hf://datasets/username/my-data@v1.0   # dataset repo, pinned to a tag, read-only
    store: hf
    mode: MOUNT
  /checkpoints:
    source: hf://buckets/username/qwen-sft   # bucket, read-write — checkpoints sync back
    store: hf
    mode: MOUNT

run: |
  python train.py --model /base-model --output_dir /checkpoints

Autentíquese una vez: hf auth login (o export HF_TOKEN=<your-token>) es todo lo que SkyPilot necesita. Reenvía su token local de Hugging Face a cada nube, de modo que las monturas de bucket y repo se autentican automáticamente:

pip install "skypilot[huggingface]"
hf auth login                              # or: export HF_TOKEN=<your-token>
sky launch qwen-sft.yaml

Si tu propio código de run descarga repositorios con acceso restringido, añade --secret HF_TOKEN al comando de inicio para exponer también el token como variable de entorno.

MOUNT y MOUNT_CACHED se comportan de manera idéntica para hf y utilizan el backend FUSE hf-mount, que requiere una imagen base con glibc ≥ 2.34 y /dev/fuse. Las nubes de VMs sin intermediarios proporcionan ambos. La imagen de Kubernetes predeterminada de SkyPilot incluye una versión de glibc más antigua, por lo que debe establecer un image_id más reciente (p. ej. docker:mirror.gcr.io/ubuntu:22.04). Consulte la documentación de almacenamiento de SkyPilot para conocer los requisitos actuales del entorno.

Consulte el post de blog de SkyPilot + Hugging Face sobre almacenamiento para ver los benchmarks y una guía completa.

Operaciones del sistema de archivos

Para operaciones de archivo directas, huggingface_hub expone un objeto de sistema de archivos preinstanciado, hffs:

from huggingface_hub import hffs

with hffs.open("buckets/username/my-bucket/hello.txt", "w") as f:
    f.write("Hello world!")

hffs.cp("buckets/username/my-bucket/hello.txt", "buckets/username/my-bucket/hello2.txt")
hffs.rm("buckets/username/my-bucket/hello2.txt")
files = hffs.ls("buckets/username/my-bucket")
text_files = hffs.glob("buckets/username/my-bucket/*.txt")

DuckDB

DuckDB 2.0 y versiones posteriores leen las rutas hf://buckets/ de forma nativa a través de la extensión httpfs (y con la extensión hf para escritura), desde la CLI y todos los clientes:

SELECT * FROM 'hf://buckets/username/my-bucket/data/**/*.parquet' LIMIT 10;
COPY tbl TO 'hf://buckets/username/my-bucket/out.parquet';

Consulte Query with DuckDB para cubetas privadas y versiones anteriores de DuckDB.

Otros idiomas

OpenDAL ofrece una interfaz de sistema de archivos similar para Rust, Java, Go, JavaScript y más.

Próximamente

La compatibilidad nativa con URLs hf:// está en camino para más bibliotecas, incluida WebDataset. Mientras tanto, todas estas ya funcionan hoy a través de la API compatible con S3.