Descripción general

DataComp-LM (DCLM) es un entorno integral para la creación y el entrenamiento de grandes modelos de lenguaje (LLMs). Ofrece un corpus estandarizado de más de 300 billones de tokens sin filtrar de CommonCrawl, recetas de preentrenamiento eficientes basadas en el framework open_lm y una amplia suite de más de 50 evaluaciones. Este repositorio proporciona herramientas y guías para procesar datos crudos, tokenizar, aleatorizar, entrenar modelos y evaluar su rendimiento.

El framework permite a los investigadores experimentar con diversas estrategias de construcción de conjuntos de datos en diferentes escalas computacionales, desde modelos de 411 millones hasta 7 mil millones de parámetros. Los experimentos demuestran que el diseño optimizado del conjunto de datos puede mejorar significativamente el rendimiento del modelo.

DCLM ha generado múltiples conjuntos de datos de alto rendimiento que superan a todos los conjuntos de datos públicos disponibles en diversas escalas.

Tabla de clsaificación (Leaderboard)

La tabla de clasificación de DCLM muestra el rendimiento de los modelos entrenados en diferentes escalas y conjuntos de datos. Se actualiza periódicamente con los nuevos envíos de la comunidad. A continuación se muestra una comparación a escala de 7B con otros modelos.

Flujo de trabajo

El proceso de DCLM consta de cinco etapas principales: (1) selección de fuentes de datos crudos; (2) procesamiento de datos; (3) tokenización y aleatorización; (4) entrenamiento del modelo; (5) evaluación del modelo. Para la elegibilidad en la tabla de clasificación, se deben utilizar los scripts proporcionados para las etapas (3) a (5).

El repositorio utiliza la carpeta exp_data para registrar las entradas y salidas de cada paso mediante archivos JSON de referencia, que actúan como identificadores únicos para los activos (conjuntos de datos, modelos, evaluaciones).

Instrucciones de configuración

1. Clonar el repositorio: ``` git clone https://github.com/mlfoundations/DCLM.git cd DCLM

2. Instalar dependencias: ``` pip install -r requirements.txt

3. Configurar el entorno: DCLM utiliza AWS para almacenamiento y Ray para procesamiento distribuido. Se recomienda Python 3.10.

Procesamiento de datos

Esta etapa permite aplicar estrategias de curación de datos personalizadas. Incluye dos componentes principales.

Filtrado y limpieza basados en Ray

El código incluye un motor de procesamiento basado en ray para aplicar operaciones de filtrado de forma altamente paralelizada. Los pasos implican definir un pipeline en un archivo YAML de configuración, configurar un clúster de Ray y ejecutar el script.

python3 ray_processing/process.py \
  --source_ref_paths <ruta_json_fuente> \
  --readable_name <nombre> \
  --output_dir <dir_salida_s3> \
  --config_path <config_yaml> \
  --source_name <nombre_fuente>

Para monitorear el progreso, se puede revisar el archivo global_stats.jsonl en el directorio de salida.

Deduplicación

La implementación más eficiente para deduplicación difusa está escrita en Rust y se encuentra en el subdirectorio dedup. Para deduplicación exacta, se proporcionan herramientas basadas en Ray como ray_processing/dedup_jsonl.py.

Tokenización y aleatorización

Después del procesamiento de datos, se prepara el conjunto de datos para el entrenamiento mediante tokenización y aleatorización.

Implementación en Rust (Recomendada)

cd rust_processing/tokshuf-rs
cargo build --release
cargo run --release -- \
  --input <ruta/dataset/crudo> \
  --local-cell-dir <ruta/tmp/local> \
  --output <ruta/salida> \
  --tokenizer "EleutherAI/gpt-neox-20b" \
  --seqlen 2049 \
  --wds-chunk-size 8192 \
  --num-local-cells 512

Implementación basada en Ray

python ray_processing/tokenize_shuffle.py \
  --source_ref_paths <jsons_fuentes> \
  --readable_name <nombre> \
  --output <dir_salida_s3> \
  --content_key text \
  --do_sample \
  --default_dataset_yaml <mixing_yaml>

