large_concept_model
1.0.0
[Blog] [Paper]
Ce référentiel fournit les implémentations et expériences officielles pour les grands modèles de concepts ( LCM ).
Le LCM opère sur une représentation sémantique explicite de niveau supérieur, que nous nommons un "concept". Les concepts sont agnostiques du langage et de la modalité et représentent une idée de niveau supérieur. Dans ce travail, un concept correspond à une phrase, et nous utilisons l'espace d'intégration du sonar, qui prend en charge jusqu'à 200 langues en texte et 57 langues dans la parole. Voir la liste des langues prises en charge ici.
Le LCM est un modèle de séquence à séquence dans l'espace concepts formé pour effectuer une prédiction de phrase auto-régressive. Nous explorons plusieurs approches:
base_lcm dans ce code).two_tower_diffusion_lcm dans cette version).Ces explorations sont effectuées à l'aide de modèles de paramètres 1.6b et de données de formation dans l'ordre des jetons 1.3T. Nous incluons dans ces recettes de référentiel pour reproduire la formation et le finetuning de 1,6b MSE LCM et la diffusion à deux tours LCM. Voir les instructions ci-dessous.
Le référentiel LCM s'appuie sur Fairseq2. Si vous avez installé uv sur votre système, vous pouvez installer un environnement virtuel avec tous les packages nécessaires en exécutant les commandes suivantes:
uv sync --extra cpu --extra eval --extra data Vous pouvez également utiliser uv run pour exécuter les commandes de démonstration avec l'environnement correct.
Notez que nous fournissons uniquement des exigences pour les dépendances cpu , si vous souhaitez utiliser le support GPU, vous devrez choisir les variantes de Torch et Fairseq2 qui fonctionnent pour votre système. Par exemple pour Torch 2.5.1 avec CUDA 1.21, vous feriez quelque chose comme:
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
Vérifiez les variantes FairSeQ2 pour des variantes possibles. Notez que LCM s'appuie actuellement sur le candidat à la libération pour Fairseq2 0.3.0 RC1.
Pour installer avec PIP, les commandes sont très similaires, mais vous devrez gérer votre propre environnement et vous assurer d'installer Fairseq2 manuellement en premier. Par exemple, pour une installation 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 ne fournit pas de build pour votre machine, vérifiez la lecture de ce projet pour la construire localement.
Note
Si vous utilisez une préfixe uv toutes les commandes avec uv run pour utiliser l'environnement créé par défaut dans .venv , par exemple, uv run torchrun --standalone . Alternativement, vous pouvez activer l'environnement une fois pour toutes avec source .venv/bin/activate .
Le LCM peut être formé et évalué à l'aide de données textuelles divisées en phrases et intégrées au sonar. Nous fournissons un pipeline de traitement d'échantillon qui peut être utilisé pour préparer ces données de formation, vous pouvez l'exécuter avec:
uv run --extra data scripts/prepare_wikipedia.py /output/dir/for/the/data
Ce pipeline montre comment obtenir un ensemble de données à partir de HuggingFace et le traiter avec sonar et SAT. Consultez le fichier pour plus de détails sur le traitement de vos propres données. Bien que le script fournit un exemple de tir de données de HuggingFace, nous fournissons également des API pour traiter JSONL, Parquet et CSV.
Le formateur décrit ci-dessous repose sur la configuration des ensembles de données. Ces cartes de données sont des fichiers YAML avec des pointeurs vers les fichiers de jeu de données (localement ou sur S3) et des informations sur son schéma. Nous fournissons quelques exemples de cartes de données dans lcm/datacards/datacards.yaml . Une fois que vous avez traité certaines données, vous pouvez mettre à jour les cartes de données avec vos chemins.
Pour s'adapter à une nouvelle normalisateur d'espace d'intégration sur un mélange pondéré donné d'ensembles de données, on peut utiliser la commande suivante:
python scripts/fit_embedding_normalizer.py --ds dataset1:4 dataset2:1 dataset3:10 --save_path " path/to/new/normalizer.pt " --max_nb_samples 1000000 Ici, dataset1 , dataset2 , dataset3 sont les noms des ensembles de données déclarés dans les cartes de données comme indiqué ci-dessus et (4, 1, 10) leurs poids relatifs respectifs. Le normalisateur résultant peut être ensuite déclaré comme un modèle comme indiqué dans lcm/cards/sonar_normalizer.yaml et référencé dans toutes les configurations de formation de modèle.
Pour former un MSE LCM, nous utiliserons l'une des commandes suivantes:
Option 1. Formation avec Slurm Utilisation de Soumisit via le lanceur de Stoptes:
python -m lcm.train
+pretrain=mse
++trainer.output_dir= " checkpoints/mse_lcm "
++trainer.experiment_name=training_mse_lcm Avec cette commande, nous soumettrons un travail de slurm nommé training_mse_lcm avec les exigences de la recette, dans ce cas:
requirements :
nodes : 4
tasks_per_node : 8
gpus_per_node : 8
cpus_per_task : 32
mem_gb : 0
timeout_min : 10000Vous pouvez remplacer les exigences du travail comme la limite de délai d'expiration et la partition de Slurm du lanceur avec:
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 Option 2. Formation localement avec torchrun (par exemple en utilisant seulement 2 GPU) avec une taille de lot plus petite (remplacement ++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 Important
Étant donné que nous modifions le nombre de GPU requis par la recette, cela ne reproduira pas la configuration expérimentale du papier.
Le répertoire de contrôle des points checkpoints/mse_lcm sera structuré comme suit:
.
├── checkpoints
│ ├── step_2000
│ ├── ...
│ └── step_250000
├── config_logs
├── executor_logs
├── model_card.yaml
├── tb # tensorboard logs
└── wandb # W&B logs
Notez que la journalisation W&B est ignorée à moins que wandb ne soit disponible. Vous pouvez installer wandb avec uv pip install wandb . Les arguments W&B peuvent être modifiés en remplaçant les valeurs de configuration Hydra dans la recette:
++trainer.wandb_project= $project_name
++trainer.wandb_run_name= $run_name Semblable à la base MSE LCM, nous pouvons soumettre un travail de formation après la recette ./recipes/train/pretrain/two_tower.yaml via:
python -m lcm.train
+pretrain=two_tower
++trainer.output_dir= " checkpoints/two_tower_lcm "
++trainer.experiment_name=training_two_tower_lcm Conseil
Pour comprendre les différents ingrédients des recettes d'entraînement, consultez cette lecture.
Pour Finetune le LCM de diffusion à deux points précédemment pré-formé sur les données supervisées, suivez ces étapes:
Étape 1. Enregistrez le point de contrôle pré-formé comme un actif Fairseq2.
Vous pouvez Finetune le point de contrôle final avec les checkpoints/two_tower_lcm/model_card.yaml ou n'importe quel point de contrôle après un nombre spécifique d'étapes de formation, par exemple, checkpoints/two_tower_lcm/checkpoints/step_2000/model_card.yaml . Pour enregistrer le point de contrôle sélectionné, copiez le fichier YAML créé automatiquement sur ./lcm/cards/mycards.yaml et renommez le modèle pour remplacer le par défaut on_the_fly_lcm . ./lcm/cards/mycards.yaml ressemblera à:
__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_towerPour en savoir plus sur la gestion des actifs Fairseq2, voir la documentation.
Étape 2. Lancez un travail de Finetuning pointant vers le modèle vers FineTune, dans ce cas 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_towerou
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_towerDe même, pour Finetune un MSE LCM, suivez les mêmes instructions pour enregistrer un point de contrôle pré-formé et soumettre un travail de finetuning avec la recette appropriée (./recipes/train/finetune/mse.yaml) via:
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_lcmNote
Pour une évaluation avancée (comparaison de différentes tâches, en comparant les résultats avec les LLM, etc.), consultez la documentation d'évaluation.
Étape 0. Téléchargez les données NLTK requises pour évaluer le rouge:
python - m nltk . downloader punkt_tab Étape 1. Générez et score des sorties d'un modèle soit en pointant son fichier model_card YAML ou après l'avoir enregistré en tant qu'actif Fairseq2 (de la même manière que nous enregistrons 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 Là où dans l'exemple, nous évaluons seulement 100 échantillons ( --data_loading.max_samples 100 ) et limitant la longueur de sortie du modèle à 10 phrases ( --task_args '{"max_gen_len": 10}' ).
Les sorties déversées dans ./evaluation_outputs/two_tower seront structurées comme suit:
.
├── metadata.jsonl
├── metrics.eval.jsonl
├── raw_results
├── results
└── tb
où metrics.eval.jsonl contient des scores de niveau corpus.
Pour évaluer un MSE LCM, nous utilisons le prédicteur associé ( base_lcm ) et évaluons avec:
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} Notez que dans cet exemple, nous montrons uniquement comment évaluer le LCM sur le même ensemble de données Finetuning (validation Split). Pour évaluer dans une tâche en aval et comparer les résultats avec le LLM, reportez-vous à la documentation d'évaluation.
Voir le fichier contributif pour aider à aider.
Si vous utilisez cette base de code, veuillez citer:
@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},
}
Ce code est publié sous la licence MIT (voir licence).
