Platform For AI：Percepat pelatihan transformer

Percepat fine-tuning Hugging Face transformer dengan cara kotak hitam

1. Daftarkan dataset Anda dengan Hugging Face atau cari dataset yang diinginkan yang telah didaftarkan. Dengan cara ini, Anda dapat menggunakan parameter --dataset-name untuk meneruskan dataset ke PAI-Rapidformer di Langkah 3.

   Untuk informasi lebih lanjut, lihat Daftarkan Dataset ke Hugging Face dan kunjungi halaman Dataset.

2. Daftarkan transformer Anda dengan Hugging Face atau cari transformer yang diinginkan yang telah didaftarkan. Dengan cara ini, Anda dapat menggunakan parameter --pretrained-model-name-or-path untuk meneruskan transformer ke PAI-Rapidformer di Langkah 3.

   Untuk informasi lebih lanjut, lihat Cara Menambahkan Model ke Transformers dan kunjungi halaman Model.

3. Konfigurasikan skrip startup di CLI PAI-Rapidformer. Contoh skrip:

   #!/bin/bash
   export CUDA_VISIBLE_DEVICES=4,5,6,7
   export MASTER_ADDR=localhost
   export MASTER_PORT=6010
   export NNODES=1
   export NODE_RANK=0
   
   rapidformer --task sequence_classification \ # Nama tugas.
               --pretrained-model-name-or-path 'bert-base-cased' \  # Nama transformer yang terdaftar.
               --data-path glue \                      # Jalur dataset yang terdaftar.
               --data-name mrpc \                      # Nama file dataset yang terdaftar.
               --epochs 3 \                               # Jumlah epoch.
               --micro-batch-size 16 \                    # Ukuran mini-batch pada GPU tunggal.
               --global-batch-size 64 \                   # Ukuran batch global pada semua GPU selama pelatihan terdistribusi.
               --lr 2e-5 \                                # Tingkat pembelajaran.
               --lr-decay-style linear \                  # Skema penurunan tingkat pembelajaran.
               --lr-warmup-iters 100 \                    # Pemanasan tingkat pembelajaran.
               --weight-decay 1e-2 \                      # Nilai penurunan bobot.
               --clip-grad 1.0 \                          # Nilai pemotongan gradien.
               --seed 42 \                                # Benih acak.
               --mixed-precision \                        # Mengaktifkan transfer data FP16.
               --onnx-runtime-training \                  # Mengaktifkan optimasi grafik yang disediakan oleh ONNX Runtime.
               --zero-1-memory-optimization \             # Menggunakan Zero Redundancy Optimizer (ZeRO) untuk mempartisi status optimizer.

   Untuk informasi lebih lanjut tentang parameter dalam skrip sebelumnya, lihat Pengaturan Parameter.

Percepat pre-training Hugging Face transformer dengan cara kotak hitam

1. Buat file .mmap sebagai dataset pre-training.

   Untuk informasi lebih lanjut, lihat Megatron-LM. Contoh kode:

   python preprocess_data.py \
     --input book_wiki_owtv2_small.json  \
     --output-prefix gpt_small \
     --vocab gpt2-vocab.json \
     --dataset-impl mmap \
     --tokenizer-type GPT2BPETokenizer \
     --merge-file gpt2-merges.txt \
     --append-eod

2. Daftarkan transformer Anda dengan Hugging Face atau cari transformer yang diinginkan yang telah didaftarkan. Dengan cara ini, Anda dapat menggunakan parameter --pretrained-model-name-or-path untuk meneruskan transformer ke PAI-Rapidformer di Langkah 3.

   Untuk informasi lebih lanjut, lihat Cara Menambahkan Model ke Transformers dan kunjungi halaman Model.

