Accelerate documentation

Trabajar con modelos grandes

Accelerate

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Trabajar con modelos grandes

Despacho y descarga

init_empty_weights

accelerate.init_empty_weights

< source >

( include_buffers: bool | None = None )

Parámetros

include_buffers (bool, opcional) — Si se deben colocar también todos los buffers en el dispositivo meta durante la inicialización.

Un gestor de contexto bajo el cual los modelos se inicializan con todos los parámetros en el dispositivo meta, creando así un modelo vacío. Útil cuando la simple inicialización del modelo agotaría la RAM disponible.

Ejemplo:

import torch.nn as nn
from accelerate import init_empty_weights

# Initialize a model with 100 billions parameters in no time and without using any RAM.
with init_empty_weights():
    tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])

Cualquier modelo creado bajo este gestor de contexto no tiene pesos. Por lo tanto, no se puede hacer algo como model.to(some_device) con él. Para cargar pesos dentro de su modelo vacío, consulte load_checkpoint_and_dispatch(). Asegúrese de sobrescribir el parámetro predeterminado device_map de load_checkpoint_and_dispatch(), de lo contrario, dispatch no se llama.

cpu_offload

accelerate.cpu_offload

< source >

( model: Moduleexecution_device: torch.device | None = Noneoffload_buffers: bool = Falsestate_dict: dict[str, torch.Tensor] | None = Nonepreload_module_classes: list[str] | None = None )

Parámetros

model (torch.nn.Module) — El modelo que se va a descargar.
execution_device (torch.device, opcional) — El dispositivo en el que se ejecutará la pasada hacia adelante del modelo (debe ser una GPU). Por defecto, será el dispositivo del primer parámetro del modelo.
offload_buffers (bool, opcional, valor predeterminado False) — Si se descargan o no los buffers junto con los parámetros del modelo.
state_dict (Dict[str, torch.Tensor], opcional) — El state dict del modelo que se mantendrá en la CPU.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.

Activa el offload completo de CPU para un modelo. Como resultado, todos los parámetros del modelo se descargarán y solo se mantendrá una copia del state dict del modelo. Durante el forward pass, los parámetros se extraerán de ese state dict y se colocarán en el dispositivo de ejecución pasado a medida que se necesiten, para luego volver a descargarse.

cpu_offload_with_hook

accelerate.cpu_offload_with_hook

< source >

( model: Moduleexecution_device: int | str | torch.device | None = Noneprev_module_hook: accelerate.hooks.UserCpuOffloadHook | None = None )

Parámetros

model (torch.nn.Module) — El modelo que se va a descargar.
execution_device(str, int or torch.device, opcional) — El dispositivo en el que se debe ejecutar el modelo. Por defecto, se utilizará el dispositivo MPS si está disponible, luego el dispositivo 0 si hay un dispositivo de aceleración, y finalmente la CPU.
prev_module_hook (UserCpuOffloadHook, opcional) — El hook devuelto por esta función para un modelo anterior en el pipeline que estás ejecutando. Si se pasa, su método de offload se llamará justo antes del forward del modelo al que está unido este hook.

Descarga un modelo en la CPU y lo devuelve al dispositivo de ejecución cuando se ejecuta. La diferencia con cpu_offload() es que el modelo permanece en el dispositivo de ejecución después del forward y solo se descarga nuevamente cuando se llama al método offload del hook devuelto. Útil para pipelines que ejecutan un modelo en un bucle.

Ejemplo:

model_1, hook_1 = cpu_offload_with_hook(model_1, device)
model_2, hook_2 = cpu_offload_with_hook(model_2, device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, device, prev_module_hook=hook_2)

hid_1 = model_1(input)
for i in range(50):
    # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
    hid_2 = model_2(hid_1)
# model2 is offloaded to the CPU just before this forward.
hid_3 = model_3(hid_3)

# For model3, you need to manually call the hook offload method.
hook_3.offload()

disk_offload

accelerate.disk_offload

< source >

( model: Moduleoffload_dir: str | os.PathLikeexecution_device: torch.device | None = Noneoffload_buffers: bool = Falsepreload_module_classes: list[str] | None = None )

