lsmpp's picture
Add files using upload-large-folder tool
ca32b0e verified

μš©μ–΄μ§‘(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에 λŒ€ν•΄ 더 μ•Œμ•„λ³΄λ €λ©΄ 이 λ¬Έμ„œλ₯Ό μ°Έκ³ ν•˜μ„Έμš”.