3. Konfigurasikan skrip startup di CLI PAI-Rapidformer. Contoh skrip:

   #!/bin/bash
   export CUDA_VISIBLE_DEVICES=4,5,6,7
   export MASTER_ADDR=localhost
   export MASTER_PORT=6010
   export NNODES=1
   export NODE_RANK=0
   
   rapidformer --task pretraining \
          --pretrained-model-name-or-path 'bert-base-uncased' \
          --num-layers 12 \
          --hidden-size 768 \
          --num-attention-heads 12 \
          --micro-batch-size 16 \
          --global-batch-size 128 \               # Ukuran batch global.
          --seq-length 512 \
          --tokenizer-type BertWordPieceLowerCase \
          --max-position-embeddings 512 \
          --train-iters 100 \
          --data-path book_wiki_owtv2_small_text_sentence \
          --vocab-file bert-en-uncased-vocab.txt  \
          --data-impl mmap \
          --split 980,20 \
          --lr 1e-3 \
          --lr-decay-style linear \
          --min-lr 0.0 \
          --lr-decay-iters 2000 \
          --weight-decay 1e-2 \
          --clip-grad 1.0 \
          --lr-warmup-fraction .01 \
          --mixed-precision \                    # Mengaktifkan transfer data FP16.
          --onnx-runtime-training \              # Mengaktifkan optimasi grafik yang disediakan oleh ONNX Runtime.
          --fsdp-memory-optimization \           # Menggunakan Fully Sharded Data Parallel (FSDP) untuk mempartisi status optimizer, gradien, dan parameter.

   Untuk informasi lebih lanjut tentang parameter dalam skrip sebelumnya, lihat Pengaturan Parameter.

Percepat fine-tuning Hugging Face transformer dengan cara kotak putih menggunakan template kode Finetuner

class MyFintuner(Finetuner):

    def __init__(self, engine):
        super().__init__(engine=engine)

    # Mendapatkan dataset pelatihan, validasi, atau pengujian.
    # Input: tidak ada.
    # Output: tiga objek dan metode objek.
    def train_valid_test_datasets_provider(self):

        return train_dataset, valid_dataset, test_dataset, collate_f

    # Membuat transformer, optimizer, atau scheduler tingkat pembelajaran.
    # Input: tidak ada.
    # Output: tiga objek.
    def model_optimizer_lr_scheduler_provider(self):

        return model, optimizer, lr_scheduler

    # Mendefinisikan logika propagasi maju.
    # Input: batch atau iterator, dan transformer.
    # Output: loss.
    def run_forward_step(self, batch_or_iterator, model):
        return loss

    # Mendefinisikan logika menggunakan dataset validasi. Logika ini disesuaikan untuk fine-tuning transformer.
    # Input: transformer dan pemuat data untuk dataset validasi.
    # Output: objek metrik.
    def run_compute_metrics(self, model, eval_dataloader):
        return metric
                

1. Impor metode PAI-Rapidformer dan transformer Hugging Face.

   from transformers/easytexmier import AutoConfig, BertForSequenceClassification
   from datasets import load_dataset, load_metric
   from rapidformer import RapidformerEngine
   from rapidformer import get_args
   from rapidformer import get_logger
   from rapidformer import get_timers
   from rapidformer import Finetuner
   from rapidformer import Pretrainer
   from rapidformer import build_train_valid_test_datasets_for_huggingface