Parámetros

model (torch.nn.Module) — El modelo que se va a descargar.
offload_dir (str o os.PathLike) — La carpeta en la que se descargan los pesos del modelo (o donde ya están descargados).
execution_device (torch.device, opcional) — El dispositivo en el que se ejecutará la pasada hacia adelante del modelo (debe ser una GPU). Por defecto, será el dispositivo del primer parámetro del modelo.
offload_buffers (bool, opcional, valor predeterminado False) — Si se descargan o no los buffers junto con los parámetros del modelo.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.

Activa el offload completo en disco para un modelo. Como resultado, todos los parámetros del modelo se descargarán como un array mapeado en memoria en una carpeta dada. Durante la pasada hacia adelante, los parámetros se accederán desde esa carpeta y se colocarán en el dispositivo de ejecución pasado a medida que se necesiten, para luego volver a descargarse.

dispatch_model

accelerate.dispatch_model

< source >

Parámetros

model (torch.nn.Module) — El modelo que se va a despachar.
device_map (Dict[str, Union[str, int, torch.device]]) — Un diccionario que asigna los nombres de los módulos en el state_dict de los modelos al dispositivo al que deben ir. Tenga en cuenta que "disk" se acepta aunque no sea un valor válido para torch.device.
main_device (str, int o torch.device, opcional) — El dispositivo principal de ejecución. Por defecto, será el primer dispositivo del device_map diferente de "cpu" o "disk".
state_dict (Dict[str, torch.Tensor], opcional) — El state dict de la parte del modelo que se mantendrá en la CPU.
offload_dir (str o os.PathLike) — La carpeta en la que se descargan los pesos del modelo (o donde ya están descargados).
offload_index (Dict, opcional) — Un diccionario que va del nombre del peso a su información (dtype/ shape o nombre de archivo safetensors). Por defecto, se usa el índice guardado en save_folder.
offload_buffers (bool, opcional, valor predeterminado False) — Si se descargan o no los buffers junto con los parámetros del modelo.
skip_keys (str o List[str], opcional) — Una lista de claves para ignorar al mover entradas o salidas entre dispositivos.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.
force_hooks (bool, opcional, valor predeterminado False) — Si se deben forzar los hooks de dispositivo para que se adjunten al modelo, incluso si todas las capas se asignan a un único dispositivo.

Despacha un modelo según un mapa de dispositivos dado. Las capas del modelo pueden distribuirse entre varias GPU, descargarse en la CPU o incluso en el disco.

load_checkpoint_and_dispatch

accelerate.load_checkpoint_and_dispatch

< source >

Parámetros

model (torch.nn.Module) — El modelo en el que queremos cargar un punto de control.
checkpoint (str o os.PathLike) — El punto de control de la carpeta a cargar. Puede ser:
- una ruta a un archivo que contiene un diccionario de estado completo del modelo
- una ruta a un archivo .json que contiene el índice de un punto de control fragmentado
- una ruta a una carpeta que contiene un archivo .index.json único y los fragmentos de un punto de control.
device_map (Dict[str, Union[int, str, torch.device]], opcional) — Un mapa que especifica dónde debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.
Para que Accelerate calcule automáticamente el device_map más optimizado, establezca device_map="auto". Para obtener más información sobre cada opción, consulte aquí. El valor predeterminado es None, lo que significa que dispatch_model() no se llamará.
max_memory (Dict, opcional) — Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible para cada GPU y la RAM de CPU disponible.
no_split_module_classes (List[str], opcional) — Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).
offload_folder (str o os.PathLike, opcional) — Si el device_map contiene algún valor "disk", la carpeta donde se descargarán los pesos.
offload_buffers (bool, opcional, valor predeterminado False) — En las capas que se descargan en la CPU o en el disco duro, si se deben descargar o no los buffers además de los parámetros.
dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
offload_state_dict (bool, opcional) — Si es True, se descargará temporalmente el state dict de CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de CPU + el shard más grande no cabe. El valor predeterminado será True si el device map seleccionado contiene valores de "disk".
skip_keys (str o List[str], opcional) — Una lista de claves para ignorar al mover entradas o salidas entre dispositivos.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.
force_hooks (bool, opcional, valor predeterminado False) — Si se deben forzar los hooks de dispositivo para que se adjunten al modelo, incluso si todas las capas se asignan a un único dispositivo.
strict (bool, opcional, valor predeterminado False) — Si se debe aplicar estrictamente que las claves del state_dict del checkpoint coincidan con las claves del state_dict del modelo.
full_state_dict (bool, opcional, valor predeterminado True) — si se establece en True, se recopilarán todos los tensores del state_dict cargado. No habrá ShardedTensor ni DTensor en el state_dict cargado.
broadcast_from_rank0 (False, opcional, valor predeterminado False) — cuando la opción es True, se debe inicializar un ProcessGroup distribuido. rank0 debe recibir un state_dict completo y retransmitirá los tensores del state_dict uno a uno a los demás ranks. Los demás ranks recibirán los tensores y los fragmentarán (si aplica) según los fragmentos locales del modelo.

