31 KiB
์ฉ์ด์ง(Glossary)
์ด ์ฉ์ด์ง์ ์ ๋ฐ์ ์ธ ๋จธ์ ๋ฌ๋ ๋ฐ ๐ค Transformers ๊ด๋ จ ์ฉ์ด๋ฅผ ์ ์ํ์ฌ ๋ฌธ์๋ฅผ ๋ ์ ์ดํดํ๋ ๋ฐ ๋์์ ์ค๋๋ค.
A
์ดํ ์ ๋ง์คํฌ (attention mask)
์ดํ ์ ๋ง์คํฌ(attention mask)๋ ์ฌ๋ฌ ์ํ์ค๋ฅผ ๋ฐฐ์น(batch)๋ก ์ฒ๋ฆฌํ ๋ ์ฌ์ฉ๋๋ ์ ํ์ ์ธ์์ ๋๋ค.
์ด ์ธ์๋ ๋ชจ๋ธ์๊ฒ ์ด๋ค ํ ํฐ์ ์ฃผ์๋ฅผ ๊ธฐ์ธ์ฌ์ผ ํ๋์ง, ๊ทธ๋ฆฌ๊ณ ์ด๋ค ํ ํฐ์ ๋ฌด์ํด์ผ ํ๋์ง๋ฅผ ์๋ ค์ค๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์ ๋ ๊ฐ์ ์ํ์ค๊ฐ ์๋ค๊ณ ๊ฐ์ ํด ๋ด ์๋ค:
>>> from transformers import BertTokenizer
>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> sequence_a = "This is a short sequence."
>>> sequence_b = "This is a rather long sequence. It is at least longer than the sequence A."
>>> encoded_sequence_a = tokenizer(sequence_a)["input_ids"]
>>> encoded_sequence_b = tokenizer(sequence_b)["input_ids"]
์ธ์ฝ๋ฉ๋ ๋ฒ์ ๋ค์ ๊ธธ์ด๊ฐ ๋ค๋ฆ ๋๋ค:
>>> len(encoded_sequence_a), len(encoded_sequence_b)
(8, 19)
๋ฐ๋ผ์ ์ด ๋ ์ํ์ค๋ฅผ ๊ทธ๋๋ก ํ๋์ ํ ์์ ๋ฃ์ ์๋ ์์ต๋๋ค. ์ฒซ ๋ฒ์งธ ์ํ์ค๋ฅผ ๋ ๋ฒ์งธ ๊ธธ์ด์ ๋ง์ถฐ ํจ๋ฉ ํ๊ฑฐ๋, ๋ฐ๋๋ก ๋ ๋ฒ์งธ ์ํ์ค๋ฅผ ์ฒซ ๋ฒ์งธ ๊ธธ์ด์ ๋ง์ถฐ ์๋ผ๋ด์ผ ํฉ๋๋ค.
์ฒซ ๋ฒ์งธ ๊ฒฝ์ฐ์๋ ID ๋ชฉ๋ก์ด ํจ๋ฉ ์ธ๋ฑ์ค๋ก ํ์ฅ๋ฉ๋๋ค. ์ด๋ ๊ฒ ํจ๋ฉ์ ์ ์ฉํ๋ ค๋ฉด ํ ํฌ๋์ด์ ์ ๋ฆฌ์คํธ๋ฅผ ์ ๋ฌํ๊ณ ๋ค์๊ณผ ๊ฐ์ด ์์ฒญํ ์ ์์ต๋๋ค:
>>> padded_sequences = tokenizer([sequence_a, sequence_b], padding=True)
์ฒซ ๋ฒ์งธ ๋ฌธ์ฅ ์ค๋ฅธ์ชฝ์ 0์ด ์ถ๊ฐ๋์ด ๋ ๋ฒ์งธ ๋ฌธ์ฅ๊ณผ ๊ธธ์ด๊ฐ ๊ฐ์์ง ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค:
>>> padded_sequences["input_ids"]
[[101, 1188, 1110, 170, 1603, 4954, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [101, 1188, 1110, 170, 1897, 1263, 4954, 119, 1135, 1110, 1120, 1655, 2039, 1190, 1103, 4954, 138, 119, 102]]
์ด๊ฒ์ PyTorch๋ TensorFlow์ ํ
์๋ก ๋ณํ๋ ์ ์์ต๋๋ค. ์ดํ
์
๋ง์คํฌ๋ ๋ชจ๋ธ์ด ํจ๋ฉ ๋ ์ธ๋ฑ์ค๋ฅผ ์ฐธ์กฐํ์ง ์๋๋ก ํด๋น ์์น๋ฅผ ๋ํ๋ด๋ ์ด์ง ํ
์์
๋๋ค. [BertTokenizer]์ ๊ฒฝ์ฐ, 1์ ์ดํ
์
์ด ํ์ํ ๊ฐ์ ๋ํ๋ด๊ณ , 0์ ํจ๋ฉ ๋ ๊ฐ์ ๋ํ๋
๋๋ค. ์ด ์ดํ
์
๋ง์คํฌ๋ ํ ํฌ๋์ด์ ๊ฐ ๋ฐํ๋๋ ๋์
๋๋ฆฌ์ "attention_mask" ํค ์๋์ ํฌํจ๋์ด ์์ต๋๋ค:
>>> padded_sequences["attention_mask"]
[[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
์คํ ์ธ์ฝ๋ฉ ๋ชจ๋ธ (autoencoding models)
์ธ์ฝ๋ ๋ชจ๋ธ๊ณผ ๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง์ ์ฐธ๊ณ ํ์ธ์.
์๊ธฐํ๊ท ๋ชจ๋ธ (autoregressive models)
์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ๋ง๊ณผ ๋์ฝ๋ ๋ชจ๋ธ์ ์ฐธ๊ณ ํ์ธ์.
B
๋ฐฑ๋ณธ (backbone)
๋ฐฑ๋ณธ(backbone)์ ์์(hidden) ์๋ ์ํ(hidden state) ๋๋ ํน์ง(feature)์ ์ถ๋ ฅํ๋ ๋คํธ์ํฌ(์๋ฒ ๋ฉ๊ณผ ๋ ์ด์ด)์
๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด ๋ฐฑ๋ณธ์ ํด๋น ํน์ง์ ์
๋ ฅ์ผ๋ก ๋ฐ์ ์์ธก์ ์ํํ๋ ํค๋์ ์ฐ๊ฒฐ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, [ViTModel]์ ํน์ ํค๋๊ฐ ์๋ ๋ฐฑ๋ณธ์
๋๋ค. ๋ค๋ฅธ ๋ชจ๋ธ๋ค๋[VitModel]์ ๋ฐฑ๋ณธ์ผ๋ก ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, DPT๋ฑ์ด ๊ทธ ์์์
๋๋ค.
C
์ธ๊ณผ์ ์ธ์ด ๋ชจ๋ธ๋ง (causal language modeling)
๋ชจ๋ธ์ด ํ ์คํธ๋ฅผ ์์๋๋ก ์ฝ์ผ๋ฉฐ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํด์ผ ํ๋ ์ฌ์ ํ์ต(pretraining) ์์ ์ ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ๋ฌธ์ฅ์ ์ ์ฒด๋ก ์ฝ๋, ๋ชจ๋ธ ๋ด๋ถ์์ ํน์ง ์์ ์ดํ์ ํ ํฐ์ ๋ง์คํน(masking)ํ์ฌ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ๊ฒ ๋ฉ๋๋ค.
์ฑ๋ (channel)
์ปฌ๋ฌ ์ด๋ฏธ์ง๋ ๋นจ๊ฐ์(R), ์ด๋ก์(G), ํ๋์(B)์ ์ธ ์ฑ๋ ๊ฐ์ ์กฐํฉํ์ฌ ๊ตฌ์ฑ๋๋ฉฐ, ํ๋ฐฑ ์ด๋ฏธ์ง๋ ๋จ์ผ ์ฑ๋๋ง์ ๊ฐ์ง๋๋ค. ๐ค Transformers์์๋ ์ด๋ฏธ์ง ํ
์์ ์ฑ๋์ด ์ฒซ ๋ฒ์งธ ๋๋ ๋ง์ง๋ง ์ฐจ์์ ์์นํ ์ ์์ต๋๋ค:[n_channels, height, width] ๋๋ [height, width, n_channels]์ ๊ฐ์ ํ์์
๋๋ค.
์ฐ๊ฒฐ ์๊ฐ๋ถ๋ฅ(connectionist temporal classification, CTC)
์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ ๋ ฌ ์ํ๋ฅผ ์ ํํ ๋ชฐ๋ผ๋ ๋ชจ๋ธ์ด ํ์ตํ ์ ์๋๋ก ๋๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. CTC๋ ์ฃผ์ด์ง ์ ๋ ฅ์ ๋ํด ๊ฐ๋ฅํ ๋ชจ๋ ์ถ๋ ฅ์ ํ๋ฅ ๋ถํฌ๋ฅผ ๊ณ์ฐํ๊ณ , ๊ทธ์ค ๊ฐ์ฅ ๊ฐ๋ฅ์ฑ์ด ๋์ ์ถ๋ ฅ์ ์ ํํฉ๋๋ค. CTC๋ ๋งํ๋ ์๋์ ์ฐจ์ด ๋ฑ ์ฌ๋ฌ ์ด์ ๋ก ์์ฑ๊ณผ ํ ์คํธ๊ฐ ํญ์ ์ ํํ๊ฒ ์ผ์นํ์ง ์๊ธฐ ๋๋ฌธ์ ์์ฑ ์ธ์ ์์ ์์ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค.
์ปจ๋ณผ๋ฃจ์ (convolution)
์ ๊ฒฝ๋ง์์ ์ฌ์ฉ๋๋ ๋ ์ด์ด์ ํ ์ข ๋ฅ๋ก, ์ ๋ ฅ ํ๋ ฌ์ ๋ํด ๋ ์์ ํ๋ ฌ(์ปค๋ ๋๋ ํํฐ)์ ์์๋ณ๋ก ๊ณฑํ ๋ค ๊ทธ ๊ฐ์ ํฉ์ฐํด ์๋ก์ด ํ๋ ฌ์ ๋ง๋๋ ์ฐ์ฐ์ ๋๋ค. ์ด ์ฐ์ฐ์ ์ปจ๋ณผ๋ฃจ์ ์ฐ์ฐ์ด๋ผ๊ณ ํ๋ฉฐ, ์ ๋ ฅ ํ๋ ฌ ์ ์ฒด์ ๊ฑธ์ณ ๋ฐ๋ณต์ ์ผ๋ก ์ํ๋ฉ๋๋ค. ๊ฐ ์ฐ์ฐ์ ์ ๋ ฅ ํ๋ ฌ์ ์๋ก ๋ค๋ฅธ ๊ตฌ๊ฐ์ ์ ์ฉ๋ฉ๋๋ค. ์ปจ๋ณผ๋ฃจ์ ์ ๊ฒฝ๋ง(CNN)์ ์ปดํจํฐ ๋น์ ๋ถ์ผ์์ ๋๋ฆฌ ์ฌ์ฉ๋ฉ๋๋ค.
D
๋ฐ์ดํฐ ๋ณ๋ ฌํ (DataParallel)
์ฌ๋ฌ ๊ฐ์ GPU์์ ํ๋ จ์ ์ํํ ๋ ์ฌ์ฉํ๋ ๋ณ๋ ฌํ ๊ธฐ๋ฒ์ผ๋ก, ๋์ผํ ๋ชจ๋ธ ๊ตฌ์ฑ์ด ์ฌ๋ฌ ๋ฒ ๋ณต์ ๋๋ฉฐ ๊ฐ ์ธ์คํด์ค๋ ์๋ก ๋ค๋ฅธ ๋ฐ์ดํฐ ์กฐ๊ฐ์ ๋ฐ์ต๋๋ค. ๋ชจ๋ ์ธ์คํด์ค๋ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌ๋ฅผ ์ํํ๋ฉฐ, ๊ฐ ํ๋ จ ๋จ๊ณ๊ฐ ๋๋ ํ ๊ฒฐ๊ณผ๋ฅผ ๋๊ธฐํํฉ๋๋ค.
DataParallel ๋ฐฉ์์ ๋ํด ๋ ์์๋ณด๋ ค๋ฉด ์ฌ๊ธฐ๋ฅผ ์ฐธ๊ณ ํ์ธ์.
๋์ฝ๋ ์ ๋ ฅ ID (decoder input IDs)
์ด ์ ๋ ฅ์ ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ์ ํนํ๋ ๊ฒ์ผ๋ก, ๋์ฝ๋์ ์ ๋ฌ๋ input ID ๋ค์ ํฌํจํฉ๋๋ค. ์ด๋ฌํ ์ ๋ ฅ์ ๋ฒ์ญ์ด๋ ์์ฝ๊ณผ ๊ฐ์ ์ํ์ค-ํฌ-์ํ์ค(sequence-to-sequence) ์์ ์ ์ฌ์ฉ๋๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ๋ง๋ค ๊ณ ์ ํ ๋ฐฉ์์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
๋๋ถ๋ถ์ ์ธ์ฝ๋-๋์ฝ๋ ๋ชจ๋ธ(BART, T5 ๋ฑ)์ labels๋ก๋ถํฐ ์๋์ผ๋ก decoder_input_ids๋ฅผ ์์ฑํฉ๋๋ค. ์ด๋ฌํ ๋ชจ๋ธ์์๋ ํ์ต ์ labels๋ฅผ ์ ๋ฌํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ผ๋ก ๊ถ์ฅ๋ฉ๋๋ค.
์ํ์ค-ํฌ-์ํ์ค ํ์ต์์ ๊ฐ ๋ชจ๋ธ์ด ์ด๋ฌํ input ID๋ฅผ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ๋์ง๋ ๋ชจ๋ธ ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
๋์ฝ๋ ๋ชจ๋ธ (decoder models)
์๊ธฐํ๊ท ๋ชจ๋ธ(Autoregressive models)์ด๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ ๋์ฝ๋ ๋ชจ๋ธ์ ์ธ๊ณผ ์ธ์ด ๋ชจ๋ธ๋ง(causal language modeling)์ด๋ผ ๋ถ๋ฆฌ๋ ์ฌ์ ํ์ต ์์ ์ ์ํํฉ๋๋ค. ์ด ์์ ์์๋ ๋ชจ๋ธ์ด ํ ์คํธ๋ฅผ ์์๋๋ก ์ฝ๊ณ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํด์ผ ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ๋ฌธ์ฅ์ ์ ์ฒด๋ฅผ ์ฝ๋, ํน์ ์์ ์ดํ์ ํ ํฐ์ ๋ง์คํฌ๋ก ๊ฐ๋ ค ์์ธกํ๊ฒ ํฉ๋๋ค.
๋ฅ๋ฌ๋ (deep learning)
์ฌ๋ฌ ์ธต์ ์ ๊ฒฝ๋ง(neural network)์ ์ฌ์ฉํ๋ ๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
E
์ธ์ฝ๋ ๋ชจ๋ธ (encoder models)
์๋ ์ธ์ฝ๋ฉ ๋ชจ๋ธ(Autoencoding models)์ด๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ ์ธ์ฝ๋ ๋ชจ๋ธ์ ํ ์คํธ๋ ์ด๋ฏธ์ง์ ๊ฐ์ ์ ๋ ฅ์ ๋ฐ์ ์๋ฒ ๋ฉ์ด๋ผ ๋ถ๋ฆฌ๋ ์์ถ๋ ์์น ํํ์ผ๋ก ๋ฐํํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ธ์ฝ๋ ๋ชจ๋ธ์ ์ ๋ ฅ ์ํ์ค์ ์ผ๋ถ๋ฅผ ๋ง์คํนํ๊ณ ๋ ์๋ฏธ ์๋ ํํ์ ์์ฑํ๋๋ก ํ์ตํ๋ masked language modeling๊ณผ ๊ฐ์ ๊ธฐ์ ์ ์ฌ์ฉํ์ฌ ์ฌ์ ํ์ต๋ฉ๋๋ค.
F
ํน์ง ์ถ์ถ (feature extraction)
๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ด ๋ ํจ๊ณผ์ ์ผ๋ก ํ์ตํ ์ ์๋๋ก, ์์ ๋ฐ์ดํฐ๋ฅผ ์ ํํ๊ณ ๋ณํํ์ฌ ๋ ์ ์ฉํ ํน์ง(feature) ์งํฉ์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ ๋๋ค. ์๋ฅผ ๋ค์ด, ์์ ํ ์คํธ๋ฅผ ์๋ ์๋ฒ ๋ฉ์ผ๋ก ๋ณํํ๊ฑฐ๋ ์ด๋ฏธ์ง๋ ๋น๋์ค ๋ฐ์ดํฐ์์ ์ค๊ณฝ์ ์ด๋ ํํ์ ๊ฐ์ ์ค์ํ ํน์ง์ ์ถ์ถํ๋ ๊ฒ์ด ์์ต๋๋ค.
ํผ๋ ํฌ์๋ ์ฒญํน (feed forward chunking)
ํธ๋์คํฌ๋จธ์ ๊ฐ residual attention Block์์๋ self-Attention Layer ๋ค์์ ๋ณดํต ๋ ๊ฐ์ Feed Forward Layer๊ฐ ์ด์ด์ง๋๋ค. ์ด Feed Forward Layers์ ์ค๊ฐ ์๋ฒ ๋ฉ ํฌ๊ธฐ๋ ์ข
์ข
๋ชจ๋ธ์ ํ๋ ์ฌ์ด์ฆ(hidden size)๋ณด๋ค ํฝ๋๋ค(์:
google-bert/bert-base-uncased ๋ชจ๋ธ์ ๊ฒฝ์ฐ).
์
๋ ฅ ํฌ๊ธฐ๊ฐ [batch_size, sequence_length]์ผ ๊ฒฝ์ฐ, ์ค๊ฐ Feed Forward ์๋ฒ ๋ฉ
[batch_size, sequence_length, config.intermediate_size]์ ์ ์ฅํ๋ ๋ฐ ํ์ํ ๋ฉ๋ชจ๋ฆฌ๋ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ํฐ ๋ถ๋ถ์ ์ฐจ์งํ ์ ์์ต๋๋ค.
Reformer: The Efficient Transformer ๋
ผ๋ฌธ์ ์ ์๋ค์ ์ด ์ฐ์ฐ์ด sequence_length ์ฐจ์์ ๋ํด ๋
๋ฆฝ์ ์ด๊ธฐ ๋๋ฌธ์,ํ ํฐ๋ง๋ค Feed Forward Layer์ ์ถ๋ ฅ ์๋ฒ ๋ฉ์ ๊ฐ ํ ํฐ๋ณ๋ก [batch_size, config.hidden_size]์ ๊ฐ๋ณ์ ์ผ๋ก ๊ณ์ฐํ ๋ค, ์ด๋ฅผ ์ด์ด ๋ถ์ฌ [batch_size, sequence_length, config.hidden_size] ํํ๋ก ๋ง๋ค ์ ์์ต๋๋ค.n = sequence_length. ์ด ๋ฐฉ์์ ๊ณ์ฐ ์๊ฐ์ ๋์ด๋์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ค์ด๋ค๊ฒ ๋ฉ๋๋ค.
[apply_chunking_to_forward] ํจ์๋ฅผ ์ฌ์ฉํ๋ ๋ชจ๋ธ์ ๊ฒฝ์ฐ, chunk_size๋ ๋ณ๋ ฌ๋ก ๊ณ์ฐ๋๋ ์ถ๋ ฅ ์๋ฒ ๋ฉ์ ๊ฐ์๋ฅผ ์ ์ํ๋ฉฐ, ์ด๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋๊ณผ ๊ณ์ฐ ์๊ฐ ๊ฐ์ ํธ๋ ์ด๋์คํ๋ฅผ ๊ฒฐ์ ํฉ๋๋ค.
chunk_size๊ฐ 0์ผ๋ก ์ค์ ๋๋ฉด, ํผ๋ ํฌ์๋ ์ฒญํน(Feed Forward Chunking)์ ์ํ๋์ง ์์ต๋๋ค.
ํ์ธํ๋ ๋ชจ๋ธ (finetuned models)
ํ์ธํ๋(Finetuning)์ ์ ์ด ํ์ต(transfer learning)์ ํ ํํ๋ก, ์ฌ์ ํ์ต๋ (pretrained) ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ๊ฐ์ค์น๋ฅผ ๊ณ ์ (freeze)ํ๊ณ , ์ถ๋ ฅ์ธต์ ์๋กญ๊ฒ ์ถ๊ฐ๋ ๋ชจ๋ธ ํค๋๋ก ๊ต์ฒดํ ๋ค, ํด๋น ๋ชจ๋ธ ํค๋๋ฅผ ๋ชฉํ ๋ฐ์ดํฐ์ ์ ๋ง๊ฒ ํ์ต์ํค๋ ๋ฐฉ์์ ๋๋ค.
์์ธํ ๋ด์ฉ์ Fine-tune a pretrained model ํํ ๋ฆฌ์ผ์ ์ฐธ๊ณ ํ์๊ณ , ๐ค Transformers๋ฅผ ์ฌ์ฉํด ๋ชจ๋ธ์ ํ์ธ ํ๋ํ๋ ๋ฐฉ๋ฒ๋ ํจ๊ป ํ์ธํด ๋ณด์ธ์.
H
ํค๋ (head)
๋ชจ๋ธ ํค๋(model head)๋ ์ ๊ฒฝ๋ง์ ๋ง์ง๋ง ์ธต์ ์๋ฏธํ๋ฉฐ, ์ด ์ธต์ ์ด์ ์ธต์์ ๋์จ ํ๋ ์ํ(hidden states)๋ฅผ ๋ฐ์ ๋ค๋ฅธ ์ฐจ์์ผ๋ก ๋ณํํฉ๋๋ค. ๊ฐ ์์ (task)์ ๋ฐ๋ผ ์๋ก ๋ค๋ฅธ ๋ชจ๋ธ ํค๋๊ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด:
- [
GPT2ForSequenceClassification]์ ๊ธฐ๋ณธ [GPT2Model] ์์ ์ํ์ค ๋ถ๋ฅ๋ฅผ ์ํ ์ ํ๊ณ์ธต(linear layer)์ ์ถ๊ฐํ ๋ชจ๋ธ ํค๋์ ๋๋ค. - [
ViTForImageClassification]์ ์ด๋ฏธ์ง ๋ถ๋ฅ๋ฅผ ์ํ ๋ชจ๋ธ ํค๋๋ก, ๊ธฐ๋ณธ [ViTModel] ์์CLSํ ํฐ์ ๋ง์ง๋ง ํ๋ ์ํ์ ์ ํ ๊ณ์ธต(linear layer)์ ์ถ๊ฐํ ๊ตฌ์กฐ์ ๋๋ค. - [
Wav2Vec2ForCTC]๋ ๊ธฐ๋ณธ [Wav2Vec2Model] ์์ CTC๋ฅผ ์ ์ฉํ ์ธ์ด ๋ชจ๋ธ๋ง ํค๋์ ๋๋ค.
I
์ด๋ฏธ์ง ํจ์น (image patch)
๋น์ ๊ธฐ๋ฐ Transformer ๋ชจ๋ธ์ ์ด๋ฏธ์ง๋ฅผ ์์ ํจ์น๋ก ๋ถํ ํ ํ, ๊ฐ ํจ์น๋ฅผ ์ ํ ์๋ฒ ๋ฉํ์ฌ ์ํ์ค๋ก ๋ชจ๋ธ์ ์
๋ ฅํฉ๋๋ค. ๋ชจ๋ธ์ ๊ตฌ์ฑ ํ์ผ์์ patch_size(๋๋ ํด์๋)๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
์ธํผ๋ฐ์ค (inference)
์ธํผ๋ฐ์ค๋ ํ์ต์ด ์๋ฃ๋ ๋ชจ๋ธ์ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ์ฌ ์์ธก์ ์ํํ๋ ๊ณผ์ ์ ๋๋ค. ๐ค Transformer์์ ์ธํผ๋ฐ์ค๋ฅผ ์ํํ๋ ๋ฐฉ๋ฒ์ Pipeline for inference ํํ ๋ฆฌ์ผ์ ์ฐธ๊ณ ํ์ธ์.
์ ๋ ฅ ID (input IDs)
์ ๋ ฅ ID๋ ์ข ์ข ๋ชจ๋ธ์ ์ ๋ ฅ์ผ๋ก ์ ๋ฌํด์ผ ํ๋ ์ ์ผํ ํ์ ํ๋ผ๋ฏธํฐ์ ๋๋ค. ์ด๋ค์ ํ ํฐ์ ์ธ๋ฑ์ค๋ก, ๋ชจ๋ธ์ด ์ ๋ ฅ์ผ๋ก ์ฌ์ฉํ ์ํ์ค๋ฅผ ๊ตฌ์ฑํ๋ ํ ํฐ๋ค์ ์ซ์ ํํ์ ๋๋ค.
ํ ํฌ๋์ด์ ๋ง๋ค ์๋ ๋ฐฉ์์ ๋ค๋ฅด์ง๋ง, ๊ธฐ๋ณธ ๋ฉ์ปค๋์ฆ์ ๋์ผํฉ๋๋ค. ๋ค์์ WordPiece ํ ํฌ๋์ด์ ์ธ BERT ํ ํฌ๋์ด์ ๋ฅผ ์ฌ์ฉํ ์์์ ๋๋ค:
>>> from transformers import BertTokenizer
>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> sequence = "A Titan RTX has 24GB of VRAM"
ํ ํฌ๋์ด์ ๋ ์ํ์ค๋ฅผ ํ ํฌ๋์ด์ ์ ํ ํฐ ๋ชฉ๋ก์ ์๋ ํญ๋ชฉ์ผ๋ก ๋ถ๋ฆฌํฉ๋๋ค.
>>> tokenized_sequence = tokenizer.tokenize(sequence)
ํ ํฐ์ ๋จ์ด์ด๊ฑฐ๋ ์๋ธ ์๋(subword)์
๋๋ค. ์๋ฅผ ๋ค์ด, "VRAM"์ ๋ชจ๋ธ์ ์ดํ ์ฌ์ ์ ์๋ ๋จ์ด์ด๊ธฐ ๋๋ฌธ์ "V", "RA", "M"์ผ๋ก ๋๋์์ต๋๋ค. ์ด ํ ํฐ๋ค์ด ๊ฐ๋ณ ๋จ์ด๊ฐ ์๋๋ผ ๊ฐ์ ๋จ์ด์ ์ผ๋ถ์์ ๋ํ๋ด๊ธฐ ์ํด "RA"์ "M" ์์ ๋๋ธ ํด์(##)๊ฐ ์ถ๊ฐ ๋ฉ๋๋ค.
>>> print(tokenized_sequence)
['A', 'Titan', 'R', '##T', '##X', 'has', '24', '##GB', 'of', 'V', '##RA', '##M']
์ด๋ฌํ ํ ํฐ๋ค์ ๋ชจ๋ธ์ด ์ดํดํ ์ ์๋ ID๋ก ๋ณํ๋ ์ ์์ต๋๋ค. ์ด ๊ณผ์ ์ ๋ฌธ์ฅ์ ๋ฐ๋ก ํ ํฌ๋์ด์ ์ ์ ๋ ฅํจ์ผ๋ก์จ ์ํ๋๋ฉฐ, ์ฑ๋ฅ ์ต์ ํ๋ฅผ ์ํด ๐ค Tokenizers์ Rust ๊ตฌํ์ ํ์ฉํฉ๋๋ค.
>>> inputs = tokenizer(sequence)
ํ ํฌ๋์ด์ ๋ ํด๋น ๋ชจ๋ธ์ด ์ฌ๋ฐ๋ฅด๊ฒ ์๋ํ๋ ๋ฐ ํ์ํ ๋ชจ๋ ์ธ์๋ฅผ ํฌํจํ ๋์
๋๋ฆฌ๋ฅผ ๋ฐํํฉ๋๋ค. ํ ํฐ ์ธ๋ฑ์ค๋ input_ids๋ผ๋ ํค์ ์ ์ฅ๋ฉ๋๋ค.
>>> encoded_sequence = inputs["input_ids"]
>>> print(encoded_sequence)
[101, 138, 18696, 155, 1942, 3190, 1144, 1572, 13745, 1104, 159, 9664, 2107, 102]
ํ ํฌ๋์ด์ ๋ (์ฐ๊ฒฐ๋ ๋ชจ๋ธ์ด ์ด๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ) ์๋์ผ๋ก "ํน์ ํ ํฐ"์ ์ถ๊ฐํฉ๋๋ค. ์ด๋ค์ ๋ชจ๋ธ์ด ํน์ ์ํฉ์์ ์ฌ์ฉํ๋ ํน๋ณํ ID์ ๋๋ค.
์ด์ ์ ID ์ํ์ค๋ฅผ ๋์ฝ๋ฉํ๋ฉด,
>>> decoded_sequence = tokenizer.decode(encoded_sequence)
์ฐ๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๊ฒ ๋ ๊ฒ์ ๋๋ค.
>>> print(decoded_sequence)
[CLS] A Titan RTX has 24GB of VRAM [SEP]
์ด๋ [BertModel]์ด ์
๋ ฅ๊ฐ์ ๊ธฐ๋ํ๋ ๋ฐฉ์์ด๊ธฐ ๋๋ฌธ์
๋๋ค.
L
๋ ์ด๋ธ (labels)
๋ ์ด๋ธ์ ๋ชจ๋ธ์ด ์์ค(loss)์ ์ง์ ๊ณ์ฐํ ์ ์๋๋ก ์ ๋ฌ๋๋ ์ ํ์ ์ธ์์ ๋๋ค. ์ด ๋ ์ด๋ธ์ ๋ชจ๋ธ์ด ์์ธกํด์ผ ํ ์ ๋ต ๊ฐ์ ์๋ฏธํ๋ฉฐ, ๋ชจ๋ธ์ ์์ธก๊ฐ๊ณผ ์ด ์ ๋ต(label) ์ฌ์ด์ ์ฐจ์ด๋ฅผ ํ์ค ์์ค ํจ์๋ฅผ ์ด์ฉํด ๊ณ์ฐํ๊ฒ ๋ฉ๋๋ค.
์ด ๋ ์ด๋ธ(label)์ ํํ๋ ๋ชจ๋ธ ํค๋(model head)์ ์ข ๋ฅ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ์๋ฅผ ๋ค์ด:
- ์ํ์ค ๋ถ๋ฅ ๋ชจ๋ธ([
BertForSequenceClassification] ๋ฑ)์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์(batch_size)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๋ฐฐ์น์ ๊ฐ ๊ฐ์ ์ ์ฒด ์ํ์ค์ ๋ํ ์์ ๋ ์ด๋ธ์ ๋ํ๋ ๋๋ค. - ํ ํฐ ๋ถ๋ฅ ๋ชจ๋ธ([
BertForTokenClassification] ๋ฑ)์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์(batch_size, seq_length)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๊ฐ ๊ฐ์ ๊ฐ๋ณ ํ ํฐ์ ๋ํ ์์ ๋ ์ด๋ธ์ ๋ํ๋ ๋๋ค. - ๋ง์คํน ์ธ์ด ๋ชจ๋ธ([
BertForMaskedLM])์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์(batch_size,seq_length)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๊ฐ ๊ฐ์ ๊ฐ๋ณ ํ ํฐ์ ๋ํ ์์ ๋ ์ด๋ธ์ ๋ํ๋ ๋๋ค. ๋ ์ด๋ธ์ ๋ง์คํน ๋ ํ ํฐ์ ํ ํฐ ID์ด๋ฉฐ, ๋๋จธ์ง ํ ํฐ์ ๋ํด์๋ ๋ฌด์ํ ๊ฐ์ ์ฌ์ฉํฉ๋๋ค(์ผ๋ฐ์ ์ผ๋ก -100). - ์ํ์ค ํฌ ์ํ์ค ์์
([
BartForConditionalGeneration], [MBartForConditionalGeneration]๋ฑ)์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์(batch_size, tgt_seq_length)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๊ฐ ๊ฐ์ ์ ๋ ฅ ์ํ์ค์ ๋์ํ๋ ํ๊ฒ ์ํ์ค๋ฅผ ๋ํ๋ ๋๋ค. ํ์ต ์ค์๋ BART์ T5๊ฐ ์ ์ ํdecoder_input_ids์ ๋์ฝ๋ attention ๋ง์คํฌ๋ฅผ ๋ด๋ถ์ ์ผ๋ก ์์ฑํ๋ฏ๋ก, ์ผ๋ฐ์ ์ผ๋ก ๋ฐ๋ก ์ ๊ณตํ ํ์๊ฐ ์์ต๋๋ค. ๋จ, ์ด๋ Encoder-Decoder ํ๋ ์์ํฌ๋ฅผ ์ง์ ํ์ฉํ๋ ๋ชจ๋ธ์๋ ์ ์ฉ๋์ง ์์ต๋๋ค. - ์ด๋ฏธ์ง ๋ถ๋ฅ ๋ชจ๋ธ([
ViTForImageClassification] ๋ฑ)์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์(batch_size)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๋ฐฐ์น์ ๊ฐ ๊ฐ์ ๊ฐ๋ณ ์ด๋ฏธ์ง์ ๋ํ ์์ ๋ ์ด๋ธ์ ๋ํ๋ ๋๋ค. - ์๋ฉํฑ ์ธ๊ทธ๋ฉํ
์ด์
๋ชจ๋ธ([
SegformerForSemanticSegmentation] ๋ฑ)์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์(batch_size, height, width)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๋ฐฐ์น์ ๊ฐ ๊ฐ์ ๊ฐ๋ณ ํฝ์ ์ ๋ํ ์์ ๋ ์ด๋ธ์ ๋ํ๋ ๋๋ค. - ๊ฐ์ฒด ํ์ง ๋ชจ๋ธ([
DetrForObjectDetection] ๋ฑ)์ ๊ฒฝ์ฐ, ๋ชจ๋ธ์class_labels์boxesํค๋ฅผ ํฌํจํ๋ ๋์ ๋๋ฆฌ๋ค์ ๋ฆฌ์คํธ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ต๋๋ค. ๋ฐฐ์น์ ๊ฐ ๊ฐ์ ๊ฐ๋ณ ์ด๋ฏธ์ง์ ๋ํ ์์ ํด๋์ค ๋ ์ด๋ธ๊ณผ ๋ฐ์ด๋ฉ ๋ฐ์ค ์ ๋ณด๋ฅผ ๋ํ๋ ๋๋ค. - ์๋ ์์ฑ ์ธ์ ๋ชจ๋ธ([
Wav2Vec2ForCTC] ๋ฑ)์ ๊ฒฝ์ฐ ๋ชจ๋ธ์(batch_size,target_length)์ฐจ์์ ํ ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ๊ฐ ๊ฐ์ ๊ฐ๋ณ ํ ํฐ์ ๋ํ ์์ ๋ ์ด๋ธ์ ๋ํ๋ ๋๋ค.
๋ชจ๋ธ๋ง๋ค ์๊ตฌํ๋ ๋ ์ด๋ธ ํ์์ด ๋ค๋ฅผ ์ ์์ผ๋ฏ๋ก, ๊ฐ ๋ชจ๋ธ์ ๋ฌธ์๋ฅผ ํ์ธํ์ฌ ํด๋น ๋ชจ๋ธ์ ๋ง๋ ๋ ์ด๋ธ ํ์์ ๋ฐ๋์ ํ์ธํ์ธ์!
๊ธฐ๋ณธ ๋ชจ๋ธ([BertModel] ๋ฑ)์ ๋ ์ด๋ธ์ ์
๋ ฅ์ผ๋ก ๋ฐ์ง ์์ต๋๋ค. ์ด๋ฌํ ๋ชจ๋ธ์ ๋จ์ํ ํน์ง(feature)์ ์ถ๋ ฅํ๋ ๊ธฐ๋ณธ ํธ๋์คํฌ๋จธ ๋ชจ๋ธ์ด๊ธฐ ๋๋ฌธ์
๋๋ค.
๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ (LLM)
๋๊ท๋ชจ ๋ฐ์ดํฐ๋ก ํ์ต๋ ํธ๋์คํฌ๋จธ ์ธ์ด ๋ชจ๋ธ(GPT-3, BLOOM, OPT ๋ฑ)์ ์ง์นญํ๋ ์ผ๋ฐ์ ์ธ ์ฉ์ด์ ๋๋ค. ์ด๋ฌํ ๋ชจ๋ธ์ ํ์ตํ ์ ์๋ ํ๋ผ๋ฏธํฐ(parameter)์ ์๊ฐ ๋งค์ฐ ๋ง์ผ๋ฉฐ, ์๋ฅผ ๋ค์ด GPT-3๋ ์ฝ 1,750์ต ๊ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค.
M
๋ง์คํน๋ ์ธ์ด ๋ชจ๋ธ๋ง (MLM)
์ฌ์ ํ์ต ๋จ๊ณ ์ค ํ๋๋ก, ๋ชจ๋ธ์ ์ผ๋ถ ํ ํฐ์ด ๋ฌด์์๋ก ๋ง์คํน ๋ ์์๋ ๋ฌธ์ฅ์ ์ ๋ ฅ๋ฐ๊ณ , ์๋์ ๋ฌธ์ฅ์ ์์ธกํด์ผ ํฉ๋๋ค.
๋ฉํฐ๋ชจ๋ฌ (multimodal)
ํ ์คํธ์ ์ด๋ฏธ์ง์ ๊ฐ์ ๋ค๋ฅธ ํํ์ ์ ๋ ฅ์ ํจ๊ป ์ฌ์ฉํ๋ ์์ ์ ๋๋ค.
N
์์ฐ์ด ์์ฑ (NLG)
ํ ์คํธ๋ฅผ ์์ฑํ๋ ๋ชจ๋ ์์ ์ ์๋ฏธํฉ๋๋ค. (์: Write With Transformers, ๋ฒ์ญ ๋ฑ).
์์ฐ์ด ์ฒ๋ฆฌ (NLP)
ํ ์คํธ๋ฅผ ๋ค๋ฃจ๋ ์์ ์ ๋ฐ์ ์ง์นญํ๋ ์ผ๋ฐ์ ์ธ ์ฉ์ด์ ๋๋ค.
์์ฐ์ด ์ดํด (NLU)
ํ ์คํธ์ ๋ด๊ธด ์๋ฏธ๋ฅผ ์ดํดํ๋ ๋ชจ๋ ์์ ์ ํฌํจํฉ๋๋ค. (์: ์ ์ฒด ๋ฌธ์ ๋ถ๋ฅ, ๊ฐ๋ณ ๋จ์ด ๋ถ๋ฅ ๋ฑ).
P
ํ์ดํ๋ผ์ธ (pipeline)
๐ค Transformers์์ ํ์ดํ๋ผ์ธ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฒ๋ฆฌํ๊ณ ๋ณํํ ํ, ๋ชจ๋ธ์ ํตํด ์์ธก๊ฐ์ ๋ฐํํ๋ ์ผ๋ จ์ ๋จ๊ณ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ํํ๋ ์ถ์ํ๋ ๊ฐ๋ ์ ๋๋ค. ํ์ดํ๋ผ์ธ์ ํฌํจ๋ ์ ์๋ ๋จ๊ณ๋ก๋ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ, ํน์ง ์ถ์ถ(feature extraction), ์ ๊ทํ(normalization) ๋ฑ์ด ์์ต๋๋ค.
์์ธํ ๋ด์ฉ์ Pipelines for inference ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์ธ์.
ํ์ดํ๋ผ์ธ ๋ณ๋ ฌํ (PP)
๋ชจ๋ธ์ ์์ง ๋ฐฉํฅ(๋ ์ด์ด ๋จ์)์ผ๋ก ์ฌ๋ฌ GPU์ ๋ถํ ํ์ฌ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๋ ๋ณ๋ ฌํ ๊ธฐ๋ฒ์ ๋๋ค. ๊ฐ GPU๋ ๋ชจ๋ธ์ ํ๋ ๋๋ ์ฌ๋ฌ ๊ฐ์ ๋ ์ด์ด๋ง์ ๋ด๋นํ๋ฉฐ, ์ ์ฒด ํ์ดํ๋ผ์ธ์ ์๋ก ๋ค๋ฅธ ๋จ๊ณ๋ฅผ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํ๊ฒ ๋ฉ๋๋ค. ๋ํ ๊ฐ GPU๋ ๋ฐฐ์น(batch)์ ์ผ๋ถ ์์ ์กฐ๊ฐ๋ง ์ฒ๋ฆฌํฉ๋๋ค. Pipeline Parallel ๋ฐฉ์์ ๋ํด ๋ ์์๋ณด๋ ค๋ฉด ์ด ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์ธ์.
ํฝ์ ๊ฐ (pixel values)
์ด๋ฏธ์ง๋ฅผ ์์น์์ผ๋ก ํํํ ํ
์๋ก, ๋ชจ๋ธ์ ์
๋ ฅ์ผ๋ก ์ ๋ฌ๋ฉ๋๋ค. ์ด ํ
์๋ ์ด๋ฏธ์ง ํ๋ก์ธ์๋ฅผ ํตํด ์์ฑ๋๋ฉด, ๊ฐ์ [batch_size, num_channels, height, width] ํํ์ ์ฐจ์์ ๊ฐ์ง๋๋ค.
ํ๋ง (pooling)
ํ๋ ฌ์ ํน์ ์ฐจ์์์ ์ต๋๊ฐ์ด๋ ํ๊ท ๊ฐ์ ์ทจํ์ฌ ๋ ์์ ํ๋ ฌ๋ก ์ค์ด๋ ์ฐ์ฐ์ ๋๋ค. ํ๋ง ๊ณ์ธต์ ์ฃผ๋ก ํฉ์ฑ๊ณฑ ๊ณ์ธต ์ฌ์ด์ ์์นํ์ฌ ํน์ง ํํ์ ๋ค์ด์ํ๋ง ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
ํฌ์ง์ ID (position IDs)
RNN ๋ชจ๋ธ๊ณผ ๋ฌ๋ฆฌ ํธ๋์คํฌ๋จธ๋ ๊ฐ ํ ํฐ์ ์์น ์ ๋ณด๋ฅผ ๋ด๋ถ์ ์ผ๋ก ๊ฐ์ง๊ณ ์์ง ์์ต๋๋ค. ๋ฐ๋ผ์ ๋ชจ๋ธ์ position_ids๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ ํฐ์ด ์ํ์ค ๋ด์์ ์ด๋ ์์น์ ์๋์ง๋ฅผ ์ธ์ํฉ๋๋ค. ์ด ๊ฐ์ ์ ํ์ ์ธ ํ๋ผ๋ฏธํฐ์
๋๋ค. ๋ชจ๋ธ์ position_ids๋ฅผ ์ ๋ฌํ์ง ์์ผ๋ฉด, ์ ๋ ์์น ์๋ฒ ๋ฉ ๋ฐฉ์์ผ๋ก ์๋ ์์ฑ๋ฉ๋๋ค. ์ ๋ ์์น ์๋ฒ ๋ฉ์ [0, config.max_position_embeddings - 1] ๋ฒ์ ๋ด์์ ์ ํ๋ฉ๋๋ค. ์ผ๋ถ ๋ชจ๋ธ์ ์ฌ์ธํ ํํ์ ์์น ์๋ฒ ๋ฉ(sinusoidal position embeddings) ๋๋ ์๋ ์์น ์๋ฒ ๋ฉ(relative position embeddings)๊ณผ ๊ฐ์ ๋ค๋ฅธ ์ ํ์ ์์น ์๋ฒ ๋ฉ์ ์ฌ์ฉํ๊ธฐ๋ ํฉ๋๋ค.
์ ์ฒ๋ฆฌ (preprocessing)
๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ์ฝ๊ฒ ์ฒ๋ฆฌํ ์ ์๋๋ก ๊ฐ๊ณต๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ ํ๋ ์์ ์ ๋๋ค. ์๋ฅผ ๋ค์ด, ํ ์คํธ๋ ์ผ๋ฐ์ ์ผ๋ก ํ ํฐํ(tokenization) ๊ณผ์ ์ ๊ฑฐ์นฉ๋๋ค. ๋ค๋ฅธ ์ ๋ ฅ ์ ํ์ ๋ํ ์ ์ฒ๋ฆฌ ๋ฐฉ์์ด ๊ถ๊ธํ๋ค๋ฉด Preprocess ํํ ๋ฆฌ์ผ์ ์ฐธ๊ณ ํด ๋ณด์ธ์.
์ฌ์ ํ์ต๋ ๋ชจ๋ธ (pretrained model)
์ผ๋ถ ๋ฐ์ดํฐ(์: ์ํคํผ๋์ ์ ์ฒด)๋ก ์ฌ์ ํ์ต(pretraining)๋ ๋ชจ๋ธ์ ๋๋ค. ์ฌ์ ํ์ต์ ์๊ธฐ ์ง๋ ํ์ต(self-supervised learning)์ ๋ชฉํ๋ฅผ ํฌํจํ๋ฉฐ, ์๋ฅผ ๋ค์ด ๋ฌธ์ฅ์ ์ฝ๊ณ ๋ค์ ๋จ์ด๋ฅผ ์์ธกํ๊ฑฐ๋ (causal language modeling) ์ฐธ๊ณ , ์ผ๋ถ ๋จ์ด๋ฅผ ๋ง์คํนํ๊ณ ์ด๋ฅผ ์์ธกํ๋ ๋ฐฉ์(masked language modeling)์ด ์์ต๋๋ค.
์์ฑ ๋ฐ ๋น์ ๋ชจ๋ธ์ ๊ณ ์ ์ ์ฌ์ ํ์ต ๋ชฉํ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, Wav2Vec2๋ ์์ฑ ํํ ์ค "์ง์ง"๋ฅผ "๊ฐ์ง" ์ค์์ ๊ตฌ๋ถํ๋ ๋์กฐ ํ์ต(contrastive learning) ๋ฐฉ์์ผ๋ก ์ฌ์ ํ์ต๋ ์์ฑ ๋ชจ๋ธ์ ๋๋ค. ๋ฐ๋ฉด, BEiT๋ ์ด๋ฏธ์ง ํจ์น ์ค ์ผ๋ถ๋ฅผ ๋ง์คํนํ๊ณ ์ด๋ฅผ ์์ธกํ๋ ๋ง์คํน ์ด๋ฏธ์ง ๋ชจ๋ธ๋ง ๋ฐฉ์์ผ๋ก ์ฌ์ ํ์ต๋ ๋น์ ๋ชจ๋ธ์ ๋๋ค. ์ด๋ ๋ง์คํน ์ธ์ด ๋ชจ๋ธ๋ง๊ณผ ์ ์ฌํ ๋ฐฉ์์ ๋๋ค.
R
์ํ ์ ๊ฒฝ๋ง (RNN)
ํ ์คํธ์ ๊ฐ์ ์ํ์ค ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด ๋ ์ด์ด์ ๋ฐ๋ณต ๊ตฌ์กฐ(๋ฃจํ)๋ฅผ ์ฌ์ฉํ๋ ์ ๊ฒฝ๋ง ๋ชจ๋ธ์ ํ ์ข ๋ฅ์ ๋๋ค.
ํํํ์ต (representation learning)
๋จธ์ ๋ฌ๋์ ํ์ ๋ถ์ผ๋ก, ์์ ๋ฐ์ดํฐ๋ก๋ถํฐ ์๋ฏธ ์๋ ํํ์ ํ์ตํ๋ ๋ฐ ์ค์ ์ ๋ก๋๋ค. ๋ํ์ ์ธ ๊ธฐ๋ฒ์ผ๋ก๋ ๋จ์ด ์๋ฒ ๋ฉ, ์คํ ์ธ์ฝ๋(autoencoder), ์์ฑ์ ์ ๋ ์ ๊ฒฝ๋ง(GAN) ๋ฑ์ด ์์ต๋๋ค.
S
์ํ๋ง ์๋ (sampling rate)
์ํ๋ง ์๋๋ 1์ด์ ์ถ์ถํ๋ (์ค๋์ค ์ ํธ) ์ํ์ ๊ฐ์๋ฅผ ํค๋ฅด์ธ (Hz) ๋จ์๋ก ๋ํ๋ธ ์ธก์ ๊ฐ์ ๋๋ค. ์ด๋ ์์ฑ์ฒ๋ผ ์ฐ์์ ์ธ ์ ํธ๋ฅผ ๋์งํธํํ์ฌ ์ด์ฐ์ ์ธ ํํ๋ก ๋ง๋๋ ๊ฒฐ๊ณผ์ ๋๋ค.
์ ํ ์ดํ ์ (self-attention)
์ ๋ ฅ์ ๊ฐ ์์๊ฐ ๋ค๋ฅธ ์ด๋ค ์์์ ์ฃผ๋ชฉํด์ผ ํ๋์ง๋ฅผ ์ค์ค๋ก ํ๋จํ๋ ๋ฉ์ปค๋์ฆ์ ๋๋ค. ์ด๋ ๋ชจ๋ธ์ด ๋ฌธ์ฅ์์ ํน์ ๋จ์ด๋ง์ ๋ณด๋ ๊ฒ์ด ์๋๋ผ, ๋ค๋ฅธ ๋จ์ด๋ค๊ณผ์ ๊ด๊ณ๋ฅผ ๊ณ ๋ คํ์ฌ ์ด๋ค ์ ๋ณด์ ๋ ์ง์คํด์ผ ํ ์ง๋ฅผ ํ์ตํ๊ฒ ํฉ๋๋ค.
์๊ธฐ์ง๋ ํ์ต (self-supervised learning)
๋ ์ด๋ธ์ด ์๋ ๋ฐ์ดํฐ๋ก๋ถํฐ ๋ชจ๋ธ์ด ์ค์ค๋ก ํ์ต ๋ชฉํ๋ฅผ ์ ์ํ์ฌ ํ์ตํ๋ ๋จธ์ ๋ฌ๋ ๊ธฐ๋ฒ์ ํ ์ข ๋ฅ์ ๋๋ค. ๋น์ง๋ ํ์ต์ด๋ ์ง๋ ํ์ต๊ณผ ๋ฌ๋ฆฌ, ํ์ต ๊ณผ์ ์์ฒด๋ ๊ฐ๋ ๋ฐฉ์ ๋์ง๋ง, ๋ผ๋ฒจ์ด ๋ช ์์ ์ผ๋ก ์ฃผ์ด์ง๋ ๊ฒ์ ์๋๋๋ค.
์์๋ก๋ ๋ง์คํฌ ์ธ์ด ๋ชจ๋ธ๋ง์ด ์์ผ๋ฉฐ, ์ด๋ ๋ฌธ์ฅ์ ์ผ๋ถ ํ ํฐ์ ์ ๊ฑฐํ ์ํ๋ก ๋ชจ๋ธ์ ์ ๋ ฅํ๊ณ , ๋ชจ๋ธ์ด ํด๋น ํ ํฐ์ ์์ธกํ๋๋ก ํ์ตํ๋ ๋ฐฉ์์ ๋๋ค.
์ค์ง๋ ํ์ต (semi-supervised learning)
์๋์ ๋ผ๋ฒจ์ด ๋ฌ๋ฆฐ ๋ฐ์ดํฐ์ ๋๋์ ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ๋ฅผ ํจ๊ป ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ์ ํ๋๋ฅผ ๋์ด๋ ๋จธ์ ๋ฌ๋ ํ๋ จ ๊ธฐ๋ฒ์ ๋์ ๋ฒ์ฃผ์ ๋๋ค. ์ด๋ ์ง๋ ํ์ต์ด๋ ๋น์ง๋ ํ์ต๊ณผ๋ ๋ค๋ฅธ ๋ฐฉ์์ ๋๋ค.
์ค์ง๋ ํ์ต ๊ธฐ๋ฒ์ ์๋ก๋ "์๊ธฐ ํ์ต(self-training)"์ด ์์ต๋๋ค. ์ด ๋ฐฉ์์ ๋จผ์ ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ๋ก ๋ชจ๋ธ์ ํ์ต์ํค๊ณ , ๊ทธ ๋ชจ๋ธ์ ์ฌ์ฉํด ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ์ ๋ํ ์์ธก์ ์ํํฉ๋๋ค. ๋ชจ๋ธ์ด ๊ฐ์ฅ ๋์ ํ์ ์ ๊ฐ์ง๊ณ ์์ธกํ ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ ์ผ๋ถ๋ฅผ ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ๋ก ์ถ๊ฐํ๊ณ , ์ด๋ฅผ ํตํด ๋ชจ๋ธ์ ๋ค์ ํ์ต์ํต๋๋ค.
์ํ์ค ํฌ ์ํ์ค (seq2seq)
์ ๋ ฅ์ผ๋ก๋ถํฐ ์๋ก์ด ์ํ์ค๋ฅผ ์์ฑํ๋ ๋ชจ๋ธ์ ๋๋ค. ์๋ฅผ ๋ค์ด ๋ฒ์ญ ๋ชจ๋ธ์ด๋ ์์ฝ ๋ชจ๋ธ์ด ์ด์ ํด๋นํ๋ฉฐ, ๋ํ์ ์ธ ์๋ก๋ Bart๋T5 ๋ชจ๋ธ์ด ์์ต๋๋ค.
๋ถํ DDP (Sharded DDP)
ZeRO ๊ฐ๋ ์ ๊ธฐ๋ฐ์ผ๋ก ๋ค์ํ ๊ตฌํ์์ ์ฌ์ฉ๋๋ ๋ค๋ฅธ ์ด๋ฆ์ผ๋ก ๋ถ๋ฆฝ๋๋ค.
์คํธ๋ผ์ด๋ (stride)
convolution ๋๋ pooling์์ ์คํธ๋ผ์ด๋(stride)๋ ์ปค๋์ด ํ๋ ฌ ์๋ฅผ ์ด๋ํ๋ ๊ฐ๊ฒฉ์ ์๋ฏธํฉ๋๋ค. ์คํธ๋ผ์ด๋๊ฐ 1์ด๋ฉด ์ปค๋์ด ํ ํฝ์ ์ฉ ์ด๋ํ๊ณ , 2์ด๋ฉด ๋ ํฝ์ ์ฉ ์ด๋ํฉ๋๋ค.
์ง๋ํ์ต (supervised learning)
์ ๋ต์ด ํฌํจ๋ ๋ผ๋ฒจ๋ง๋ ๋ฐ์ดํฐ๋ฅผ ์ง์ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ํ์ต ๋ฐฉ์์ ๋๋ค. ํ์ต ์ค์ธ ๋ชจ๋ธ์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ๊ณ , ์์ธก ๊ฒฐ๊ณผ๋ฅผ ์ ๋ต๊ณผ ๋น๊ตํ์ฌ ์ค์ฐจ๋ฅผ ๊ณ์ฐํฉ๋๋ค. ๋ชจ๋ธ์ ์ด ์ค์ฐจ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธํ๋ฉฐ, ์ด๋ฌํ ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ ์ฑ๋ฅ์ ์ต์ ํํฉ๋๋ค.
T
ํ ์ ๋ณ๋ ฌํ (TP)
์ฌ๋ฌ GPU์์ ํ๋ จํ๊ธฐ ์ํ ๋ณ๋ ฌํ ๊ธฐ๋ฒ์ผ๋ก, ๊ฐ ํ ์๋ฅผ ์ฌ๋ฌ ๋ฉ์ด๋ฆฌ(chunk)๋ก ๋๋๋๋ค. ๋ฐ๋ผ์ ์ ์ฒด ํ ์๊ฐ ๋จ์ผ GPU์ ์์ฃผํ๋ ๋์ , ํ ์์ ๊ฐ ์กฐ๊ฐ(shard)์ด ์ง์ ๋ GPU์ ์์ฃผํ๊ฒ ๋ฉ๋๋ค. ์ด ์กฐ๊ฐ๋ค์ ๊ฐ๊ฐ ๋ค๋ฅธ GPU์์ ๊ฐ๋ณ์ ์ผ๋ก ๋ณ๋ ฌ ์ฒ๋ฆฌ๋๋ฉฐ, ์ฒ๋ฆฌ ๋จ๊ณ๊ฐ ๋๋ ๋ ๊ฒฐ๊ณผ๊ฐ ๋๊ธฐํ๋ฉ๋๋ค. ์ด๋ฌํ ๋ถํ ์ด ์ํ ๋ฐฉํฅ์ผ๋ก ์ผ์ด๋๊ธฐ ๋๋ฌธ์, ์ด๋ ๋๋๋ก ์ํ์ ๋ณ๋ ฌํ๋ผ๊ณ ๋ถ๋ฆฝ๋๋ค. Tensor Parallelism์ ๋ํด ๋ ์์๋ณด๋ ค๋ฉด ์ฌ๊ธฐ๋ฅผ ์ฐธ๊ณ ํ์ธ์.
ํ ํฐ (token)
์ผ๋ฐ์ ์ธ ๋จ์ด ๋จ์์ด์ง๋ง, ๋์ ๋ฐ๋ผ ์๋ธ ์๋(์์ฃผ ์ฌ์ฉ๋์ง ์๋ ๋จ์ด๋ ์๋ธ ์๋๋ก ๋ถ๋ฆฌ๋จ)๋ ๋ฌธ์ฅ ๋ถํธ๋ ํฌํจ๋ ์ ์๋ ๋ฌธ์ฅ์ ๊ตฌ์ฑ ์์์ ๋๋ค.
ํ ํฐ ํ์ ID (token type IDs)
์ผ๋ถ ๋ชจ๋ธ์ ๋ฌธ์ฅ ์ ๋ถ๋ฅ๋ ์ง์ ์๋ต ์์ ์ ์ํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์ด๋ฌํ ์์
์์๋ ๋ ๊ฐ์ ์๋ก ๋ค๋ฅธ ์ํ์ค๋ฅผ ํ๋์ "input_ids" ํญ๋ชฉ์ผ๋ก ๊ฒฐํฉํด์ผ ํ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก [CLS] ๋ถ๋ฅ์ฉ ๋ฐ [SEP] ๊ตฌ๋ถ์ฉ๊ณผ ๊ฐ์ ํน์ ํ ํฐ์ ์ฌ์ฉํ์ฌ ์ฒ๋ฆฌํฉ๋๋ค. ์๋ฅผ ๋ค์ด, BERT ๋ชจ๋ธ์ ๋ ๊ฐ์ ์ํ์ค๋ฅผ ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ตฌ์ฑํฉ๋๋ค:
>>> # [CLS] SEQUENCE_A [SEP] SEQUENCE_B [SEP]
๋ ๊ฐ์ ์ํ์ค๋ฅผ tokenizer์ ๋ฆฌ์คํธ๊ฐ ์๋ ๊ฐ๋ณ ์ธ์๋ก ์ ๋ฌํ๋ฉด, ํ ํฌ๋์ด์ ๊ฐ ์๋์ผ๋ก ์ด๋ฌํ ๋ฌธ์ฅ์ ์์ฑํด ์ค๋๋ค. ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
>>> from transformers import BertTokenizer
>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> sequence_a = "HuggingFace is based in NYC"
>>> sequence_b = "Where is HuggingFace based?"
>>> encoded_dict = tokenizer(sequence_a, sequence_b)
>>> decoded = tokenizer.decode(encoded_dict["input_ids"])
๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์ต๋๋ค:
>>> print(decoded)
[CLS] HuggingFace is based in NYC [SEP] Where is HuggingFace based? [SEP]
์ด ์ฝ๋๋ ์ผ๋ถ ๋ชจ๋ธ์ด ๋ ๊ฐ์ ์ํ์ค๋ฅผ ์ด๋ป๊ฒ ๊ตฌ๋ถํ๋์ง ์ดํดํ๋ ๋ฐ ์ถฉ๋ถํฉ๋๋ค. ๊ทธ๋ฌ๋ BERT์ ๊ฐ์ ๋ค๋ฅธ ๋ชจ๋ธ์ ํ ํฐ ํ์ ID(๋๋ ์ธ๊ทธ๋จผํธ ID)๋ฅผ ์ถ๊ฐ๋ก ์ฌ์ฉํฉ๋๋ค. ์ด ID๋ 0๊ณผ 1๋ก ๊ตฌ์ฑ๋ ์ด์ง ๋ง์คํฌ๋ก, ๋ ์ํ์ค๋ฅผ ๊ตฌ๋ถํ๋ ์ญํ ์ ํฉ๋๋ค.
ํ ํฌ๋์ด์ ๋ ์ด ๋ง์คํฌ๋ฅผ "token_type_id" ํญ๋ชฉ์ผ๋ก ๋ฐํํฉ๋๋ค:
>>> encoded_dict["token_type_ids"]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
์ง๋ฌธ์ ์ฌ์ฉ๋๋ ์ฒซ ๋ฒ์งธ ์ํ์ค์ธ "context"๋ ๋ชจ๋ ํ ํฐ์ด 0์ผ๋ก ํ์๋ฉ๋๋ค. ๋ฐ๋ฉด ๋ ๋ฒ์งธ ์ํ์ค์ธ "question"์ ๋ชจ๋ ํ ํฐ์ด 1๋ก ํ์๋ฉ๋๋ค.
์ผ๋ถ ๋ชจ๋ธ(์: [XLNetModel])์ 2๋ก ํ์๋๋ ์ถ๊ฐ ํ ํฐ์ ์ฌ์ฉํ๊ธฐ๋ ํฉ๋๋ค.
์ ์ดํ์ต (transfer learning)
์ฌ์ ํ์ต๋(pretrained) ๋ชจ๋ธ์ ๊ฐ์ ธ์ ํน์ ์์ ์ ๋ง๋ ๋ฐ์ดํฐ์ ์ ๋ํด ์ถ๊ฐ ํ์ตํ๋ ๊ธฐ์ ์ ๋๋ค. ๋ชจ๋ธ์ ์ฒ์๋ถํฐ ํ์ต์ํค๋ ๋์ , ๊ธฐ์กด ๋ชจ๋ธ์ด ํ์ตํ ์ง์์ ์ถ๋ฐ์ ์ผ๋ก ์ผ์ ๋์ฑ ๋น ๋ฅด๊ฒ ํ์ตํ ์ ์์ต๋๋ค. ์ด๋ฅผ ํตํด ํ์ต ์๋๋ฅผ ๋์ด๊ณ ํ์ํ ๋ฐ์ดํฐ์๋ ์ค์ผ ์ ์์ต๋๋ค.
ํธ๋์คํฌ๋จธ (transformer)
์ ํ ์ดํ ์ ๋ฉ์ปค๋์ฆ์ ๊ธฐ๋ฐ์ผ๋ก ํ ๋ฅ๋ฌ๋ ๋ชจ๋ธ ์ํคํ ์ฒ์ ๋๋ค.
U
๋น์ง๋ ํ์ต (unsupervised learning)
์ ๋ต(๋ ์ด๋ธ)์ด ํฌํจ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํด ๋ชจ๋ธ์ ํ์ต์ํค๋ ๋ฐฉ์์ ๋๋ค. ๋น์ง๋ ํ์ต์ ๋ฐ์ดํฐ ๋ถํฌ์ ํต๊ณ์ ํน์ฑ์ ํ์ฉํด ์ ์ฉํ ํจํด์ ์ฐพ์๋ ๋๋ค.
Z
Zero Redundancy Optimizer (ZeRO)
TensorParallel๊ณผ ์ ์ฌํ๊ฒ ํ ์๋ฅผ ์ค๋ฉ(sharding)ํ๋ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๊ธฐ๋ฒ์ด์ง๋ง, ์์ ํ(forward)๋ ์ญ์ ํ(backward) ๊ณ์ฐ ์์ ์ ์ ์ฒด ํ ์๋ฅผ ๋ค์ ๋ณต์ํ๋ค๋ ์ ์์ ์ฐจ์ด๊ฐ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋ชจ๋ธ ์์ฒด๋ฅผ ์์ ํ ํ์๊ฐ ์์ต๋๋ค. ์ด ๋ฐฉ๋ฒ์ GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๊ฒฝ์ฐ ์ด๋ฅผ ๋ณด์ํ๊ธฐ ์ํ ๋ค์ํ ์คํ๋ก๋ฉ (offloading) ๊ธฐ๋ฒ๋ ์ง์ํฉ๋๋ค. ZeRO์ ๋ํด ๋ ์์๋ณด๋ ค๋ฉด ์ด ๋ฌธ์๋ฅผ ์ฐธ๊ณ ํ์ธ์.