# Megatron-LM

يتيح [Megatron-LM](https://github.com/NVIDIA/Megatron-LM) تدريب نماذج اللغة التحويلية الكبيرة على نطاق واسع. فهو يوفر توازيًا فعّالًا للنموذج يعتمد على المصفوفات (Tensor) والخطوط (Pipeline) والتسلسلات (Sequence) لتدريب نماذج اللغة التحويلية المسبقة التدريب مثل [GPT](https://huggingface.co/papers/2005.14165) (فك الترميز فقط)، و[BERT](https://huggingface.co/papers/1810.04805) (ترميز فقط)، و[T5](https://huggingface.co/papers/1910.10683) (ترميز-فك ترميز). للحصول على معلومات تفصيلية وكيفية عمل الأمور في الخلفية، يُرجى الرجوع إلى مستودع [repo](https://github.com/NVIDIA/Megatron-LM) على GitHub.

## ما الذي تم دمجه؟

تدمج Accelerate الميزة التالية من Megatron-LM لتمكين التدريب المسبق/التحسين على نطاق كبير لنماذج BERT (المُشفِّر)، وGPT (المُفكِّك)، أو T5 (المُشفِّر والمُفكِّك):

a. **توازي الموترات (TP)**: يقلل من بصمة الذاكرة دون إضافة الكثير من الاتصالات على الرتب داخل العقدة. يتم تقسيم كل موتر إلى عدة أجزاء، حيث يقيم كل شريحة على وحدة معالجة رسومية منفصلة. في كل خطوة، تتم معالجة نفس الدفعة المصغرة من البيانات بشكل مستقل ومتوازٍ بواسطة كل شريحة، تليها مزامنة عبر جميع وحدات المعالجة الرسومية (عملية `all-reduce`). في طبقة محوّلة بسيطة، يؤدي هذا إلى إجراء `all-reduces` في المسار الأمامي وإجراءين في المسار الخلفي. لمزيد من التفاصيل، يُرجى الرجوع إلى ورقة البحث [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://huggingface.co/papers/1909.08053) وقسم مدونة [The Technology Behind BLOOM Training](https://huggingface.co/blog/bloom-megatron-deepspeed#tensor-parallelism).

ب. **توازي خط الأنابيب (PP)**: يقلل من بصمة الذاكرة ويتيح التدريب على نطاق واسع عبر التوازي بين العقد. يقلل من فقاعات التوازي البسيط لخط الأنابيب عبر جدولة PipeDream-Flush/جدولة 1F1B وجدولة 1F1B المتداخلة. يتم توزيع الطبقات بشكل متساوٍ عبر مراحل خط الأنابيب. على سبيل المثال، إذا كان النموذج يحتوي على `24` طبقة وكان لدينا `4` وحدات معالجة رسومية للتوازي عبر خط الأنابيب، فستحتوي كل وحدة معالجة رسومية على `6` طبقات (24/4). لمزيد من التفاصيل حول الجداول الزمنية لتقليل وقت الخمول في خط الأنابيب، يرجى الرجوع إلى ورقة البحث [Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM](https://huggingface.co/papers/2104.04473) وهذا القسم من المدونة [The Technology Behind BLOOM Training](https://huggingface.co/blog/bloom-megatron-deepspeed#pipeline-parallelism).

c. **توازي التسلسل (SP)**: يقلل من بصمة الذاكرة دون أي اتصال إضافي. لا ينطبق إلا عند استخدام TP. يقلل من ذاكرة التنشيط المطلوبة لأنه يمنع وجود النسخ نفسها على رتب توازي الموترات بعد `all-reduce` عن طريق استبدالها بـ `reduce-scatter` وسيتم استبدال عملية `no-op` بـ `all-gather`. بما أن `all-reduce = reduce-scatter + all-gather`، فهذا يوفر كمية كبيرة من ذاكرة التنشيط دون تكلفة اتصال إضافية. ببساطة، يقوم بتجزئة مخرجات كل طبقة من طبقات المحول على طول بُعد التسلسل، على سبيل المثال، إذا كان طول التسلسل `1024` وحجم TP هو `4`، فسيحتوي كل معالج رسومي على `256` رمزًا (1024/4) لكل عينة. يزيد هذا من حجم الدفعة الذي يمكن دعمه للتدريب. لمزيد من التفاصيل، يرجى الرجوع إلى ورقة البحث [Reducing Activation Recomputation in Large Transformer Models](https://huggingface.co/papers/2205.05198).

d. **التوازي في البيانات (DP)** عبر المُحسِّن الموزَّع: يقلِّل من البصمة الذاكرة عن طريق تقسيم حالات المُحسِّن والتدرّجات عبر رتب DP (على عكس الطريقة التقليدية التي تُكرِّر حالة المُحسِّن عبر رتب التوازي في البيانات). على سبيل المثال، عند استخدام مُحسِّن Adam مع التدريب بدقة مختلطة، يمثل كل معامل 12 بايت من الذاكرة. يتم توزيع هذا بالتساوي على وحدات معالجة الرسوميات، أي أن كل معامل سيُمثّل 3 بايت (12/4) إذا كان لدينا 4 وحدات معالجة رسوميات. لمزيد من التفاصيل، يُرجى الرجوع إلى ورقة البحث [ZeRO: Memory Optimizations Toward Training Trillion Parameter Models](https://huggingface.co/papers/1910.02054) والقسم التالي من المدونة [The Technology Behind BLOOM Training](https://huggingface.co/blog/bloom-megatron-deepspeed#zero-data-parallelism).

e. **التوازي بين الخبراء (EP)** يُستخدم التوازي بين الخبراء في Megatron-LM لطبقات مزيج الخبراء (MoE)، حيث يوجد عدد كبير من "الخبراء" (شبكات أمامية صغيرة) لكن يُفعَّل عدد قليل منها فقط لكل رمز. بدلاً من وضع جميع الخبراء على كل وحدة معالجة رسومية، يوزّع Megatron خبراء مختلفين على وحدات معالجة رسومية مختلفة—وهذا هو التوازي بين الخبراء. أثناء التدريب، تُوجَّه الرموز إلى وحدات المعالجة الرسومية التي تستضيف الخبراء المختارين لها، وتُحسب هناك، ثم تُعاد، مما يقلل من تكلفة الذاكرة. وغالبًا ما يُدمج مع التوازي على مستوى الموترات/الخطوط الأنابيب للنماذج واسعة النطاق. f. **إعادة الحساب الكاملة للتفعيلات**: يقلل بصمة الذاكرة للتفعيلات بشكل كبير عبر فحص نقاط التفعيل الذكية. فهو لا يخزّن التفعيلات التي تشغل مساحة ذاكرة كبيرة بينما تكون سريعة إعادة حسابها، مما يحقق توازنًا ممتازًا بين الذاكرة وإعادة الحساب. على سبيل المثال، بالنسبة إلى GPT-3، يؤدي هذا إلى تقليل بنسبة 70% في الذاكرة المطلوبة للتفعيلات مقابل زيادة طفيفة بنسبة 2.7% فقط في عمليات FLOPs لإعادة حساب التفعيلات. لمزيد من التفاصيل، يُرجى الرجوع إلى ورقة البحث [Reducing Activation Recomputation in Large Transformer Models](https://huggingface.co/papers/2205.05198).

g. **النواة المدمجة**: Softmax المدمج، وLayer Norm المدمج بدقة مختلطة، وتجميع التدرجات المدمج لحساب تدرجات الأوزان للطبقة الخطية. بالإضافة إلى GeLU المدمج المُجمَّع بواسطة PyTorch JIT، وإضافة Bias+Dropout+Residual المدمجة.

h. **دعم مجموعات البيانات الفهرسية**: تنسيق ثنائي فعّال لمجموعات البيانات للتدريب على نطاق واسع. دعم ملف الفهرس `mmap` و`cached` وتنسيق المحمّل `lazy`.

i. **إعادة تشكيل نقاط التفتيش والتوافق المتبادل**: أداة لإعادة تشكيل نقاط تفتيش Megatron-LM ذات أحجام التوازي المتغير للتensors وخطوط الأنابيب إلى نقاط التفتيش المقسمة المحبوبة في Transformers، حيث يحظى بدعم كبير مع مجموعة واسعة من الأدوات مثل Accelerate Big Model Inference وMegatron-DeepSpeed Inference وغيرها. كما يتوفر دعم لتحويل نقاط التفتيش المقسمة في Transformers إلى نقاط تفتيش Megatron-LM ذات أحجام التوازي المتغير للتensors وخطوط الأنابيب للتدريب على نطاق واسع.

## المتطلبات المسبقة 

ستحتاج إلى تثبيت أحدث إصدارات pytorch وcuda وnccl وNVIDIA [APEX](https://github.com/NVIDIA/apex#quick-start) بالإضافة إلى مكتبة nltk. راجع [التوثيق](https://github.com/NVIDIA/Megatron-LM#setup) لمزيد من التفاصيل. طريقة أخرى لإعداد البيئة هي سحب حاوية NVIDIA PyTorch التي تأتي مع جميع التثبيتات المطلوبة من NGC.

فيما يلي طريقة خطوة بخطوة لإعداد بيئة conda:

1. إنشاء بيئة افتراضية
```
conda create --name ml
```

2. بافتراض أن الجهاز مثبت عليه CUDA 11.3، يتم تثبيت الإصدار المقابل من PyTorch GPU
```
conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
```

3. تثبيت 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 ..
```

4. تثبيت 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
إذا كنت ترغب في ضبط نموذج، تأكد من أن لديك نقطة تحقق (checkpoint) بصيغة 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 حتى لا تكون هناك حاجة إلى حالات المُحسِّن.

## تسريع إضافة Megatron-LM

تُدعم الميزات المهمة مباشرةً عبر أمر `accelerate config`. يُظهر المثال أدناه أسئلةً مطابقةً لاستخدام ميزات Megatron-LM:

```bash
:~$ 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)، يجب استخدام الجدولة (scheduler) المتوافقة معه.
وبالتالي، فإن الدعم متوفر فقط لمجدول Megatron-LM. سيتعين على المستخدم إنشاء `accelerate.utils.MegatronLMDummyScheduler`. يُعرض مثال أدناه:

```python
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,
    )
```

2. يتطلب الحصول على تفاصيل حجم الدفعة الإجمالي الآن مراعاة أحجام التوازي على مستوى الموترات والتوازي على مستوى خط الأنابيب.
يُظهر ما يلي مثالاً على كيفية الحصول على حجم الدفعة الإجمالي الفعّال:

```python
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
```

3. عند استخدام Megatron-LM، تكون الخسائر مُتوسّطة بالفعل عبر مجموعة التوازي في البيانات

```python
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)
```

4. في Megatron-LM، نحتاج إلى حفظ النموذج باستخدام `accelerator.save_state`

```python
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
    )
```

هذا كل شيء! نحن مستعدون للانطلاق 🚀. يمكنك العثور على السكربت التجريبي في مجلد الأمثلة عند المسار `accelerate/examples/by_feature/megatron_lm_gpt_pretraining.py`. لنشغّله لبنية نموذج `gpt-large` باستخدام 4 وحدات معالجة رسومية A100-80GB.

```bash
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"
```

فيما يلي بعض المقاطع المهمة من سجلات الإخراج:

```bash
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. فيما يلي مثال على التغييرات المطلوبة لتخصيص خطوة التدريب عند استخدام Megatron-LM.
ستقوم بتنفيذ `accelerate.utils.AbstractTrainStep` أو الوراثة من أطفالها المقابلة `accelerate.utils.GPTTrainStep`، `accelerate.utils.BertTrainStep` أو `accelerate.utils.T5TrainStep`.

```python
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,
    }
```

2. لاستخدام مجموعات بيانات Megatron-LM، يلزم إجراء بعض التغييرات الإضافية. محمّلات البيانات لهذه المجموعات
متاحة فقط على الرتبة 0 لكل مجموعة توازي الموترات. وبذلك، توجد رتب لن يكون فيها مُحمِّل البيانات متاحًا، مما يتطلب تعديلات على حلقة التدريب. إن القدرة على القيام بكل هذا تُظهر مدى مرونة Accelerate وقابليتها للتوسعة. والتغييرات المطلوبة هي على النحو التالي.

a. فيما يتعلق بمجموعات بيانات Megatron-LM المُفهرسة، نحتاج إلى استخدام `MegatronLMDummyDataLoader` وتمرير حُجج المجموعة المطلوبة إليه مثل `data_path` و`seq_length` وغيرها. راجع [هنا](https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/training/arguments.py) للاطلاع على قائمة الحُجج المتاحة.
    
```python
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` ثلاث مرات للحصول على مُحمِّلات بيانات التدريب والتحقق والاختبار وفقًا لنِسَب `args.splits_string`
    
```python
model, optimizer, lr_scheduler, train_dataloader, eval_dataloader, _ = accelerator.prepare(
    model, optimizer, lr_scheduler, megatron_dataloader, megatron_dataloader, megatron_dataloader
)
```

c. تعديلات على حلقات التدريب والتقييم، حيث يكون مُحمِّل البيانات متاحًا فقط على رتب الموازاة على مستوى المصفوفات 0. لذا، نحتاج إلى التكرار فقط إذا لم يكن مُحمِّل البيانات `None`، وإلا نوفر قاموسًا فارغًا. بناءً على ذلك، نستخدم حلقة `while` للتكرار، ونكسر الحلقة عندما يصبح `completed_steps` مساويًا لـ `args.max_train_steps`. هذا مشابه لإعداد Megatron-LM، حيث يجب على المستخدم تقديم `max_train_steps` عند استخدام مجموعات البيانات الفهرسة في Megaton-LM. يُظهر هذا مدى مرونة Accelerate وقابليتها للتوسيع.

```python
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 تحت النماذج المقابلة لها.
Currently, it is available for GPT model [checkpoint_reshaping_and_interoperability.py](https://github.com/huggingface/transformers/blob/main/src/transformers/models/megatron_gpt2/checkpoint_reshaping_and_interoperability.py)

2. فيما يلي مثال على تحويل نقطة التفتيش من Megatron-LM إلى نقطة تفتيش مقسّمة عالمية لـ Transformers.
```bash
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
```

3. تحويل نقطة التفتيش من transformers إلى megatron مع `tp_size=2` و`pp_size=2` و`dp_size=2`.
```bash
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 إرجاع القيم اللوجستية (logits) ودالة `megatron_generate` لتوليد النص

1. يتطلب إرجاع القيم اللوجستية (logits) تعيين `require_logits=True` في MegatronLMPlugin كما هو موضح أدناه.
ستتوفر هذه في المرحلة الأخيرة من خط المعالجة.
```python
megatron_lm_plugin = MegatronLMPlugin(return_logits=True)
```

2. طريقة `megatron_generate` لنموذج GPT الخاص بـ Megatron-LM: ستستخدم هذه الطريقة توازي الموترات وتوازي خط الأنابيب لإتمام
لأداء عمليات التوليد لدفعة من المدخلات عند استخدام التوليد الجشعي مع أو بدون أخذ عينات top_k/top_p، وللمدخلات الفردية عند استخدام فك الترميز بالبحث الحزمي. يتم دعم مجموعة فرعية فقط من ميزات generate في transformers. سيساعد ذلك في استخدام النماذج الكبيرة عبر توازي الموترات وتوازي خطوط الأنابيب للتوليد (حيث يقوم بالفعل بتخزين مفاتيح القيم ويستخدم الأنوية المدمجة افتراضيًا). يتطلب ذلك أن يكون حجم توازي البيانات 1، وأن يكون توازي التسلسل ونقطة التفتيش للتفعيل معطلين. كما يتطلب تحديد المسار إلى ملف مفردات المرمّز وملف الدمج. يُظهر المثال أدناه كيفية تكوين واستخدام طريقة `megatron_generate` لنموذج GPT الخاص بـ Megatron-LM.
```python
# 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)
```

3. يتوفر مثال شامل من البداية إلى النهاية لاستخدام طريقة `megatron_generate` لنموذج GPT الخاص بـ Megatron-LM في
[megatron_gpt2_generation.py](https://github.com/pacman100/accelerate-megatron-test/blob/main/src/inference/megatron_gpt2_generation.py) مع ملف الإعدادات [megatron_lm_gpt_generate_config.yaml](https://github.com/pacman100/accelerate-megatron-test/blob/main/src/Configs/megatron_lm_gpt_generate_config.yaml). يتوفر سكربت bash الذي يحتوي على أمر accelerate launch في [megatron_lm_gpt_generate.sh](https://github.com/pacman100/accelerate-megatron-test/blob/main/megatron_lm_gpt_generate.sh). وتتوفر سجلات المخرجات الخاصة بالسكربت في [megatron_lm_gpt_generate.log](https://github.com/pacman100/accelerate-megatron-test/blob/main/output_logs/megatron_lm_gpt_generate.log).

## دعم تضمينات الموضع ROPE وALiBi واهتمام الاستعلام المتعدد

1. بالنسبة لانتباه ROPE/ALiBi، مرّر `position_embedding_type` مع `("absolute" | "rotary" | "alibi")` إلى `MegatronLMPlugin` كما هو موضح أدناه.
```python
other_megatron_args = {"position_embedding_type": "alibi"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)
```

2. لانتباه الاستعلام المتعدد (Multi-Query Attention)، مرّر `attention_head_type` مع `("multihead" | "multiquery")` إلى `MegatronLMPlugin` كما هو موضح أدناه.
```python
other_megatron_args = {"attention_head_type": "multiquery"}
megatron_lm_plugin = MegatronLMPlugin(other_megatron_args=other_megatron_args)
```

## ملاحظات

1. يدعم نماذج Transformers GPT2 وMegatron-BERT وT5.
يتناول هذا القسم فئات النماذج من نوع المُفكِّك فقط، والمُرمِّز فقط، والمُرمِّز-المُفكِّك.

2. يُعاد فقط loss من تمرير النموذج الأمامي على النحو
يوجد تفاعل معقد إلى حد كبير بين خط الأنابيب، وتوازي الموترات، وتوازي البيانات في الخلفية. تُرجع الاستدعاء `model(**batch_data)` الخسائر (losses) المُتوسّطة عبر رتب توازي البيانات. وهذا مناسب لمعظم الحالات التي تُنفَّذ فيها مهام التدريب المسبق باستخدام ميزات Megatron-LM، حيث يمكنك بسهولة حساب `perplexity` باستخدام الخسارة. بالنسبة لنموذج GPT، يُدعَم إرجاع القيم اللوجستية (logits) بالإضافة إلى الخسائر. هذه القيم اللوجستية لا تُجمَّع عبر رتب توازي البيانات. استخدم `accelerator.utils.gather_across_data_parallel_groups` لجمع القيم اللوجستية عبر رتب توازي البيانات. يمكن استخدام هذه القيم اللوجستية مع التسميات (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، تكون الدفعات الدقيقة في التوازي عبر خط الأنابيب
يعني الإعداد gradient_accumulation_steps التجميع التدرّجي.

7. عند استخدام Megatron-LM، استخدم `accelerator.save_state` و`accelerator.load_state` لحفظ نقاط التفتيش وتحميلها.

8. فيما يلي خريطة من معماريات نماذج Megatron-LM إلى معماريات نماذج transformers المكافئة.
تُؤيَّد هياكل نماذج transformers هذه فقط.

a. Megatron-LM [BertModel](https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/models/bert/bert_model.py) : نماذج transformers التي تحتوي على `megatron-bert` في نوع النموذج الخاص بالإعدادات، مثل [MegatronBERT](https://huggingface.co/docs/transformers/model_doc/megatron-bert)
    
ب. Megatron-LM [GPTModel](https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/models/gpt/gpt_model.py) : نماذج transformers التي تحتوي على `gpt2` في نوع النموذج ضمن الإعدادات، مثل [OpenAI GPT2](https://huggingface.co/docs/transformers/model_doc/gpt2)
   
c. Megatron-LM [T5Model](https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/models/T5/t5_model.py) : نماذج transformers التي تحتوي على `t5` في نوع النموذج ضمن الإعدادات، مثل [T5](https://huggingface.co/docs/transformers/model_doc/t5) و [MT5](https://huggingface.co/docs/transformers/model_doc/mt5)