2. Lengkapi konfigurasi dari empat metode dalam template kode. Contoh kode:

   class MyFintuner(Finetuner):
       def __init__(self,engine):
           super().__init__(engine=engine)
   
       def train_valid_test_datasets_provider(self):
           tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
   
           def tokenize_function(examples):
               # max_length=None => use the model max length (it's actually the default)
               outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
               return outputs
   
           datasets = load_dataset(args.dataset_path, args.dataset_name)
           # Apply the method we just defined to all the examples in all the splits of the dataset
           tokenized_datasets = datasets.map(
               tokenize_function,
               batched=True,
               remove_columns=["idx", "sentence1", "sentence2"],
           )
           tokenized_datasets.rename_column_("label", "labels")
   
           train_dataset = tokenized_datasets["train"]
           valid_dataset = tokenized_datasets['validation']
           test_dataset = tokenized_datasets['test']
   
           def collate_fn(examples):
               return tokenizer.pad(examples, padding="longest", return_tensors="pt")
   
           return train_dataset, valid_dataset, test_dataset, collate_fn
   
       def model_optimizer_lr_scheduler_provider(self):
           args = get_args()
           model = BertForSequenceClassification.from_pretrained(args.load)
           return model, None, None
   
       def run_forward_step(self, batch, model):
           output_tensor = model(**batch)
           return output_tensor.loss
   
       # after each epoch run metric on eval dataset
       def run_compute_metrics(self, model, eval_dataloader):
           model = model[0]
           metric = load_metric(args.dataset_path, args.dataset_name)
           for step, batch in enumerate(eval_dataloader):
               with torch.no_grad():
                   outputs = model(**batch)
               predictions = outputs.logits.argmax(dim=-1)
   
               metric.add_batch(
                   predictions=self.gather(predictions),
                   references=self.gather(batch["labels"]),
               )
   
           eval_metric = metric.compute()
           return eval_metric
                           

3. Inisialisasi PAI-Rapidformer dan buat objek pelatih. Panggil metode finetune() dan simpan output sebagai file bernama rapidformer_finetune_huggingface_bert_trainer.py.

   engine = RapidformerEngine()
   trainer = MyFintuner(engine=engine)
   trainer.train()

4. Konfigurasikan skrip startup di CLI PAI-Rapidformer. Di skrip startup, atur parameter --user-script ke rapidformer_finetune_huggingface_bert_trainer.py dan konfigurasikan saklar percepatan. Contoh skrip:

   #!/bin/bash
   export CUDA_VISIBLE_DEVICES=4,5,6,7
   export MASTER_ADDR=localhost
   export MASTER_PORT=6010
   export NNODES=1
   export NODE_RANK=0
   
   rapidformer --user-script rapidformer_finetune_huggingface_bert_trainer.py
               --task sequence_classification \
               --pretrained-model-name-or-path 'bert-base-cased' \
               --data-path glue \
               --data-name mrpc \
               --epochs 3 \
               --micro-batch-size 16 \
               --global-batch-size 16 \
               --lr 2e-5 \
               --lr-decay-style linear \
               --lr-warmup-iters 100 \
               --weight-decay 1e-2 \
               --clip-grad 1.0 \
               --mixed-precision                                 # Mengaktifkan transfer data FP16.
               --zero-3-memory-optimization \                    # Menggunakan ZeRO untuk mempartisi status optimizer, gradien, dan parameter.
               --onnx-runtime-training \                         # Mengaktifkan optimasi grafik yang disediakan oleh ONNX Runtime.

Percepat pre-training Hugging Face transformer dengan cara kotak putih menggunakan template kode Pretrainer

Setelah Anda memahami template kode, ikuti petunjuk di bagian Percepat Fine-tuning Hugging Face Transformer dengan Cara Kotak Hitam untuk menyiapkan dataset dan transformer. Kemudian, lakukan langkah-langkah berikut:

1. Impor metode PAI-Rapidformer dan transformer Hugging Face.

   Catatan

   Karena pre-training model bergantung pada iterator untuk membaca data, Anda perlu menggunakan Micro Processor Units (MPUs) untuk mewujudkan pemrosesan data paralel.

   from megatron import mpu
   from transformers import BertConfig, BertForPreTraining
   from rapidformer import RapidformerEngine, get_args, PreTrainer
   from rapidformer import build_train_valid_test_datasets_for_huggingface

