처음부터 구현하는 훈련 루프

Ask a Question Open In Colab Open In Studio Lab

이제 Trainer 클래스를 사용하지 않고 최신 PyTorch 모범 사례를 활용해 처음부터 훈련 루프를 구현하여 이전 섹션과 동일한 결과를 얻는 방법을 알아보겠습니다. 이전과 마찬가지로 섹션 2에서 데이터 처리를 완료했다고 가정하고 진행하겠습니다. 필요한 모든 내용을 담은 간단한 요약은 다음과 같습니다.

🏗️ 처음부터 훈련하기: 이 섹션은 이전 내용을 기반으로 합니다. PyTorch 훈련 루프와 모범 사례에 대한 포괄적인 가이드는 🤗 Transformers 훈련 문서커스텀 훈련 쿡북을 확인하세요.

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

raw_datasets = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)


def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)


tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

훈련 준비

실제로 훈련 루프를 작성하기 전에 몇 가지 객체를 정의해야 합니다. 첫 번째는 배치를 반복하는 데 사용할 데이터로더입니다. 하지만 이러한 데이터로더를 정의하기 전에 tokenized_datasets에 약간의 후처리를 적용해야 합니다. 이는 Trainer가 자동으로 수행했던 작업들을 직접 처리하기 위해서입니다. 구체적으로 다음과 같은 작업이 필요합니다.

tokenized_datasets에는 이러한 각 단계에 대한 메서드가 있습니다.

tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])
tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
tokenized_datasets.set_format("torch")
tokenized_datasets["train"].column_names

그런 다음 결과에 모델이 허용할 컬럼만 있는지 확인할 수 있습니다.

["attention_mask", "input_ids", "labels", "token_type_ids"]

이제 이 작업들이 완료되었으니 데이터로더를 정의해보겠습니다.

from torch.utils.data import DataLoader

train_dataloader = DataLoader(
    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
)
eval_dataloader = DataLoader(
    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
)

데이터 처리가 제대로 되었는지 확인하기 위해 배치를 한번 살펴보겠습니다.

for batch in train_dataloader:
    break
{k: v.shape for k, v in batch.items()}
{'attention_mask': torch.Size([8, 65]),
 'input_ids': torch.Size([8, 65]),
 'labels': torch.Size([8]),
 'token_type_ids': torch.Size([8, 65])}

훈련 데이터로더에 대해 shuffle=True를 설정하고 배치 내에서 최대 길이까지 패딩하므로 실제 모양은 약간 다를 수 있습니다.

이제 데이터 전처리를 완전히 마쳤습니다(모든 ML 실무자들에게는 만족스럽지만 달성하기 어려운 목표죠!). 다음으로 모델을 준비해보겠습니다. 이전 섹션과 동일한 방식으로 모델을 인스턴스화합니다.

from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

훈련 중에 모든 것이 원활하게 진행되도록 하기 위해 배치를 이 모델에 전달합니다.

outputs = model(**batch)
print(outputs.loss, outputs.logits.shape)
tensor(0.5441, grad_fn=<NllLossBackward>) torch.Size([8, 2])

모든 🤗 Transformers 모델은 labels가 제공될 때 손실을 반환하며, 로짓도 얻습니다(배치의 각 입력에 대해 2개씩, 따라서 8 x 2 크기의 텐서).

훈련 루프를 작성할 준비가 거의 완료되었습니다! 옵티마이저와 학습률 스케줄러 두 가지만 빠졌습니다. Trainer가 수행한 작업을 수동으로 복제하려고 하므로 동일한 기본값을 사용하겠습니다. Trainer에서 사용하는 옵티마이저는 AdamW로, 가중치 감소 정규화에 대한 변형이 있는 Adam과 동일합니다(Ilya Loshchilov와 Frank Hutter의 “Decoupled Weight Decay Regularization” 참조)

from torch.optim import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)

💡 최신 최적화 팁: 더 나은 성능을 위해 다음을 시도해볼 수 있습니다.

🚀 최적화 리소스: 옵티마이저와 훈련 전략에 대해 자세히 알아보려면 🤗 Transformers 최적화 가이드를 참조하세요.

마지막으로, 기본적으로 사용되는 학습률 스케줄러는 최대값(5e-5)에서 0까지의 선형 감소입니다. 이를 올바르게 정의하려면 수행할 훈련 단계 수를 알아야 하는데, 이는 실행하려는 에포크 수에 훈련 배치 수(훈련 데이터로더의 길이)를 곱한 것입니다. Trainer는 기본적으로 3개의 에포크를 사용하므로 이를 따르겠습니다.