Este script crea un conjunto de datos en formato webdataset y un archivo manifest.jsonl requerido para el entrenamiento.

Entrenamiento del modelo

Para entrenar un modelo con un conjunto de datos tokenizado y una receta fija:

torchrun --nproc-per-node <num_gpus> -m training.train -- \
  --scale <escala> \
  --data-config <json_tokenizado> \
  --logs <dir_logs> \
  --attn-name torch_attn \
  [--remote-sync <bucket_s3>] \
  [--report-to-wandb] \
  [--num-checkpoints <num>] \
  [--multiple-data-passes] \
  [--acc 4] \
  [--torchcompile]

Las escalas disponibles y sus costos computacionales correspondientes se encuentran en training/configs.

Evaluación del modelo

Los archivos YAML de evaluación en la carpeta eval definen las tareas a evaluar. Para evaluar un modelo entrenado:

Método 1: Usando la base de datos de experimentos

python tools/eval_expdb.py \
  --num_gpus <num_gpus> \
  --no_skip \
  --output_dir <dir_salida> \
  --eval_yaml "eval/<eval_yaml>" \
  -f "uuid=<uuid_modelo>" \
  --skip_perplexity

Método 2: Evaluación directa

torchrun --nproc_per_node <num_gpus> eval/eval_openlm_ckpt.py \
  --checkpoint <ruta_checkpoint> \
  --eval-yaml <eval_yaml> \
  --config <archivo_params_modelo> \
  --model <config_open_lm> \
  --output-file <ruta_archivo_salida>

Recursos disponibles

Conjuntos de datos

• Pools de competencia: Disponibles para descargar desde data/competition_pools/preextracted/.
• DCLM-BASELINE: El conjunto de datos final procesado, disponible en Hugging Face y en el bucket S3 de CommonCrawl.
• DCLM-RefinedWeb: Una versión del dataset con todos los pasos de preprocesamiento excepto el filtrado final con fastText.

Modelos preentrenados

Modelos entrenados con los datasets de DCLM están disponibles a través de la colección DCLM en Hugging Face.

Ejemplo completo: Entrenando un modelo de 1B con la línea base

Configuración con Conda

conda create -n dclm python=3.10
conda activate dclm
git clone https://github.com/mlfoundations/DCLM.git
cd DCLM
export PYTHONPATH="$(pwd):$PYTHONPATH"
pip install -r requirements.txt

Tokenización y aleatorización

# Instalar Rust y compilar la herramienta
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup.sh
bash rustup.sh -y && source ~/.bashrc
cd rust_processing/tokshuf-rs && cargo build --release

# Descargar y procesar datos
aws s3 cp --recursive s3://commoncrawl/contrib/datacomp/DCLM-baseline/global-shard_03_of_10/local-shard_1_of_10/ ./dclm_raw
cargo run --release -- \
  --input ./dclm_raw \
  --local-cell-dir ./tmp_cells \
  --output ./dclm_tokenized \
  --tokenizer "EleutherAI/gpt-neox-20b" \
  --seqlen 2049 \
  --wds-chunk-size 8192 \
  --num-local-cells 512

Entrenamiento

torchrun --nproc-per-node 8 -m training.train -- \
  --scale 1b_1x_fast \
  --data-config exp_data/datasets/tokenized/dclm_procesado.json \
  --logs ./logs_entrenamiento \
  --attn-name torch_attn \
  --torchcompile

Evaluación

python tools/eval_expdb.py \
  --num_gpus 8 \
  --no_skip \
  --output_dir exp_data/evals/ \
  --eval_yaml "eval/mmlu_and_lowvar.yaml" \
  -f "uuid=<UUID_DEL_MODELO>" \
  --skip_perplexity

Contribución y citación

Las contribuciones son bienvenidas siguiendo las directrices del proyecto. Si utiliza los datos o modelos de DCLM, consulte el archivo de citación propocrionado en el repositorio.

Este proyecto está bajo la licencia MIT.