2. Lengkapi konfigurasi metode untuk percepatan pre-training menggunakan kelas turunan dari PreTrainer. Contoh kode:

   class MyBertPreTrainer(PreTrainer):
   
       def __init__(self,engine):
           super().__init__(engine=engine)
   
       def train_valid_test_datasets_provider(self, train_val_test_num_samples):
           args = get_args()
   
           train_ds, valid_ds, test_ds = build_train_valid_test_datasets_for_huggingface(
               data_prefix=args.data_path,
               data_impl=args.data_impl,
               splits_string=args.split,
               train_valid_test_num_samples=train_val_test_num_samples,
               max_seq_length=args.seq_length,
               masked_lm_prob=args.mask_prob,
               short_seq_prob=args.short_seq_prob,
               seed=args.seed,
               skip_warmup=(not args.mmap_warmup),
               binary_head=True)
   
           return train_ds, valid_ds, test_ds
   
       def model_optimizer_lr_scheduler_provider(self):
           args = get_args()
           model = AutoModelForPreTraining.from_pretrained(args.pretrained_model_name_or_path)
           return model, None, None
   
       def run_forward_step(self, data_iterator, model):
           # Items and their type.
           keys = ['input_ids', 'attention_mask', 'token_type_ids', 'labels', 'next_sentence_label']
           datatype = torch.int64
   
           # Broadcast data.
           if data_iterator is not None:
               data = next(data_iterator)
           else:
               data = None
           data_b = mpu.broadcast_data(keys, data, datatype)
           input_ids = data_b['input_ids'].long()
           attention_mask = data_b['attention_mask'].long()
           token_type_ids = data_b['token_type_ids'].long()
           labels = data_b['labels'].long()
           next_sentence_label = data_b['next_sentence_label'].long()
           output_tensor = model(input_ids=input_ids, attention_mask=attention_mask,
                                 token_type_ids=token_type_ids, labels=labels, next_sentence_label=next_sentence_label)
   
           return output_tensor['loss']

3. Inisialisasi PAI-Rapidformer dan buat objek pelatih. Panggil metode pretrain() dan simpan output sebagai file bernama rapidformer_pretrain_huggingface_bert_trainer.py.

   engine = RapidformerEngine()
   trainer = MyBertPreTrainer(engine=engine)
   trainer.train()

4. Konfigurasikan skrip startup di CLI PAI-Rapidformer. Di skrip startup, konfigurasikan saklar percepatan. Contoh skrip:

   #!/bin/bash
   export CUDA_VISIBLE_DEVICES=4,5,6,7
   export MASTER_ADDR=localhost
   export MASTER_PORT=6010
   export NNODES=1
   export NODE_RANK=0
   
   DATA_PATH=book_wiki_owtv2_small_text_sentence
   
   rapidformer --user-script rapidformer_pretrain_huggingface_bert_trainer.py \
          --pretrained-model-name-or-path 'bert-base-uncased' \
          --num-layers 12 \
          --hidden-size 768 \
          --num-attention-heads 12 \
          --micro-batch-size 16 \
          --global-batch-size 64 \
          --seq-length 512 \
          --tokenizer-type BertWordPieceLowerCase \
          --max-position-embeddings 512 \
          --train-iters 100 \
          --data-path $DATA_PATH \
          --vocab-file bert-en-uncased-vocab.txt  \
          --data-impl mmap \                               # Mengaktifkan percepatan.
          --split 980,20 \
          --lr 1e-3 \
          --lr-decay-style linear \
          --weight-decay 1e-2 \
          --clip-grad 1.0 \
          --lr-warmup-fraction .01 \
          --zero-3-memory-optimization \                    # Menggunakan ZeRO untuk mempartisi status optimizer, gradien, dan parameter.
          --onnx-runtime-training \                         # Mengaktifkan optimasi grafik yang disediakan oleh ONNX Runtime.
          --mixed-precision                                 # Mengaktifkan transfer data FP16.

Percepat fine-tuning Hugging Face transformer dengan cara kotak putih menggunakan pelatih kustom