Carga un punto de control (posiblemente fragmentado) dentro de un modelo, enviando potencialmente los pesos a un dispositivo dado a medida que se cargan, y añade los varios hooks que harán que este modelo funcione correctamente (incluso si está dividido entre dispositivos).

Ejemplo:

>>> from accelerate import init_empty_weights, load_checkpoint_and_dispatch
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoConfig, AutoModelForCausalLM

>>> # Download the Weights
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> weights_location = hf_hub_download(checkpoint, "pytorch_model.bin")

>>> # Create a model and initialize it with empty weights
>>> config = AutoConfig.from_pretrained(checkpoint)
>>> with init_empty_weights():
...     model = AutoModelForCausalLM.from_config(config)

>>> # Load the checkpoint and dispatch it to the right devices
>>> model = load_checkpoint_and_dispatch(
...     model, weights_location, device_map="auto", no_split_module_classes=["GPTJBlock"]
... )

load_checkpoint_in_model

accelerate.load_checkpoint_in_model

< source >

Parámetros

model (torch.nn.Module) — El modelo en el que queremos cargar un punto de control.
checkpoint (str o os.PathLike) — El checkpoint de la carpeta a cargar. Puede ser:
- una ruta a un archivo que contiene un diccionario de estado completo del modelo
- una ruta a un archivo .json que contiene el índice de un punto de control fragmentado
- una ruta a una carpeta que contiene un archivo .index.json único y los fragmentos de un punto de control.
- una ruta a una carpeta que contenga un archivo pytorch_model.bin o model.safetensors único.
device_map (Dict[str, Union[int, str, torch.device]], opcional) — Un mapa que especifica dónde debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.
offload_folder (str o os.PathLike, opcional) — Si el device_map contiene algún valor "disk", la carpeta donde se descargarán los pesos.
dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
offload_state_dict (bool, opcional, valor predeterminado False) — Si True, se descargará temporalmente el state dict de CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de CPU + el fragmento más grande no cabe.
offload_buffers (bool, opcional, valor predeterminado False) — Si se incluyen o no los buffers en los pesos que se descargan en el disco.
keep_in_fp32_modules(List[str], opcional) — Una lista de los módulos que se mantienen en el tipo de datos torch.float32.
offload_8bit_bnb (bool, opcional) — Si se habilita o no el offload de módulos de 8 bits en cpu/disco.
strict (bool, opcional, valor predeterminado False) — Si se debe aplicar estrictamente que las claves del state_dict del checkpoint coincidan con las claves del state_dict del modelo.
full_state_dict (bool, opcional, valor predeterminado True) — si se establece en True, se recopilarán todos los tensores del state_dict cargado. No habrá ShardedTensor ni DTensor en el state_dict cargado.
broadcast_from_rank0 (False, opcional, valor predeterminado False) — cuando la opción es True, se debe inicializar un ProcessGroup distribuido. rank0 debe recibir un state_dict completo y retransmitirá los tensores del state_dict uno a uno a los demás ranks. Los demás ranks recibirán los tensores y los fragmentarán (si aplica) según los fragmentos locales del modelo.

