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 позволяет обучать большие трансформерные языковые модели в промышленных масштабах. Он обеспечивает эффективный параллелизм моделей на основе тензоров, конвейеров и последовательностей для предобучения трансформерных языковых моделей, таких как GPT (только декодер), BERT (только энкодер) и T5 (энкодер-декодер). Подробную информацию о том, как всё устроено, можно найти в репозитории repo на GitHub.

Что интегрировано?

Accelerate интегрирует следующую функцию Megatron-LM для обеспечения крупномасштабного предобучения/дообучения моделей BERT (Encoder), GPT (Decoder) или T5 (Encoder и Decoder):

a. Tensor Parallelism (TP): уменьшает потребление памяти без значительного дополнительного обмена данными между рангами внутри узла. Каждый тензор разбивается на несколько фрагментов, каждый из которых размещается на отдельном GPU. На каждом шаге один и тот же мини-батч данных обрабатывается независимо и параллельно каждым фрагментом, после чего выполняется синхронизация на всех GPU (операция all-reduce). В простом слое трансформера это приводит к 2 all-reduces в прямом проходе и 2 в обратном. Подробнее см. в исследовательской статье Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism и в этом разделе блога The Technology Behind BLOOM Training.

b. Параллелизм конвейера (Pipeline Parallelism, PP): уменьшает потребление памяти и позволяет осуществлять обучение в больших масштабах за счёт межпроцессорного параллелизма. Сокращает время простоя (bubble) наивного PP с помощью расписаний PipeDream-Flush/1F1B и Interleaved 1F1B. Слои распределяются равномерно по стадиям PP. Например, если модель содержит 24 слоёв, а для параллелизма конвейера используется 4 GPU, то на каждый GPU приходится 6 слоёв (24/4). Дополнительные сведения о расписаниях, сокращающих время простоя PP, приведены в научной статье Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM и в этом разделе блога The Technology Behind BLOOM Training.

c. Sequence Parallelism (SP): уменьшает потребление памяти без дополнительных коммуникаций. Применимо только при использовании TP. Оно снижает объём памяти, занимаемой активациями, поскольку предотвращает наличие одинаковых копий на рангах tensor parallel после all-reduce, заменяя их на reduce-scatter, а операцию no-op — на all-gather. Поскольку all-reduce = reduce-scatter + all-gather, это экономит значительный объём памяти для активаций без увеличения стоимости коммуникаций. Если говорить просто, оно разбивает выходные данные каждого слоя трансформера вдоль измерения последовательности, например, если длина последовательности равна 1024, а размер TP равен 4, то на каждом GPU будет по 256 токенов (1024/4) для каждого примера. Это позволяет увеличить размер батча, который можно поддерживать при обучении. Дополнительные сведения см. в исследовательской статье Reducing Activation Recomputation in Large Transformer Models.

d. Параллелизм данных (DP) с использованием распределённого оптимизатора: уменьшает потребление памяти за счёт распределения состояний оптимизатора и градиентов по рангам DP (в отличие от традиционного метода, при котором состояние оптимизатора дублируется на всех рангах параллелизма данных). Например, при использовании оптимизатора Adam с обучением в смешанной точности каждый параметр занимает 12 байт памяти. Эта память распределяется поровну между GPU, то есть при наличии 4 GPU каждый параметр будет занимать 3 байта (12/4). Подробнее см. в исследовательской статье ZeRO: Memory Optimizations Toward Training Trillion Parameter Models и в следующем разделе блога The Technology Behind BLOOM Training.

e. Экспертная параллельность (EP) Экспертная параллельность в Megatron-LM используется для слоёв Mixture-of-Experts (MoE), где существует множество «экспертов» (небольших полносвязных сетей), но для каждого токена активируется лишь несколько из них. Вместо размещения всех экспертов на каждом GPU Megatron распределяет различных экспертов по разным GPU — это и есть экспертная параллельность. Во время обучения токены направляются на те GPU, на которых размещены выбранные для них эксперты, вычисляются там, а затем возвращаются обратно, что снижает затраты памяти. Часто используется в сочетании с тензорной и конвейерной параллельностью для моделей большого масштаба. f. Полный пересчёт активаций: значительно снижает объём памяти, занимаемый активациями, за счёт умного чекпоинтинга активаций. Не сохраняет активации, которые занимают много памяти, но быстро пересчитываются, тем самым достигая отличного баланса между памятью и стоимостью пересчёта. Например, для GPT-3 это приводит к сокращению требуемой памяти для активаций на 70% при накладных расходах на пересчёт активаций всего в 2,7% FLOPs. Дополнительные сведения см. в исследовательской статье Reducing Activation Recomputation in Large Transformer Models.

g. Fused Kernels: Fused Softmax, Mixed Precision Fused Layer Norm и Fused gradient accumulation для вычисления градиентов весов линейного слоя. Скомпилированные PyTorch JIT Fused GeLU и Fused Bias+Dropout+Residual addition.

h. Поддержка индексированных наборов данных: эффективный двоичный формат наборов данных для обучения в больших масштабах. Поддержка файла индекса в форматах mmap, cached и загрузчика lazy.

