llm foundry
v0.15.1
Este repositório contém código para treinamento, finetuning, avaliação e implantação de LLMs para inferência com o Composer e a plataforma MosaicML. Projetado para ser fácil de usar, eficiente e flexível, esta base de código permite uma rápida experimentação com as técnicas mais recentes.
Você encontrará neste repositório:
llmfoundry/ - código -fonte para modelos, conjuntos de dados, retornos de chamada, serviços públicos etc.scripts/ - scripts para executar cargas de trabalho LLMdata_prep/ - converter dados de texto de fontes originais em formato StreamingDataSettrain/ - Trem modelos Finetune Huggingface e MPT de parâmetros 125m - 70Btrain/benchmarking - Taxa de transferência de treinamento de perfil e MFUinference/ - Converter modelos em formato Huggingface ou Onnx e gerar respostasinference/benchmarking - Latência e taxa de transferência de inferência do perfileval/ -Avalie o LLMS em tarefas acadêmicas (ou personalizadas) no aprendizado de contextomcli/ - Inicie qualquer uma dessas cargas de trabalho usando o MCLI e a plataforma MosaicmlTUTORIAL.md - um mergulho mais profundo no repositório, exemplo de fluxos de trabalho e perguntas frequentesO DBRX é um código aberto LLM de última geração treinado pela equipe de Mosaic Databricks. Ele usa a arquitetura da mistura de especialistas (MOE) e foi treinado com versões otimizadas da Foundry Composer, LLM e megablocks. O modelo possui 132b parâmetros totais e 36b parâmetros ativos. Lançamos dois modelos DBRX:
| Modelo | Comprimento do contexto | Download |
|---|---|---|
| Base dbrx | 32768 | https://huggingface.co/databricks/dbrx-base |
| DBRX Instruct | 32768 | https://huggingface.co/databricks/dbrx-instruct |
Nosso modelo e pesos e código são licenciados para pesquisadores e entidades comerciais. A licença de código aberto dos Databricks pode ser encontrada na licença e nossa política de uso aceitável pode ser encontrada aqui.
Para obter mais informações sobre os modelos DBRX, consulte https://github.com/databricks/dbrx.
Transformadores pré-gravados em mosaico (MPT) são modelos de estilo GPT com alguns recursos especiais-atenção flash para eficiência, álibi para extrapolação do comprimento do contexto e melhorias de estabilidade para mitigar os picos de perda. Como parte da série Foundation da MosaicML, temos vários modelos de MPT:
| Modelo | Comprimento do contexto | Download | Uso comercial? |
|---|---|---|---|
| MPT-30B | 8192 | https://huggingface.co/mosicml/mpt-30b | Sim |
| MPT-30B-INUTRUTA | 8192 | https://huggingface.co/mosaicml/mpt-30b-instruct | Sim |
| MPT-30B-BACK | 8192 | https://huggingface.co/mosicml/mpt-30b-chat | Não |
| MPT-7B-8K | 8192 | https://huggingface.co/mosicml/mpt-7b-8k | Sim |
| MPT-7B-8K-CAT | 8192 | https://huggingface.co/mosicml/mpt-7b-8k-clat | Não |
| MPT-7B | 2048 | https://huggingface.co/mosicml/mpt-7b | Sim |
| MPT-7B-INUTRUTA | 2048 | https://huggingface.co/mosaicml/mpt-7b-instruct | Sim |
| MPT-7B-BACK | 2048 | https://huggingface.co/mosicml/mpt-7b-chat | Não |
| MPT-7B-StoryWriter | 65536 | https://huggingface.co/mosicml/mpt-7b-storywriter | Sim |
Para experimentar esses modelos localmente, siga as instruções nos scripts/inference/README.md para solicitar modelos HF usando nossos scripts hf_gereate.py ou hf_chat.py.
Ficamos impressionados com todo o trabalho incrível que a comunidade colocou no MPT! Aqui fornecemos alguns links para alguns deles:
replit-code-v1-3b é um modelo de linguagem causal de 2.7b focado na conclusão do código. O modelo foi treinado em um subconjunto do conjunto de dados da pilha Dedup v1.2, cobrindo 20 idiomas como Java, Python e C ++Vídeos tutoriais da comunidade:
Algo faltando? Contribua com um PR!
Esta base de código foi testada com o Pytorch 2.4 com o NVIDIA A100S e H100S. Essa base de código também pode funcionar em sistemas com outros dispositivos, como cartões da NVIDIA do consumidor e cartões AMD, mas não estamos testando ativamente esses sistemas. Se você tiver sucesso/falha usando a LLM Foundry em outros sistemas, informe -nos em um problema do GitHub e atualizaremos a matriz de suporte!
| Dispositivo | Versão da tocha | Versão CUDA | Status |
|---|---|---|---|
| A100-40GB/80 GB | 2.5.1 | 12.4 | ✅ Suporte |
| H100-80GB | 2.5.1 | 12.4 | ✅ Suporte |
É altamente recomendável usar nossas imagens pré -construídas do Docker. Você pode encontrá -los aqui: https://hub.docker.com/orgs/mosaicml/repositórios.
As imagens mosaicml/pytorch são fixadas em versões específicas de pytorch e cuda e são estáveis e raramente atualizadas.
As imagens mosaicml/llm-foundry são construídas com novas tags em todos os compromissos com o ramo main . Você pode selecionar um hash de confirmação específico, como mosaicml/llm-foundry:2.5.1_cu124-9867a7b ou pegar o mais recente usando mosaicml/llm-foundry:2.5.1_cu124-latest .
Observação: as imagens mosaicml/llm-foundry não vêm com o pacote llm-foundry pré-instalado, apenas as dependências. Você ainda precisará pip install llm-foundry da Pypi ou da fonte.
| Imagem do Docker | Versão da tocha | Versão CUDA | LLM Foundry Dependências instaladas? |
|---|---|---|---|
mosaicml/pytorch:2.5.1_cu124-python3.11-ubuntu22.04 | 2.5.1 | 12.4 (Infiniband) | Não |
mosaicml/llm-foundry:2.5.1_cu124-latest | 2.5.1 | 12.4 (Infiniband) | Sim |
mosaicml/llm-foundry:2.5.1_cu124_aws-latest | 2.5.1 | 12.4 (EFA) | Sim |
Isso pressupõe que você já tenha pytorch, cmake e embalagens instaladas. Caso contrário, você pode instalá -los com pip install cmake packaging torch .
Para começar, clone o repositório e configure seu ambiente. As instruções para fazer isso diferem um pouco, dependendo se você está usando o Docker.
Recomendamos fortemente trabalhar com a LLM Foundry dentro de um recipiente do docker (consulte a imagem recomendada do Docker acima). Se você estiver fazendo isso, siga estas etapas para clonar o repositório e instalar os requisitos.
git clone https://github.com/mosaicml/llm-foundry.git
cd llm-foundry
pip install -e " .[gpu] " # or `pip install -e .` if no NVIDIA GPU.Se você optar por não usar o Docker, deve criar e usar um ambiente virtual.
git clone https://github.com/mosaicml/llm-foundry.git
cd llm-foundry
# Creating and activate a virtual environment
python3 -m venv llmfoundry-venv
source llmfoundry-venv/bin/activate
pip install cmake packaging torch # setup.py requires these be installed
pip install -e " .[gpu] " # or `pip install -e .` if no NVIDIA GPU.As GPUs NVIDIA H100 têm suporte a FP8; Já instalamos a atenção e o transformador em nossas imagens do Docker (veja acima). Se você não estiver usando nossas imagens do Docker, pode instalar esses pacotes com:
pip install flash-attn --no-build-isolation
pip install git+https://github.com/NVIDIA/TransformerEngine.git@stableVeja aqui para obter mais detalhes sobre como ativar o TransformerEngine Camadas e AMP_FP8.
Em nosso teste de GPUs AMD, a configuração Env inclui:
git clone https://github.com/mosaicml/llm-foundry.git
cd llm-foundry
# Creating and activate a virtual environment
python3 -m venv llmfoundry-venv-amd
source llmfoundry-venv-amd/bin/activate
# installs
pip install cmake packaging torch
pip install -e . # This installs some things that are not needed but they don't hurt
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.4.2Por fim , instale o ROCM ativado a atenção flash (instruções aqui).
Notas:
numpy==1.23.5 ) antes que tudo funcione sem problemas. O suporte à fundição da LLM nos dispositivos Intel Gaudi é experimental, use o ramo habana_alpha e veja o ReadMe naquela filial que possui instruções de instalação e problemas conhecidos.
Para resultados de desempenho de treinamento e inferência nos aceleradores Intel Gaudi2, consulte nosso blog: https://www.databricks.com/blog/llm-trening-and-inference-intel-gaudi2-ai-accellerator
Observe que siga as etapas de instalação acima antes de tentar o QuickStart!
Aqui está um fluxo de trabalho de ponta a ponta para a preparação de um subconjunto do conjunto de dados C4, treinando um modelo MPT-125M para 10 lotes, convertendo o modelo em formato Hugging SFACE, avaliando o modelo no desafio do Winograd e gerando respostas aos avisos.
(Lembre -se de que este é um início rápido apenas para demonstrar as ferramentas - para obter boa qualidade, o LLM deve ser treinado por mais de 10 lotes?)
cd scripts
# Convert C4 dataset to StreamingDataset format
python data_prep/convert_dataset_hf.py
--dataset allenai/c4 --data_subset en
--out_root my-copy-c4 --splits train_small val_small
--concat_tokens 2048 --tokenizer EleutherAI/gpt-neox-20b --eos_text ' <|endoftext|> '
# Train an MPT-125m model for 10 batches
composer train/train.py
train/yamls/pretrain/mpt-125m.yaml
variables.data_local=my-copy-c4
train_loader.dataset.split=train_small
eval_loader.dataset.split=val_small
max_duration=10ba
eval_interval=0
save_folder=mpt-125m
# Convert the model to HuggingFace format
python inference/convert_composer_to_hf.py
--composer_path mpt-125m/ep0-ba10-rank0.pt
--hf_output_path mpt-125m-hf
--output_precision bf16
# --hf_repo_for_upload user-org/repo-name
# Evaluate the model on a subset of tasks
composer eval/eval.py
eval/yamls/hf_eval.yaml
icl_tasks=eval/yamls/copa.yaml
model_name_or_path=mpt-125m-hf
# Generate responses to prompts
python inference/hf_generate.py
--name_or_path mpt-125m-hf
--max_new_tokens 256
--prompts
" The answer to life, the universe, and happiness is "
" Here's a quick recipe for baking chocolate chip cookies: Start by " Nota: O comando composer usado acima para treinar o modelo refere -se ao lançador distribuído da biblioteca compositor.
Se você tiver um token de autenticação de Huggingface habilitado para gravação, pode opcionalmente fazer upload do seu modelo para o hub! Basta exportar seu token assim:
export HF_TOKEN=your-auth-token e descomment a linha que contém --hf_repo_for_upload ... na chamada acima para inference/convert_composer_to_hf.py .
Você pode usar o registro para personalizar seus fluxos de trabalho sem gastar na biblioteca. Alguns componentes da fundição LLM são registráveis, como modelos, madeireiros e retornos de chamada. Isso significa que você pode registrar novas opções para esses componentes e usá -las na sua configuração YAML.
Para ajudar a encontrar e entender os componentes registráveis, você pode usar o comando da CLI llmfoundry registry .
Nós fornecemos dois comandos atualmente:
llmfoundry registry get [--group] : Liste todos os registros e seus componentes, especificando opcionalmente um registro específico. Exemplo de uso: llmfoundry registry get --group loggers ou llmfoundry registry getllmfoundry registry find <group> <name> : Obtenha informações sobre um componente registrado específico. Exemplo de uso: llmfoundry registry find loggers wandb Use --help em qualquer um desses comandos para obter mais informações.
Esses comandos também podem ajudá -lo a entender do que cada registro é composto, pois cada registro contém um documento que será impresso. O conceito geral é que cada registro define uma interface e os componentes registrados nesse registro devem implementar essa interface. Se houver uma parte da biblioteca que não seja extensível no momento, mas você acha que deveria ser, abra um problema!
Existem algumas maneiras de registrar um novo componente:
Você pode especificar componentes registrados por meio de um ponto de entrada do Python se estiver criando seu próprio pacote com componentes registrados. Este seria o uso esperado se você estiver construindo uma grande extensão da fundição da LLM e substituirá muitos componentes. Observe que as coisas registradas através dos pontos de entrada substituirão os componentes registrados diretamente no código.
Por exemplo, o seguinte registraria a classe MyLogger , sob a chave my_logger , no Registro llm_foundry.loggers :
[build-system]
requires = ["setuptools>=42", "wheel"]
build-backend = "setuptools.build_meta"
[project]
name = "foundry_registry"
version = "0.1.0"
dependencies = [
" mosaicml " ,
" llm-foundry " ,
]
# Note: Even though in python code, this would be llmfoundry.registry.loggers,
# when specified in the entry_points, it has to be "llmfoundry_loggers". That is,
# the segments of the name should be joined by an _ in the entry_points section.
[project.entry-points."llmfoundry_loggers"]
my_logger = "foundry_registry.loggers:MyLogger" Se o desenvolvimento de novos componentes por meio de pontos de entrada, é importante observar que os pontos de entrada do Python são globais para o ambiente Python. Isso significa que, se você tiver vários pacotes que registram componentes com a mesma chave, a última instalada será a usada. Isso pode ser útil para substituir componentes na fundição da LLM, mas também pode levar a comportamentos inesperados, se não for cuidadosos. Além disso, se você alterar o PyProject.toml, precisará reinstalar o pacote para que as alterações entrem em vigor. Você pode fazer isso rapidamente instalando com pip install -e . --no-deps para evitar reinstalar as dependências.
Você também pode registrar um componente diretamente em seu código:
from composer . loggers import LoggerDestination
from llmfoundry . registry import loggers
class MyLogger ( LoggerDestination ):
pass
loggers . register ( "my_logger" , func = MyLogger )Você também pode usar decoradores para registrar componentes diretamente do seu código:
from composer . loggers import LoggerDestination
from llmfoundry . registry import loggers
@ loggers . register ( "my_logger" )
class MyLogger ( LoggerDestination ):
pass Para as abordagens de chamadas diretas e decoradores, se estiver usando os scripts de trem/avaliação da Foundry LLM, você precisará fornecer o argumento code_paths , que é uma lista de arquivos precisa executar para registrar seus componentes. Por exemplo, você pode ter um arquivo chamado foundry_imports.py que contém o seguinte:
from foundry_registry . loggers import MyLogger
from llmfoundry . registry import loggers
loggers . register ( "my_logger" , func = MyLogger ) Você então forneceria code_paths para os scripts de trem/avaliação em sua configuração YAML:
...
code_paths :
- foundry_imports.py
...Um deles seria o uso esperado se você estiver construindo uma pequena extensão da fundição da LLM, substituindo apenas alguns componentes e, portanto, não deseja criar um pacote inteiro.
Confira o tutorial.md para continuar aprendendo sobre como trabalhar com a LLM Foundry. O tutorial destaca o exemplo de fluxos de trabalho, aponta para outros recursos em todo o repositório e responde a perguntas frequentes!
Se você tiver algum problema com o código, arquive problemas do GitHub diretamente neste repositório.
Se você deseja treinar LLMs na plataforma MosaicML, entre em contato conosco pelo [email protected]!