Untuk percepatan berbasis pelatih kustom, PAI-Rapidformer hanya menyediakan beberapa fitur percepatan, seperti Apex FusedAdam, partisi status model, dan optimasi grafik. Karena pelatihan presisi campuran memerlukan modifikasi kompleks pada proses pelatihan, kami sarankan Anda menggunakan template kode yang disediakan oleh PAI-Rapidformer untuk mempercepat pelatihan. Bagian ini memberikan contoh tentang cara mengoptimalkan kode yang digunakan untuk fine-tuning Hugging Face transformer untuk melakukan percepatan intrusif.

import torch
from datasets import load_dataset, load_metric
from torch.utils.data import DataLoader
from transformers import (
    AdamW,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    get_linear_schedule_with_warmup,
    BertForSequenceClassification,

)

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
datasets = load_dataset("glue", "mrpc")
metric = load_metric("glue", "mrpc")

def tokenize_function(examples):
    # max_length=None => use the model max length (it's actually the default)
    outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
    return outputs

tokenized_datasets = datasets.map(
    tokenize_function,
    batched=True,
    remove_columns=["idx", "sentence1", "sentence2"],
)

model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", return_dict=True)

optimizer = AdamW(params=model.parameters(), lr=args.lr, correct_bias=True)

lr_scheduler = get_linear_schedule_with_warmup(
    optimizer=optimizer,
    num_warmup_steps=args.lr_warmup_iters,
    num_training_steps=args.train_iters
)

device = torch.device("cuda", args.local_rank)

for epoch in range(args.epochs):
    model.train()
    for step, batch in enumerate(train_dataloader):
        batch.to(device)
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()

    model.eval()
    for step, batch in enumerate(eval_dataloader):
        batch.to(device)
        with torch.no_grad():
            outputs = model(**batch)
            predictions = outputs.logits.argmax(dim=-1)
            metric.add_batch(
                    predictions=engine.gather(predictions),
                    references=engine.gather(batch["labels"]))

     eval_metric = metric.compute()
     print("epoch {}: {}".format(epoch, eval_metric))

1. Aktifkan pemrosesan data paralel.

   Buat objek finetuner. Kemudian, panggil metode finetuner.build_data_loader untuk membangun pemuat data. Pemuat data mendukung pemrosesan data paralel dan secara otomatis mengirimkan data ke GPU. Dalam hal ini, Anda dapat menghapus batch.to(device) dari kode contoh sebelumnya.

   + from rapidformer import RapidformerEngine
   + engine = RapidformerEngine()
   + finetuner = Finetuner(engine=engine)
   
   - train_dataloader = DataLoader(tokenized_datasets["train"])
   - eval_dataloader = DataLoader(tokenized_datasets["train"])
   
   + train_dataloader = finetuner.build_data_loader(tokenized_datasets["train"])
   + eval_dataloader = finetuner.build_data_loader(tokenized_datasets["validation"])

2. Aktifkan Apex FusedAdam.

   Ganti optimizer asli dengan Apex FusedAdam yang disediakan oleh PAI-Rapidformer. Anda dapat mengganti optimizer dengan memanggil metode engine.compose untuk mengenkapsulasi transformer, optimizer, dan scheduler tingkat pembelajaran.

   + from rapidformer import RapidformerEngine
   + engine = RapidformerEngine()
   + finetuner = Finetuner(engine=engine)
   
   - optimizer = AdamW(params=model.parameters(), lr=args.lr, correct_bias=True)
   - lr_scheduler = get_linear_schedule_with_warmup(optimizer=optimizer,
       num_warmup_steps=args.lr_warmup_iters,
       num_training_steps=args.train_iters
   )
   
   
   + lr_scheduler = partial(
           get_linear_schedule_with_warmup,
           num_warmup_steps=args.lr_warmup_iters,
           num_training_steps=args.train_iters
       )
   
   + model, optimizer, lr_scheduler = engine.compose(model_obj=model,
         lr_scheduler_fn=lr_scheduler)

   Catatan

   Jika Anda mengaktifkan pemrosesan data paralel, Apex FusedAdam, dan presisi campuran, pelatihan presisi campuran memerlukan Anda melakukan operasi tertentu, seperti memodifikasi proses pelatihan, mengaktifkan transfer data FP16, dan mengaktifkan penskalaan loss. Ini melibatkan modifikasi frontend yang kompleks. Untuk menghindari modifikasi semacam itu, Anda dapat menerapkan percepatan menggunakan pelatih. Template kode Finetuner yang disediakan oleh PAI-Rapidformer mendukung berbagai fitur percepatan, seperti pemrosesan data paralel, Apex FusedAdam, pelatihan presisi campuran PyTorch, pelatihan presisi campuran yang disediakan oleh optimizer Megatron, dan percepatan optimasi memori yang disediakan oleh DeepSpeed dan FairScale.

