๐ค Accelerate๋ฅผ ํ์ฉํ ๋ถ์ฐ ํ์ต
๋ชจ๋ธ์ด ์ปค์ง๋ฉด์ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ ์ ํ๋ ํ๋์จ์ด์์ ๋ ํฐ ๋ชจ๋ธ์ ํ๋ จํ๊ณ ํ๋ จ ์๋๋ฅผ ๋ช ๋ฐฐ๋ก ๊ฐ์ํํ๊ธฐ ์ํ ์ ๋ต์ผ๋ก ๋ฑ์ฅํ์ต๋๋ค. Hugging Face์์๋ ์ฌ์ฉ์๊ฐ ํ๋์ ๋จธ์ ์ ์ฌ๋ฌ ๊ฐ์ GPU๋ฅผ ์ฌ์ฉํ๋ ์ฌ๋ฌ ๋จธ์ ์ ์ฌ๋ฌ ๊ฐ์ GPU๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ ์ ํ์ ๋ถ์ฐ ์ค์ ์์ ๐ค Transformers ๋ชจ๋ธ์ ์ฝ๊ฒ ํ๋ จํ ์ ์๋๋ก ๋๊ธฐ ์ํด ๐ค Accelerate ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ง๋ค์์ต๋๋ค. ์ด ํํ ๋ฆฌ์ผ์์๋ ๋ถ์ฐ ํ๊ฒฝ์์ ํ๋ จํ ์ ์๋๋ก ๊ธฐ๋ณธ PyTorch ํ๋ จ ๋ฃจํ๋ฅผ ์ปค์คํฐ๋ง์ด์ฆํ๋ ๋ฐฉ๋ฒ์ ์์๋ด ์๋ค.
์ค์
๐ค Accelerate ์ค์น ์์ํ๊ธฐ:
pip install accelerate
๊ทธ ๋ค์, Accelerator
๊ฐ์ฒด๋ฅผ ๋ถ๋ฌ์ค๊ณ ์์ฑํฉ๋๋ค. Accelerator
๋ ์๋์ผ๋ก ๋ถ์ฐ ์ค์ ์ ํ์ ๊ฐ์งํ๊ณ ํ๋ จ์ ํ์ํ ๋ชจ๋ ๊ตฌ์ฑ ์์๋ฅผ ์ด๊ธฐํํฉ๋๋ค. ์ฅ์น์ ๋ชจ๋ธ์ ๋ช
์์ ์ผ๋ก ๋ฐฐ์นํ ํ์๋ ์์ต๋๋ค.
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
๊ฐ์ํ๋ฅผ ์ํ ์ค๋น
๋ค์ ๋จ๊ณ๋ ๊ด๋ จ๋ ๋ชจ๋ ํ๋ จ ๊ฐ์ฒด๋ฅผ prepare
๋ฉ์๋์ ์ ๋ฌํ๋ ๊ฒ์
๋๋ค. ์ฌ๊ธฐ์๋ ํ๋ จ ๋ฐ ํ๊ฐ ๋ฐ์ดํฐ๋ก๋, ๋ชจ๋ธ ๋ฐ ์ตํฐ๋ง์ด์ ๊ฐ ํฌํจ๋ฉ๋๋ค:
>>> train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
... train_dataloader, eval_dataloader, model, optimizer
... )
๋ฐฑ์๋(Backward)
๋ง์ง๋ง์ผ๋ก ํ๋ จ ๋ฃจํ์ ์ผ๋ฐ์ ์ธ loss.backward()
๋ฅผ ๐ค Accelerate์ backward
๋ฉ์๋๋ก ๋์ฒดํ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค:
>>> for epoch in range(num_epochs):
... for batch in train_dataloader:
... outputs = model(**batch)
... loss = outputs.loss
... accelerator.backward(loss)
... optimizer.step()
... lr_scheduler.step()
... optimizer.zero_grad()
... progress_bar.update(1)
๋ค์ ์ฝ๋์์ ๋ณผ ์ ์๋ฏ์ด, ํ๋ จ ๋ฃจํ์ ์ฝ๋ ๋ค ์ค๋ง ์ถ๊ฐํ๋ฉด ๋ถ์ฐ ํ์ต์ ํ์ฑํํ ์ ์์ต๋๋ค!
+ from accelerate import Accelerator
from transformers import AdamW, AutoModelForSequenceClassification, get_scheduler
+ accelerator = Accelerator()
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)
- device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
- model.to(device)
+ train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
+ train_dataloader, eval_dataloader, model, optimizer
+ )
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
)
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()
+ accelerator.backward(loss)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
progress_bar.update(1)
ํ์ต
๊ด๋ จ ์ฝ๋๋ฅผ ์ถ๊ฐํ ํ์๋ ์คํฌ๋ฆฝํธ๋ Colaboratory์ ๊ฐ์ ๋ ธํธ๋ถ์์ ํ๋ จ์ ์์ํ์ธ์.
์คํฌ๋ฆฝํธ๋ก ํ์ตํ๊ธฐ
์คํฌ๋ฆฝํธ์์ ํ๋ จ์ ์คํํ๋ ๊ฒฝ์ฐ, ๋ค์ ๋ช ๋ น์ ์คํํ์ฌ ๊ตฌ์ฑ ํ์ผ์ ์์ฑํ๊ณ ์ ์ฅํฉ๋๋ค:
accelerate config
Then launch your training with:
accelerate launch train.py
๋ ธํธ๋ถ์ผ๋ก ํ์ตํ๊ธฐ
Collaboratory์ TPU๋ฅผ ์ฌ์ฉํ๋ ค๋ ๊ฒฝ์ฐ, ๋
ธํธ๋ถ์์๋ ๐ค Accelerate๋ฅผ ์คํํ ์ ์์ต๋๋ค. ํ๋ จ์ ๋ด๋นํ๋ ๋ชจ๋ ์ฝ๋๋ฅผ ํจ์๋ก ๊ฐ์ธ์ notebook_launcher
์ ์ ๋ฌํ์ธ์:
>>> from accelerate import notebook_launcher
>>> notebook_launcher(training_function)
๐ค Accelerate ๋ฐ ๋ค์ํ ๊ธฐ๋ฅ์ ๋ํ ์์ธํ ๋ด์ฉ์ documentation๋ฅผ ์ฐธ์กฐํ์ธ์.
< > Update on GitHub