Accelerate documentation

Megatron-LM

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Megatron-LM

Megatron-LM permite entrenar modelos de lenguaje transformer a gran escala. Proporciona paralelismo de modelos eficiente basado en tensor, pipeline y secuencia para el preentrenamiento de modelos de lenguaje basados en transformer, como GPT (solo decodificador), BERT (solo codificador) y T5 (codificador-decodificador). Para obtener información detallada y saber cómo funcionan las cosas por detrás, consulte el repositorio de github.

¿Qué está integrado?

Accelerate integra la siguiente funcionalidad de Megatron-LM para habilitar el preentrenamiento/ajuste fino a gran escala de modelos BERT (codificador), GPT (decodificador) o T5 (codificador y decodificador):

a. Paralelismo de tensores (TP): Reduce la huella de memoria sin mucha comunicación adicional en los rangos intra-nodo. Cada tensor se divide en varios fragmentos, con cada fragmento ubicado en una GPU diferente. En cada paso, el mismo mini-lote de datos se procesa de forma independiente y en paralelo por cada fragmento, seguido de una sincronización entre todas las GPUs (operación all-reduce). En una capa de transformador simple, esto da lugar a 2 all-reduces en la ruta de propagación hacia adelante y 2 en la ruta de propagación hacia atrás. Para más detalles, consulte el artículo de investigación Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism y esta sección del blog The Technology Behind BLOOM Training.

b. Paralelismo de pipeline (PP): Reduce la huella de memoria y permite el entrenamiento a gran escala mediante la paralelización entre nodos. Reduce la burbuja del PP ingenuo mediante el calendario PipeDream-Flush/calendario 1F1B y el calendario Interleaved 1F1B. Las capas se distribuyen de forma uniforme entre las etapas de PP. Por ejemplo, si un modelo tiene 24 capas y tenemos 4 GPUs para el paralelismo de pipeline, cada GPU tendrá 6 capas (24/4). Para más detalles sobre los calendarios para reducir el tiempo inactivo de PP, consulte el artículo de investigación Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM y esta sección del blog The Technology Behind BLOOM Training.

c. Sequence Parallelism (SP): Reduce la huella de memoria sin comunicación adicional. Solo es aplicable cuando se usa TP. Reduce la memoria de activaciones necesaria, ya que evita que las mismas copias estén en los rangos de paralelismo de tensor después de all-reduce, reemplazándolas con reduce-scatter y la operación no-op se reemplaza por all-gather. Dado que all-reduce = reduce-scatter + all-gather, esto ahorra una gran cantidad de memoria de activaciones sin coste de comunicación adicional. En términos simples, fragmenta las salidas de cada capa de transformer a lo largo de la dimensión de secuencia, por ejemplo, si la longitud de la secuencia es 1024 y el tamaño de TP es 4, cada GPU tendrá 256 tokens (1024/4) para cada muestra. Esto aumenta el tamaño de lote que se puede soportar para el entrenamiento. Para más detalles, consulte el artículo de investigación Reducing Activation Recomputation in Large Transformer Models.

d. Paralelismo de datos (DP) mediante Distributed Optimizer: reduce la huella de memoria al fragmentar los estados del optimizador y los gradientes entre los rangos de DP (en lugar del método tradicional de replicar el estado del optimizador entre los rangos de paralelismo de datos). Por ejemplo, al usar el optimizador Adam con entrenamiento de precisión mixta, cada parámetro ocupa 12 bytes de memoria. Esto se distribuye de manera equitativa entre las GPU, es decir, cada parámetro ocuparía 3 bytes (12/4) si tenemos 4 GPU. Para más detalles, consulte el artículo de investigación ZeRO: Memory Optimizations Toward Training Trillion Parameter Models y la siguiente sección del blog The Technology Behind BLOOM Training.

e. Paralelismo de expertos (EP) El paralelismo de expertos en Megatron-LM se utiliza para las capas de Mixture-of-Experts (MoE), donde existen muchos “expertos” (pequeñas redes feed-forward) pero solo se activan unos pocos para cada token. En lugar de colocar todos los expertos en cada GPU, Megatron distribuye diferentes expertos en diferentes GPUs; esto es el paralelismo de expertos. Durante el entrenamiento, los tokens se enrutan a las GPUs que alojan sus expertos seleccionados, se calculan allí y luego se envían de vuelta, reduciendo el costo de memoria. A menudo se combina con el paralelismo de tensor/pipeline para modelos a gran escala. f. Recomputación completa de activaciones: Reduce significativamente la huella de memoria de las activaciones mediante un checkpointing inteligente de activaciones. No almacena activaciones que ocupan mucha memoria pero son rápidas de recomputar, logrando así un gran equilibrio entre memoria y recomputación. Por ejemplo, para GPT-3, esto conduce a una reducción del 70 % en la memoria requerida para las activaciones, a costa de solo un 2,7 % de sobrecarga de FLOPs para la recomputación de activaciones. Para más detalles, consulte el artículo de investigación Reducing Activation Recomputation in Large Transformer Models.

g. Kernels fusionados: Softmax fusionado, Layer Norm fusionado de precisión mixta y acumulación de gradientes fusionada en el cálculo del gradiente de pesos de la capa lineal. Adición fusionada de GeLU compilado con JIT de PyTorch y de Bias+Dropout+Residual.

h. Soporte para conjuntos de datos indexados: formato binario eficiente de conjuntos de datos para el entrenamiento a gran escala. Soporte para el archivo de índice mmap, cached y el formato de cargador lazy.

i. Reformateo de puntos de control e interoperabilidad: Utilidad para reformatear puntos de control de Megatron-LM con tamaños variables de paralelismo de tensor y de pipeline a los populares puntos de control fragmentados de Transformers, que cuenta con un gran soporte con una gran cantidad de herramientas como Accelerate Big Model Inference, Megatron-DeepSpeed Inference, etc. También se ofrece soporte para convertir puntos de control fragmentados de Transformers a puntos de control de Megatron-LM con tamaños variables de paralelismo de tensor y de pipeline para el entrenamiento a gran escala.

Prerrequisitos

Deberá instalar las últimas versiones de pytorch, cuda, nccl y NVIDIA APEX, así como la biblioteca nltk. Consulte la documentación para obtener más detalles. Otra forma de configurar el entorno es obtener un contenedor de PyTorch de NVIDIA que incluye todas las instalaciones necesarias desde NGC.

A continuación se muestra un método paso a paso para configurar el entorno de conda:

  1. Crear un entorno virtual
conda create --name ml
  1. Suponiendo que la máquina tenga CUDA 11.3 instalado, la instalación de la versión de PyTorch para GPU correspondiente
conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
  1. Instalar Nvidia APEX
git clone https://github.com/NVIDIA/apex
cd apex
pip install -v --disable-pip-version-check --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./
cd ..
  1. Instalación de Megatron-LM
git clone https://github.com/NVIDIA/Megatron-LM.git
cd Megatron-LM
git checkout 9a1c0d05c992c8a241da384ab27dce2021bb56dd
you need to manually move gpt_builders.py to megatron/training and update
include = [
    "megatron.core", 
    "megatron.core.*",
    "megatron.training",
    "megatron.training.*",
    "megatron.legacy",
    "megatron.legacy.*",
]
in pyproject.toml file to unblock yourself from using Megatron
pip install --no-use-pep517 -e .

Preparar el punto de control de Megaton-LM

Si deseas ajustar un modelo, asegúrate de tener un checkpoint en formato torch dist listo. Si solo tienes acceso al modelo de huggingface, considera convertirlo a un checkpoint en formato torch dist aceptable por Megatron. Un ejemplo es usar el script de slime, tomando los modelos GLM como ejemplo:

source /your/path/to/slime/scripts/models/glm4.5-355B-A32B.sh
srun torchrun --nproc-per-node 8 \
   /your/path/to/slime/tools/convert_hf_to_torch_dist.py \
    ${MODEL_ARGS[@]} \
    --hf-checkpoint /your/path/to/huggingface/models/GLM4.5-355B-A32B \
    --save /your/path/to/megatron/models/GLM4.5-355B-A32B_torch_dist

Después de la conversión, asegúrese de: 1. en /your/path/to/megatron/models/GLM4.5-355B-A32B_torch_dist: cambie el contenido de latest_checkpointed_iteration.txt de release a 0 y cambie el nombre del directorio release a iter_0000000; 2: en la configuración, asegúrese de que megatron_lm_no_load_optim sea true para que no se necesiten estados del optimizador.

Plugin de Accelerate para Megatron-LM

Las funciones importantes se admiten directamente mediante el comando accelerate config. A continuación se muestra un ejemplo de las preguntas correspondientes para usar las funciones de Megatron-LM:

:~$ accelerate config --config_file "megatron_gpt_config.yaml"
In which compute environment are you running? ([0] This machine, [1] AWS (Amazon SageMaker)): 0
Which type of machine are you using? ([0] No distributed training, [1] multi-CPU, [2] multi-GPU, [3] TPU): 2
How many different machines will you use (use more than 1 for multi-node training)? [1]: 
Do you want to use DeepSpeed? [yes/NO]: 
Do you want to use FullyShardedDataParallel? [yes/NO]: 
Do you want to use Megatron-LM ? [yes/NO]: yes
What is the Tensor Parallelism degree/size? [1]:2
Do you want to enable Sequence Parallelism? [YES/no]: 
What is the Pipeline Parallelism degree/size? [1]:2
What is the number of micro-batches? [1]:2
Do you want to enable selective activation recomputation? [YES/no]: 
Do you want to use distributed optimizer which shards optimizer state and gradients across data parallel ranks? [YES/no]: 
What is the gradient clipping value based on global L2 Norm (0 to disable)? [1.0]: 
How many GPU(s) should be used for distributed training? [1]:4
Do you wish to use FP16 or BF16 (mixed precision)? [NO/fp16/bf16]: bf16

La configuración resultante se muestra a continuación:

~$ cat megatron_gpt_config.yaml 
compute_environment: LOCAL_MACHINE
deepspeed_config: {}
distributed_type: MEGATRON_LM
downcast_bf16: 'no'
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
megatron_lm_config:
  megatron_lm_gradient_clipping: 1.0
  megatron_lm_num_micro_batches: 2
  megatron_lm_pp_degree: 2
  megatron_lm_recompute_activations: true
  megatron_lm_sequence_parallelism: true
  megatron_lm_tp_degree: 2
  megatron_lm_use_distributed_optimizer: true
mixed_precision: bf16
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
use_cpu: false

Tomaremos como ejemplo el preentrenamiento de GPT. Los cambios mínimos necesarios en el run_clm_no_trainer.py oficial para usar Megatron-LM son los siguientes:

  1. Dado que Megatron-LM utiliza su propia implementación de Optimizer, se debe utilizar el scheduler correspondiente compatible con él. Por lo tanto, solo se incluye soporte para el scheduler de Megatron-LM. El usuario deberá crear accelerate.utils.MegatronLMDummyScheduler. A continuación se muestra un ejemplo:
from accelerate.utils import MegatronLMDummyScheduler

if accelerator.distributed_type == DistributedType.MEGATRON_LM:
    lr_scheduler = MegatronLMDummyScheduler(
        optimizer=optimizer,
        total_num_steps=args.max_train_steps,
        warmup_num_steps=args.num_warmup_steps,
    )
else:
    lr_scheduler = get_scheduler(
        name=args.lr_scheduler_type,
        optimizer=optimizer,
        num_warmup_steps=args.num_warmup_steps * args.gradient_accumulation_steps,
        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
    )
  1. Obtener los detalles del tamaño total del lote ahora requiere tener en cuenta los tamaños de paralelismo de tensor y de pipeline. A continuación se muestra un ejemplo de cómo obtener el tamaño total efectivo del lote:
if accelerator.distributed_type == DistributedType.MEGATRON_LM:
    total_batch_size = accelerator.state.megatron_lm_plugin.global_batch_size
else:
    total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
  1. Al usar Megatron-LM, las pérdidas ya están promediadas en el grupo de paralelismo de datos
if accelerator.distributed_type == DistributedType.MEGATRON_LM:
    losses.append(loss)
else:
    losses.append(accelerator.gather_for_metrics(loss.repeat(args.per_device_eval_batch_size)))

if accelerator.distributed_type == DistributedType.MEGATRON_LM:
    losses = torch.tensor(losses)
else:
    losses = torch.cat(losses)
  1. Para Megatron-LM, necesitamos guardar el modelo usando accelerator.save_state
if accelerator.distributed_type == DistributedType.MEGATRON_LM:
    accelerator.save_state(args.output_dir)
else:
    unwrapped_model = accelerator.unwrap_model(model)
    unwrapped_model.save_pretrained(
        args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save
    )

¡Listo! Ya estamos listos para comenzar 🚀. Puede encontrar el script de ejemplo en la carpeta examples en la ruta accelerate/examples/by_feature/megatron_lm_gpt_pretraining.py. Ejecutémoslo para la arquitectura de modelo gpt-large utilizando 4 GPUs A100-80GB.

accelerate launch --config_file megatron_gpt_config.yaml \
examples/by_feature/megatron_lm_gpt_pretraining.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name wikitext \
--dataset_config_name wikitext-2-raw-v1 \
--block_size 1024 \
--learning_rate 5e-5 \
--per_device_train_batch_size 24 \
--per_device_eval_batch_size 24 \
--num_train_epochs 5 \
--with_tracking \
--report_to "wandb" \
--output_dir "awesome_model"

A continuación se muestran algunos extractos importantes de los registros de salida:

Loading extension module fused_dense_cuda...
>>> done with compiling and loading fused kernels. Compilation time: 3.569 seconds
 > padded vocab (size: 50257) with 175 dummy tokens (new size: 50432)
Building gpt model in the pre-training mode.
The Megatron LM model weights are initialized at random in `accelerator.prepare`. Please use `accelerator.load_checkpoint` to load a pre-trained checkpoint matching the distributed setup.
Preparing dataloader
Preparing dataloader
Preparing model
 > number of parameters on (tensor, pipeline) model parallel rank (1, 0): 210753280
 > number of parameters on (tensor, pipeline) model parallel rank (1, 1): 209445120
 > number of parameters on (tensor, pipeline) model parallel rank (0, 0): 210753280
 > number of parameters on (tensor, pipeline) model parallel rank (0, 1): 209445120
Preparing optimizer
Preparing scheduler
> learning rate decay style: linear
10/10/2022 22:57:22 - INFO - __main__ - ***** Running training *****
10/10/2022 22:57:22 - INFO - __main__ -   Num examples = 2318
10/10/2022 22:57:22 - INFO - __main__ -   Num Epochs = 5
10/10/2022 22:57:22 - INFO - __main__ -   Instantaneous batch size per device = 24
10/10/2022 22:57:22 - INFO - __main__ -   Total train batch size (w. parallel, distributed & accumulation) = 48
10/10/2022 22:57:22 - INFO - __main__ -   Gradient Accumulation steps = 1
10/10/2022 22:57:22 - INFO - __main__ -   Total optimization steps = 245
 20%|████████████▍                                                 | 49/245 [01:04<04:09,  1.27s/it]
 10/10/2022 22:58:29 - INFO - __main__ - epoch 0: perplexity: 1222.1594275215962 eval_loss: 7.10837459564209
 40%|████████████████████████▊                                     | 98/245 [02:10<03:07,  1.28s/it]
 10/10/2022 22:59:35 - INFO - __main__ - epoch 1: perplexity: 894.5236583794557 eval_loss: 6.796291351318359
 60%|████████████████████████████████████▌                        | 147/245 [03:16<02:05,  1.28s/it]
 10/10/2022 23:00:40 - INFO - __main__ - epoch 2: perplexity: 702.8458788508042 eval_loss: 6.555137634277344
 80%|████████████████████████████████████████████████▊            | 196/245 [04:22<01:02,  1.28s/it]
 10/10/2022 23:01:46 - INFO - __main__ - epoch 3: perplexity: 600.3220028695281 eval_loss: 6.39746618270874
100%|█████████████████████████████████████████████████████████████| 245/245 [05:27<00:00,  1.28s/it]

Hay un gran número de otras opciones/funcionalidades que se pueden configurar usando accelerate.utils.MegatronLMPlugin.

Funciones avanzadas para aprovechar la escritura de pasos de entrenamiento personalizados y los conjuntos de datos indexados de Megatron-LM

Para aprovechar más funciones, consulte los detalles a continuación.

  1. A continuación se muestra un ejemplo de los cambios necesarios para personalizar el Train Step al usar Megatron-LM. Deberá implementar accelerate.utils.AbstractTrainStep o heredar de sus hijos correspondientes accelerate.utils.GPTTrainStep, accelerate.utils.BertTrainStep o accelerate.utils.T5TrainStep.
from accelerate.utils import MegatronLMDummyScheduler, GPTTrainStep, avg_losses_across_data_parallel_group


# Custom loss function for the Megatron model
class GPTTrainStepWithCustomLoss(GPTTrainStep):
    def __init__(self, megatron_args, **kwargs):
        super().__init__(megatron_args)
        self.kwargs = kwargs

    def get_loss_func(self):
        def loss_func(inputs, loss_mask, output_tensor):
            batch_size, seq_length = output_tensor.shape
            losses = output_tensor.float()
            loss_mask = loss_mask.view(-1).float()
            loss = losses.view(-1) * loss_mask

            # Resize and average loss per sample
            loss_per_sample = loss.view(batch_size, seq_length).sum(axis=1)
            loss_mask_per_sample = loss_mask.view(batch_size, seq_length).sum(axis=1)
            loss_per_sample = loss_per_sample / loss_mask_per_sample

            # Calculate and scale weighting
            weights = torch.stack([(inputs == kt).float() for kt in self.kwargs["keytoken_ids"]]).sum(axis=[0, 2])
            weights = 1.0 + self.kwargs["alpha"] * weights
            # Calculate weighted average
            weighted_loss = (loss_per_sample * weights).mean()

            # Reduce loss across data parallel groups
            averaged_loss = avg_losses_across_data_parallel_group([weighted_loss])

            return weighted_loss, {"lm loss": averaged_loss[0]}

        return loss_func

    def get_forward_step_func(self):
        def forward_step(data_iterator, model):
            """Forward step."""
            # Get the batch.
            tokens, labels, loss_mask, attention_mask, position_ids = self.get_batch(data_iterator)
            output_tensor = model(tokens, position_ids, attention_mask, labels=labels)

            return output_tensor, partial(self.loss_func, tokens, loss_mask)

        return forward_step


def main():
    # Custom loss function for the Megatron model
    keytoken_ids = []
    keywords = ["plt", "pd", "sk", "fit", "predict", " plt", " pd", " sk", " fit", " predict"]
    for keyword in keywords:
        ids = tokenizer([keyword]).input_ids[0]
        if len(ids) == 1:
            keytoken_ids.append(ids[0])
    accelerator.print(f"Keytoken ids: {keytoken_ids}")
    accelerator.state.megatron_lm_plugin.custom_train_step_class = GPTTrainStepWithCustomLoss
    accelerator.state.megatron_lm_plugin.custom_train_step_kwargs = {
        "keytoken_ids": keytoken_ids,
        "alpha": 0.25,
    }
  1. Para usar los conjuntos de datos de Megatron-LM, se requieren algunos cambios adicionales. Los dataloaders para estos conjuntos de datos solo están disponibles en el rank 0 de cada grupo de paralelismo de tensor. Por lo tanto, hay ranks donde el dataloader no estará disponible y esto requiere ajustes en el bucle de entrenamiento. El hecho de poder hacer todo esto demuestra lo flexible y extensible que es Accelerate. Los cambios necesarios son los siguientes.

a. Para los conjuntos de datos indexados de Megatron-LM, es necesario utilizar MegatronLMDummyDataLoader y pasarle los argumentos de conjunto de datos requeridos, como data_path, seq_length, etc. Vea aquí la lista de argumentos disponibles.

from accelerate.utils import MegatronLMDummyDataLoader

megatron_dataloader_config = {
    "data_path": args.data_path,
    "splits_string": args.splits_string,
    "seq_length": args.block_size,
    "micro_batch_size": args.per_device_train_batch_size,
}
megatron_dataloader = MegatronLMDummyDataLoader(**megatron_dataloader_config)
accelerator.state.megatron_lm_plugin.megatron_dataset_flag = True

b. megatron_dataloader se repite 3 veces para obtener los dataloaders de entrenamiento, validación y prueba, según las proporciones de args.splits_string

model, optimizer, lr_scheduler, train_dataloader, eval_dataloader, _ = accelerator.prepare(
    model, optimizer, lr_scheduler, megatron_dataloader, megatron_dataloader, megatron_dataloader
)

c. Cambios en los bucles de entrenamiento y evaluación, ya que el dataloader solo está disponible en los rangos 0 de paralelismo de tensor Por lo tanto, solo debemos iterar si el dataloader no es None; en caso contrario, proporcionar un diccionario vacío De esta manera, iteramos mediante un bucle while y se interrumpe cuando completed_steps es igual a args.max_train_steps. Esto es similar a la configuración de Megatron-LM, donde el usuario debe proporcionar max_train_steps al usar conjuntos de datos indexados de Megaton-LM. Esto muestra lo flexible y extensible que es Accelerate.

