[ํ์ด์ฌ] ๋ ธ๋ต ๋์์ด๋์ ์ฝ๋ฉ ๋ฐฐ์ฐ๊ธฐ - LLM ๊ธฐ๋ฐ ํ๋ก์ ํธ (์ด์ฌ์ ๊ฐ๋ ์ ๋ฆฌ)
์์งํ mps๋ .to(device)๋ ํ ํฌ๋์ด์ ๋ฑ๋ฑ ๋ชจ๋ฅด๋ ๋จ์ด๊ฐ ๋๋ฌด ๋ง์์ overwhelmed ๋๋ ๊ฒ ๊ฐ์ ์ด๋ ค์ค ๐ญ
๐ญ ์์ ๊ณต๊ฐ… ๋๋ฌด ๋ง์ ๊ฐ๋ ์ด ํ๊บผ๋ฒ์ ์์์ง๋ฉด ๋ฉ๋ถ ์ค๋ ๊ฑฐ ์ง์ง ๋น์ฐํ ๊ฑฐ์ผ!
๐ ์ง๊ธ ๊ฐ์ฅ ์ค์ํ ๊ฑด “์ ์ฒด ๊ฐ๋ ์ ์ก๊ณ , ํ๋์ฉ ์ตํ๋ ๊ฒ!”
๐ ๋๋ฌด ๊ธํ๊ฒ ๋ค ์ดํดํ๋ ค๊ณ ํ์ง ๋ง๊ณ , ์ฒ์ฒํ ํต์ฌ ๊ฐ๋ ๋ถํฐ ์ตํ๋ฉด ๋ผ! ๐๐ฅ
๐ฅ LLM ๋ชจ๋ธ ์ฝ๋ฉ์์ ๊ผญ ์์์ผ ํ ๊ฐ๋ 5๊ฐ์ง (์ด์ฌ์์ฉ ๊ฐ๋ ์ ๋ฆฌ!)
๐ก ์ง๊ธ ๋ค๊ฐ ๊ฒช๊ณ ์๋ MPS, to(device), ํ ํฌ๋์ด์ ๊ฐ์ ๊ฐ๋ ๋ค์ ์ฝ๊ฒ ์ ๋ฆฌํด์ค๊ฒ!
๐ก ์ด 5๊ฐ์ง๋ง ์๋ฉด, ๋๋จธ์ง๋ ์์ฐ์ค๋ฝ๊ฒ ์ดํด๋ ๊ฑฐ์ผ!
1๏ธโฃ MPS → Mac์์ GPU๋ฅผ ์ฐ๋ ๋ฐฉ๋ฒ!
โ
**MPS(Metal Performance Shaders)**๋ Mac์์ GPU ๊ฐ์์ ์ฌ์ฉํ ์ ์๋๋ก ํด์ฃผ๋ ๊ธฐ๋ฅ!
โ
Windows์ CUDA(์๋น๋์ GPU) ๋์ , Mac์์๋ MPS๋ฅผ ์ฌ์ฉํด์ผ ํจ!
๐ ์ฝ๊ฒ ๋งํ๋ฉด?
โ Windows์์๋ cuda๋ฅผ ์จ์ผ ํ๊ณ ,
โ Mac์์๋ mps๋ฅผ ์จ์ผ GPU ๊ฐ์์ ์ฌ์ฉํ ์ ์์!
๐ ์ฝ๋ ์์
import torch
device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
print(device) # "mps" ๋๋ "cpu" ์ถ๋ ฅ๋จ!
๐ ์ด์ Mac์์ MPS๊ฐ ์ง์๋๋ฉด ์๋์ผ๋ก GPU ์ฌ์ฉ! ๐๐ฅ
2๏ธโฃ to(device) → ๋ฐ์ดํฐ๋ฅผ GPU๋ก ๋ณด๋ด๋ ๋ฐฉ๋ฒ!
โ to(device)๋ ๋ชจ๋ธ๊ณผ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ์ฅ์น(GPU/CPU)์์ ์ฐ์ฐํ๋๋ก ํด์ฃผ๋ ํจ์!
๐ ์ ํ์ํ ๊น?
๐ฅ ๋ชจ๋ธ์ด GPU(mps)์ ์๋๋ฐ, ์ ๋ ฅ ๋ฐ์ดํฐ๊ฐ CPU์ ์์ผ๋ฉด ์ถฉ๋(์๋ฌ) ๋ฐ์!
๐ฅ ๊ทธ๋์ ๋ชจ๋ธ๊ณผ ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ๊ณณ(GPU/CPU)์ผ๋ก ๋ณด๋ด์ผ ํจ!
๐ ์ฝ๋ ์์
model.to(device) # ๋ชจ๋ธ์ GPU(MPS)๋ก ์ด๋!
inputs = tokenizer("์๋
ํ์ธ์", return_tensors="pt").to(device) # ๋ฐ์ดํฐ๋ GPU๋ก ์ด๋!
๐ฅ ์ด์ ๋ชจ๋ธ๊ณผ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ ์ฅ์น์์ ์คํ๋จ! (์๋ฌ ๋ฐฉ์ง!)
3๏ธโฃ ํ ํฌ๋์ด์ (Tokenization) → ํ ์คํธ๋ฅผ ์ซ์๋ก ๋ณํํ๋ ๊ณผ์ !
โ LLM ๋ชจ๋ธ์ ํ ์คํธ๋ฅผ ์ดํด ๋ชป ํ๊ณ , ์ซ์๋ง ์ดํดํจ!
โ ๊ทธ๋์ ํ ํฌ๋์ด์ (tokenizer)๋ฅผ ์ฌ์ฉํด์ ๋ฌธ์ฅ์ ์ซ์๋ก ๋ณํํด์ผ ํจ!
๐ ์ฝ๋ ์์
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("beomi/kcbert-base") # ํ๊ตญ์ด ์ ์ฉ ํ ํฌ๋์ด์ !
tokens = tokenizer.tokenize("์๋
ํ์ธ์!")
print(tokens) # ['์', '##๋
', '##ํ์ธ์', '!']
๐ฅ ์ฆ, ํ ํฌ๋์ด์ ๋ ๋ฌธ์ฅ์ ์์ ์กฐ๊ฐ(ํ ํฐ)์ผ๋ก ๋๋๊ณ ์ซ์๋ก ๋ณํํด์ค! ๐
4๏ธโฃ AutoModelForMaskedLM → ๋ง์คํฌ(MASK)๋ ๋จ์ด๋ฅผ ์์ธกํ๋ ๋ชจ๋ธ!
โ AutoModelForMaskedLM์ ๋ฌธ์ฅ์์ ๊ฐ๋ ค์ง [MASK] ๋จ์ด๋ฅผ ๋ง์ถ๋ ๋ชจ๋ธ!
โ BERT ๊ฐ์ ๋ชจ๋ธ์ด ์ด๋ฐ Masked Language Modeling(MLM) ๊ธฐ๋ฅ์ ๊ฐ์ง.
๐ ์ฝ๋ ์์
from transformers import AutoModelForMaskedLM
model = AutoModelForMaskedLM.from_pretrained("beomi/kcbert-base")
๐ฅ ์ด์ ๋๋ [MASK]๋ฅผ ์ข์ํด ๊ฐ์ ๋ฌธ์ฅ์ ์ฃผ๋ฉด, AI๊ฐ [MASK]์ ๋ค์ด๊ฐ ๋จ์ด๋ฅผ ์์ธกํด์ค!
5๏ธโฃ torch.argmax() → ๊ฐ์ฅ ํ๋ฅ ๋์ ๋จ์ด ์ฐพ๊ธฐ!
โ torch.argmax()๋ AI๊ฐ ์์ธกํ ๊ฒฐ๊ณผ ์ค์์ ๊ฐ์ฅ ํ๋ฅ ๋์ ๋จ์ด๋ฅผ ์ ํํ๋ ํจ์!
๐ ์ฝ๋ ์์
import torch
predictions = torch.tensor([[0.1, 0.3, 0.8, 0.2]]) # ์์ธก ํ๋ฅ ๊ฐ๋ค
best_index = torch.argmax(predictions, dim=-1) # ๊ฐ์ฅ ๋์ ํ๋ฅ ๊ฐ์ ์์น ์ฐพ๊ธฐ
print(best_index) # ์ถ๋ ฅ: tensor([2]) (๊ฐ์ฅ ํ๋ฅ ๋์ ์ธ๋ฑ์ค)
๐ฅ ์ฆ, torch.argmax()๋ “์ด ์ค์์ ๊ฐ์ฅ ํ๋ฅ ๋์ ๊ฑฐ ๊ณจ๋ผ์ค!” ๋ผ๊ณ ํ ๋ ์! ๐๐ฅ
๐ฅ ๊ฒฐ๋ก : ์ด 5๊ฐ์ง๋ง ๊ธฐ์ตํ๋ฉด ๋!
๊ฐ๋ | ์ค๋ช |
1๏ธโฃ MPS | Mac์์ GPU ๊ฐ์์ ์ฌ์ฉํ๋ ๊ธฐ๋ฅ (Windows๋ CUDA) |
2๏ธโฃ to(device) | ๋ชจ๋ธ๊ณผ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ์ฅ์น(GPU/CPU)์์ ์คํํ๋๋ก ๋ง์ถ๊ธฐ |
3๏ธโฃ ํ ํฌ๋์ด์ | ๋ฌธ์ฅ์ ์ซ์๋ก ๋ณํํ๋ ๋๊ตฌ |
4๏ธโฃ AutoModelForMaskedLM | [MASK] ๋ถ๋ถ์ ์์ธกํ๋ ๋ชจ๋ธ (BERT ๊ธฐ๋ฐ) |
5๏ธโฃ torch.argmax() | ๊ฐ์ฅ ํ๋ฅ ๋์ ์์ธก ๊ฒฐ๊ณผ๋ฅผ ์ ํํ๋ ํจ์ |
๐ฅ ์ด์ ํ๋์ฉ ๊ฐ๋ ์ ์ดํดํ๋ฉด์ ์ฒ์ฒํ ์งํํ๋ฉด ๋ผ!
๐ฅ ๋๋ฌด ๋ถ๋ด ๊ฐ์ง ๋ง๊ณ , “์ดํด ์ ๊ฐ๋ฉด ๋ฌผ์ด๋ณด๋ฉด ๋๋ค!” ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ!