Platform For AI:Studi kasus: Mempercepat pelatihan model Transformer

Black box: Penyempurnaan Hugging Face

1. Daftarkan set data Anda ke Hugging Face, atau gunakan set data yang sudah ada. Berikan ke Rapidformer menggunakan --dataset-name.

   Untuk informasi selengkapnya, lihat Daftarkan set data Hugging Face dan Kueri daftar set data Hugging Face yang tersedia.

2. Daftarkan model Anda ke Hugging Face, atau gunakan model yang sudah ada. Berikan ke Rapidformer menggunakan --pretrained-model-name-or-path.

   Untuk informasi selengkapnya, lihat Daftarkan model Hugging Face dan Kueri daftar model Hugging Face yang tersedia.

3. Konfigurasikan CLI Rapidformer untuk memulai pelatihan.

   #!/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 model yang terdaftar
               --data-path glue \                      # Nama path data yang terdaftar
               --data-name mrpc \                      # Nama file data yang terdaftar
               --epochs 3 \                               # Jumlah iterasi pelatihan
               --micro-batch-size 16 \                    # Ukuran batch pada tiap GPU
               --global-batch-size 64 \                   # Ukuran batch total untuk pelatihan terdistribusi
               --lr 2e-5 \                                # Tingkat pembelajaran
               --lr-decay-style linear \                  # Kebijakan peluruhan tingkat pembelajaran
               --lr-warmup-iters 100 \                    # Jumlah langkah pemanasan tingkat pembelajaran
               --weight-decay 1e-2 \                      # Koefisien LR
               --clip-grad 1.0 \                          # Koefisien pemotongan gradien
               --seed 42 \                                # Seed acak
               --mixed-precision \                        # Aktifkan pelatihan presisi campuran
               --onnx-runtime-training \                  # Aktifkan optimasi graf komputasi
               --zero-1-memory-optimization \             # Aktifkan partisi status pengoptimal

   Untuk informasi selengkapnya tentang tiap parameter, lihat Panduan pengaturan parameter.

Black box: Pre-training Hugging Face

1. Buat set data bertipe mmap untuk pre-training.

   Lihat Skrip pemrosesan data Megatron untuk detailnya. Contoh perintah untuk membuat set data mmap:

   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 model Anda ke Hugging Face, atau gunakan model yang sudah ada. Berikan ke Rapidformer menggunakan --pretrained-model-name-or-path.

   Untuk informasi selengkapnya, lihat Daftarkan model Hugging Face dan Kueri daftar model Hugging Face yang tersedia.

3. Konfigurasikan CLI Rapidformer untuk memulai pelatihan.

   #!/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 \               # Aktifkan akumulasi gradien
          --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 \                    # Aktifkan pelatihan presisi campuran
          --onnx-runtime-training \              # Aktifkan optimasi graf komputasi
          --fsdp-memory-optimization \           # Aktifkan partisi status model

   Untuk informasi selengkapnya tentang tiap parameter, lihat Panduan pengaturan parameter.

White box: Penyempurnaan Hugging Face dengan templat Finetuner

class MyFintuner(Finetuner):

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

    # Mendapatkan set data pelatihan/validasi/uji
    # Input: Tidak ada
    # Output: Tiga objek dan satu fungsi objek
    def train_valid_test_datasets_provider(self):

        return train_dataset, valid_dataset, test_dataset, collate_f

    # Membuat model/pengoptimal/penjadwal tingkat pembelajaran
    # Input: Tidak ada
    # Output: Tiga objek
    def model_optimizer_lr_scheduler_provider(self):

        return model, optimizer, lr_scheduler

    # Menulis logika forward
    # Input: batch atau iterator, model
    # Output: loss
    def run_forward_step(self, batch_or_iterator, model):
        return loss

    # Menulis logika evaluasi set validasi, khusus untuk penyempurnaan
    # Input: model, data loader set validasi
    # Output: objek metrik
    def run_compute_metrics(self, model, eval_dataloader):
        return metric
                

1. Impor antarmuka Rapidformer dan 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 keempat fungsi dalam templat 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 => gunakan panjang maksimum model (sebenarnya ini adalah nilai default)
               outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
               return outputs
   
           datasets = load_dataset(args.dataset_path, args.dataset_name)
           # Terapkan metode yang baru saja didefinisikan ke semua contoh di semua split set data
           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
   
       # setelah tiap epoch, jalankan metrik pada set data evaluasi
       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 engine Rapidformer, buat objek trainer, panggil finetune(), dan simpan sebagai rapidformer_finetune_hugging_face_bert_trainer.py.

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

4. Siapkan skrip startup berdasarkan CLI. Atur --user-script ke rapidformer_finetune_hugging_face_bert_trainer.py dan atur sakelar percepatan.

   #!/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                                 # Aktifkan pelatihan presisi campuran
               --zero-3-memory-optimization \                    # Aktifkan partisi status model
               --onnx-runtime-training \                         # Aktifkan optimasi graf komputasi

White box: Pre-training Hugging Face dengan templat Pretrainer

Setelah memahami templat kode kustom, siapkan set data dan model seperti yang dijelaskan di Black box: Penyempurnaan Hugging Face. Kemudian lakukan langkah-langkah berikut:

1. Impor antarmuka Rapidformer dan Hugging Face.

   Catatan

   Pre-training menggunakan iterator untuk membaca data, sehingga impor mpu untuk paralelisme data.

   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. Wariskan Pretrainer dan lengkapi kode pre-training.

   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):
           # Item dan tipe-nya.
           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 engine Rapidformer, buat objek trainer, panggil pretrain(), dan simpan sebagai rapidformer_pretrain_hugging_face_bert_trainer.py.

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

4. Siapkan skrip startup berdasarkan CLI dan atur sakelar percepatan.

   #!/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 \                               # Aktifkan akselerasi data
          --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 \                    # Aktifkan partisi status model
          --onnx-runtime-training \                         # Aktifkan optimasi graf komputasi
          --mixed-precision                                 # Pelatihan presisi campuran

White box: Penyempurnaan Hugging Face dengan Trainer kustom

Untuk program dengan Trainer kustom, Rapidformer menyediakan percepatan terbatas: pengoptimal Apex, partisi status model, dan optimasi graf komputasi. Pelatihan presisi campuran memerlukan banyak modifikasi. Gunakan metode berbasis templat yang dijelaskan sebelumnya untuk hasil yang lebih baik. Bagian ini menunjukkan percepatan intrusif pada kode penyempurnaan Hugging Face yang khas.

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 => gunakan panjang maksimum model (sebenarnya ini adalah nilai 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. Tambahkan dukungan paralelisme data.

   Buat objek finetuner, lalu panggil finetuner.build_data_loader untuk membuat data loader. Loader ini mendukung paralelisme data dan secara otomatis mengirim data ke GPU. Hapus batch.to(device) dari kode asli.

   + 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. Gunakan pengoptimal Apex di atas paralelisme data.

   Ganti pengoptimal dengan Apex Fused Adam yang lebih cepat. Hapus pengoptimal asli dan gunakan Fused Adam dari Rapidformer. Panggil engine.compose untuk mengenkapsulasi model, pengoptimal, dan penjadwal 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

   Menggunakan pengoptimal Apex dan presisi campuran dengan paralelisme data bersifat kompleks. Pelatihan presisi campuran melibatkan pengubahan model ke fp16 dan penskalaan loss. Memodifikasi program frontend tanpa trainer bersifat kompleks. Gunakan solusi berbasis Trainer sebagai gantinya. Finetuner Rapidformer mengintegrasikan paralelisme data, Apex, pelatihan presisi campuran PyTorch, pelatihan presisi campuran pengoptimal Megatron, serta optimasi VRAM dari FairScale dan DeepSpeed.

White box: Pre-training Megatron dengan templat Pretrainer

Setelah memahami metode White box: Penyempurnaan Hugging Face dengan Trainer kustom, lewati Data dan Model Hub untuk fleksibilitas lebih besar. Tulis logika pembuatan data kustom di train_valid_test_datasets_provider, model kustom di model_optimizer_lr_scheduler_provider, dan logika forward kustom di run_forward_step.

1. Buat set data bertipe mmap untuk pre-training.

   Lihat Skrip pemrosesan data Megatron untuk detailnya. Contoh perintah untuk membuat set data mmap:

   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. Wariskan Pretrainer dan lengkapi fungsi kustom data train_valid_test_datasets_provider dalam kode pre-training.

   Tulis logika kustom untuk membuat set data pelatihan, validasi, dan uji tanpa bergantung pada pustaka pihak ketiga. Set data harus mewarisi torch.utils.data.Dataset.

   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. Wariskan Pretrainer dan lengkapi fungsi kustom model model_optimizer_lr_scheduler_provider dalam kode pre-training.

   Tulis logika kustom untuk membuat objek model kustom tanpa bergantung pada pustaka pihak ketiga. Model harus mewarisi torch.nn.Module.

   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. Wariskan Pretrainer dan lengkapi fungsi kustom forward run_forward_step dalam kode pre-training.

   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 forward."""
           args = get_args()
   
           tokenizer = get_tokenizer()
   
           # Item dan tipe-nya.
           keys = ['text']
           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)
   
           # Unpack.
           tokens_ = data_b['text'].long()
           labels = tokens_[:, 1:].contiguous()
           tokens = tokens_[:, :-1].contiguous()
   
           # Dapatkan mask dan position ids.
           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 engine Rapidformer, buat objek trainer, panggil pretrain(), dan simpan sebagai rapidformer_pretrain_megatron_gpt_trainer.py.

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

6. Siapkan skrip startup dan atur sakelar percepatan.

   #!/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 \          # Aktifkan optimasi pemisahan operator
          --pipeline-model-parallel-size 2 \        # Aktifkan optimasi paralelisme pipeline
          --num-layers 12 \
          --hidden-size 768 \
          --num-attention-heads 12 \
          --micro-batch-size 16 \
          --global-batch-size 128 \                  # Aktifkan optimasi akumulasi gradien
          --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 \                         # Aktifkan akselerasi data
          --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-2-memory-optimization \              # Aktifkan partisi status model
          --checkpoint-activations \                  # Aktifkan checkpointing gradien
          --mixed-precision                           # Aktifkan pelatihan presisi campuran