while completed_steps < args.max_train_steps:
    model.train()
    batch = next(train_dataloader) if train_dataloader is not None else {}
    outputs = model(**batch)
    loss = outputs.loss
    ...

    if completed_steps % eval_interval == 0:
        eval_completed_steps = 0
        losses = []
        while eval_completed_steps < eval_iters:
            model.eval()
            with torch.no_grad():
                batch = next(eval_dataloader) if eval_dataloader is not None else {}
                outputs = model(**batch)

Utilidad para el redimensionamiento de puntos de control y la interoperabilidad

  1. Los scripts para estos se encuentran en la biblioteca Transformers bajo los modelos correspondientes. Actualmente, está disponible para el modelo GPT checkpoint_reshaping_and_interoperability.py

  2. A continuación se muestra un ejemplo de conversión de un checkpoint de Megatron-LM a un checkpoint fragmentado universal de Transformers.

python checkpoint_reshaping_and_interoperability.py \
--convert_checkpoint_from_megatron_to_transformers \
--load_path "gpt/iter_0005000" \
--save_path "gpt/trfs_checkpoint" \
--max_shard_size "200MB" \
--tokenizer_name "gpt2" \
--print-checkpoint-structure
  1. Conversión de un checkpoint de transformers a megatron con tp_size=2, pp_size=2 y dp_size=2.
python checkpoint_utils/megatgron_gpt2/checkpoint_reshaping_and_interoperability.py \
--load_path "gpt/trfs_checkpoint" \
--save_path "gpt/megatron_lm_checkpoint" \
--target_tensor_model_parallel_size 2 \
--target_pipeline_model_parallel_size 2 \
--target_data_parallel_size 2 \
--target_params_dtype "bf16" \
--make_vocab_size_divisible_by 128 \
--use_distributed_optimizer \
--print-checkpoint-structure

Los modelos GPT de Megatron-LM admiten devolver logits y la función megatron_generate para la generación de texto

  1. Para devolver los logits, es necesario establecer require_logits=True en MegatronLMPlugin, como se muestra a continuación. Estos estarán disponibles en la última etapa de la pipeline.
megatron_lm_plugin = MegatronLMPlugin(return_logits=True)
  1. Método megatron_generate para el modelo GPT de Megatron-LM: esto utilizará la paralelización de tensores y de pipeline para completar las generaciones de un lote de entradas al usar muestreo greedy con o sin top_k/top_p, y para entradas de prompt individuales al usar decodificación con búsqueda de haces. Solo se admite un subconjunto de las funciones de generate de transformers. Esto ayudará a utilizar modelos grandes mediante la paralelización de tensores y de pipeline para la generación (ya realiza el almacenamiento en caché de claves y valores y usa núcleos fusionados de forma predeterminada). Esto requiere que el tamaño de la paralelización de datos sea 1, y que la paralelización de secuencias y el punto de control de activaciones estén deshabilitados. También requiere especificar la ruta al archivo de vocabulario y al archivo de fusiones del tokenizador. El siguiente ejemplo muestra cómo configurar y usar el método megatron_generate para el modelo GPT de Megatron-LM.
# specifying tokenizer's vocab and merges file
vocab_file = os.path.join(args.resume_from_checkpoint, "vocab.json")
merge_file = os.path.join(args.resume_from_checkpoint, "merges.txt")
other_megatron_args = {"vocab_file": vocab_file, "merge_file": merge_file}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)

# inference using `megatron_generate` functionality
tokenizer.pad_token = tokenizer.eos_token
max_new_tokens = 64
batch_texts = [
    "Are you human?",
    "The purpose of life is",
    "The arsenal was constructed at the request of",
    "How are you doing these days?",
]
batch_encodings = tokenizer(batch_texts, return_tensors="pt", padding=True)

# top-p sampling
generated_tokens = model.megatron_generate(
    batch_encodings["input_ids"],
    batch_encodings["attention_mask"],
    max_new_tokens=max_new_tokens,
    top_p=0.8,
    top_p_decay=0.5,
    temperature=0.9,
)
decoded_preds = tokenizer.batch_decode(generated_tokens.cpu().numpy())
accelerator.print(decoded_preds)

# top-k sampling
generated_tokens = model.megatron_generate(
    batch_encodings["input_ids"],
    batch_encodings["attention_mask"],
    max_new_tokens=max_new_tokens,
    top_k=50,
    temperature=0.9,
)
decoded_preds = tokenizer.batch_decode(generated_tokens.cpu().numpy())
accelerator.print(decoded_preds)