Carga un punto de control (posiblemente fragmentado) dentro de un modelo, enviando potencialmente los pesos a un dispositivo dado a medida que se cargan.

Una vez cargado en los dispositivos, aún debe llamar a dispatch_model() en su modelo para que pueda ejecutarse. Para agrupar la carga del checkpoint y el despacho en una sola llamada, use load_checkpoint_and_dispatch().

infer_auto_device_map

accelerate.infer_auto_device_map

< source >

Parámetros

model (torch.nn.Module) — El modelo a analizar.
max_memory (Dict, opcional) — Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible. Ejemplo: max_memory={0: "1GB"}.
no_split_module_classes (List[str], opcional) — Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).
dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
special_dtypes (Dict[str, Union[str, torch.device]], opcional) — Si se proporciona, dtypes especiales a considerar para algunos pesos específicos (anulará el dtype utilizado de forma predeterminada para todos los pesos).
verbose (bool, opcional, valor predeterminado False) — Indica si se deben proporcionar declaraciones de depuración mientras la función construye el device_map.
clean_result (bool, opcional, valor predeterminado True) — Limpia el device_map resultante agrupando todos los submódulos que se colocan en el mismo dispositivo.
offload_buffers (bool, opcional, valor predeterminado False) — En las capas que se descargan en la CPU o en el disco duro, si se deben descargar o no los buffers además de los parámetros.
fallback_allocation (bool, opcional, valor predeterminado False) — Si la asignación regular falla, intenta asignar un módulo que quepa dentro del límite de tamaño usando BFS.

Calcule un mapa de dispositivos para un modelo dado dando prioridad a las GPUs, luego descargue en la CPU y finalmente descargue en el disco, de modo que:

no superamos la memoria disponible de ninguna de las GPU.
si se necesita descargar en la CPU, siempre queda espacio en la GPU 0 para volver a colocar la capa descargada en la CPU que tiene el mayor tamaño.
si se necesita offload a la CPU, no superamos la RAM disponible en la CPU.
si se necesita descargar en el disco, siempre queda espacio en la CPU para volver a colocar la capa descargada en el disco que tiene el mayor tamaño.

Todos los cálculos se realizan analizando los tamaños y los dtypes de los parámetros del modelo. Como resultado, el modelo puede estar en el dispositivo meta (como lo estaría si se inicializara dentro del administrador de contexto init_empty_weights).

Hooks

ModelHook

clase accelerate.hooks.ModelHook

< source >

( )

Un hook que contiene callbacks para ejecutarse justo antes y después del método forward de un modelo. La diferencia con los hooks existentes de PyTorch es que estos reciben los kwargs.

Atributo de clase:

no_grad (bool, opcional, valor predeterminado False) — Indica si se debe ejecutar la pasada de propagación hacia adelante real bajo el gestor de contexto torch.no_grad().

detach_hook

< source >

( module )

Parámetros

module (torch.nn.Module) — El módulo desvinculado de este hook.

Para ejecutarse cuando el hook se desvincula de un módulo.

init_hook

< source >

( module )

Parámetros

module (torch.nn.Module) — El módulo adjunto a este hook.

Para ejecutarse cuando el hook se adjunta al módulo.

post_forward

< source >

( moduleoutput ) → Any

Parámetros

module (torch.nn.Module) — El módulo cuya pasada hacia adelante se ejecutó justo antes de este evento.
output (Any) — La salida del módulo.

Devuelve

Any

La output procesada.

Para ejecutarse justo después del método forward del modelo.

pre_forward

< source >

( module*args**kwargs ) → Tuple[Tuple[Any], Dict[Str, Any]]

Parámetros

module (torch.nn.Module) — El módulo cuya pasada hacia adelante se ejecutará justo después de este evento.
args (Tuple[Any]) — Los argumentos posicionales pasados al módulo.
kwargs (Dict[Str, Any]) — Los argumentos de palabra clave pasados al módulo.

