Accelerate documentation
Megatron-LM
Megatron-LM
Megatron-LM, büyük ölçekli transformer dil modellerinin eğitimini mümkün kılar. GPT (Sadece Dekoder), BERT (Sadece Kodlayıcı) ve T5 (Kodlayıcı-Dekoder) gibi transformer tabanlı Dil Modellerinin ön eğitimi için verimli tensör, boru hattı ve dizi tabanlı model paralelliği sağlar. Detaylı bilgi ve arka planda işleyiş hakkında lütfen github deposuna bakın.
Hangi bileşenler entegre edildi?
Accelerate, BERT (Encoder), GPT (Decoder) veya T5 modellerinin (Encoder ve Decoder) büyük ölçekli ön eğitimi/ince ayarını etkinleştirmek için Megatron-LM'nin aşağıdaki özelliğini entegre eder:
a. Tensor Parallelism (TP): Düğüm içi rank'lerde çok ek iletişim gerektirmeden bellek ayak izini azaltır.
Her tensor, her shard'ın ayrı bir GPU'da barındırıldığı şekilde birden fazla parçaya bölünür. Her adımda, aynı mini-batch verisi
her shard tarafından bağımsız ve paralel olarak işlenir ve ardından tüm GPU'lar arasında senkronizasyon yapılır (all-reduce işlemi).
Basit bir transformer katmanında bu, ileri yönde 2 all-reduces ve geri yönde 2 all-reduces işlemine yol açar.
Daha fazla ayrıntı için lütfen Megatron-LM: Training Multi-Billion Parameter Language Models Using
Model Parallelism araştırma makalesine ve
blog yazısının bu bölümüne The Technology Behind BLOOM Training başvurun.
b. Pipeline Parallelism (PP): Bellek ayak izini azaltır ve düğümler arası paralelleştirme yoluyla büyük ölçekli eğitimi mümkün kılar.
PipeDream-Flush zamanlaması/1F1B zamanlaması ve Interleaved 1F1B zamanlaması sayesinde basit PP'nin boşluk oranını (bubble) azaltır.
Katmanlar, PP aşamaları arasında eşit olarak dağıtılır. Örneğin, bir modelin 24 katmanı varsa ve pipeline paralelleştirme için 4 GPU kullanılıyorsa, her GPU'da 6 katman bulunur (24/4). PP'nin boşta kalma süresini azaltmaya yönelik zamanlamalar hakkında daha fazla ayrıntı için lütfen Efficient Large-Scale Language Model Training on GPU Clusters
Using Megatron-LM araştırma makalesine ve
blog yazısının bu bölümüne The Technology Behind BLOOM Training başvurun.
c. Sıralama Paralelliği (SP): Ek bir iletişim gerektirmeden bellek ayak izini azaltır. Yalnızca TP kullanıldığında geçerlidir.
all-reduce sonrasında aynı kopyaların tensor paralel sıralarında bulunmasını önlediği için gerekli aktivasyon belleğini azaltır; bunun yerine reduce-scatter kullanılır ve no-op işlemi all-gather ile değiştirilir.
all-reduce = reduce-scatter + all-gather olduğundan, bu yöntem ek iletişim maliyeti olmadan çok fazla aktivasyon belleği tasarrufu sağlar.
Kısaca ifade etmek gerekirse, her transformer katmanının çıktıları sıralama boyutu boyunca parçalanır; örneğin,
sıralama uzunluğu 1024 ve TP boyutu 4 ise, her GPU'da örnek başına 256 token (1024/4) bulunur.
Bu, eğitimde desteklenebilecek parti boyutunu artırır. Daha fazla ayrıntı için lütfen Reducing Activation Recomputation in Large Transformer Models araştırma makalesine başvurun.
d. Dağıtık Optimizer ile Veri Paralelliği (DP): Optimizer durumlarını ve gradyanları DP rank'ları arasında parçalayarak (sharding) bellek ayak izini azaltır (veri paralel rank'ları arasında optimizer durumunu kopyalayan geleneksel yönteme kıyasla). Örneğin, karma hassasiyetli eğitimde Adam optimizer kullanıldığında, her parametre 12 baytlık bellek alanı gerektirir. Bu, GPU'lar arasında eşit olarak dağıtılır; yani 4 GPU varsa, her parametre 3 bayt (12/4) yer kaplar. Daha fazla ayrıntı için lütfen ZeRO: Memory Optimizations Toward Training Trillion Parameter Models araştırma makalesine ve The Technology Behind BLOOM Training blogunun ilgili bölümüne başvurun.
e. Uzman Paralelliği (EP) Megatron-LM'deki uzman paralelliği, Mixture-of-Experts (MoE) katmanları için kullanılır; bu katmanlarda birçok “uzman” (küçük ileri beslemeli ağ) bulunur ancak her token için yalnızca birkaçı etkinleştirilir. Tüm uzmanları her GPU'ya yerleştirmek yerine Megatron, farklı uzmanları farklı GPU'lara dağıtır—bu, uzman paralelliğidir. Eğitim sırasında tokenlar, seçilen uzmanlarını barındıran GPU'lara yönlendirilir, orada hesaplanır ve ardından geri gönderilir; bu da bellek maliyetini azaltır. Genellikle büyük ölçekli modellerde tensor/pipeline paralelliğiyle birlikte kullanılır. f. Tam Aktivasyon Yeniden Hesaplama: Akıllı aktivasyon checkpointing yoluyla aktivasyonların bellek ayak izini önemli ölçüde azaltır. Yeniden hesaplanması hızlı olan ancak büyük bellek alanı kaplayan aktivasyonları saklamaz; böylece bellek ve yeniden hesaplama arasında mükemmel bir denge sağlar. Örneğin, GPT-3 için bu, aktivasyonların yeniden hesaplanmasında yalnızca %2,7 FLOPs ek maliyeti karşılığında aktivasyonlar için gereken bellekte %70'lik bir azalmaya yol açar. Daha fazla ayrıntı için lütfen Reducing Activation Recomputation in Large Transformer Models araştırma makalesine başvurun.
g. Fused Kernels: Fused Softmax, Mixed Precision Fused Layer Norm ve lineer katman ağırlık gradyanı hesaplamasına Fused gradient accumulation. PyTorch JIT derlenmiş Fused GeLU ve Fused Bias+Dropout+Residual ekleme.
h. Indexli veri setleri desteği: Büyük ölçekli eğitim için veri setlerinin verimli ikili biçimi. mmap, cached indeks dosyası ve lazy yükleyici biçimi desteği.
i. Checkpoint yeniden şekillendirme ve etkileşim: Değişken tensor ve pipeline paralel boyutlarına sahip Megatron-LM checkpoint'lerini, Accelerate Big Model Inference, Megatron-DeepSpeed Inference gibi çok sayıda araçla mükemmel destek sunan Transformers parçalı checkpoint'lerine yeniden şekillendirmek için bir yardımcı araç. Büyük ölçekli eğitim için Transformers parçalı checkpoint'lerinden değişken tensor ve pipeline paralel boyutlarına sahip Megatron-LM checkpoint'lerine dönüştürme desteği de mevcuttur.
Ön Gereksinimler
En güncel pytorch, cuda, nccl ve NVIDIA APEX sürümlerini ve nltk kütüphanesini yüklemeniz gerekecektir. Daha fazla ayrıntı için belgelere bakın. Ortamı kurmanın bir başka yolu da NGC'den, gerekli tüm yüklemeleri içeren bir NVIDIA PyTorch Container çekmektir.
Aşağıda, conda ortamını kurmak için adım adım bir yöntem bulunmaktadır:
- Sanal ortam oluşturun
conda create --name ml- CUDA 11.3 yüklü olduğu varsayılan makinede, ilgili PyTorch GPU Version'ın yüklenmesi
conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch- Nvidia APEX'i yükleyin
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 ..- Megatron-LM'yi Yükleme
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 kontrol noktasını hazırla
Bir model ince ayar yapmak istiyorsanız, hazır bir torch dist formatında checkpoint'e sahip olduğunuzdan emin olun. Sadece huggingface modeline erişiminiz varsa, Megatron tarafından kabul edilebilir bir torch dist formatında checkpoint'e dönüştürmeyi düşünün. Bir örnek olarak, GLM modellerini örnek alarak slime'in betiğini kullanabilirsiniz:
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
Dönüştürme işleminden sonra şunları kontrol edin: 1. /your/path/to/megatron/models/GLM4.5-355B-A32B_torch_dist altında: latest_checkpointed_iteration.txt dosyasının içeriğini release değerinden 0 değerine değiştirin ve release dizinini iter_0000000 olarak yeniden adlandırın; 2: yapılandırmada, optimizör durumlarının gerekmemesi için megatron_lm_no_load_optim değerinin true olduğundan emin olun.
Accelerate Megatron-LM Eklentisi
Önemli özellikler, accelerate config komutu aracılığıyla doğrudan desteklenir.
Megatron-LM özelliklerinin kullanımına ilişkin soruların bir örneği aşağıda gösterilmektedir:
:~$ 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]: bf16Sonuç olarak oluşan yapılandırma aşağıda gösterilmektedir:
~$ 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: falseGPT ön eğitimi örneğini ele alacağız. Megatron-LM kullanmak için resmi run_clm_no_trainer.py dosyasında yapılması gereken asgari değişiklikler aşağıdaki gibidir:
- Megatron-LM kendi Optimizer uygulamasını kullandığından, bununla uyumlu olan ilgili scheduler'ın kullanılması gerekir.
Bu nedenle yalnızca Megatron-LM scheduler'ı için destek mevcuttur. Kullanıcının
accelerate.utils.MegatronLMDummyScheduleroluşturması gerekir. Aşağıda bir örnek verilmiştir:
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,
)- Toplam batch boyutunun detaylarını almak artık tensor ve pipeline paralel boyutlarının bilinmesini gerektirir. Etkili toplam batch boyutunu alma örneği aşağıda gösterilmektedir:
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- Megatron-LM kullanıldığında, kayıplar zaten veri paralel grubu üzerinde ortalama alınmıştır
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)- Megatron-LM için modelin
accelerator.save_statekullanılarak kaydedilmesi gerekir
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
)İşte! Hazırız 🚀. Örnek betiği, accelerate/examples/by_feature/megatron_lm_gpt_pretraining.py yolundaki examples klasöründe bulabilirsiniz.
Şimdi, 4 A100-80GB GPU kullanarak gpt-large model mimarisi için çalıştıralım.
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şağıda, çıktı günlüklerinden bazı önemli alıntılar yer almaktadır:
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 ile ayarlanabilecek çok sayıda başka seçenek/özellik bulunmaktadır.
Özel eğitim adımı yazma ve Megatron-LM Endeksli Veri Setlerini kullanma için gelişmiş özellikler
Daha fazla özelliği kullanmak için lütfen aşağıdaki ayrıntıları inceleyin.
- Megatron-LM kullanırken Train Step'i özelleştirmek için gerekli değişikliklerin bir örneği aşağıdadır.
accelerate.utils.AbstractTrainStep'i uygulayacak veya bunların karşılık gelen alt sınıflarındanaccelerate.utils.GPTTrainStep,accelerate.utils.BertTrainStepveyaaccelerate.utils.T5TrainStep'ten birinden türetme yapacaksınız.
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,
}- Megatron-LM veri setlerini kullanmak için birkaç ek değişiklik gereklidir. Bu veri setleri için veri yükleyiciler yalnızca her tensör paralel grubunun 0. sıralamasında (rank 0) kullanılabilir. Bu nedenle, veri yükleyicinin kullanılamayacağı sıralamalar (rank) vardır ve bu durum eğitim döngüsünde ayarlamalar gerektirir. Tüm bunları yapabilme imkânı, Accelerate'ın ne kadar esnek ve genişletilebilir olduğunu göstermektedir. Gereken değişiklikler aşağıdaki gibidir.
a. Megatron-LM indeksli veri kümeleri için MegatronLMDummyDataLoader kullanmamız ve data_path, seq_length gibi gerekli veri kümesi argümanlarını ona iletmemiz gerekir.
Kullanılabilir argümanların listesini burada bulabilirsiniz.
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 = Trueb. megatron_dataloader, eğitim, doğrulama ve test veri yükleyicilerini almak için args.splits_string oranlarına göre 3 kez tekrarlanır
model, optimizer, lr_scheduler, train_dataloader, eval_dataloader, _ = accelerator.prepare(
model, optimizer, lr_scheduler, megatron_dataloader, megatron_dataloader, megatron_dataloader
)c. Dataloader yalnızca tensor paralel sıralarında 0 olduğundan eğitim ve değerlendirme döngülerine yapılan değişiklikler
Bu nedenle, dataloader None değilse yalnızca o zaman yinelemeliyiz, aksi halde boş bir sözlük sağlamalıyız
Buna göre, while döngüsüyle yineleyip completed_steps, args.max_train_steps değerine eşit olduğunda döngüden çıkıyoruz. Bu, Megatron-LM kurulumuna benzer; burada kullanıcı, Megaton-LM indeksli veri kümelerini kullanırken max_train_steps değerini sağlamak zorundadır.
Bu, Accelerate'in ne kadar esnek ve genişletilebilir olduğunu göstermektedir.
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)Kontrol Noktası Şekil Değiştirme ve Birlikte Çalışabilirlik Yardımcı Aracı
Bu işlemlerin betikleri, Transformers kütüphanesinde ilgili modellerin altında yer almaktadır. Şu anda GPT modeli için checkpoint_reshaping_and_interoperability.py olarak mevcuttur.
Aşağıda, bir kontrol noktasının Megatron-LM'den evrensel Transformers parçalı kontrol noktasına dönüştürülmesine dair bir örnek yer almaktadır.
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-structuretp_size=2,pp_size=2vedp_size=2ile checkpoint'in transformers'tan megatron'a dönüştürülmesi.
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-structureMegatron-LM GPT modelleri, metin üretimi için logits döndürmeyi ve megatron_generate işlevini destekler
- Logit değerlerinin döndürülmesi, aşağıda gösterildiği gibi MegatronLMPlugin içinde
require_logits=Trueayarının yapılmasını gerektirir. Bunlar, hattın (pipeline) son aşamasında kullanılabilir olacaktır.
megatron_lm_plugin = MegatronLMPlugin(return_logits=True)- Megatron-LM GPT modeli için
megatron_generateyöntemi: Bu yöntem, girdi birimleri için üretimleri tamamlamak üzere Tensor ve Pipeline Parallelism kullanır; bu, top_k/top_p örneklemesi ile veya olmadan açgözlü (greedy) yöntem ve beam search çözümleme kullanıldığında bireysel istem girdileri için geçerlidir. transformers generate'inin yalnızca bir alt kümesi desteklenir. Bu, üretim için büyük modellerin tensor ve pipeline paralelliği yoluyla kullanılmasına yardımcı olur (zaten varsayılan olarak anahtar-değer önbellekleme yapar ve füzyonlu çekirdekler kullanır). Bunun için veri paralelliği boyutunun 1 olması, sequence paralelliğinin ve activation checkpointing'in devre dışı bırakılması gerekir. Ayrıca, tokenizer'ın sözlük dosyasının ve birleştirme (merges) dosyasının yolunun belirtilmesi gerekir. Aşağıdaki örnek, Megatron-LM GPT modeli içinmegatron_generateyönteminin nasıl yapılandırılacağını ve kullanılacağını gösterir.
# 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)- Megatron-LM GPT modeli için
megatron_generateyönteminin uçtan uca kullanım örneği, megatron_gpt2_generation.py dosyasında ve yapılandırma dosyası megatron_lm_gpt_generate_config.yaml ile birlikte mevcuttur. accelerate launch komutunu içeren bash betiği megatron_lm_gpt_generate.sh adresinde bulunabilir. Betik çıktısının günlükleri megatron_lm_gpt_generate.log adresinde mevcuttur.
ROPE ve ALiBi Konumsal gömme ile Çoklu Sorgu Dikkat (Multi-Query Attention) desteği
- ROPE/ALiBi dikkati için, aşağıda gösterildiği gibi
position_embedding_typedeğerini("absolute" | "rotary" | "alibi")olarakMegatronLMPluginsınıfına iletin.
other_megatron_args = {"position_embedding_type": "alibi"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)- Multi-Query Attention için
MegatronLMPlugin'e aşağıda gösterildiği gibiattention_head_typeparametresini("multihead" | "multiquery")değeriyle iletin.
other_megatron_args = {"attention_head_type": "multiquery"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)Dikkat Edilmesi Gerekenler
Transformers GPT2, Megatron-BERT ve T5 modellerini destekler. Bu, yalnızca Dekoder, yalnızca Kodlayıcı ve Kodlayıcı-Dekoder model sınıflarını kapsar.
Modelin ileri geçişinden yalnızca kayıp döndürülür çünkü arka planda boru hattı, tensör ve veri paralelliği arasında oldukça karmaşık bir etkileşim vardır.
model(**batch_data)çağrısı, veri paralel sıraları arasında ortalama alınmış kayıpları döndürür. Bu, ön eğitim işlerinin Megatron-LM özellikleri kullanılarak çalıştırıldığı ve kayıp kullanılarakperplexitydeğerinin kolayca hesaplanabildiği çoğu durum için uygundur. GPT modeli için, kayıpların yanı sıra logitlerin de döndürülmesi desteklenmektedir. Bu logitler, veri paralel sıraları arasında toplanmaz. Logitleri veri paralel sıraları arasında toplamak içinaccelerator.utils.gather_across_data_parallel_groupsişlevini kullanın. Bu logitler, etiketlerle birlikte çeşitli performans metriklerinin hesaplanmasında kullanılabilir.Ana süreç, kayıplar/logitler pipeline'ın son aşamasında mevcut olduğu için son rank'tır. Megatron-LM entegrasyonu kullanıldığında
accelerator.is_main_processveaccelerator.is_local_main_process, son rank içinTruedöndürür.accelerator.prepareçağrısında, verilen bir Transformers modeline karşılık gelen, rastgele ağırlıklara sahip bir Megatron-LM modeli oluşturulur. Eşleşen TP, PP ve DP bölümlerine sahip Megatron-LM kontrol noktasını yüklemek için lütfenaccelerator.load_statekullanın.Şu anda, checkpoint yeniden şekillendirme ve etkileşim desteği yalnızca GPT için kullanılabilir. Yakında BERT ve T5 için de genişletilecektir.
gradient_accumulation_steps1 olmalıdır. Megatron-LM kullanıldığında, pipeline parallelism ayarındaki micro batches, gradient accumulation ile eş anlamlıdır.Megatron-LM kullanırken, kontrol noktalarını kaydetmek ve yüklemek için
accelerator.save_stateveaccelerator.load_statekullanın.Aşağıda, Megatron-LM model mimarilerinden eşdeğer transformers model mimarilerine yapılan eşlemeler yer almaktadır. Yalnızca bu transformers model mimarileri desteklenmektedir.
a. Megatron-LM BertModel :
config'in model type alanında megatron-bert geçen transformers modelleri, örn. MegatronBERT
b. Megatron-LM GPTModel :
config'in model türünde gpt2 geçen transformers modelleri, örn. OpenAI GPT2
c. Megatron-LM T5Model :
config'in model türünde t5 geçen transformers modelleri, örn. T5 ve MT5