사전 훈련 언어 모델
Part 1에서 우리는 임베딩과 순환망, 트랜스포머 구조를 통해 단어를 벡터로 표현하고 시퀀스를 모델링하는 기초를 다졌다. 이 장에서는 그 구성 요소들이 실제로 어떻게 거대한 규모로 쌓여 사전 훈련 언어 모델이 되는지를 다룬다. 직접 모델을 처음부터 학습시키는 대신, 대규모 텍스트로 미리 훈련된 모델을 내려받아 그대로 사용하는 관점에 집중한다.
언어 모델은 주어진 텍스트 시퀀스에서 다음 단어(토큰)를 예측하는 모델이다. 다음 토큰을 반복적으로 예측해 이어 붙이면 새로운 문장이 생성된다. 이 장에서는 한국어로 사전 훈련된 KoGPT2를 예제로 삼아, 모델을 적재하고 구조와 매개변수 규모를 살펴본 뒤, 텍스트 생성과 다음 토큰 예측이 실제로 어떤 계산으로 이뤄지는지를 단계별로 확인한다.
사전 훈련 언어모델¶
언어모델 (LM)은 주어진 텍스트 시퀀스에서 다음 단어를 예측하는 모델입니다. 사전 훈련된 언어모델은 대규모 텍스트 데이터로 미리 학습된 모델로, 다양한 자연어 처리 작업에 활용됩니다.
보통 대규모 데이터에 대해 사전 훈련되면, 모델의 규모가 커지기 때문에 대형 언어모델 (LLM; Large Language Model)이라고도 불립니다. 대표적인 사전 훈련 언어모델로는 OpenAI의 GPT 시리즈 등이 있습니다.
사전 훈련 모델 적재¶
Hugging Face transformers 라이브러리는 이미 학습된 모델 가중치와 토크나이저를 표준화된 인터페이스로 제공한다. 토크나이저는 사람이 읽는 문자열을 모델이 다루는 정수 시퀀스로 바꿔 주고, 모델은 그 정수 시퀀스를 입력받아 다음 토큰의 확률 분포를 출력한다. 인과적(causal) 언어 모델은 AutoModelForCausalLM 으로 적재한다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
print(type(tokenizer).__name__, type(model).__name__)
모델 구조 들여다보기¶
적재한 모델 객체를 출력하면 내부에 쌓인 층의 구성이 그대로 드러난다. 토큰 임베딩과 위치 임베딩, 여러 개의 트랜스포머 블록(자기 주의 + 피드포워드), 그리고 마지막에 어휘 크기만큼의 로짓을 내보내는 언어 모델 헤드로 이뤄져 있다. Part 1에서 다룬 구성 요소들이 반복적으로 적층되어 있음을 확인할 수 있다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
print(model)매개변수 규모¶
사전 훈련 모델을 "대형"이라 부르는 이유는 매개변수의 수에 있다. 텐서가 담고 있는 원소의 총 개수는 numel()(number of elements)로 얻는다.
import torch
x = torch.arange(10)
print(x)
print(x.numel())모델의 모든 매개변수 텐서에 대해 numel() 값을 합산하면 전체 매개변수 개수가 나온다. 이 수치가 모델의 표현 용량과 메모리 사용량을 가늠하는 1차 척도가 된다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
print(f'모델 매개변수: {sum(p.numel() for p in model.parameters()):,}')텍스트 생성¶
프롬프트(입력 문장)를 정수 시퀀스로 변환한 뒤 generate 를 호출하면, 모델은 다음 토큰을 한 번에 하나씩 예측해 이어 붙이며 문장을 완성한다. max_new_tokens 로 생성할 토큰 수를 제한하고, repetition_penalty 로 같은 토큰이 반복되는 경향을 억제한다. 생성된 정수 시퀀스는 다시 토크나이저로 디코딩해 사람이 읽는 문자열로 되돌린다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
prompt = '근육이 커지기 위해서는' # 프롬프트 (입력 문장)
# 정수시퀀스 변환
입력토큰 = tokenizer.encode(prompt, return_tensors='pt')
pd.DataFrame({
'토큰': tokenizer.tokenize(prompt),
'정수시퀀스': 입력토큰.flatten().tolist()}).T
# 모델을 사용하여 텍스트 생성
with torch.inference_mode():
출력토큰 = model.generate(
입력토큰,
max_new_tokens=128,
repetition_penalty=2.0,
)
# 정수 시퀀스 디코딩: 정수ID -> 텍스트 토큰 -> 문자열 병합
출력문장 = tokenizer.decode(출력토큰[0], skip_special_tokens=True)
print(출력문장)다음 토큰 예측의 내부¶
generate 가 편의 함수라면, 모델을 직접 호출했을 때 무엇이 나오는지 살펴보자. 모델에 입력 시퀀스를 그대로 넣으면 logits 텐서를 돌려준다. 그 형태는 (배치 크기, 시퀀스 길이, 어휘 수) 로, 입력의 각 위치마다 어휘 전체에 대한 점수(로짓)가 하나씩 매겨진다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
prompt = '나는 너를 사랑하는데, 너도 나를'
입력시퀀스 = tokenizer.encode(prompt, return_tensors='pt')
display(pd.DataFrame({
'토큰': tokenizer.tokenize(prompt),
'정수시퀀스': 입력시퀀스.flatten().tolist()}).T)
with torch.inference_mode():
outputs = model(입력시퀀스)
print(type(outputs))
print(outputs.keys())
print(outputs.logits.shape) # (배치 크기, 시퀀스 길이, 어휘 수)로짓에 소프트맥스를 적용하면 어휘에 대한 확률 분포가 된다. 각 입력 토큰 위치에서 가장 확률이 높은 토큰을 고르면, 그 위치 다음에 올 것으로 모델이 예측한 토큰을 얻는다. 아래 표는 입력 토큰마다 모델이 예측한 다음 토큰과 그 확률을 나란히 보여 준다. 마지막 위치의 예측이 곧 생성될 다음 토큰이며, generate 는 이 과정을 반복할 뿐이다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
prompt = '나는 너를 사랑하는데, 너도 나를'
입력시퀀스 = tokenizer.encode(prompt, return_tensors='pt')
with torch.inference_mode():
outputs = model(입력시퀀스)
토큰목록 = tokenizer.tokenize(prompt)
logits = outputs.logits[0] # (시퀀스 길이, 어휘 수)
# 각 입력 토큰 위치마다 최대값 계산 (벡터화)
예측확률 = torch.softmax(logits, dim=-1)
다음토큰확률, 다음토큰ID = 예측확률.max(dim=-1) # (시퀀스 길이,)
예측토큰목록 = tokenizer.convert_ids_to_tokens(다음토큰ID.tolist())
rows = pd.DataFrame({
'입력 토큰': 토큰목록,
'예측 토큰': 예측토큰목록,
'확률': 다음토큰확률.tolist(),
})
rows['확률'] = rows['확률'].round(3)
display(rows.set_index('입력 토큰').T)OpenAI GPT2¶
KoGPT2는 OpenAI의 GPT-2 구조를 한국어 데이터로 학습한 모델이다. 앞에서는 AutoModelForCausalLM 으로 구조에 무관하게 적재했지만, 모델 클래스를 명시적으로 지정해 적재할 수도 있다. GPT-2 계열은 GPT2LMHeadModel 클래스를 사용한다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
from transformers import GPT2LMHeadModel
gpt2 = GPT2LMHeadModel.from_pretrained(model_id).to('cpu').eval()
print(type(gpt2).__name__)
토크나이저와 특수 토큰¶
토크나이저는 문장의 시작·끝(bos, eos), 미등록어(unk), 자리채움(pad), 마스킹(mask)에 해당하는 특수 토큰을 함께 관리한다. 한국어 텍스트는 형태소 단위에 가깝게 분절되어 정수 시퀀스로 변환된다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
text = '나는 너를 사랑하는데'
pd.DataFrame({'형태소': tokenizer.tokenize(text), '시퀀스': tokenizer.encode(text)}).T어휘 수(vocab_size)는 모델 헤드가 매 위치에서 점수를 매겨야 하는 후보 토큰의 총수이며, 곧 출력 로짓 차원의 크기다. 모델 구조를 함께 출력해 임베딩과 트랜스포머 블록의 크기를 확인한다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
gpt2 = model
print(f'어휘수: {tokenizer.vocab_size}')
print(gpt2)연산 장치 배치¶
대형 모델을 실용적으로 다루려면 GPU 같은 가속 장치로 옮겨야 한다. 모델 객체 자체에는 단일한 .device 속성이 없다. 매개변수가 여러 장치에 분산될 수 있기 때문이다. 따라서 장치는 개별 매개변수 텐서 단위로 확인한다. 아래는 작은 임베딩 모델을 만들어 to('cuda') 후 각 매개변수가 어느 장치에 올라가는지 점검하는 예다.
import torch
import torch.nn as nn
어휘수, 벡터차원, 시퀀스길이 = (1000, 100, 8)
pytorch_model = nn.Sequential(
nn.Embedding(어휘수, 벡터차원),
nn.Flatten(),
nn.Linear(시퀀스길이 * 벡터차원, 어휘수)
)
print(pytorch_model)
연산장치 = 'cuda' if torch.cuda.is_available() else 'cpu'
pytorch_model.to(연산장치)
# print(pytorch_model.device) # 오류! 모델 자체는 .device 정보가 없습니다.
# 여러 장치에 분산되어 있을 수 있음.
for p in pytorch_model.parameters():
print(p.device, p.shape)
입력토큰 = torch.randint(어휘수, (2, 시퀀스길이), device=연산장치)
출력 = pytorch_model(입력토큰)
assert 출력.shape == (2, 어휘수)
print("입력/출력 형상:", 입력토큰.shape, 출력.shape)
실제 생성에서는 입력 시퀀스와 모델을 같은 연산 장치에 올린 뒤 generate 를 호출해야 한다. 입력과 가중치가 서로 다른 장치에 있으면 연산이 불가능하기 때문이다. temperature 는 확률 분포의 날카로움을 조절해 생성의 다양성에 영향을 준다.
import torch
import pandas as pd
from transformers import PreTrainedTokenizerFast, AutoModelForCausalLM
from IPython.display import display
model_id = 'skt/kogpt2-base-v2'
tokenizer = PreTrainedTokenizerFast.from_pretrained(
model_id, bos_token='</s>', eos_token='</s>', unk_token='<unk>',
pad_token='<pad>', mask_token='<mask>')
model = AutoModelForCausalLM.from_pretrained(model_id).to('cpu').eval()
gpt2 = model
프롬프트 = '근육이 커지기 위해서는'
입력시퀀스 = tokenizer.encode(프롬프트, return_tensors='pt')
연산장치 = 'cuda' if torch.cuda.is_available() else 'cpu'
입력시퀀스 = 입력시퀀스.to(연산장치)
print(type(입력시퀀스), 입력시퀀스.shape)
print(f'연산장치: {입력시퀀스.device}')
print('모델 매개변수')
gpt2.to(연산장치)
for p in gpt2.parameters():
print(p.device)
break
with torch.no_grad():
출력시퀀스 = gpt2.generate(
입력시퀀스,
max_new_tokens=32, # 신규 토큰수 설정
repetition_penalty=2.0, # 반복 토큰 생성 패널티 (기본값: 1.0),
temperature=1.0,
)
생성된텍스트 = tokenizer.decode(출력시퀀스[0])
print(f'프롬프트: {프롬프트}', end=' ...\n')
print(생성된텍스트[len(프롬프트):].strip())