Devuelve

Tuple[Tuple[Any], Dict[Str, Any]]

Una tupla con los args y kwargs tratados.

Para ejecutarse justo antes del método forward del modelo.

AlignDevicesHook

clase accelerate.hooks.AlignDevicesHook

< source >

Parámetros

execution_device (torch.device, opcional) — El dispositivo en el que deben colocarse las entradas y los pesos del modelo antes de la pasada hacia adelante.
offload (bool, opcional, valor predeterminado False) — Si las pesas deben o no descargarse después de la pasada hacia adelante.
io_same_device (bool, opcional, valor predeterminado False) — Indica si la salida debe colocarse en el mismo dispositivo que la entrada.
weights_map (Mapping[str, torch.Tensor], opcional) — Cuando los pesos del modelo se descargan, un mapa (posiblemente perezoso) de los nombres de los parámetros a los valores de los tensores.
offload_buffers (bool, opcional, valor predeterminado False) — Si se incluyen o no los buffers del módulo asociado al realizar el offloading.
place_submodules (bool, opcional, valor predeterminado False) — Si se colocan los submódulos en execution_device durante el evento init_hook.

Un ModelHook genérico que garantiza que las entradas y los pesos del modelo estén en el mismo dispositivo para la pasada hacia adelante del módulo asociado, con la posibilidad de descargar los pesos después de la pasada hacia adelante.

SequentialHook

clase accelerate.hooks.SequentialHook

< source >

( *hooks )

Un hook que puede contener varios hooks e itera a través de ellos en cada evento.

LayerwiseCastingHook

clase accelerate.hooks.LayerwiseCastingHook

< source >

( storage_dtype: dtypecompute_dtype: dtypenon_blocking: bool )

Un hook que convierte los pesos de un módulo a un dtype de alta precisión para el cálculo y a un dtype de baja precisión para el almacenamiento. Este proceso puede provocar una pérdida de calidad en la salida, pero puede reducir significativamente la huella de memoria.

Agregar hooks

add_hook_to_module

accelerate.hooks.add_hook_to_module

< source >

( module: Modulehook: ModelHookappend: bool = False ) → torch.nn.Module

Parámetros

module (torch.nn.Module) — El módulo al que se adjuntará el hook.
hook (ModelHook) — El hook que se debe adjuntar.
append (bool, opcional, valor predeterminado False) — Si el hook debe encadenarse con uno existente (si el módulo ya contiene un hook) o no.

Devuelve

torch.nn.Module

El mismo módulo, con el hook adjunto (el módulo se modifica in situ, por lo que el resultado puede descartarse).

Añade un hook a un módulo dado. Esto reescribe el método forward del módulo para incluir el hook; para eliminar este comportamiento y restaurar el método forward original, use remove_hook_from_module.

Si el módulo ya contiene un hook, este se reemplazará por el nuevo hook pasado por defecto. Para encadenar dos hooks, pase append=True, de modo que encadene el hook actual y el nuevo en una instancia de la clase SequentialHook.

attach_execution_device_hook

accelerate.hooks.attach_execution_device_hook

< source >

Parámetros

module (torch.nn.Module) — El módulo al que queremos adjuntar los hooks.
execution_device (int, str o torch.device) — El dispositivo en el que deben colocarse las entradas y los pesos del modelo antes de la pasada hacia adelante.
skip_keys (str o List[str], opcional) — Una lista de claves para ignorar al mover entradas o salidas entre dispositivos.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.
tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], opcional, valor predeterminado None) — Un mapa de punteros de datos a diccionarios de dispositivos a pesos vinculados ya despachados. Para un dispositivo de ejecución dado, este parámetro es útil para reutilizar el primer puntero disponible de un peso compartido para todos los demás, en lugar de duplicar la memoria.

Adjunta recursivamente AlignDevicesHook a todos los submódulos de un modelo dado para asegurarse de que tengan el dispositivo de ejecución correcto

attach_align_device_hook

accelerate.hooks.attach_align_device_hook

< source >

