large_concept_model

Grandes modelos conceituais

Modelagem de idiomas em um espaço de representação de frases

[Blog] [Papel]

Este repositório fornece as implementações e experimentos oficiais para grandes modelos conceituais ( LCM ).

O LCM opera em uma representação semântica explícita de nível superior, que nomeamos um "conceito". Os conceitos são de idioma e modalidade-agnóstico e representam uma idéia de nível superior. Neste trabalho, um conceito corresponde a uma frase e usamos o espaço de incorporação do sonar, que suporta até 200 idiomas em texto e 57 idiomas na fala. Veja a lista de idiomas suportados aqui.

Abordagem

O LCM é um modelo de sequência para sequência no espaço dos conceitos treinados para realizar previsão de sentenças auto-regressivas. Exploramos várias abordagens:

• Regressão MSE ( base_lcm neste código).
• Variantes de geração baseada em difusão (incluímos two_tower_diffusion_lcm nesta versão).
• Modelos que operam em um espaço de sonar quantizado (em breve).

Essas explorações são realizadas usando modelos de parâmetros 1.6b e dados de treinamento na ordem de tokens 1.3T. Incluímos nesta receita do repositório para reproduzir o treinamento e a finetuning de LCM de 1,6b MSE e LCM de difusão de duas torre. Veja as instruções abaixo.

Instalação

Usando UV

O repositório LCM depende do Fairseq2. Se você estiver uv no seu sistema, poderá instalar um ambiente virtual com todos os pacotes necessários executando os seguintes comandos:

uv sync --extra cpu --extra eval --extra data

Você também pode usar uv run para executar os comandos de demonstração com o ambiente correto.

Observe que fornecemos apenas requisitos para as dependências cpu ; se você quiser usar o suporte à GPU, precisará escolher as variantes de tocha e FairSeq2 que funcionam para o seu sistema. Por exemplo, para a Torch 2.5.1 com o CUDA 1.21, você faria 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 as variantes FairSeq2 para possíveis variantes. Observe que o LCM atualmente conta com o candidato a FairSeq2 0.3.0 RC1.

Usando pip

Para instalar com o PIP, os comandos são muito semelhantes, mas você terá que gerenciar seu próprio ambiente e instalar o FairSeq2 manualmente primeiro. Por exemplo, para uma instalação 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] "

Se o FairSeq2 não fornecer uma compilação para sua máquina, verifique o ReadMe desse projeto para construí -lo localmente.

Uso

Observação

Se estiver usando o prefixo uv , todos os comandos com uv run para usar o ambiente criado por padrão em .venv , por exemplo, uv run torchrun --standalone . Como alternativa, você pode ativar o ambiente de uma vez por todas com source .venv/bin/activate .

Preparando dados

O LCM pode ser treinado e avaliado usando dados textuais divididos em frases e incorporado ao sonar. Fornecemos um pipeline de processamento de amostra que pode ser usado para preparar esses dados de treinamento, você pode executá -lo com:

 uv run --extra data scripts/prepare_wikipedia.py /output/dir/for/the/data

Este pipeline mostra como obter um conjunto de dados da HuggingFace e processá -lo com sonar e sentar. Confira o arquivo para obter mais detalhes sobre o processamento de seus próprios dados. Embora o script forneça um exemplo de extração de dados do HuggingFace, também fornecemos APIs para processar JSONL, Parquet e CSV.

Datacards

O treinador descrito abaixo depende de dados de dados de configuração dos conjuntos de dados. Esses datacards são arquivos YAML com ponteiros para os arquivos do conjunto de dados (localmente ou no S3) e informações sobre seu esquema. Fornecemos alguns datacards de amostra em lcm/datacards/datacards.yaml . Depois de processar alguns dados, você pode atualizar os datacards com seus caminhos.

Ajustar um normalizador

Para se ajustar a um novo normalizador de espaço de incorporação em uma determinada mistura ponderada de conjuntos de dados, pode -se usar o seguinte 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

Aqui, dataset1 , dataset2 , dataset3 são os nomes dos conjuntos de dados declarados nos datacards, como mostrado acima e (4, 1, 10) seus respectivos pesos relativos. O normalizador resultante pode ser declarado em seguida como um modelo, como mostrado em lcm/cards/sonar_normalizer.yaml e referenciado em todas as configurações de treinamento de modelos.

Modelos pré-treinamento

Base MSE LCM

Para treinar um MSE LCM, usaremos um dos seguintes comandos:

Opção 1. Treinamento com Slurm usando o Submitit através do lançador de Stopes:

python -m lcm.train 
    +pretrain=mse 
    ++trainer.output_dir= " checkpoints/mse_lcm " 
    ++trainer.experiment_name=training_mse_lcm 

Com este comando, enviaremos um trabalho de SLURM chamado training_mse_lcm com os requisitos da receita, neste caso:

 requirements :
  nodes : 4
  tasks_per_node : 8
  gpus_per_node : 8
  cpus_per_task : 32
  mem_gb : 0
  timeout_min : 10000

Você pode substituir os requisitos do trabalho, como o limite de tempo limite e a partição do lançador do Slurm com:

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

Opção 2. Treinamento localmente com torchrun (por exemplo, usando apenas 2 GPUs) com um tamanho menor em lote (substituindo ++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

Como estamos alterando o número de GPUs exigidas pela receita, isso não reproduzirá a configuração experimental do artigo.

Os checkpoints/mse_lcm serão estruturados como:

 .
├── checkpoints
│   ├── step_2000
│   ├── ...
│   └── step_250000
├── config_logs
├── executor_logs
├── model_card.yaml
├── tb   # tensorboard logs
└── wandb  # W&B logs

Observe que o log de W&B é ignorado, a menos que wandb esteja disponível. Você pode instalar wandb com uv pip install wandb . Os argumentos da W&B podem ser alterados substituindo os valores de configuração Hydra na receita:

++trainer.wandb_project= $project_name
++trainer.wandb_run_name= $run_name 

LCM de difusão de duas torres

Semelhante ao MSE LCM base, podemos enviar um trabalho de treinamento após a receita em ./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 

Dica

Para entender os diferentes ingredientes das receitas de treinamento, consulte este ReadMe.

Modelos de Finetuning

Para finalizar o LCM de difusão de duas torres anteriormente pré-treinado em dados supervisionados, siga estas etapas:

Etapa 1. Registre o ponto de verificação pré-treinado como um ativo FairSeq2.

Você pode finalizar o ponto de verificação final com os checkpoints/two_tower_lcm/model_card.yaml ou qualquer ponto de verificação após um número específico de etapas de treinamento, por exemplo, checkpoints/two_tower_lcm/checkpoints/step_2000/model_card.yaml . Para registrar o ponto de verificação selecionado, copie o arquivo YAML criado automaticamente para ./lcm/cards/mycards.yaml e renomeie o modelo para substituir o padrão on_the_fly_lcm . ./lcm/cards/mycards.yaml parecerá:

 __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_tower

Para saber mais sobre como gerenciar ativos FairSeq2, consulte a documentação.

Etapa 2. Inicie um trabalho de Finetuning apontando para o modelo para o FineTune, neste 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_tower

ou

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_tower

Da mesma forma, para o Finetune um MSE LCM, siga as mesmas instruções para registrar um ponto de verificação pré-treinado e enviar um trabalho de Finetuning com a receita apropriada (./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_lcm

Avaliando modelos

Observação

Para uma avaliação avançada (comparando diferentes tarefas, comparando resultados com LLMs, etc.), verifique a documentação da avaliação.

Etapa 0. Faça o download dos dados do NLTK necessários para avaliar o Rouge:

 python - m nltk . downloader punkt_tab

Etapa 1. Gere e pontuam saídas de um modelo, apontando para o seu arquivo model_card yaml ou depois de registrá -lo como um ativo Fairseq2 (da mesma maneira 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

Onde, no exemplo, estamos avaliando apenas 100 amostras ( --data_loading.max_samples 100 ) e limitando o comprimento da saída do modelo a 10 frases ( --task_args '{"max_gen_len": 10}' ).

Saídas despejadas em ./evaluation_outputs/two_tower serão estruturadas como:

 .
├── metadata.jsonl
├── metrics.eval.jsonl
├── raw_results
├── results
└── tb

onde metrics.eval.jsonl contém pontuações no nível de corpus.

Para avaliar um MSE LCM, usamos o preditor associado ( base_lcm ) e avaliamos com:

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} 

Observe que, neste exemplo, mostramos apenas como avaliar o LCM no mesmo conjunto de dados Finetuning (Split de validação). Para avaliar em uma tarefa a jusante e comparar resultados com o LLM, consulte a documentação da avaliação.

Contribuindo

Consulte o arquivo contribuinte sobre como ajudar.

Citação

Se você usar 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},
}

Licença

Este código é liberado sob a licença do MIT (consulte a licença).