Accelerate documentation
Inferencia de modelos grandes
Inferencia de modelos grandes
Uno de los mayores avances que ofrece Accelerate es Big Model Inference, que te permite realizar inferencia con modelos que no caben por completo en tu tarjeta gráfica.
En este tutorial se mostrará cómo usar Big Model Inference en Accelerate y el ecosistema de Hugging Face.
Accelerate
A continuación se muestra un flujo de trabajo típico para cargar un modelo de PyTorch. ModelClass es un modelo que excede la memoria de la GPU de su dispositivo (mps o cuda o xpu).
import torch
my_model = ModelClass(...)
state_dict = torch.load(checkpoint_file)
my_model.load_state_dict(state_dict)Con Big Model Inference, el primer paso es inicializar un esqueleto vacío del modelo con el gestor de contexto init_empty_weights. Esto no requiere memoria porque my_model es “sin parámetros”.
from accelerate import init_empty_weights
with init_empty_weights():
my_model = ModelClass(...)A continuación, los pesos se cargan en el modelo para la inferencia.
El método load_checkpoint_and_dispatch() carga un checkpoint dentro de su modelo vacío y distribuye los pesos de cada capa entre todos los dispositivos disponibles, comenzando con los dispositivos más rápidos (GPU, MPS, XPU, NPU, MLU, SDAA, MUSA) antes de pasar a los más lentos (CPU y disco duro).
Establecer device_map="auto" llena automáticamente todo el espacio disponible primero en las GPU, luego en la CPU y, por último, en el disco duro (la opción más lenta) si aún no hay suficiente memoria.
Consulte la guía Diseño de un mapa de dispositivos para obtener más detalles sobre cómo diseñar su propio mapa de dispositivos.
from accelerate import load_checkpoint_and_dispatch
model = load_checkpoint_and_dispatch(
model, checkpoint=checkpoint_file, device_map="auto"
)Si hay ciertos “bloques” de capas que no deben dividirse, pásalos a no_split_module_classes (ver aquí para más detalles).
Los pesos de un modelo también se pueden dividir en varios puntos de control para ahorrar memoria, por ejemplo, cuando el state_dict no cabe en la memoria (consulte aquí para más detalles).
Ahora que el modelo está completamente despachado, puedes realizar la inferencia.
input = torch.randn(2,3)
device_type = next(iter(model.parameters())).device.type
input = input.to(device_type)
output = model(input)Cada vez que una entrada se procesa a través de una capa, se envía desde la CPU a la GPU (o desde el disco a la CPU y luego a la GPU), se calcula la salida y la capa se elimina de la GPU para continuar descendiendo por la secuencia. Si bien esto añade cierta sobrecarga a la inferencia, permite ejecutar modelos de cualquier tamaño en tu sistema, siempre que la capa más grande quepa en tu GPU.
Se pueden utilizar varias GPU o “paralelismo de modelo”, pero solo una GPU estará activa en cada momento. Esto obliga a la GPU a esperar a que la GPU anterior le envíe la salida. Debe iniciar su script normalmente con Python en lugar de usar otras herramientas como torchrun y accelerate launch.
A continuación, un ejemplo completo de inferencia de modelos grandes.
import torch
from accelerate import init_empty_weights, load_checkpoint_and_dispatch
with init_empty_weights():
model = MyModel(...)
model = load_checkpoint_and_dispatch(
model, checkpoint=checkpoint_file, device_map="auto"
)
input = torch.randn(2,3)
device_type = next(iter(model.parameters())).device.type
input = input.to(device_type)
output = model(input)Ecosistema de Hugging Face
Otras bibliotecas del ecosistema de Hugging Face, como Transformers o Diffusers, admiten la inferencia de modelos grandes en sus constructores from_pretrained.
Solo necesitas añadir device_map="auto" en from_pretrained para habilitar la inferencia de modelos grandes.
Por ejemplo, cargue el modelo de 11 mil millones de parámetros Big Sciences T0pp con Big Model Inference.
from transformers import AutoModelForSeq2SeqLM
model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", device_map="auto")Después de cargar el modelo, se ejecutan los pasos de inicialización vacía y despacho inteligente mencionados anteriormente, y el modelo queda completamente listo para aprovechar todos los recursos de tu máquina. A través de estos constructores, también puedes ahorrar más memoria especificando el parámetro torch_dtype para cargar un modelo con una precisión inferior.
from transformers import AutoModelForSeq2SeqLM
model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0pp", device_map="auto", torch_dtype=torch.float16)Próximos pasos
Para una explicación más detallada de Big Model Inference, asegúrate de consultar la guía conceptual.
Update on GitHub