( module: Moduleexecution_device: torch.device | None = Noneoffload: bool = Falseweights_map: collections.abc.Mapping | None = Noneoffload_buffers: bool = Falsemodule_name: str = ''skip_keys: str | list[str] | None = Nonepreload_module_classes: list[str] | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None )

Parámetros

module (torch.nn.Module) — El módulo al que queremos adjuntar los hooks.
execution_device (torch.device, opcional) — El dispositivo en el que deben colocarse las entradas y los pesos del modelo antes de la pasada hacia adelante.
offload (bool, opcional, valor predeterminado False) — Si las pesas deben o no descargarse después de la pasada hacia adelante.
weights_map (Mapping[str, torch.Tensor], opcional) — Cuando los pesos del modelo se descargan, un mapa (posiblemente perezoso) de los nombres de los parámetros a los valores de los tensores.
offload_buffers (bool, opcional, valor predeterminado False) — Si se incluyen o no los buffers del módulo asociado al realizar el offloading.
module_name (str, opcional, valor predeterminado "") — El nombre del módulo.
skip_keys (str o List[str], opcional) — Una lista de claves para ignorar al mover entradas o salidas entre dispositivos.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.
tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], opcional, valor predeterminado None) — Un mapa de punteros de datos a diccionarios de dispositivos a pesos vinculados ya despachados. Para un dispositivo de ejecución dado, este parámetro es útil para reutilizar el primer puntero disponible de un peso compartido para todos los demás, en lugar de duplicar la memoria.

Adjunta recursivamente AlignDevicesHook a todos los submódulos de un modelo dado que tienen parámetros y/o buffers directos.

attach_align_device_hook_on_blocks

accelerate.hooks.attach_align_device_hook_on_blocks

< source >

Parámetros

module (torch.nn.Module) — El módulo al que queremos adjuntar los hooks.
execution_device (torch.device o Dict[str, torch.device], opcional) — El dispositivo en el que deben colocarse las entradas y los pesos del modelo antes de la pasada hacia adelante. Puede ser un solo dispositivo para todo el módulo, o un diccionario que asocia el nombre del módulo con el dispositivo.
offload (bool, opcional, valor predeterminado False) — Indica si los pesos deben descargarse (offload) después de la pasada hacia adelante. Puede ser un único booleano para todo el módulo, o un diccionario que asocia el nombre del módulo a un booleano.
weights_map (Mapping[str, torch.Tensor], opcional) — Cuando los pesos del modelo se descargan, un mapa (posiblemente perezoso) de los nombres de los parámetros a los valores de los tensores.
offload_buffers (bool, opcional, valor predeterminado False) — Si se incluyen o no los buffers del módulo asociado al realizar el offloading.
module_name (str, opcional, valor predeterminado "") — El nombre del módulo.
skip_keys (str o List[str], opcional) — Una lista de claves para ignorar al mover entradas o salidas entre dispositivos.
preload_module_classes (List[str], opcional) — Una lista de clases cuyas instancias deben cargar todos sus pesos (incluso en los submódulos) al principio del forward. Esto solo debe usarse para clases que tienen submódulos registrados pero que no se llaman directamente durante el forward, por ejemplo, si se registra una capa lineal dense, pero en el forward se usan dense.weight y dense.bias en algunas operaciones en lugar de llamar a dense directamente.
tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], opcional, valor predeterminado None) — Un mapa de punteros de datos a diccionarios de dispositivos a pesos vinculados ya despachados. Para un dispositivo de ejecución dado, este parámetro es útil para reutilizar el primer puntero disponible de un peso compartido para todos los demás, en lugar de duplicar la memoria.

Adjunta AlignDevicesHook a todos los bloques de un modelo dado según sea necesario.

attach_layerwise_casting_hooks

accelerate.big_modeling.attach_layerwise_casting_hooks

< source >

( module: Modulestorage_dtype: dtypecompute_dtype: dtypeskip_modules_pattern: str | tuple[str, ...] | None = Noneskip_modules_classes: tuple[type[torch.nn.Module], ...] | None = Nonenon_blocking: bool = False )

