large_concept_model
1.0.0
[Blog] [Documento]
Este repositorio proporciona las implementaciones y experimentos oficiales para modelos de concepto grande ( LCM ).
El LCM funciona con una representación semántica explícita de nivel superior, que nombramos un "concepto". Los conceptos son del lenguaje y la modalidad agnóstica y representan una idea de nivel superior. En este trabajo, un concepto corresponde a una oración, y usamos el espacio de incrustación de sonar, que respalda hasta 200 idiomas en texto y 57 idiomas en el habla. Vea la lista de idiomas compatibles aquí.
El LCM es un modelo de secuencia a secuencia en el espacio de conceptos entrenado para realizar una predicción de oraciones auto-regresivas. Exploramos múltiples enfoques:
base_lcm en este código).two_tower_diffusion_lcm en esta versión).Estas exploraciones se realizan utilizando modelos de parámetros 1.6B y datos de entrenamiento en el orden de tokens 1.3T. Incluimos en este repositorio recetas para reproducir la capacitación y el ficha de 1,6B MSE LCM y la difusión de dos torres LCM. Vea las instrucciones a continuación.
El repositorio de LCM se basa en Fairseq2. Si tiene instalado uv en su sistema, puede instalar un entorno virtual con todos los paquetes necesarios ejecutando los siguientes comandos:
uv sync --extra cpu --extra eval --extra data También puede usar uv run para ejecutar los comandos de demostración con el entorno correcto.
Tenga en cuenta que solo proporcionamos requisitos para las dependencias cpu , si desea utilizar el soporte de GPU, deberá elegir las variantes de antorcha y FairSeq2 que funcionan para su sistema. Por ejemplo, para la antorcha 2.5.1 con CUDA 1.21, haría algo como:
uv pip install torch==2.5.1 --extra-index-url https://download.pytorch.org/whl/cu121 --upgrade
uv pip install fairseq2==v0.3.0rc1 --pre --extra-index-url https://fair.pkg.atmeta.com/fairseq2/whl/rc/pt2.5.1/cu121 --upgrade
Verifique las variantes Fairseq2 para ver las posibles variantes. Tenga en cuenta que LCM se basa actualmente en el candidato de lanzamiento para Fairseq2 0.3.0 RC1.
Para instalar con PIP, los comandos son muy similares, pero deberá administrar su propio entorno y asegurarse de instalar Fairseq2 manualmente primero. Por ejemplo, para una instalación cpu .
pip install --upgrade pip
pip install fairseq2==v0.3.0rc1 --pre --extra-index-url https://fair.pkg.atmeta.com/fairseq2/whl/rc/pt2.5.1/cpu
pip install -e " .[data,eval] "Si Fairseq2 no proporciona una compilación para su máquina, consulte el readme de ese proyecto para construirlo localmente.
Nota
Si usa el prefijo uv todos los comandos con uv run para usar el entorno creado de forma predeterminada en .venv , EG, uv run torchrun --standalone . Alternativamente, puede activar el entorno de una vez por todas con source .venv/bin/activate .
El LCM puede ser entrenado y evaluado utilizando datos textuales divididos en oraciones e integrado con sonar. Proporcionamos una tubería de procesamiento de muestras que se puede utilizar para preparar dichos datos de capacitación, puede ejecutarlo con:
uv run --extra data scripts/prepare_wikipedia.py /output/dir/for/the/data
Esta tubería muestra cómo obtener un conjunto de datos de Huggingface y procesarlo con Sonar y SAT. Consulte el archivo para obtener más detalles sobre cómo procesar sus propios datos. Si bien el script proporciona un ejemplo de extraer datos de Huggingface, también proporcionamos API para procesar JSONL, Parquet y CSV.
El entrenador que se describe a continuación se basa en Datacards que configuran los conjuntos de datos. Estos datos son archivos YAML con punteros a los archivos del conjunto de datos (localmente o en S3) e información sobre su esquema. Proporcionamos algunos de muestra Datacards en lcm/datacards/datacards.yaml . Una vez que haya procesado algunos datos, puede actualizar los Datacards con sus rutas.
Para ajustar un nuevo normalizador de espacio de incrustación en una mezcla ponderada dada de conjuntos de datos, se puede usar el siguiente comando:
python scripts/fit_embedding_normalizer.py --ds dataset1:4 dataset2:1 dataset3:10 --save_path " path/to/new/normalizer.pt " --max_nb_samples 1000000 Aquí, dataset1 , dataset2 , dataset3 son los nombres de los conjuntos de datos declarados en los DataCards como se muestra arriba y (4, 1, 10) sus respectivos pesos relativos. El normalizador resultante se puede declarar a continuación como un modelo como se muestra en lcm/cards/sonar_normalizer.yaml y referenciado en todas las configuraciones de entrenamiento de modelos.
Para entrenar un MSE LCM, usaremos uno de los siguientes comandos:
Opción 1. Entrenamiento con slurm usando Submitit a través del lanzador de Stopes:
python -m lcm.train
+pretrain=mse
++trainer.output_dir= " checkpoints/mse_lcm "
++trainer.experiment_name=training_mse_lcm Con este comando, enviaremos un trabajo de slurm llamado training_mse_lcm con los requisitos de la receta, en este caso:
requirements :
nodes : 4
tasks_per_node : 8
gpus_per_node : 8
cpus_per_task : 32
mem_gb : 0
timeout_min : 10000Puede anular los requisitos del trabajo como el límite de tiempo de espera y la partición de slurm del lanzador con:
python -m lcm.train
+pretrain=mse
++trainer.output_dir= " checkpoints/mse_lcm "
++trainer.experiment_name=training_mse_lcm
++trainer.requirements.timeout_min=100
++trainer.requirements.cpus_per_task=8
++launcher.partition= $partition_name Opción 2. Entrenamiento localmente con torchrun (por ejemplo, usando solo 2 GPU) con un tamaño por lotes más pequeño (anular ++trainer.data_loading_config.max_tokens=1000 ):
CUDA_VISIBLE_DEVICES=0,1 torchrun --standalone --nnodes=1 --nproc-per-node=2
-m lcm.train launcher=standalone
+pretrain=mse
++trainer.data_loading_config.max_tokens=1000
++trainer.output_dir= " checkpoints/mse_lcm "
+trainer.use_submitit=false Importante
Dado que estamos cambiando el número de GPU requeridas por la receta, esto no reproducirá la configuración experimental del documento.
Los puntos de control del directorio checkpoints/mse_lcm se estructurarán como:
.
├── checkpoints
│ ├── step_2000
│ ├── ...
│ └── step_250000
├── config_logs
├── executor_logs
├── model_card.yaml
├── tb # tensorboard logs
└── wandb # W&B logs
Tenga en cuenta que el registro de W&B se omite a menos que wandb esté disponible. Puede instalar wandb con uv pip install wandb . Los argumentos W&B se pueden cambiar anulando los valores de configuración de Hydra en la receta:
++trainer.wandb_project= $project_name
++trainer.wandb_run_name= $run_name Similar a la base MSE LCM podemos enviar un trabajo de capacitación después de la receta en ./recipes/train/pretrain/two_tower.yaml a través de:
python -m lcm.train
+pretrain=two_tower
++trainer.output_dir= " checkpoints/two_tower_lcm "
++trainer.experiment_name=training_two_tower_lcm Consejo
Para comprender los diferentes ingredientes de las recetas de capacitación, consulte este Readme.
Para fineritar el LCM de difusión de dos torres previamente previamente capacitado en los datos supervisados, siga estos pasos:
Paso 1. Registre el punto de control previamente capacitado como un activo FairSeq2.
Puede Finet el punto de control final con los checkpoints/two_tower_lcm/model_card.yaml o cualquier punto de control después de un número específico de pasos de entrenamiento, por ejemplo, checkpoints/two_tower_lcm/checkpoints/step_2000/model_card.yaml . Para registrar el punto de control seleccionado, copie el archivo YAML creado automáticamente a ./lcm/cards/mycards.yaml y cambie el nombre del modelo para reemplazar el predeterminado on_the_fly_lcm . ./lcm/cards/mycards.yaml se verá como:
__source__ : inproc
checkpoint : file://path_to/large_concept_model/checkpoints/two_tower_lcm/checkpoints/step_2000/model.pt
model_arch : two_tower_diffusion_lcm_1_6B
model_family : two_tower_diffusion_lcm
name : my_pretrained_two_towerPara obtener más información sobre cómo administrar los activos de Fairseq2, consulte la documentación.
Paso 2. Inicie un trabajo de sintonización que apunta al modelo a Finetune, en este caso my_pretrained_two_tower :
CUDA_VISIBLE_DEVICES=0,1 torchrun --standalone --nnodes=1 --nproc-per-node=2
-m lcm.train launcher=standalone
+finetune=two_tower
++trainer.output_dir= " checkpoints/finetune_two_tower_lcm "
++trainer.data_loading_config.max_tokens=1000
+trainer.use_submitit=false
++trainer.model_config_or_name=my_pretrained_two_towero
python -m lcm.train
+finetune=two_tower
++trainer.output_dir= " checkpoints/finetune_two_tower_lcm "
++trainer.experiment_name=finetune_two_tower_lcm
++trainer.model_config_or_name=my_pretrained_two_towerDel mismo modo, para Finetune un MSE LCM, siga las mismas instrucciones para registrar un punto de control previamente capacitado y enviar un trabajo de Finetuning con la receta apropiada (./recipes/train/finetune/mse.yaml) a través de:
python -m lcm.train
+finetune=mse
++trainer.output_dir= " checkpoints/finetune_mse_lcm "
++trainer.experiment_name=finetune_mse_lcm
++trainer.model_config_or_name=my_pretrained_mse_lcmNota
Para una evaluación avanzada (comparación con diferentes tareas, comparando resultados con LLMS, etc.), verifique la documentación de evaluación.
Paso 0. Descargue los datos NLTK requeridos para evaluar Rouge:
python - m nltk . downloader punkt_tab Paso 1. Genere y obtenga salidas de un modelo señalando su archivo model_card Yaml o después de registrarlo como un activo FairSeq2 (de la misma manera que registramos my_pretrained_two_tower )::
model_card=./checkpoints/finetune_two_tower_lcm/checkpoints/step_1000/model_card.yaml
OUTPUT_DIR=evaluation_outputs/two_tower
torchrun --standalone --nnodes=1 --nproc-per-node=1 -m lcm.evaluation
--predictor two_tower_diffusion_lcm
--show_progress true
--data_loading.max_samples 100
--model_card ${model_card}
--launcher standalone
--dataset.source_suffix_text ' [MODEL]: '
--tasks finetuning_data_lcm.validation
--task_args ' {"max_gen_len": 10, "eos_config": {"text": "End of text."}} '
--data_loading.batch_size 4 --generator_batch_size 4
--dump_dir ${OUTPUT_DIR}
--inference_timesteps 40
--initial_noise_scale 0.6
--guidance_scale 3
--guidance_rescale 0.7 En dónde en el ejemplo solo estamos evaluando 100 muestras ( --data_loading.max_samples 100 ) y limitando la longitud de salida del modelo a 10 oraciones ( --task_args '{"max_gen_len": 10}' ).
Las salidas arrojadas en ./evaluation_outputs/two_tower se estructurarán como:
.
├── metadata.jsonl
├── metrics.eval.jsonl
├── raw_results
├── results
└── tb
Donde metrics.eval.jsonl contiene puntajes a nivel de corpus.
Para evaluar un MSE LCM, utilizamos el predictor asociado ( base_lcm ) y evaluamos con:
model_card=./checkpoints/finetune_mse_lcm/checkpoints/step_1000/model_card.yaml
OUTPUT_DIR=evaluation_outputs/mse_lcm
torchrun --standalone --nnodes=1 --nproc-per-node=1 -m lcm.evaluation
--predictor base_lcm --sample_latent_variable False
--show_progress true
--data_loading.max_samples 100
--model_card ${model_card}
--launcher standalone
--dataset.source_suffix_text ' [MODEL]: '
--tasks finetuning_data_lcm.validation
--task_args ' {"max_gen_len": 10, "eos_config": {"text": "End of text."}} '
--data_loading.batch_size 4 --generator_batch_size 4
--dump_dir ${OUTPUT_DIR} Tenga en cuenta que en este ejemplo, solo mostramos cómo evaluar el LCM en el mismo conjunto de datos Finetuning (división de validación). Para evaluar en una tarea aguas abajo y comparar los resultados con el LLM, consulte la documentación de evaluación.
Vea el archivo contribuyente sobre cómo ayudar.
Si usa esta base de código, cite:
@article{lcm2024,
author = {{LCM team}, Lo"{i}c Barrault, Paul-Ambroise Duquenne, Maha Elbayad, Artyom Kozhevnikov, Belen Alastruey, Pierre Andrews, Mariano Coria, Guillaume Couairon, Marta R. Costa-juss`{a}, David Dale, Hady Elsahar, Kevin Heffernan, Jo~{a}o Maria Janeiro, Tuan Tran, Christophe Ropers, Eduardo Sánchez, Robin San Roman, Alexandre Mourachko, Safiyyah Saleem, Holger Schwenk},
title = {{Large Concept Models}: Language Modeling in a Sentence Representation Space},
publisher = {arXiv},
year = {2024},
url = {https://arxiv.org/abs/2412.08821},
}
Este código se publica bajo la licencia MIT (ver licencia).