from transformers import get_scheduler

num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)
print(num_training_steps)
1377

훈련 루프

마지막으로 한 가지 더 고려할 점이 있습니다. GPU를 사용할 수 있다면 GPU를 활용하는 것이 좋습니다(CPU에서는 훈련이 몇 분 대신 몇 시간이 걸릴 수 있거든요). 이를 위해 모델과 배치를 배치할 device를 정의하겠습니다.

import torch

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
device
device(type='cuda')

이제 훈련할 준비가 모두 끝났습니다! 훈련 진행 상황을 확인할 수 있도록 tqdm 라이브러리를 사용해서 진행률 표시줄을 추가해보겠습니다.

from tqdm.auto import tqdm

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

💡 최신 훈련 최적화: 훈련 루프를 더욱 효율적으로 만들려면 다음을 고려하세요.

🔧 구현 가이드: 이러한 최적화의 자세한 예제는 🤗 Transformers 효율적인 훈련 가이드다양한 옵티마이저를 참조하세요.

보시다시피 훈련 루프의 핵심 구조는 소개 부분에서 봤던 것과 매우 유사합니다. 하지만 현재 상태로는 모델의 성능에 대한 정보를 전혀 얻을 수 없습니다. 평가 기능을 요청하지 않았기 때문이죠. 이 문제를 해결하기 위해 평가 루프를 추가해야 합니다.

평가 루프

이전과 마찬가지로 🤗 Evaluate 라이브러리에서 제공하는 메트릭을 사용하겠습니다. metric.compute() 메서드는 이미 알고 계시죠. 하지만 메트릭에는 또 다른 유용한 기능이 있습니다. add_batch() 메서드를 사용해서 예측 루프를 진행하면서 배치별로 결과를 누적할 수 있습니다. 모든 배치를 처리한 후에 metric.compute()를 호출하면 최종 결과를 얻을 수 있습니다. 평가 루프에서 이를 구현하는 방법을 살펴보겠습니다.

📊 평가 모범 사례: 더 정교한 평가 전략과 메트릭에 대해서는 🤗 Evaluate 문서평가 실무 가이드를 살펴보세요.

import evaluate

metric = evaluate.load("glue", "mrpc")
model.eval()
for batch in eval_dataloader:
    batch = {k: v.to(device) for k, v in batch.items()}
    with torch.no_grad():
        outputs = model(**batch)

    logits = outputs.logits
    predictions = torch.argmax(logits, dim=-1)
    metric.add_batch(predictions=predictions, references=batch["labels"])

metric.compute()
{'accuracy': 0.8431372549019608, 'f1': 0.8907849829351535}

다시 말하지만, 모델 헤드 초기화의 무작위성과 데이터 셔플링으로 인해 결과가 약간 다를 수 있지만 같은 수준이어야 합니다.

✏️ 직접 해보세요! 이전 훈련 루프를 수정하여 SST-2 데이터셋에서 모델을 미세 조정해보세요.

🤗 Accelerate로 훈련 루프 강화하기

앞서 정의한 훈련 루프는 단일 CPU 또는 GPU에서 잘 작동합니다. 하지만 🤗 Accelerate 라이브러리를 사용하면 몇 가지 조정만으로 여러 GPU 또는 TPU에서 분산 훈련을 활성화할 수 있습니다. 🤗 Accelerate는 분산 훈련, 혼합 정밀도, 장치 배치의 복잡성을 자동으로 처리합니다. 훈련 및 검증 데이터로더 생성부터 시작하여 수동 훈련 루프는 다음과 같습니다.

Accelerate 심화: 분산 훈련, 혼합 정밀도, 하드웨어 최적화에 대한 모든 것을 🤗 Accelerate 문서에서 알아보고 transformers 문서에서 실용적인 예제를 살펴보세요.

from accelerate import Accelerator
from torch.optim import AdamW
from transformers import AutoModelForSequenceClassification, get_scheduler

accelerator = Accelerator()

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)

train_dl, eval_dl, model, optimizer = accelerator.prepare(
    train_dataloader, eval_dataloader, model, optimizer
)

num_epochs = 3
num_training_steps = num_epochs * len(train_dl)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dl:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

추가할 첫 번째 줄은 import 줄입니다. 두 번째 줄은 환경을 살펴보고 적절한 분산 설정을 초기화하는 Accelerator 객체를 인스턴스화합니다. 🤗 Accelerate는 장치 배치를 처리하므로 모델을 장치에 올리는 줄을 제거할 수 있습니다(또는 원한다면 device 대신 accelerator.device를 사용하도록 변경할 수 있습니다).