Percepat pre-training Megatron transformer dengan cara kotak putih menggunakan template kode Pretrainer

Dibandingkan dengan metode percepatan yang dijelaskan dalam bagian Percepat Fine-tuning Hugging Face Transformer dengan Cara Kotak Putih Menggunakan Pelatih Kustom, metode percepatan ini lebih fleksibel. Anda tidak perlu menggunakan Data Hub atau Model Hub. Sebagai gantinya, Anda dapat memanggil metode train_valid_test_datasets_provider, model_optimizer_lr_scheduler_provider, dan run_forward_step untuk mendefinisikan logika produksi data kustom, konstruksi transformer kustom, dan propagasi maju.

1. Buat file .mmap sebagai dataset pre-training.

   Untuk informasi lebih lanjut, lihat Megatron-LM. Contoh kode:

   python preprocess_data.py \
     --input /apsarapangu/disk2/jerry.lp/pretrain_datasets/en/book_wiki_owtv2_small.json  \
     --output-prefix /apsarapangu/disk2/jerry.lp/pretrain_datasets/en/gpt_small \
     --vocab gpt2-vocab.json \
     --dataset-impl mmap \
     --tokenizer-type GPT2BPETokenizer \
     --merge-file gpt2-merges.txt \
     --append-eod

2. Gunakan kelas turunan dari PreTrainer untuk mengonfigurasi metode train_valid_test_datasets_provider yang digunakan untuk menghasilkan data kustom.

   Anda dapat mendefinisikan logika produksi data kustom untuk membuat dataset pelatihan, validasi, dan pengujian, tanpa perlu menggunakan pustaka pihak ketiga. Dataset harus mewarisi kelas torch.utils.data.Dataset. Contoh kode:

   from rapidformer import RapidformerEngine, get_args, PreTrainer
   
   class MegatronGPTPreTrainer(PreTrainer):
       def __init__(self,
                    engine,
                    ):
           super().__init__(engine=engine)
   
       def train_valid_test_datasets_provider(self, train_val_test_num_samples):
           args = get_args()
   
           train_ds, valid_ds, test_ds = build_train_valid_test_datasets(
               data_prefix=args.data_path,
               data_impl=args.data_impl,
               splits_string=args.split,
               train_valid_test_num_samples=train_val_test_num_samples,
               seq_length=args.seq_length,
               seed=args.seed,
               skip_warmup=(not args.mmap_warmup))
   
           return train_ds, valid_ds, test_ds

3. Gunakan kelas turunan dari PreTrainer untuk mengonfigurasi metode model_optimizer_lr_scheduler_provider yang digunakan untuk membangun transformer kustom.

   Anda dapat mendefinisikan logika konstruksi transformer kustom untuk membangun transformer kustom, tanpa perlu menggunakan pustaka pihak ketiga. Model harus mewarisi kelas torch.nn.Module. Contoh kode:

   from rapidformer import RapidformerEngine, get_args, PreTrainer
   from yourmodel import GPTModel
   
   class MegatronGPTPreTrainer(PreTrainer):
       def __init__(self,
                    engine,
                    ):
           super().__init__(engine=engine)
   
       def model_optimizer_lr_scheduler_provider(self):
           model = GPTModel()
           return model, None, None

