้กน็›ฎๆ–‡ไปถๅคน

ๆ–‡ไปถ
wehub-resource-sync e06fe8e8c6
Secret Leaks / trufflehog (push) Failing after 1s
Build documentation / build (push) Failing after 1s
Build documentation / build_other_lang (push) Failing after 0s
CodeQL Security Analysis / CodeQL Analysis (push) Failing after 0s
PR CI / pr-ci (push) Failing after 1s
Slow tests on important models (on Push - A10) / Get all modified files (push) Failing after 1s
Slow tests on important models (on Push - A10) / Model CI (push) Has been skipped
Self-hosted runner (benchmark) / Benchmark (aws-g5-4xlarge-cache) (push) Has been cancelled
New model PR merged notification / Notify new model (push) Has been cancelled
Update Transformers metadata / build_and_package (push) Has been cancelled
chore: import upstream snapshot with attribution
2026-07-13 11:57:37 +08:00

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์— ๋Œ€ํ•ด ๋” ์•Œ์•„๋ณด๋ ค๋ฉด ์ด ๋ฌธ์„œ๋ฅผ ์ฐธ๊ณ ํ•˜์„ธ์š”.