i. Формирование контрольных точек и совместимость: Утилита для изменения формы контрольных точек Megatron-LM с различными размерами тензорного и конвейерного параллелизма до популярных разбитых контрольных точек Transformers, которые отлично поддерживаются множеством инструментов, таких как Accelerate Big Model Inference, Megatron-DeepSpeed Inference и другие. Также доступна поддержка преобразования разбитых контрольных точек Transformers в контрольные точки Megatron-LM с различными размерами тензорного и конвейерного параллелизма для обучения в больших масштабах.

Предварительные требования

Вам потребуется установить последние версии pytorch, cuda, nccl и NVIDIA APEX, а также библиотеку nltk. Подробнее см. в документации. Другой способ настроить окружение — использовать контейнер NVIDIA PyTorch с NGC, в который уже включены все необходимые компоненты.

Ниже приведена пошаговая инструкция по настройке окружения conda:

  1. Создание виртуального окружения
conda create --name ml
  1. При условии, что на машине установлена CUDA 11.3, установка соответствующей GPU-версии PyTorch
conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
  1. Установка 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. Установка 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 .

Подготовка контрольной точки Megaton-LM

Если вы хотите выполнить дообучение модели, убедитесь, что у вас есть готовый контрольный пункт в формате torch dist. Если у вас есть доступ только к модели huggingface, рассмотрите возможность её конвертации в контрольный пункт в формате torch dist, совместимый с Megatron. В качестве примера можно использовать скрипт из slime, на примере моделей GLM:

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

После конвертации убедитесь: 1. в /your/path/to/megatron/models/GLM4.5-355B-A32B_torch_dist: измените содержимое latest_checkpointed_iteration.txt с release на 0 и переименуйте каталог release в iter_0000000; 2: в конфигурации убедитесь, что megatron_lm_no_load_optim установлено в true, чтобы не требовалось состояние оптимизатора.

Плагин Accelerate для Megatron-LM

Важные функции поддерживаются непосредственно через команду accelerate config. Пример соответствующих вопросов для использования функций 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

Ниже показан полученный конфиг:

~$ 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

Возьмём в качестве примера предварительное обучение GPT. Минимальные изменения, необходимые для официального run_clm_no_trainer.py, чтобы использовать Megatron-LM, приведены ниже:

  1. Поскольку Megatron-LM использует собственную реализацию Optimizer, необходимо использовать совместимый с ним планировщик. Соответственно, поддерживается только планировщик Megatron-LM. Пользователю потребуется создать accelerate.utils.MegatronLMDummyScheduler. Приведенный ниже пример:
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. Получение деталей общего размера батча теперь требует учёта размеров тензорного и конвейерного параллелизма. Пример получения эффективного общего размера батча приведён ниже:
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. При использовании Megatron-LM потери уже усреднены по группе data parallel
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. Для Megatron-LM необходимо сохранить модель с помощью 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
    )

Всё готово! Мы можем начинать 🚀. Пример скрипта находится в папке examples по пути accelerate/examples/by_feature/megatron_lm_gpt_pretraining.py. Запустим его для архитектуры модели gpt-large с использованием 4 GPU 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"

Ниже приведены важные фрагменты из журналов вывода:

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]

Существует множество других параметров и возможностей, которые можно настроить с помощью accelerate.utils.MegatronLMPlugin.

Расширенные возможности для написания собственного шага обучения и использования индексируемых наборов данных Megatron-LM

Для использования дополнительных возможностей ознакомьтесь с деталями ниже.

  1. Ниже приведен пример изменений, необходимых для настройки Train Step при использовании Megatron-LM. Вам нужно будет реализовать accelerate.utils.AbstractTrainStep или унаследоваться от соответствующих дочерних классов accelerate.utils.GPTTrainStep, accelerate.utils.BertTrainStep или 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. Для использования наборов данных Megatron-LM требуется внести несколько дополнительных изменений. Загрузчики данных для этих наборов доступны только на ранге 0 каждой группы тензорного параллелизма. В связи с этим существуют ранги, на которых загрузчик данных недоступен, что требует корректировок в цикле обучения. Возможность реализовать всё это демонстрирует, насколько гибким и расширяемым является Accelerate. Требуемые изменения приведены ниже.

a. Для индексированных наборов данных Megatron-LM необходимо использовать MegatronLMDummyDataLoader и передавать ему требуемые аргументы набора данных, такие как data_path, seq_length и т. д. Список доступных аргументов приведен здесь.

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 повторяется 3 раза, чтобы получить даталоадеры для обучения, валидации и тестирования в соответствии с пропорциями из args.splits_string

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

c. Изменения в циклах обучения и оценки, так как dataloader доступен только на тензорно-параллельных рангах 0 Следовательно, итерировать нужно только в том случае, если dataloader не равен None, иначе следует предоставить пустой словарь Соответственно, мы используем цикл while и прерываем его, когда completed_steps становится равным args.max_train_steps Это похоже на настройку Megatron-LM, где при использовании индексированных датасетов Megaton-LM пользователь должен указать max_train_steps. Это демонстрирует, насколько гибким и расширяемым является 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)

