large_concept_model
1.0.0
[Blog] [Papier]
Dieses Repository bietet die offiziellen Implementierungen und Experimente für große Konzeptmodelle ( LCM ).
Das LCM arbeitet mit einer expliziten semantischen Darstellung auf höherer Ebene, die wir als "Konzept" bezeichnen. Konzepte sind sprach- und modalitätsagnostisch und stellen eine Idee auf höherer Ebene dar. In dieser Arbeit entspricht ein Konzept einem Satz, und wir verwenden den SONAR -Einbettungsraum, der bis zu 200 Sprachen im Text und 57 Sprachen in der Sprache unterstützt. Weitere Informationen finden Sie in der Liste der unterstützten Sprachen.
Das LCM ist ein Sequenz-zu-Sequenz-Modell in den Konzepten, die Raum für eine automatische Ansichtssatzvorhersage geschult sind. Wir untersuchen mehrere Ansätze:
base_lcm in diesem Code).two_tower_diffusion_lcm ein).Diese Erkundungen werden unter Verwendung von 1,6B -Parametermodellen und Trainingsdaten in der Reihenfolge von 1,3T -Token durchgeführt. Wir nehmen in diese Repository-Rezepte ein, um das Training und die Finetunierung von 1,6B MSE-LCM- und zwei-Turm-Diffusions-LCM zu reproduzieren. Siehe Anweisungen unten.
Das LCM -Repository basiert auf Fairseq2. Wenn Sie uv auf Ihrem System installiert haben, können Sie eine virtuelle Umgebung mit allen erforderlichen Paketen installieren, indem Sie die folgenden Befehle ausführen:
uv sync --extra cpu --extra eval --extra data Sie können auch uv run verwenden, um die Demo -Befehle mit der richtigen Umgebung auszuführen.
Beachten Sie, dass wir nur Anforderungen an cpu -Abhängigkeiten bereitstellen. Wenn Sie die GPU -Unterstützung verwenden möchten, müssen Sie die Varianten von Fackel und FairSeq2 auswählen, die für Ihr System funktionieren. Zum Beispiel für Torch 2.5.1 mit CUDA 1.21 würden Sie so etwas tun:
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
Überprüfen Sie fairseq2 -Varianten auf mögliche Varianten. Beachten Sie, dass LCM derzeit auf den Release -Kandidaten für Fairseq2 0.3.0 RC1 angewiesen ist.
Um mit PIP zu installieren, sind die Befehle sehr ähnlich, aber Sie müssen Ihre eigene Umgebung verwalten und fairseq2 zuerst manuell installieren. Zum Beispiel für eine cpu -Installation.
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] "Wenn Fairseq2 keinen Build für Ihre Maschine bereitstellt, überprüfen Sie die Readme dieses Projekts, um es lokal zu erstellen.
Notiz
Wenn Sie alle Befehle mit uv -Präfix mit uv run verwenden, um die standardmäßige Umgebung in .venv , z. B. uv run torchrun --standalone zu verwenden. Alternativ können Sie die Umgebung einmal für alle mit source .venv/bin/activate aktivieren.
Das LCM kann unter Verwendung von Textdaten, die in Sätzen geteilt und mit Sonar eingebettet sind, trainiert und bewertet werden. Wir bieten eine Probenverarbeitungspipeline, mit der Sie solche Trainingsdaten erstellen können. Sie können sie mit:
uv run --extra data scripts/prepare_wikipedia.py /output/dir/for/the/data
Diese Pipeline zeigt, wie man einen Datensatz von Huggingface bekommt und ihn mit Sonar und SAT verarbeitet. Weitere Informationen zur Verarbeitung Ihrer eigenen Daten finden Sie in der Datei. Während das Skript ein Beispiel für das Ziehen von Daten von Huggingface bietet, stellen wir auch APIs zur Verarbeitung von JSONL, Parquet und CSV zur Verfügung.
Der nachstehend beschriebene Trainer basiert auf Datacards, die die Datensätze konfigurieren. Diese Rechnungsprüfungen sind YAML -Dateien mit Zeigern auf die Datensatzdateien (lokal oder auf S3) und Informationen zu seinem Schema. Wir stellen einige Beispieldatakards in lcm/datacards/datacards.yaml . Sobald Sie einige Daten verarbeitet haben, können Sie die Datacards mit Ihren Pfaden aktualisieren.
Um einen neuen Einbettungsraumnormalizer auf eine bestimmte gewichtete Mischung aus Datensätzen anzupassen, kann man den folgenden Befehl verwenden:
python scripts/fit_embedding_normalizer.py --ds dataset1:4 dataset2:1 dataset3:10 --save_path " path/to/new/normalizer.pt " --max_nb_samples 1000000 Hier sind dataset1 , dataset2 , dataset3 die Namen von Datensätzen, die in den Datakards wie oben gezeigt und (4, 1, 10) ihre jeweiligen relativen Gewichte deklariert sind. Der resultierende Normalisierer kann als nächstes als Modell deklariert werden, wie in lcm/cards/sonar_normalizer.yaml gezeigt und in allen Modelltrainingskonfigurationen verwiesen.
Um eine MSE -LCM zu trainieren, werden wir einen der folgenden Befehle verwenden:
Option 1. Training mit Slurm mit Subjekt über den Launcher von Stopes:
python -m lcm.train
+pretrain=mse
++trainer.output_dir= " checkpoints/mse_lcm "
++trainer.experiment_name=training_mse_lcm Mit diesem Befehl werden wir in diesem Fall einen Slurm -Job mit dem Namen training_mse_lcm mit den Anforderungen des Rezepts einreichen:
requirements :
nodes : 4
tasks_per_node : 8
gpus_per_node : 8
cpus_per_task : 32
mem_gb : 0
timeout_min : 10000Sie können die Anforderungen des Auftrags wie das Zeitüberschreitungslimit und die Slurm -Partition des Launcher mit:
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. Training lokal mit torchrun (z. B. nur 2 GPUs) mit einer kleineren Chargengröße (überschreiben ++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 Wichtig
Da wir die Anzahl der vom Rezept erforderlichen GPUs ändern, reproduziert dies nicht die experimentelle Einrichtung des Papiers.
Die Checkpoints -Verzeichnis checkpoints/mse_lcm werden als:
.
├── checkpoints
│ ├── step_2000
│ ├── ...
│ └── step_250000
├── config_logs
├── executor_logs
├── model_card.yaml
├── tb # tensorboard logs
└── wandb # W&B logs
Beachten Sie, dass die W & B -Protokollierung übersprungen wird, es sei denn, wandb ist verfügbar. Sie können wandb mit uv pip install wandb . W & B -Argumente können durch überschreibende Hydra -Konfigurationswerte im Rezept geändert werden:
++trainer.wandb_project= $project_name
++trainer.wandb_run_name= $run_name Ähnlich wie bei der Basis -MSE -LCM können wir einen Schulungsauftrag einreichen, der nach dem Rezept in ./Recipes/train/prain/two_tower.yaml über:
python -m lcm.train
+pretrain=two_tower
++trainer.output_dir= " checkpoints/two_tower_lcm "
++trainer.experiment_name=training_two_tower_lcm Tipp
Um die verschiedenen Zutaten von Trainingsrezepten zu verstehen, überprüfen Sie diese Readme.
Befolgen Sie die folgenden Schritte:
Schritt 1. Registrieren Sie den vorgeborenen Checkpoint als Fairseq2-Vermögenswert.
Sie können den endgültigen Kontrollpunkt mit den Karten checkpoints/two_tower_lcm/model_card.yaml oder einem beliebigen Kontrollpunkt nach einer bestimmten Anzahl von Trainingsschritten, z. B. checkpoints/two_tower_lcm/checkpoints/step_2000/model_card.yaml , finanzieren. Um den ausgewählten Checkpoint zu registrieren, kopieren Sie die automatisch erstellte YAML -Datei auf ./lcm/cards/mycards.yaml und benennen Sie das Modell um, um die Standardeinstellung on_the_fly_lcm zu ersetzen. ./lcm/cards/mycards.yaml sieht aus wie:
__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_towerWeitere Informationen zum Verwalten von FairSeq2 -Vermögenswerten finden Sie unter Dokumentation.
Schritt 2. Starten Sie einen Finetuning -Job, der auf das Modell auf Fintune hinweist, in diesem Fall 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_toweroder
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_towerIn ähnlicher Weise befolgen Sie die gleichen Anweisungen zur Registrierung eines vorgeborenen Kontrollpunkts, um einen MSE-LCM zu beenden und einen Finetuning-Job mit dem entsprechenden Rezept (./recipes/train/finetune/mse.yaml) zu senden:
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_lcmNotiz
Für die erweiterte Bewertung (Benchmarking verschiedener Aufgaben, Vergleich der Ergebnisse mit LLMs usw.) überprüfen Sie die Bewertungsdokumentation.
Schritt 0. Download NLTK -Daten, die zur Bewertung von Rouge erforderlich sind:
python - m nltk . downloader punkt_tab Schritt 1. Erstellen und Bewertungsausgänge eines Modells entweder durch Hinweis auf seine model_card yaml -Datei oder nach der Registrierung als FairSeq2 -Asset (genauso wie wir my_pretrained_two_tower registrieren):
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 Wo wir im Beispiel nur 100 Proben bewerten ( --data_loading.max_samples 100 ) und die Modellausgabelänge auf 10 Sätze ( --task_args '{"max_gen_len": 10}' ) begrenzt.
Ausgänge in ./evaluation_outputs/two_tower werden strukturiert als:
.
├── metadata.jsonl
├── metrics.eval.jsonl
├── raw_results
├── results
└── tb
wobei metrics.eval.jsonl Corpus-Level-Scores enthält.
Um eine MSE -LCM zu bewerten, verwenden wir den zugehörigen Prädiktor ( base_lcm ) und bewerten mit:
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} Beachten Sie, dass wir in diesem Beispiel nur zeigen, wie das LCM auf demselben Finetuning -Datensatz (Validierungsaufteilung) bewertet wird. Um in einer nachgeschalteten Aufgabe zu bewerten und Ergebnisse mit dem LLM zu vergleichen, siehe die Bewertungsdokumentation.
Sehen Sie sich die beitragende Datei an, um zu helfen.
Wenn Sie diese Codebasis verwenden, zitieren Sie bitte:
@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},
}
Dieser Code wird unter der MIT -Lizenz veröffentlicht (siehe Lizenz).
