llm foundry
v0.15.1
Este repositorio contiene código para capacitación, fina, evaluación e implementación de LLM para inferencia con el compositor y la plataforma MOSAICML. Diseñado para ser fácil de usar, eficiente y flexible, esta base de código permite una rápida experimentación con las últimas técnicas.
Encontrarás en este repositorio:
llmfoundry/ - Código fuente para modelos, conjuntos de datos, devoluciones de llamada, utilidades, etc.scripts/ - scripts para ejecutar cargas de trabajo LLMdata_prep/ - Convertir datos de texto de fuentes originales a formato de transmisióntrain/ - Train o Finetune Huggingface y modelos MPT de 125m - 70b parámetrostrain/benchmarking - rendimiento de entrenamiento de perfil y MFUinference/ - Convertir modelos a formato Huggingface o ONNX, y generar respuestasinference/benchmarking - latencia de inferencia de perfil y rendimientoeval/ -Evaluar LLMS en tareas académicas (o personalizadas) en tareas de aprendizaje en contextomcli/ - Inicie cualquiera de estas cargas de trabajo utilizando MCLI y la plataforma MOSAICMLTUTORIAL.md : una inmersión más profunda en el repositorio, los flujos de trabajo de ejemplo y las preguntas frecuentesDBRX es un LLM de código abierto de última generación capacitado por el equipo de Mosaic de Databricks. Utiliza la arquitectura de la mezcla de expertos (MOE) y fue entrenado con versiones optimizadas de Composer, LLM Foundry y Megablocks. El modelo tiene parámetros totales de 132B y parámetros activos 36B. Hemos lanzado dos modelos DBRX:
| Modelo | Longitud de contexto | Descargar |
|---|---|---|
| Base de DBRX | 32768 | https://huggingface.co/databricks/dbrx-base |
| Instrucción DBRX | 32768 | https://huggingface.co/databricks/dbrx-instruct |
Nuestros pesos y código de modelos tienen licencia tanto para investigadores como para entidades comerciales. La licencia de código abierto de Databricks se puede encontrar en la licencia, y nuestra política de uso aceptable se puede encontrar aquí.
Para obtener más información sobre los modelos DBRX, consulte https://github.com/databricks/dbrx.
Los transformadores de mosaico previos a la aparición (MPT) son modelos de estilo GPT con algunas características especiales: atención para flash para la eficiencia, la coartada para la extrapolación de la longitud de contexto y las mejoras de estabilidad para mitigar los picos de pérdidas. Como parte de la serie Foundation de MosaicML, tenemos varios modelos MPT de código abierto:
| Modelo | Longitud de contexto | Descargar | ¿Uso comercial? |
|---|---|---|---|
| MPT-30B | 8192 | https://huggingface.co/mosaicml/mpt-30b | Sí |
| MPT-30B-INSTRUST | 8192 | https://huggingface.co/mosaicml/mpt-30b-instruct | Sí |
| Mpt-30b-chat | 8192 | https://huggingface.co/mosaicml/mpt-30b-chat | No |
| MPT-7B-8K | 8192 | https://huggingface.co/mosaicml/mpt-7b-8k | Sí |
| MPT-7B-8K-CHAT | 8192 | https://huggingface.co/mosaicml/mpt-7b-8k-chat | No |
| MPT-7B | 2048 | https://huggingface.co/mosaicml/mpt-7b | Sí |
| MPT-7B-INSTRUST | 2048 | https://huggingface.co/mosaicml/mpt-7b-instruct | Sí |
| Mpt-7b-chat | 2048 | https://huggingface.co/mosaicml/mpt-7b-chat | No |
| Mpt-7b-storywriter | 65536 | https://huggingface.co/mosaicml/mpt-7b-storywriter | Sí |
Para probar estos modelos localmente, siga las instrucciones en scripts/inference/README.md para solicitar modelos HF utilizando nuestros scripts hf_generate.py o hf_chat.py.
¡Nos ha abrumado todo el trabajo increíble que la comunidad ha puesto en MPT! Aquí proporcionamos algunos enlaces a algunos de ellos:
replit-code-v1-3b es un modelo de lenguaje causal de 2.7B centrado en la finalización del código. El modelo ha sido entrenado en un subconjunto del conjunto de datos de la pila dedup v1.2 que cubre 20 idiomas como Java, Python y C ++Videos tutoriales de la comunidad:
Algo falta? ¡Contribuir con un PR!
Esta base de código se ha probado con Pytorch 2.4 con NVIDIA A100S y H100S. Esta base de código también puede funcionar en sistemas con otros dispositivos, como las tarjetas NVIDIA de consumo y las tarjetas AMD, pero no estamos probando activamente estos sistemas. Si tiene éxito/falla usando LLM Foundry en otros sistemas, háganos saber en un problema de GitHub y actualizaremos la matriz de soporte.
| Dispositivo | Versión de antorcha | Versión CUDA | Estado |
|---|---|---|---|
| A100-40GB/80GB | 2.5.1 | 12.4 | ✅ Apoyado |
| H100-80GB | 2.5.1 | 12.4 | ✅ Apoyado |
Recomendamos encarecidamente usar nuestras imágenes de Docker prebuilt. Puede encontrarlos aquí: https://hub.docker.com/orgs/mosaicml/repositories.
Las imágenes mosaicml/pytorch están fijadas en versiones específicas de Pytorch y Cuda, y son estables y rara vez se actualizan.
Las imágenes mosaicml/llm-foundry están construidas con nuevas etiquetas sobre cada compromiso con la rama main . Puede seleccionar un hash de confirmación específico como mosaicml/llm-foundry:2.5.1_cu124-9867a7b o tomar el último usando mosaicml/llm-foundry:2.5.1_cu124-latest .
Tenga en cuenta: las imágenes mosaicml/llm-foundry no vienen con el paquete llm-foundry preinstalado, solo las dependencias. Aún deberá pip install llm-foundry desde Pypi o desde la fuente.
| Imagen de Docker | Versión de antorcha | Versión CUDA | ¿Las dependencias de fundición LLM instaladas? |
|---|---|---|---|
mosaicml/pytorch:2.5.1_cu124-python3.11-ubuntu22.04 | 2.5.1 | 12.4 (infiniband) | No |
mosaicml/llm-foundry:2.5.1_cu124-latest | 2.5.1 | 12.4 (infiniband) | Sí |
mosaicml/llm-foundry:2.5.1_cu124_aws-latest | 2.5.1 | 12.4 (EFA) | Sí |
Esto supone que ya tiene instalados Pytorch, CMake y Packaging. Si no es así, puede instalarlos con pip install cmake packaging torch .
Para comenzar, clone el repositorio y configure su entorno. Las instrucciones para hacerlo difieren ligeramente dependiendo de si está usando Docker.
Recomendamos encarecidamente trabajar con LLM Foundry dentro de un contenedor Docker (consulte nuestra imagen de Docker recomendada arriba). Si lo está haciendo, siga estos pasos para clonar el repositorio e instalar los 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.Si elige no usar Docker, debe crear y usar un entorno 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.Las GPU NVIDIA H100 tienen soporte FP8; Ya hemos instalado atención flash y transformador en nuestras imágenes Docker (ver arriba). Si no está utilizando nuestras imágenes Docker, puede instalar estos paquetes con:
pip install flash-attn --no-build-isolation
pip install git+https://github.com/NVIDIA/TransformerEngine.git@stableConsulte aquí para obtener más detalles sobre habilitar las capas TransformerEngine y AMP_FP8.
En nuestras pruebas de AMD GPU, la configuración de ENV incluye:
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 último , instale la atención flash habilitada ROCM (instrucciones aquí).
Notas:
numpy==1.23.5 ) antes de que todo funcione sin problemas. El soporte para LLM Foundry en dispositivos Intel Gaudi es experimental, utilice la rama habana_alpha y vea el readMe en esa rama que tiene instrucciones de instalación y problemas conocidos.
Para obtener resultados de rendimiento de capacitación e inferencia en los aceleradores Intel Gaudi2, consulte nuestro blog: https://www.databricks.com/blog/llm-training-andinference-intel-gaudi2-ai-accelerators
¡Tenga en cuenta que asegúrese de pasar por los pasos de instalación anteriores antes de probar el inicio rápido!
Aquí hay un flujo de trabajo de extremo a extremo para preparar un subconjunto del conjunto de datos C4, capacitar un modelo MPT-125M para 10 lotes, convertir el modelo en formato de cara de abrazo, evaluar el modelo en el desafío de Winograd y generar respuestas a indicaciones.
(Recuerde que esto es un inicio rápido solo para demostrar las herramientas: para obtener buena calidad, ¿el LLM debe estar capacitado por más 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: El comando composer utilizado anteriormente para entrenar el modelo se refiere al lanzador distribuido de la biblioteca del compositor.
Si tiene un token de autenticación de Huggingface habilitado para escribir escritos, ¡opcionalmente puede cargar su modelo en el Hub! Simplemente exporte su token así:
export HF_TOKEN=your-auth-token y descomplement la línea que contiene --hf_repo_for_upload ... en la llamada anterior a inference/convert_composer_to_hf.py .
Puede usar el registro para personalizar sus flujos de trabajo sin bifurcar la biblioteca. Algunos componentes de LLM Foundry son registrables, como modelos, registradores y devoluciones de llamada. Esto significa que puede registrar nuevas opciones para estos componentes y luego usarlas en su configuración YAML.
Para ayudar a encontrar y comprender los componentes registrables, puede usar el comando llmfoundry registry CLI.
Proporcionamos dos comandos actualmente:
llmfoundry registry get [--group] : enumere todos los registros y sus componentes, que opcionalmente especifican un registro específico. Uso de ejemplo: llmfoundry registry get --group loggers o llmfoundry registry getllmfoundry registry find <group> <name> : Obtenga información sobre un componente registrado específico. Ejemplo de uso: llmfoundry registry find loggers wandb Use --help en cualquiera de estos comandos para obtener más información.
Estos comandos también pueden ayudarlo a comprender de qué está compuesto cada registro, ya que cada registro contiene un documento que se imprimirá. El concepto general es que cada registro define una interfaz, y los componentes registrados en ese registro deben implementar esa interfaz. Si hay una parte de la biblioteca que actualmente no se puede extender, pero cree que debería ser, ¡abra un problema!
Hay algunas formas de registrar un nuevo componente:
Puede especificar componentes registrados a través de un punto de entrada de Python si está creando su propio paquete con componentes registrados. Este sería el uso esperado si está construyendo una gran extensión a LLM Foundry y anulará muchos componentes. Tenga en cuenta que las cosas registradas a través de EntryPoints anularán los componentes registrados directamente en el código.
Por ejemplo, lo siguiente registraría la clase MyLogger , debajo de la clave my_logger , en el 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" Si se desarrolla nuevos componentes a través de EntryPoints, es importante tener en cuenta que los puntos de entrada de Python son globales para el entorno de Python. Esto significa que si tiene múltiples paquetes que registran componentes con la misma clave, el último instalado será el utilizado. Esto puede ser útil para anular los componentes en la fundición de LLM, pero también puede conducir a un comportamiento inesperado si no tiene cuidado. Además, si cambia el pyproject.toml, deberá reinstalar el paquete para que los cambios entren en vigencia. Puede hacerlo rápidamente instalando con pip install -e . --no-deps para evitar reinstalar las dependencias.
También puede registrar un componente directamente en su código:
from composer . loggers import LoggerDestination
from llmfoundry . registry import loggers
class MyLogger ( LoggerDestination ):
pass
loggers . register ( "my_logger" , func = MyLogger )También puede usar decoradores para registrar componentes directamente desde su código:
from composer . loggers import LoggerDestination
from llmfoundry . registry import loggers
@ loggers . register ( "my_logger" )
class MyLogger ( LoggerDestination ):
pass Tanto para los enfoques de llamadas directas como para el decorador, si usa los scripts LLM Foundry Train/Eval, deberá proporcionar el argumento code_paths , que es una lista de archivos que debe ejecutar para registrar sus componentes. Por ejemplo, puede tener un archivo llamado foundry_imports.py que contiene lo siguiente:
from foundry_registry . loggers import MyLogger
from llmfoundry . registry import loggers
loggers . register ( "my_logger" , func = MyLogger ) Luego proporcionaría code_paths a los scripts Train/Eval en su configuración YAML:
...
code_paths :
- foundry_imports.py
...Uno de estos sería el uso esperado si está construyendo una pequeña extensión para LLM Foundry, solo anulando algunos componentes y, por lo tanto, no desea crear un paquete completo.
Echa un vistazo a Tutorial.MD para seguir aprendiendo sobre trabajar con LLM Foundry. ¡El tutorial destaca los flujos de trabajo de ejemplo, lo señala otros recursos a lo largo del repositorio y respuestas preguntas frecuentes!
Si se encuentra con algún problema con el código, presente los problemas de GitHub directamente a este repositorio.
Si desea entrenar LLM en la plataforma Mosaicml, ¡comuníquese con nosotros a [email protected]!