4. Gunakan kelas turunan dari PreTrainer untuk mengonfigurasi metode run_forward_step yang digunakan untuk mewujudkan propagasi maju.

   from rapidformer import RapidformerEngine, get_args, PreTrainer
   
   class MyGPTPreTrainer(PreTrainer):
       def __init__(self,
                    engine,
                    ):
           super().__init__(engine=engine)
   
   
       def run_forward_step(self, data_iterator, model):
           """Langkah maju."""
           args = get_args()
   
           tokenizer = get_tokenizer()
   
           # Item dan tipe mereka.
           keys = ['text']
           datatype = torch.int64
   
           # Siarkan data.
           if data_iterator is not None:
               data = next(data_iterator)
           else:
               data = None
           data_b = mpu.broadcast_data(keys, data, datatype)
   
           # Bongkar.
           tokens_ = data_b['text'].long()
           labels = tokens_[:, 1:].contiguous()
           tokens = tokens_[:, :-1].contiguous()
   
           # Dapatkan mask dan ID posisi.
           attention_mask, loss_mask, position_ids = get_ltor_masks_and_position_ids(
               tokens,
               tokenizer.eod,
               args.reset_position_ids,
               args.reset_attention_mask,
               args.eod_mask_loss)
   
           output_tensor = model(tokens, position_ids, attention_mask,
                                 labels=labels)
   
           losses = output_tensor.float()
           loss_mask = loss_mask.view(-1).float()
           loss = torch.sum(losses.view(-1) * loss_mask) / loss_mask.sum()
   
           return loss
   
   
                           

5. Inisialisasi PAI-Rapidformer dan buat objek pelatih. Lalu, panggil metode pretrain() dan simpan output sebagai file bernama rapidformer_pretrain_megatron_gpt_trainer.py.

   engine = RapidformerEngine()
   trainer = MyGPTPreTrainer(engine=engine)
   trainer.train()

6. Konfigurasikan skrip startup di CLI PAI-Rapidformer. Di skrip startup, konfigurasikan saklar percepatan. Contoh skrip:

   #!/bin/bash
   export CUDA_VISIBLE_DEVICES=4,5,6,7
   export MASTER_ADDR=localhost
   export MASTER_PORT=6010
   export NNODES=1
   export NODE_RANK=0
   
   DATA_PATH=book_wiki_owtv2_small_text_sentence
   PRETRAINED_CHECKPOINT=
   
   rapidformer --user-script rapidformer_pretrain_megatron_gpt_trainer.py \
          --tensor-model-parallel-size 2 \          # Ukuran paralelisme tensor.
          --pipeline-model-parallel-size 2 \        # Ukuran paralelisme pipeline.
          --num-layers 12 \
          --hidden-size 768 \
          --num-attention-heads 12 \
          --micro-batch-size 16 \
          --global-batch-size 128 \                  # Ukuran batch global.
          --seq-length 512 \
          --tokenizer-type GPT2BPETokenizer \
          --max-position-embeddings 512 \
          --train-iters 100 \
          --data-path $DATA_PATH \
          --vocab-file gpt2-vocab.json \
          --merge-file gpt2-merges.txt \
          --data-impl mmap \                         # Mengaktifkan percepatan.
          --split 980,20 \
          --lr 1e-3 \
          --lr-decay-style linear \
          --weight-decay 1e-2 \
          --clip-grad 1.0 \
          --lr-warmup-fraction .01 \
          --log-interval 1 \
          --zero-3-memory-optimization \                    # Menggunakan ZeRO untuk mempartisi status optimizer dan gradien.
          --checkpoint-activations \                  # Mengaktifkan titik pemeriksaan.
          --mixed-precision                           # Mengaktifkan transfer data FP16.