Parámetros

module (torch.nn.Module) — El módulo cuyos módulos hoja se convertirán a un dtype de alta precisión para el cálculo y a un dtype de baja precisión para el almacenamiento.
storage_dtype (torch.dtype) — El dtype al que se debe convertir el módulo antes/después de la pasada hacia adelante para el almacenamiento.
compute_dtype (torch.dtype) — El dtype al que se debe convertir el módulo durante la pasada hacia adelante para el cálculo.
skip_modules_pattern (tuple[str, ...], por defecto None) — Una lista de patrones para coincidir con los nombres de los módulos que se deben omitir durante el proceso de conversión por capas. Si se establece en None junto con skip_modules_classes siendo None, la conversión por capas se aplica directamente al módulo en lugar de a sus submódulos internos.
skip_modules_classes (tuple[type[torch.nn.Module], ...], por defecto None) — Una lista de clases de módulos que se deben omitir durante el proceso de conversión por capas.
non_blocking (bool, por defecto False) — Si es True, las operaciones de conversión de pesos son no bloqueantes.

Aplica el casteo por capas a un módulo dado. El módulo esperado aquí es un nn.Module de PyTorch. Esto es útil para reducir los requisitos de memoria cuando no se desea cuantizar completamente un modelo. Los parámetros del modelo pueden mantenerse, por ejemplo, en torch.float8_e4m3fn y subir su precisión a un tipo de mayor precisión, como torch.bfloat16, durante la pasada hacia adelante, y luego volver a bajarlos a torch.float8_e4m3fn para lograr ahorros de memoria.

Ejemplo:

>>> from accelerate.hooks import attach_layerwise_casting_hooks
>>> from transformers import AutoModelForCausalLM
>>> import torch

>>> # Model
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)

>>> # Attach hooks and perform inference
>>> attach_layerwise_casting_hooks(model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
>>> with torch.no_grad():
...     model(...)

Los usuarios también pueden pasar los módulos que desean evitar que se conviertan a un tipo de menor precisión.

>>> attach_layerwise_casting_hooks(
...     model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16, skip_modules_pattern=["norm"]
... )

Eliminación de hooks

remove_hook_from_module

accelerate.hooks.remove_hook_from_module

< source >

( module: Modulerecurse = False ) → torch.nn.Module

Parámetros

module (torch.nn.Module) — El módulo al que se adjuntará el hook.
recurse (bool, opcional) — Si se deben eliminar los hooks de forma recursiva

Devuelve

torch.nn.Module

El mismo módulo, con el hook desacoplado (el módulo se modifica in situ, por lo que el resultado puede descartarse).

Elimina cualquier hook adjunto a un módulo mediante add_hook_to_module.

remove_hook_from_submodules

accelerate.hooks.remove_hook_from_submodules

< source >

( module: Module )

Parámetros

module (torch.nn.Module) — El módulo en el que se eliminarán todos los hooks.

Elimina recursivamente todos los hooks adjuntos a los submódulos de un modelo dado.

Utilidades

has_offloaded_params

accelerate.utils.has_offloaded_params

< source >

( module: Module ) → bool

Parámetros

module (torch.nn.Module) — El módulo que se debe comprobar para un hook de offload.

Devuelve

bool

True si el módulo tiene un hook de offload y el offloading está habilitado, False en caso contrario.

Comprueba si un módulo tiene parámetros descargados verificando si el módulo dado tiene un AlignDevicesHook adjunto con la descarga habilitada

align_module_device

accelerate.utils.align_module_device

< source >

( module: Moduleexecution_device: torch.device | None = None )

Parámetros

module (torch.nn.Module) — Módulo con parámetros para alinear.
execution_device (torch.device, opcional) — Si se proporciona, reemplaza el dispositivo de ejecución del módulo dentro del contexto. De lo contrario, usa el dispositivo de ejecución del hook o pasa

Gestor de contexto que mueve los parámetros de un módulo al dispositivo de ejecución especificado.

Update on GitHub

←Registro Manejadores de Kwargs→