llm foundry
v0.15.1
Ce référentiel contient du code pour la formation, la fin de la formation, l'évaluation et le déploiement de LLMS pour l'inférence avec le compositeur et la plate-forme MOSAICML. Conçu pour être facile à utiliser, efficace et flexible, cette base de code permet une expérimentation rapide avec les dernières techniques.
Vous trouverez dans ce repo:
llmfoundry/ - Code source pour les modèles, ensembles de données, rappels, utilitaires, etc.scripts/ - scripts pour exécuter les charges de travail LLMdata_prep/ - convertir les données de texte à partir de sources originales au format StreamingDatasettrain/ - Train ou Finetune HuggingFace et MTMPS Modèles à partir de paramètres de 125 m à 70btrain/benchmarking - débit de formation de profil et MFUinference/ - Convertir des modèles au format HuggingFace ou ONNX et générer des réponsesinference/benchmarking - Profil latence et débit d'inférence du profileval/ - Évaluer les LLM sur les tâches académiques (ou personnalisées) dans le contextemcli/ - Lancez l'une de ces charges de travail à l'aide de MCLI et de la plate-forme MOSAICMLTUTORIAL.md - une plongée plus profonde dans le dépôt, des exemples de workflows et des FAQDBRX est une LLM open source de pointe formée par l'équipe Mosaic de Databricks. Il utilise l'architecture du mélange de réseaux (MOE) et a été formé avec des versions optimisées du compositeur, de la fonderie LLM et des mégablocks. Le modèle a 132b paramètres totaux et 36B paramètres actifs. Nous avons publié deux modèles DBRX:
| Modèle | Durée du contexte | Télécharger |
|---|---|---|
| Base dbrx | 32768 | https://huggingface.co/databricks/dbrx-base |
| DBRX | 32768 | https://huggingface.co/databricks/dbrx-instruct |
Notre modèle de poids et de code sont autorisés aux chercheurs et aux entités commerciales. La licence open source de Databricks peut être trouvée sur la licence, et notre politique d'utilisation acceptable peut être trouvée ici.
Pour plus d'informations sur les modèles DBRX, voir https://github.com/databricks/dbrx.
Les transformateurs prétractés en mosaïque (MPT) sont des modèles de style GPT avec certaines caractéristiques spéciales - l'attention des flashs pour l'efficacité, l'alibi pour l'extrapolation de la longueur de contexte et les améliorations de stabilité pour atténuer les pics de perte. Dans le cadre de la série Foundation de Mosaicml, nous avons open source plusieurs modèles MPT:
| Modèle | Durée du contexte | Télécharger | Utilisation commerciale? |
|---|---|---|---|
| MPT-30B | 8192 | https://huggingface.co/mosaicml/mpt-30b | Oui |
| MPT-30B-INSTRUCT | 8192 | https://huggingface.co/mosaicml/mpt-30b-instruct | Oui |
| MPT-30B-CHAT | 8192 | https://huggingface.co/mosaicml/mpt-30b-chat | Non |
| MPT-7B-8K | 8192 | https://huggingface.co/mosaicml/mpt-7b-8k | Oui |
| MPT-7B-8K-CHAT | 8192 | https://huggingface.co/mosaicml/mpt-7b-8k-chat | Non |
| MPT-7B | 2048 | https://huggingface.co/mosaicml/mpt-7b | Oui |
| MPT-7B-INSTRUCT | 2048 | https://huggingface.co/mosaicml/mpt-7b-instruct | Oui |
| MPT-7B | 2048 | https://huggingface.co/mosaicml/mpt-7b-chat | Non |
| MPT-7B-Storywriter | 65536 | https://huggingface.co/mosaicml/mpt-7b-storywriter | Oui |
Pour essayer ces modèles localement, suivez les instructions dans scripts/inference/README.md pour inviter des modèles HF à l'aide de nos scripts HF_GENERETER.PY ou HF_CHAT.py.
Nous avons été submergés par tout le travail incroyable que la communauté a mis dans MPT! Ici, nous fournissons quelques liens vers certains d'entre eux:
replit-code-v1-3b est un modèle de langue causale 2.7b axé sur l'achèvement du code. Le modèle a été formé sur un sous-ensemble de l'ensemble de données Stack Dedup V1.2 couvrant 20 langues telles que Java, Python et C ++Vidéos de tutoriel de la communauté:
Quelque chose de manque? Contribuez avec un PR!
Cette base de code a été testée avec Pytorch 2.4 avec NVIDIA A100S et H100S. Cette base de code peut également fonctionner sur des systèmes avec d'autres appareils, tels que les cartes NVIDIA et les cartes AMD, mais nous ne testons pas activement ces systèmes. Si vous avez du succès / défaillance en utilisant LLM Foundry sur d'autres systèmes, veuillez nous en informer dans un problème GitHub et nous mettrons à jour la matrice de support!
| Appareil | Version de torche | Version CUDA | Statut |
|---|---|---|---|
| A100-40 Go / 80 Go | 2.5.1 | 12.4 | ✅ Soutenu |
| H100-80 Go | 2.5.1 | 12.4 | ✅ Soutenu |
Nous vous recommandons fortement d'utiliser nos images Docker prédéfinies. Vous pouvez les trouver ici: https://hub.docker.com/orgs/mosaicml/repositories.
Les images mosaicml/pytorch sont épinglées sur des versions Pytorch et Cuda spécifiques, et sont stables et rarement mises à jour.
Les images mosaicml/llm-foundry sont construites avec de nouvelles balises sur chaque engagement dans la branche main . Vous pouvez sélectionner un hachage de validation spécifique tel que mosaicml/llm-foundry:2.5.1_cu124-9867a7b ou en prendre le dernier en utilisant mosaicml/llm-foundry:2.5.1_cu124-latest .
Veuillez noter: les images mosaicml/llm-foundry ne sont pas livrées avec le package llm-foundry préinstallé, juste les dépendances. Vous devrez toujours pip install llm-foundry soit à partir de PYPI ou de Source.
| Image docker | Version de torche | Version CUDA | Dépendances de fonderie LLM installées? |
|---|---|---|---|
mosaicml/pytorch:2.5.1_cu124-python3.11-ubuntu22.04 | 2.5.1 | 12.4 (Infiniband) | Non |
mosaicml/llm-foundry:2.5.1_cu124-latest | 2.5.1 | 12.4 (Infiniband) | Oui |
mosaicml/llm-foundry:2.5.1_cu124_aws-latest | 2.5.1 | 12.4 (EFA) | Oui |
Cela suppose que vous avez déjà installé Pytorch, Cmake et Packaging. Sinon, vous pouvez les installer avec pip install cmake packaging torch .
Pour commencer, clonez le dépôt et configurez votre environnement. Les instructions pour le faire diffèrent légèrement selon que vous utilisez Docker.
Nous recommandons fortement de travailler avec LLM Foundry à l'intérieur d'un conteneur Docker (voir notre image Docker recommandée ci-dessus). Si vous le faites, suivez ces étapes pour cloner le dépôt et installer les exigences.
git clone https://github.com/mosaicml/llm-foundry.git
cd llm-foundry
pip install -e " .[gpu] " # or `pip install -e .` if no NVIDIA GPU.Si vous choisissez de ne pas utiliser Docker, vous devez créer et utiliser un environnement virtuel.
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.Les GPU NVIDIA H100 ont un support FP8; Nous avons déjà installé l'attention du flash et le transformateur dans nos images Docker (voir ci-dessus). Si vous n'utilisez pas nos images Docker, vous pouvez installer ces packages avec:
pip install flash-attn --no-build-isolation
pip install git+https://github.com/NVIDIA/TransformerEngine.git@stableVoir ici pour plus de détails sur l'activation des couches TransformEREngine et AMP_FP8.
Dans nos tests sur les GPU AMD, la configuration Env comprend:
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.2Enfin , installez l'attention du Flash activé ROCM (instructions ici).
Notes:
numpy==1.23.5 ) avant que tout ne fonctionne sans problème. La prise en charge de LLM Foundry sur les appareils Intel Gaudi est expérimentale, veuillez utiliser la branche habana_alpha et voir la lecture de cette branche qui a des instructions d'installation et des problèmes connus.
Pour les résultats de performance de formation et d'inférence sur les accélérateurs Intel Gaudi2, consultez notre blog: https://www.databricks.com/blog/llm-training-and-inference-intel-gaudi2-ai-accelerators
Remarque Assurez-vous de passer par les étapes d'installation ci-dessus avant d'essayer le start!
Voici un flux de travail de bout en bout pour la préparation d'un sous-ensemble de l'ensemble de données C4, la formation d'un modèle MPT-125m pour 10 lots, la conversion du modèle en étreinte, évaluant le modèle sur le défi Winograd et générant des réponses aux invites.
(N'oubliez pas que c'est un Quickstart juste pour démontrer les outils - pour obtenir de bonne qualité, le LLM doit être formé pour plus de 10 lots?)
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 " Remarque: La commande composer utilisée ci-dessus pour former le modèle fait référence au lanceur distribué de la bibliothèque compositeur.
Si vous avez un jeton Auth HuggingFace en écriture, vous pouvez éventuellement télécharger votre modèle sur le hub! Exportez simplement votre jeton comme ceci:
export HF_TOKEN=your-auth-token et non-comment la ligne contenant --hf_repo_for_upload ... dans l'appel ci-dessus à inference/convert_composer_to_hf.py .
Vous pouvez utiliser le registre pour personnaliser vos workflows sans fournir la bibliothèque. Certains composants de LLM Foundry sont enregistrables, tels que les modèles, les bûcherons et les rappels. Cela signifie que vous pouvez enregistrer de nouvelles options pour ces composants, puis les utiliser dans votre configuration YAML.
Pour aider à trouver et à comprendre les composants enregistrables, vous pouvez utiliser la commande CLI llmfoundry registry .
Nous fournissons actuellement deux commandes:
llmfoundry registry get [--group] : Listez tous les registres et leurs composants, spécifiant éventuellement un registre spécifique. Exemple d'utilisation: llmfoundry registry get --group loggers ou llmfoundry registry getllmfoundry registry find <group> <name> : Obtenez des informations sur un composant enregistré spécifique. Exemple d'utilisation: llmfoundry registry find loggers wandb Utilisez --help sur l'une de ces commandes pour plus d'informations.
Ces commandes peuvent également vous aider à comprendre de quoi chaque registre est composé, car chaque registre contient un docstring qui sera imprimé. Le concept général est que chaque registre définit une interface, et les composants enregistrés à ce registre doivent implémenter cette interface. S'il y a une partie de la bibliothèque qui n'est pas actuellement extensible, mais vous pensez que cela devrait l'être, veuillez ouvrir un problème!
Il existe plusieurs façons d'enregistrer un nouveau composant:
Vous pouvez spécifier des composants enregistrés via un point d'entrée Python si vous construisez votre propre package avec des composants enregistrés. Ce serait l'utilisation prévue si vous construisez une grande extension à LLM Foundry et que vous allez remplacer de nombreux composants. Notez que les choses enregistrées via les points d'entrée remplaceront les composants enregistrés directement dans le code.
Par exemple, les éléments suivants enregistreraient la classe MyLogger , sous la clé my_logger , dans le registre 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" Si vous développez de nouveaux composants via des points d'entrée, il est important de noter que les points d'entrée Python sont globaux dans l'environnement Python. Cela signifie que si vous avez plusieurs packages qui enregistrent des composants avec la même clé, le dernier installé sera celui utilisé. Cela peut être utile pour remplacer les composants dans LLM Foundry, mais peut également conduire à un comportement inattendu s'il n'est pas prudent. De plus, si vous modifiez le Pyproject.toml, vous devrez réinstaller le package pour que les modifications prennent effet. Vous pouvez le faire rapidement en installant avec pip install -e . --no-deps pour éviter de réinstaller les dépendances.
Vous pouvez également enregistrer un composant directement dans votre code:
from composer . loggers import LoggerDestination
from llmfoundry . registry import loggers
class MyLogger ( LoggerDestination ):
pass
loggers . register ( "my_logger" , func = MyLogger )Vous pouvez également utiliser des décorateurs pour enregistrer les composants directement à partir de votre code:
from composer . loggers import LoggerDestination
from llmfoundry . registry import loggers
@ loggers . register ( "my_logger" )
class MyLogger ( LoggerDestination ):
pass Pour les approches directes de l'appel et du décorateur, si vous utilisez les scripts LLM Foundry Train / Eval, vous devrez fournir l'argument code_paths , qui est une liste de fichiers à exécuter afin d'enregistrer vos composants. Par exemple, vous pouvez avoir un fichier appelé foundry_imports.py qui contient ce qui suit:
from foundry_registry . loggers import MyLogger
from llmfoundry . registry import loggers
loggers . register ( "my_logger" , func = MyLogger ) Vous fournisseriez ensuite code_paths aux scripts Train / Eval dans votre configuration YAML:
...
code_paths :
- foundry_imports.py
...L'un d'eux serait l'utilisation attendue si vous construisez une petite extension à LLM Foundry, ne dépassant que quelques composants, et que vous ne voulez donc pas créer un package entier.
Consultez Tutorial.md pour continuer à apprendre à travailler avec LLM Foundry. Le tutoriel met en évidence des exemples de workflows, vous indique d'autres ressources tout au long du dépôt et répond aux questions fréquemment posées!
Si vous rencontrez des problèmes avec le code, veuillez déposer des problèmes GitHub directement à ce dépôt.
Si vous souhaitez former des LLM sur la plate-forme Mosaicml, contactez-nous à dé[email protected]!