# adding `bos` token at the start
generated_tokens = model.megatron_generate(
    batch_encodings["input_ids"], batch_encodings["attention_mask"], max_new_tokens=max_new_tokens, add_BOS=True
)
decoded_preds = tokenizer.batch_decode(generated_tokens.cpu().numpy())
accelerator.print(decoded_preds)

# beam search => only takes single prompt
batch_texts = ["The purpose of life is"]
batch_encodings = tokenizer(batch_texts, return_tensors="pt", padding=True)
generated_tokens = model.megatron_generate(
    batch_encodings["input_ids"],
    batch_encodings["attention_mask"],
    max_new_tokens=max_new_tokens,
    num_beams=20,
    length_penalty=1.5,
)
decoded_preds = tokenizer.batch_decode(generated_tokens.cpu().numpy())
accelerator.print(decoded_preds)
  1. Un ejemplo de extremo a extremo del uso del método megatron_generate para el modelo GPT de Megatron-LM está disponible en megatron_gpt2_generation.py con el archivo de configuración megatron_lm_gpt_generate_config.yaml. El script de bash con el comando accelerate launch está disponible en megatron_lm_gpt_generate.sh. Los registros de salida del script están disponibles en megatron_lm_gpt_generate.log.

Soporte para embeddings posicionales ROPE y ALiBi y atención Multi-Query

  1. Para la atención ROPE/ALiBi, pase position_embedding_type con ("absolute" | "rotary" | "alibi") a MegatronLMPlugin como se muestra a continuación.
other_megatron_args = {"position_embedding_type": "alibi"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)
  1. Para Multi-Query Attention, pase attention_head_type con ("multihead" | "multiquery") a MegatronLMPlugin como se muestra a continuación.
other_megatron_args = {"attention_head_type": "multiquery"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)

Precauciones

  1. Admite modelos GPT2, Megatron-BERT y T5 de Transformers. Esto abarca las clases de modelos solo decodificador, solo codificador y codificador-decodificador.

  2. Solo se devuelve la pérdida desde la pasada hacia adelante del modelo, ya que existe una interacción bastante compleja entre la paralelización de pipeline, de tensores y de datos en segundo plano. La llamada model(**batch_data) devuelve las pérdidas promediadas entre los rangos de paralelismo de datos. Esto es adecuado para la mayoría de los casos en los que las tareas de preentrenamiento se ejecutan utilizando las funciones de Megatron-LM y se puede calcular fácilmente la perplexity a partir de la pérdida. Para el modelo GPT, se admite devolver los logits además de las pérdidas. Estos logits no se recogen entre los rangos de paralelismo de datos. Utilice accelerator.utils.gather_across_data_parallel_groups para recopilar los logits entre los rangos de paralelismo de datos. Estos logits, junto con las etiquetas, pueden utilizarse para calcular diversas métricas de rendimiento.

  3. El proceso principal es el último rank, ya que las pérdidas/logits están disponibles en la última etapa del pipeline. accelerator.is_main_process y accelerator.is_local_main_process devuelven True para el último rank al usar la integración de Megatron-LM.

  4. En la llamada a accelerator.prepare, se crea un modelo Megatron-LM correspondiente a un modelo Transformers dado, con pesos aleatorios. Utilice accelerator.load_state para cargar el checkpoint de Megatron-LM con las particiones TP, PP y DP coincidentes.

  5. Actualmente, el soporte para el redimensionamiento de puntos de control y la interoperabilidad solo está disponible para GPT. Pronto se extenderá a BERT y T5.

  6. gradient_accumulation_steps debe ser 1. Al usar Megatron-LM, los micro lotes en la configuración de paralelismo de pipeline son sinónimos de acumulación de gradientes.

  7. Al usar Megatron-LM, utilice accelerator.save_state y accelerator.load_state para guardar y cargar puntos de control.

  8. A continuación se muestra el mapeo de las arquitecturas de modelos de Megatron-LM a las arquitecturas de modelos equivalentes de transformers. Solo se admiten estas arquitecturas de modelos de transformers.

a. Megatron-LM BertModel : modelos de transformers con megatron-bert en el tipo de modelo de la configuración, p. ej., MegatronBERT

b. Megatron-LM GPTModel : modelos de transformers con gpt2 en el tipo de modelo de la configuración, p. ej., OpenAI GPT2

c. Megatron-LM T5Model : modelos de transformers con t5 en el tipo de modelo de la configuración, por ejemplo, T5 y MT5

Update on GitHub