Phase 00: Setup & Tooling

Gestión de datos

Type: Build

Language:Python

Prerequisites: Phase 0, Lesson 01

Time: ~45 minutes

Objetivos de aprendizaje

• Cargar, transmitir y almacenar en caché conjuntos de datos utilizando el Face Hugging datasetsbiblioteca
• Convertir entre los formatos CSV, JSON, Parquet y Arrow y explicar sus compensaciones
• Crear divisiones reproducibles de tren/validación/pruebas con semillas aleatorias fijas
• Gestionar archivos de modelos y conjuntos de datos grandes utilizando .gitignore, Git LFS o DVC

El problema

Cada proyecto de IA comienza con datos. Necesitas encontrar conjuntos de datos, descargarlos, convertirlos entre formatos, dividirlos para entrenamiento y evaluación, y versionarlos para que los experimentos sean reproducibles. Hacer esto manualmente cada vez es lento y propenso a errores. Necesitas un flujo de trabajo repetible.

El concepto

graph TD
    A["Hugging Face Hub"] --> B["datasets library"]
    B --> C["Load / Stream"]
    C --> D["Local Cache<br/>~/.cache/huggingface/"]
    B --> E["Format Conversion<br/>CSV, JSON, Parquet, Arrow"]
    E --> F["Data Splits<br/>train / val / test"]
    F --> G["Your Training Pipeline"]

El rostro abrazadodatasetsLa biblioteca es la forma estándar de cargar datos para el trabajo de IA. Se encarga de descargar, almacenar en caché, convertir formato y transmitir fuera de la caja.

Construye el mismo

Paso 1: Instalar la biblioteca de conjuntos de datos

bashCopypip install datasets huggingface_hub

Paso 2: Cargar un conjunto de datos

pythonCopyfrom datasets import load_dataset

dataset = load_dataset("stanfordnlp/imdb")
print(dataset)
print(dataset["train"][0])

Esto descarga el conjunto de datos de revisión de películas de IMDB. Después de la primera descarga, se carga desde la caché en ~/.cache/huggingface/datasets/¿ Qué ?

Paso 3: Transmite grandes conjuntos de datos

Algunos conjuntos de datos son demasiado grandes para caber en el disco.

pythonCopydataset = load_dataset("wikimedia/wikipedia", "20231101.en", split="train", streaming=True)

for i, example in enumerate(dataset):
    print(example["title"])
    if i >= 4:
        break

El streaming te da una oportunidad .IterableDatasetEl uso de memoria se mantiene constante independientemente del tamaño del conjunto de datos.

Paso 4: Formatos de conjunto de datos

El datasetsLa biblioteca utiliza Apache Arrow bajo el capó. Puedes convertirlo a otros formatos dependiendo de lo que tu tubería necesite.

pythonCopydataset = load_dataset("stanfordnlp/imdb", split="train")

dataset.to_csv("imdb_train.csv")
dataset.to_json("imdb_train.json")
dataset.to_parquet("imdb_train.parquet")

Comparación de formato:

Para el trabajo de IA, Parquet es el mejor formato de almacenamiento. Arrow es lo que se trabaja en la memoria. CSV y JSON son para el intercambio.

Paso 5: División de datos

Cada proyecto de ML necesita tres divisiones:

• TrainEl modelo aprende de esto (normalmente el 80%)
• Validation: Verifica el progreso durante la formación (normalmente 10%)
• Test: Evaluación final después de la formación (normalmente 10%)

Algunos conjuntos de datos vienen pre-divididos. Cuando no lo hacen, dividielos tú mismo:

pythonCopydataset = load_dataset("stanfordnlp/imdb", split="train")

split = dataset.train_test_split(test_size=0.2, seed=42)
train_val = split["train"].train_test_split(test_size=0.125, seed=42)

train_ds = train_val["train"]
val_ds = train_val["test"]
test_ds = split["test"]

print(f"Train: {len(train_ds)}, Val: {len(val_ds)}, Test: {len(test_ds)}")

Siempre fije una semilla para la reproducibilidad.

Paso 6: Descargar y almacenar modelos en caché

Los modelos son archivos grandes.huggingface_hublibrería maneja descarga y almacenamiento en caché.

pythonCopyfrom huggingface_hub import hf_hub_download, snapshot_download

model_path = hf_hub_download(
    repo_id="sentence-transformers/all-MiniLM-L6-v2",
    filename="config.json"
)
print(f"Cached at: {model_path}")

model_dir = snapshot_download("sentence-transformers/all-MiniLM-L6-v2")
print(f"Full model at: {model_dir}")

Modelos en caché para ~/.cache/huggingface/hub/Una vez descargados, se cargan instantáneamente en las siguientes carreras.

Paso 7: Manejar archivos grandes

Los pesos de modelo y los grandes conjuntos de datos no deben entrar en git.

Option A: .gitignore (simplest)

Copy*.bin
*.safetensors
*.pt
*.onnx
data/*.parquet
data/*.csv
models/

Option B: Git LFS (track large files in git)

bashCopygit lfs install
git lfs track "*.bin"
git lfs track "*.safetensors"
git add .gitattributes

Git LFS almacena los punteros en su repo y los archivos reales en un servidor separado. GitHub le da 1 GB gratis.

Option C: DVC (data version control)

bashCopypip install dvc
dvc init
dvc add data/training_set.parquet
git add data/training_set.parquet.dvc data/.gitignore
git commit -m "Track training data with DVC"

DVC crea pequeñas ..dvcLos datos en sí viven en S3, GCS, o otro backend de almacenamiento remoto.

Para este curso,.gitignoreUtilice DVC cuando necesite reproducir experimentos exactos en máquinas.

Paso 8: Modelos de almacenamiento

Local storagefunciona para conjuntos de datos de menos de ~ 10 GB. El caché HF maneja esto automáticamente.

Cloud storagees para cualquier cosa más grande o compartida entre máquinas:

pythonCopyimport os

local_path = os.path.expanduser("~/.cache/huggingface/datasets/")

# s3_path = "s3://my-bucket/datasets/"
# gcs_path = "gs://my-bucket/datasets/"

DVC se integra directamente con S3 y GCS:

bashCopydvc remote add -d myremote s3://my-bucket/dvc-store
dvc push

El almacenamiento en la nube se vuelve relevante cuando se ajusta a las instancias remotas de la GPU.

Datos utilizados en este curso

No es necesario descargar todas estas cosas ahora, cada lección especifica lo que necesita.

Usalo

Ejecutar el script de utilidad para verificar todo funciona:

bashCopypython code/data_utils.py

Esto descarga un pequeño conjunto de datos, lo convierte, lo divide y imprime un resumen.

Envío

Esta lección produce:

• code/data_utils.py- utilidad de carga y almacenamiento en caché de datos reutilizables
• outputs/prompt-data-helper.md- de manera rápida para encontrar el conjunto de datos adecuado para una tarea

Los ejercicios

1. Carga el glueconjunto de datos con el mrpcConfigurar e inspeccionar los primeros 5 ejemplos
2. Envía el c4conjunto de datos y contar cuántos ejemplos puede procesar en 10 segundos
3. Convierta un conjunto de datos a Parquet y compara el tamaño del archivo a CSV
4. Crear una división de tren/val/prueba 70/15/15 con semilla fija y verificar los tamaños

Términos clave

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.