Утилита для изменения формы контрольных точек и обеспечения совместимости

  1. Скрипты для этого представлены в библиотеке Transformers в соответствующих моделях. В настоящее время это доступно для модели GPT checkpoint_reshaping_and_interoperability.py

  2. Ниже приведен пример конвертации контрольной точки из Megatron-LM в универсальную шунтированную контрольную точку 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. Конвертация контрольной точки из transformers в megatron с tp_size=2, pp_size=2 и 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

Модели GPT в Megatron-LM поддерживают возврат логитов и функцию megatron_generate для генерации текста

  1. Для возврата logits необходимо установить require_logits=True в MegatronLMPlugin, как показано ниже. Они будут доступны на последнем этапе конвейера.
megatron_lm_plugin = MegatronLMPlugin(return_logits=True)
  1. Метод megatron_generate для модели GPT в Megatron-LM: этот метод использует тензорное и конвейерное параллелизм для выполнения генерации для батча входных данных при использовании жадного алгоритма с или без выборки top_k/top_p, а также для отдельных входных промптов при использовании декодирования с поиском луча (beam search). Поддерживается только подмножество функций generate из transformers. Это поможет в использовании больших моделей через тензорное и конвейерное параллелизм для генерации (кэширование ключей и значений уже реализовано, а слиянные ядра используются по умолчанию). Для этого требуется, чтобы размер параллелизма данных был равен 1, а последовательное параллелизм и контрольные точки активаций были отключены. Также необходимо указать путь к файлу словаря токенизатора и файлу слияний (merges). Приведённый ниже пример показывает, как настроить и использовать метод megatron_generate для модели GPT в 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. Полный пример использования метода megatron_generate для модели GPT в Megatron-LM доступен в файле megatron_gpt2_generation.py с конфигурационным файлом megatron_lm_gpt_generate_config.yaml. Bash-скрипт с командой accelerate launch доступен в файле megatron_lm_gpt_generate.sh. Журналы вывода скрипта доступны в файле megatron_lm_gpt_generate.log.

Поддержка позиционных эмбеддингов ROPE и ALiBi, а также Multi-Query Attention

  1. Для внимания ROPE/ALiBi передайте position_embedding_type со значением ("absolute" | "rotary" | "alibi") в MegatronLMPlugin, как показано ниже.
other_megatron_args = {"position_embedding_type": "alibi"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)
  1. Для Multi-Query Attention передайте attention_head_type со значением ("multihead" | "multiquery") в MegatronLMPlugin, как показано ниже.
other_megatron_args = {"attention_head_type": "multiquery"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)

Ограничения

  1. Поддерживает модели GPT2, Megatron-BERT и T5 из Transformers. Это охватывает классы моделей только с декодером, только с энкодером и с энкодером-декодером.

  2. Из прямого прохода модели возвращается только loss, поскольку за кулисами происходит сложное взаимодействие конвейерного, тензорного и data parallelism. Вызов model(**batch_data) возвращает усреднённые по рангам data parallelism значения loss. Для большинства случаев, когда задачи pre-training выполняются с использованием функций Megatron-LM, этого достаточно, и вы можете легко вычислить perplexity по значению loss. Для модели GPT поддерживается возврат logits в дополнение к loss. Эти logits не собираются по рангам data parallelism. Используйте accelerator.utils.gather_across_data_parallel_groups, чтобы собрать logits по рангам data parallelism. Эти logits вместе с labels можно использовать для вычисления различных метрик производительности.

  3. Основной процесс — это последний ранг, поскольку потери/логиты доступны на последнем этапе конвейера. accelerator.is_main_process и accelerator.is_local_main_process возвращают True для последнего ранга при использовании интеграции с Megatron-LM.

  4. В вызове accelerator.prepare создаётся модель Megatron-LM, соответствующая заданной модели Transformers, со случайными весами. Используйте accelerator.load_state, чтобы загрузить контрольную точку Megatron-LM с соответствующими разделами TP, PP и DP.

  5. В настоящее время поддержка изменения формы контрольных точек и взаимодействия доступна только для GPT. В ближайшее время она будет расширена на BERT и T5.

  6. gradient_accumulation_steps должен быть равен 1. При использовании Megatron-LM микробатчи в настройках pipeline parallelism эквивалентны накоплению градиентов.

  7. При использовании Megatron-LM для сохранения и загрузки контрольных точек используйте accelerator.save_state и accelerator.load_state.

  8. Ниже приведено соответствие между архитектами моделей Megatron-LM и эквивалентными архитектами моделей transformers. Поддерживаются только эти архитектуры моделей transformers.

a. Megatron-LM BertModel : модели transformers, у которых в model type конфигурации указано megatron-bert, например, MegatronBERT

b. Megatron-LM GPTModel: модели transformers, у которых в model type конфигурации указано gpt2, например, OpenAI GPT2

c. Megatron-LM T5Model: модели transformers, у которых в model type конфигурации указано t5, например, T5 и MT5

Update on GitHub