그런 다음 주요 작업은 데이터로더, 모델, 옵티마이저를 accelerator.prepare()에 보내는 줄에서 수행됩니다. 이는 분산 훈련이 의도한 대로 작동하도록 적절한 컨테이너에서 해당 객체들을 래핑합니다. 수행해야 할 나머지 변경 사항은 배치를 device에 올리는 줄을 제거하고(다시, 유지하고 싶다면 accelerator.device를 사용하도록 변경하기만 하면 됩니다) loss.backward()accelerator.backward(loss)로 바꾸는 것입니다.

⚠️ Cloud TPU가 제공하는 속도 향상의 이점을 얻으려면 토크나이저의 `padding="max_length"` 및 `max_length` 인수로 샘플을 고정 길이로 패딩하는 것을 권장합니다.

복사해서 가지고 놀고 싶다면 🤗 Accelerate를 사용한 완전한 훈련 루프는 다음과 같습니다.

from accelerate import Accelerator
from torch.optim import AdamW
from transformers import AutoModelForSequenceClassification, get_scheduler

accelerator = Accelerator()

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)

train_dl, eval_dl, model, optimizer = accelerator.prepare(
    train_dataloader, eval_dataloader, model, optimizer
)

num_epochs = 3
num_training_steps = num_epochs * len(train_dl)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dl:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

이것을 train.py 스크립트에 넣으면 모든 종류의 분산 설정에서 실행할 수 있는 스크립트가 됩니다. 분산 설정에서 시도해보려면 다음 명령을 실행하세요.

accelerate config

이 명령은 몇 가지 질문에 답하라는 메시지를 표시하고 다음 명령에서 사용되는 구성 파일에 답변을 덤프합니다.

accelerate launch train.py

이 명령이 분산 훈련을 시작합니다.

노트북에서 이를 시도하고 싶다면(예: Colab에서 TPU로 테스트하기 위해) 코드를 training_function()에 붙여넣고 다음과 함께 마지막 셀을 실행하기만 하면 됩니다.

from accelerate import notebook_launcher

notebook_launcher(training_function)

🤗 Accelerate 리포지토리에서 더 많은 예제를 찾을 수 있습니다.

🌐 분산 훈련: 다중 GPU 및 다중 노드 훈련에 대한 포괄적인 내용은 🤗 Transformers 분산 훈련 가이드훈련 확장 쿡북을 확인하세요.

다음 단계와 모범 사례

이제 처음부터 훈련을 구현하는 방법을 배웠으므로 프로덕션 사용을 위한 몇 가지 추가 고려사항이 있습니다.

모델 평가: 정확도뿐만 아니라 여러 메트릭에서 항상 모델을 평가하세요. 포괄적인 평가를 위해 🤗 Evaluate 라이브러리를 사용하세요.

하이퍼파라미터 튜닝: 체계적인 하이퍼파라미터 최적화를 위해 Optuna 또는 Ray Tune과 같은 라이브러리 사용을 고려하세요.

모델 모니터링: 훈련 전반에 걸쳐 훈련 메트릭, 학습 곡선, 검증 성능을 추적하세요.

모델 공유: 훈련이 완료되면 커뮤니티에서 사용할 수 있도록 Hugging Face Hub에서 모델을 공유하세요.

효율성: 대형 모델의 경우 그래디언트 체크포인팅, 매개변수 효율적인 미세 조정(LoRA, AdaLoRA), 양자화 방법과 같은 기술을 고려하세요.

이것으로 커스텀 훈련 루프를 사용한 미세 조정에 대한 심화 과정을 마칩니다. 여기서 배운 기술들은 훈련 프로세스에 대한 완전한 제어가 필요하거나 Trainer API가 제공하는 것을 넘어서는 커스텀 훈련 로직을 구현하고자 할 때 도움이 될 것입니다.

섹션 퀴즈

커스텀 훈련 루프와 고급 훈련 기법에 대한 이해를 테스트해보세요.

1. Adam과 AdamW 옵티마이저의 주요 차이점은 무엇인가요?

2. 훈련 루프에서 올바른 연산 순서는 무엇인가요?

3. 🤗 Accelerate 라이브러리는 주로 무엇을 도와주나요?

4. 훈련 루프에서 배치를 장치로 이동하는 이유는 무엇인가요?

5. 평가 전에 model.eval() 은 무엇을 하나요?

6. 평가 중 torch.no_grad() 의 목적은 무엇인가요?

7. 훈련 루프에서 🤗 Accelerate를 사용할 때 무엇이 변경되나요?

💡 핵심 요점:

< > Update on GitHub