[NLP] 토큰화 | study book

NLP는 인간 언어의 구조, 의미 맥락을 분석하고 이해하는 알고리즘을 개발하기 위해서 다음과 같은 문제가 해결돼야 한다.

 

• 모호성: 단어와 구가 사용되는 맥락에 따라 여러 의미를 갖게 되어 모호한 경우가 많다. 이러한 모호성을 구분해야한다.
• 가변성: 사투리, 강세, 신조어, 작문 스타일 등으로 매우 가변적이다. 이러한 문제도 해결해야한다.
• 구조: 구문을 파악하여 의미를 해석해야한다. 알고리즘은 문장의 구조와 문법적 요소를 이해하며 의미를 추론하거나 분석할 수 있어야한다.

Corpus(말뭉치)

코퍼스란 자연어 모델을 훈련하고평가하는 데 사용되는 대규모의 자연어를 뜻한다.

토큰화

토큰은 개별 단어나 문장 부호와 같은 텍스트를 의미하며 말뭉치보다 더 작은 단위다. 개별 단어, 구두점 또는 기타 의미 단위일 수 있다. 토큰화는 이러한 토큰단위로 나누는 과정을 의미한다.

토크나이저

텍스트 문자열을 토큰으로 나누는 알고리즘 또는 소프트웨어를 의미한다.

예시

입력 : '형태소 분석기를 이용해 간단하게 토큰화할 수 있다.'
출력 : '형태소' '분석기' '를' '이용' '하' '여' '간단' '하' '게' '토큰' '화' '하' 'ㄹ' '수' '있' '다' '.'

기본 토크나이저 방식

토크나이저를 구축하는 방법은 공백 분할, 정규표현식 적용, 어휘 사전 적용, 머신러닝 활용등이 있다. 이 중 어휘 사전은 사전에 정의된 단어를 활용해 토크나이저를 구축하는데 직접 어휘 사전을 구축하기 때문에 없는 단어나 토큰이 존재할 수 있다. 이런 토큰을 OOV(Out of Vocab) 이라고 한다.

 

큰 어휘 사전을 구축하게 되면 학습 비용도 크고 차원의 저주에 빠질 수 있다. 토큰이나 단어를 벡터화 하면 토큰 개수만큼 차원이 필요하고 희소 데이터로 표현된다.

단어 토큰화

단어 토큰화는 품사 태깅, 개체명 인식, 기계 번역 등의 작업에서 널리 사용되며 가장 일반적인 토큰화 방법이다.

review = " 현실과 구분 불가능한 cg. 시각적 즐거음은 최고! 더불어 ost는 더더욱 최고!!"
tokenized = review.split()
print(tokenized)

주어진 문장을 특정 구분자를 입력하지 않으면 공백을 기준으로 나눈다. 토큰들이 의미로 잘 나뉜 거 같지만 "최고!" 와 "최고!!"는 비슷한 느낌이지만 서로 다른 토큰으로 나뉜다. "cg." 또한 "cg"와 비슷한 의미를 지니지만 "cg"는 토큰으로 존재하지 않아 OOV가 된다. 이처럼 단어 토큰화는 한국어 접사, 문장 부호, 오타 혹은 띄어쓰기 오류등에 취약하다.

글자 토큰화

글자 토큰화는 띄어쓰기뿐만 아니라 글자 단위로 문장을 나누는 방식이다. 작은 단어 사전을 구축할 수 있다는 장점이 있다. 학습 시 자원을 아낄 수 있으며 전체 말뭉치를 학습할 때 각 단어를 더 자주 학습할 수 있다는 장점이 있다.

 

글자 토큰화는 언어 모델링과 같은 시퀀스 예측 작업에서 활용된다. 예를 들어 다음 문자를 예측하는 언어 모델에서 글자 토큰화는 유용하다.

review = "현실과 구분 불가능한 cg. 시각적 즐거음은 최고! 더불어 ost는 더더욱 최고!!"
tokenized = list(review)
print(tokenized)

한글자 한글자 모두 토큰화 되었다. 한글의 경우 자소단위로 나눠서 자소 단위 토큰화를 수행한다. 그러한 자소 단위로 나누는 것을 도와주는 jamo 라이브러리를 활용할 수 있다. 자모 라이브러리는 한글 음절 분해 및 합성 라이브러리다.

• 자소: 언어의 문자 체계에서 의미상 구별할 수 있는 가장 작은 단위, a,b,c,ㄱ,ㄴ,ㄷ 등이 된다.

from jamo import h2j, j2hcj

decomposed = j2hcj(h2j(review))

tokenized = list(decomposed)
print(tokenized)

review = "현실과 구분 불가능한 cg. 시각적 즐거음은 최고! 더불어 ost는 더더욱 최고!!"

자모는 조합형 자모와 혼합형 자모로 나눠봐야한다.

 

h2j : 한글을 유니코드 1100에서 11FE 사이의 조합형 한글 자모로 변환해준다.

j2hcj : 조합형 한글 자모로 바뀐 자모를 완성형 자모로 변환해준다.

 

전체저그올 쉽게 이해하자면 과정을 2번 거쳐야 분해할 수 있다.

형태소 토큰화

형태소 토큰화는 텍스트를 형태소 단위로 나누는 토큰화 방법으로 언어의 문법 구조를 고려해 단어를 분리하고 의미 있는 단위로 분류하는 작업이다. 한국어와 같이 교착어 언어에서 중요하다. 각 단어가 띄어쓰기로 구분되지 않기 때문에 각 형태소를 적절히 구분해 처리해야 한다.

형태소 어휘 사전

형태소 어휘 사전은 각 형태소 정보를 포함하는 사전인데 단어에 형태소를 추가한 단어가 저장된다. 예를들어 "그는 나에게 인사를 했다" 는 "그는" "나에게" "인사를" "했다" 이런식으로 구성된다.

텍스트 데이터를 형태소 분석하여 각 형태소에 해당되는 품사를 태깅하는 작업을 품사 태깅(Part Of Speech, POS Tagging)이라고 한다. 이를 통해 문맥을 고려하는데 더욱 정확한 분석이 가능해진다.

 

앞선 예시에서 품사 태깅을 수행한다면 "그 + 는 + 나 + 에게 + 인사 + 를 + 했다" 로 태깅할 수 있다.

KoNLPy

KoNLPy는 한국어 자연어 처리를 위해 개발된 라이브러리로 명사 추출, 형태소 분석, 품사 태깅 등의 기능을 제공한다. 텍스트 마이닝, 감성 분석, 토픽 모델링 등 다양한 NLP 작업에서 사용한다.

 

KoNLPy는 자버 언어 기반의 한국어 형태소 분석기로 JDK 기반으로 개발됐다. Okt(Open Korean Text), 꼬꼬마(KKma), 코모란(Komoran), 한나눔(Hananum), 메캅(Mecab) 등의 다양한 형태소 분석기를 지원한다.

OKt

from konlpy.tag import Okt

okt = Okt()

sentence = "무엇이든 상상할 수 있는 사람은 무엇이든 만들어 낼 수 있다."

nouns = okt.nouns(sentence)  
phrases = okt.phrases(sentence)  
morphs = okt.morphs(sentence)  
pos = okt.pos(sentence)

print("명사 추출 :", nouns)  
print("구 추출 :", phrases)  
print("형태소 추출 :", morphs)  
print("품사 태깅 :", pos)

okt.nouns : 명사 추출
okt.phrases : 구 추출
okt.morphs : 형태소 추출
okt.pos : 품사 태깅

꼬꼬마

from konlpy.tag import Kkma

kkma = Kkma()

sentence = "무엇이든 상상할 수 있는 사람은 무엇이든 만들어 낼 수 있다."

nouns = kkma.nouns(sentence)  
sentences = kkma.sentences(sentence)  
morphs = kkma.morphs(sentence)  
pos = kkma.pos(sentence)

print("명사 추출 :", nouns)  
print("문장 추출 :", sentences)  
print("형태소 추출 :", morphs)  
print("품사 태깅 :", pos)

클래스는 다르지만 메소드 이름은 똑같다. 하지만 여기서 추출되는 튜플의 캐그 형식은 조금씩 차이가 있다. 그리고 반환되는 품사의 개수가 약간씩 차이가 발생한다. 형태소 같은 경우 Okt는 '낼' '수'를 반환하지 안았고 '할'을 '하' 'ㄹ'로 반환했다. 품사역시 Okt는 19개 꼬꼬마는 56개의 품사로 태깅했다.

 

태그에 관한 약자는 설명을 생략한다.

NLTK (Natural Language Toolkit)

자연어 처리를 위해 개발된 라이브러리로 토큰화, 형태소 분석, 구문 분석, 개체명 인식, 감성 분석 등과 같은 기능을 제공한다. NLTK는 주로 영어 자연어 처리를 위해 개발되었지만 네델란드어, 프랑스어, 독일어 등과 같은 다양한 언어의 자연어 처리를 위한 데이터와 모델을 제공한다.

 

NLTK를 활용하기 위해서는 해당 작업을 수행할 수 있는 모델을 다운받아야한다. Punkt나 Averaged Perceptron Tagger 모델 등이 있다.

두 모델 모두 트리뱅크라는 대규모 영어 말뭉치 기반으로 학습됐다. Punkt 모델은 통계기반, Averaged Perceptron Tagger는 퍼셉트론 기반으로 품사 태깅을 수행한다.

import nltk

# 모델 불러오기

nltk.download("punkt")  
nltk.download("averaged\_perceptron\_tagger")

from nltk import tokenize

sentence = "Those who can imagine anything, can create the impossible."

word\_tokens = tokenize.word\_tokenize(sentence)  
sent\_tokens = tokenize.sent\_tokenize(sentence)

print(word\_tokens)  
print(sent\_tokens)

아까는 한글을 토큰화 했다면 이번에는 nltk를 이용해 영문을 토큰화하였다. 단어 토크나이저와 문장 토크나이저가 있는데 단어토크나이저는 공백을 기준으로 단어를 분리하고 구두점 등을 처리해 각각의 단어를 추출해 리스트로 반환한다.

문장 토크나이저는 문장을 입력받아 마침표, 느낌표,물음표 등의 구두점을 기준으로 문장을 분리해 리스트를 반환한다.

from nltk import tag  
from nltk import tokenize

sentence = "Those who can imagine anything, can create the impossible."

word\_tokens = tokenize.word\_tokenize(sentence)  
pos = tag.pos\_tag(word\_tokens)

print(pos)

nltk의 태깅 방식은 위와 같다. 총 35개의 품사를 태깅할 수 있다. 약자에 대한 설명은 생략한다.

spaCy

spaCy는 사이썬(Cython, 오타아님)을 기반으로 개발된 오픈 소스 라이브러리로 NLTK와 마찬가지로 자연어 처리를 위한 기능을 제공한다. NLTK와의 차이점은 빠른 속도와 높은 정확도를 목표로 하는 머신러닝 기반의 라이브러리라는 점이다.

import spacy

nlp = spacy.load("en\_core\_web\_sm")  
sentence = "Those who can imagine anything, can create the impossible."  
doc = nlp(sentence)

for token in doc:  
print(f"\[{token.pos\_:5} - {token.tag\_:3}\] : {token.text}")

사전 학습 모델로 en_core_web_sm 를 사용한다. spaCy는 OOP이기 때문에 처리한 결과를 doc 객체에 저장한다.doc 객체는 다시 여러 token 객체로 이뤄져 있으며 token 객체에 대한 정보를 기반으로 다양한 자연어처리 수행이 가능하다.

 

token 객체의 프로퍼티설명은 다음과 같다.

pos_ : 기본 품사 속성
tag_ : 세분화 품사 속성
text : 원본 텍스트 데이터
text_with_ws : 토큰 사이의 공백을 포함하는 텍스트 데이터
vector: 벡터
vector_norm : 벡터 노름

 

태그 약자에 대한 설명은 생략한다.

하위 단어 토큰화

하위 단어 토큰화란 하나의 단어가 빈번하게 사용되는 하위 단어의 조합으로 나우어 토큰화 하는 방법이다. Reinforcement 라는 단어가 비교적 길어 처리가 어려울 수 있다. 하위 단어 토큰화를 적용한다면 Rein force ment 등으로 나눠 처리할 수 있다. 이러한 방법을 하는 이유는 OOV, 신조어, 은어, 고유어등의 문제를 완화할 수 있다. 예를 들어 "시보리도 짱짱해고 허리도 어벙하지안구 죠하효" 처럼 외래어와 고유어, 사투리 등 섞여있다. "시" "보리" "도" "짱짱해고" "허리" "도" "어" "벙하지안구" "죠" "하" "효" 처럼 전문 용어와 고유어가 많은 데이터를 처리할 때 약점을 보인다.

 

하위 단어 토큰화 방법으로 바이트 페어 인코딩, 워드피스, 유니그램 모델 등이 있다.

바이트 페어 인코딩 (Byte Pair Encoding, BPE)

BPE란 다이그램 코딩이라고도 하며 하위 단어 토큰화의 한 종류다. 텍스트 데이터에서 가장 빈번하게 등장하는 글자 쌍의 조합을 찾아 부호화하는 압축 알고리즘으로 초기에는 데이터 압축을 위해 개발됐으나 자연어 처리 분야에서 하위 단어 토큰화를 위한 방법으로 사용된다.

 

연속된 글자 쌍이 더 이상 나타나지 않거나 정해진 어휘 사전 크기에 도달할 때 까지 조합탐지와 부호화를 반복하여 자주 등장하는 단어는 하나의 토큰으로 토큰화되고 덜 등장하는 단어는 여러 토큰의 조합으로 표현된다.

abracadabra -> AracadAra -> ABcadAB -> CCadC

 

데이터에서 가장 많은 글자의 빈도수를 측정하고 가장 빈도수가 높은 글자 쌍을 탐색한다. 첫 스텝에서 'ab' 글자 쌍이 가장 빈도수가 높아 없는 새로운 글자 A로 치환한다. 다음 'ra' 빈도수가 높아 'B' 아직 AB라는 글자 쌍이 다시 생기므로 'C"로 치환.

더 이상 치환할 수 있는 글자 쌍이 존재하지 않으므로 입력 데이터를 더 이상 압축할 수 없다.

 

다음과 같은 빈도, 어휘 사전을 바이트 페어 인코딩을 적용해보자.

빈도 사전: ('low', 5)('low', 2)('newest', 6)('widest', 3)
어휘 사전: low, lower, newest, widest

 

사전내 모든 단어를 글자 단위로 나눈다. 그리고 가장 자주 등장한 글자 쌍을 찾는다. 'es' 쌍이 newest에서 6번 widest에서 3번 등장해 총 9번으로 가장 많다. 그러므로 es를 어휘 사전에 추가한다. 동일 과정을 반복한다. 'es'와 't' 쌍을 다시 'est'로 병합하고 어휘 사전에 추가한다.

 

최종적으로 10번을 수행하면 다음과 같은 어휘 사전이 생성된다.

빈도 사전: (low, 5) (low,e,r,2) (n,e,w,est,6) (w,i,d,est,3)
어휘 사전: (d,e,i,l,n,o,r,s,t,w,es,est,lo,low,ne,new,newest,wi,wid,widest)

 

BPE 알고리즘을 사용해 말뭉치에서 자중 등장하는 글자 쌍을 찾아 어휘 사전을 구축했다. 따라서 기존 말뭉치에 없었던 단어가 입력되도 OOV로 처리되지 않고 기존 어휘 사전에서 찾을 수 있다.

센텐스피스(Setencepiece)

센텐스피스 라이브러리는 구글에서 개발한 오픈소스 하위 단어 토크나이저 라이브러리다. BPE와 유사한 알고리즘을 사용해 토큰화하여 단어를 생성한다. 워드피스, 유니코드 기반이기에 다양한 알고리즘을 지원하며 사용자가 직접 하이퍼 파라미터를 조정하여 토크나이징을 할 수 있다.

from Korpora import Korpora

corpus = Korpora.load("korean\_petitions")  
dataset = corpus.train  
petition = dataset\[0\]

print("청원 시작일 :", petition.begin)  
print("청원 종료일 :", petition.end)  
print("청원 동의 수 :", petition.num\_agree)  
print("청원 범주 :", petition.category)  
print("청원 제목 :", petition.title)  
print("청원 본문 :", petition.text\[:30\])

코포라를 통해 말뭉치 불러오기를 수행할 수 있다. 청와대의 청원 데이터를 불러온다.

from Korpora import Korpora

corpus = Korpora.load("korean\_petitions")  
petitions = corpus.get\_all\_texts()  
with open("/content/corpus.txt", "w", encoding="utf-8") as f:  
for petition in petitions:  
f.write(petition + "\\n")

get_all_texts 는 본문 데이터를 한번에 불러올 수 있다. 그것을 하나의 텍스트 파일로 저장한다.

from sentencepiece import SentencePieceTrainer

SentencePieceTrainer.Train(  
"--input=../content/corpus.txt  
\--model\_prefix=/content/petition\_bpe  
\--vocab\_size=8000 model\_type=bpe"  
)

SentencePieceTrainer을 통해 토크나이저 모델을 학습할 수 있다. 센텐스피스는 문자열 입력으로 인자를 전달받는다.
input : 말뭉치 텍스트 파일 경로
model_prefix : 모델 파일 이름
vocab_size : 어휘 사전 크기
character_coverage : 말뭉치 내 존재하는 글자 중 토크나이저가 다룰 수 있는 글자의 비율
model_type : unigram, bpe, char, word
max_sentence_length : 최대 문장 길이

 

토크나이저 모델 학습이 완료되면 petition_bpe.model 파일과 petition_bpe.vocab 파일이 생성된다. 어휘 사전 파일을 열어보면 밑줄 문자가 포함된 데이터를 볼 수 있는데 띄어쓰기나 공백도 특수문자로 췯급해 토큰화 과정에서 _로 공백을 표현한다.

from sentencepiece import SentencePieceProcessor

tokenizer = SentencePieceProcessor()  
tokenizer.load("/content/petition\_bpe.model")

sentence = "안녕하세요, 토크나이저가 잘 학습되었군요!"  
sentences = \["이렇게 입력값을 리스트로 받아서", "쉽게 토크나이저를 사용할 수 있답니다"\]

tokenized\_sentence = tokenizer.encode\_as\_pieces(sentence)  
tokenized\_sentences = tokenizer.encode\_as\_pieces(sentences)  
print("단일 문장 토큰화 :", tokenized\_sentence)  
print("여러 문장 토큰화 :", tokenized\_sentences)

encoded\_sentence = tokenizer.encode\_as\_ids(sentence)  
encoded\_sentences = tokenizer.encode\_as\_ids(sentences)  
print("단일 문장 정수 인코딩 :", encoded\_sentence)  
print("여러 문장 정수 인코딩 :", encoded\_sentences)

decode\_ids = tokenizer.decode\_ids(encoded\_sentences)  
decode\_pieces = tokenizer.decode\_pieces(encoded\_sentences)  
print("정수 인코딩에서 문장 변환 :", decode\_ids)  
print("하위 단어 토큰에서 문장 변환 :", decode\_pieces)

SentencePieceProcessor를 통해 학습된 모델 기반으로 토큰화를 수행할 수 있다. _ids 가 붙은 메소드는 토큰에 매핑된 ID 값을 의미한다. 그리고 다음과 같이 활용할 수 있다.

from sentencepiece import SentencePieceProcessor

tokenizer = SentencePieceProcessor()  
tokenizer.load("/content/petition\_bpe.model")

vocab = {idx: tokenizer.id\_to\_piece(idx) for idx in range(tokenizer.get\_piece\_size())}  
print(list(vocab.items())\[:5\])  
print("vocab size :", len(vocab))

id_to_piece 메소드를 통해서 하위 단어의 개수 만큼 아이디 순서대로 가져온다. 여기서 <unk> <s>, </s>를 확인할 수 있다.
<unk> : 언노운의 약자로 OOV 발생 시 매핑된다.
<s>와 </s> : 문장의 시작과 끝 지점을 표시한다.

워드피스

워드피스또한 BPE 와 비슷한 방식으로 학습되지만 빈도 기반이 아닌 확률 기반으로 글자 쌍을 병합한다. 워드피스는 학습 과정에서 확률적인 정보를 사용한다. 모델이 새로운 하위 단어를 생성할 때 이전 하위 단어와 함께 나타날 확률을 계산해 가장 높은 확률을 가진 하위 단어를 선택한다. 이렇게 선택된 하위 단어는 이후에 더 높은 확률로 선택될 가능성이 높으며 이를 통해 모델이 좀 더 정확한 하위 단어로 분리할 수 있다. 각 글자 쌍에 점수 부여 방식은 다음과 같다.

$$ score = \frac{f(x,y)}{f(x),f(y)} $$

f는 빈도를 나타내는 함수이며 x,y는 병합하련느 하위 단어이다. f(x,y)는 xy 글자 쌍의 빈도가 된다.

빈도 사전: (l,o,w, 5) (l,o,w,e,r,2) (n,e,w,e,s,t,6) (w,i,d,e,s,t,3)
어휘 사전: (d,e,i,l,n,o,r,s,t,w)

 

가장 빈번한 등장의 쌍은 e와 s다. 하지만 e는 17번 s는 9번 등장하여 점수는 9/17x9=0.06이 된다. i와 d는 3번 밖에 등장하지 않지만 각각 3번씩이므로 3/3x3=0.33이 된다. 따라서 es 대신 id를 우선으로 병합한다.

2번째는 lo가 점수가 높아 다음과 같이 변한다.

 

빈도 사전: (lo,w, 5) (lo,w,e,r,2) (n,e,w,e,s,t,6) (w,id,e,s,t,3)
어휘 사전: (d,e,i,l,n,o,r,s,t,w,id,lo)

토크나이저스

토크나이저스 라이브러리의 워드피스 API를 이용하면 쉽고 빠르게 토크나이저를 구현할 수 있다. 이번엔 센텐스피스 라이브러리 대신 허깅 페이스의 토크나이저스 라이브러리를 사용한다.

 

토크나이저스는 정규화와 사전 토큰화를 제공한다.

 

정규화는 일관된 형식으로 텍스트를 표준화하고 모호한 경우를 방지하기 위해 일부 문자를 대체 혹은 제거한다. 불필요한 공백제거, 대소문자 변환 ,유니코드 정규화, 구두점 처리, 특수 문자 처리 등을 제공한다.

 

사전 토큰화는 입력 문장을 토큰화하기 전에 단어와 같은 작은 단위로 나누는 기능을 제공한다. 공백 혹은 구두점을 기준으로 입력 문장을 나눠 텍스트 데이터를 효율적으로 처리한다.

from tokenizers import Tokenizer  
from tokenizers.models import WordPiece  
from tokenizers.normalizers import Sequence, NFD, Lowercase  
from tokenizers.pre\_tokenizers import Whitespace

tokenizer = Tokenizer(WordPiece())  
tokenizer.normalizer = Sequence(\[NFD(), Lowercase()\])  
tokenizer.pre\_tokenizer = Whitespace()

tokenizer.train(\["/content/corpus.txt"\])  
tokenizer.save("/contentmodels/petition\_wordpiece.json")

토크나이저스로 워드피스를 가져온다. normalizer 메소드로 정규화를 하는데 시퀀스 형식으로 인스턴스를 전달한다. NFD는 유니코드 정규화, Lowercase는 소문자 변환을 사용한다.

 

사전 토큰화 방식도 pre_tokenizer 메소드를 통해서 불러온다. Whitespace 객체는 단어 경계를 공백과 구두점을 기준으로 사전 토큰화를 진행한다. \w+|[&\w\s]+ 정규표현식을 사용한다.

 

나머지 정규화 클래스와 사전 토큰화 클래스는 생략한다.

from tokenizers import Tokenizer
from tokenizers.decoders import WordPiece as WordPieceDecoder

tokenizer = Tokenizer.from_file("/content/petition_wordpiece.json")
tokenizer.decoder = WordPieceDecoder()

sentence = "안녕하세요, 토크나이저가 잘 학습되었군요!"
sentences = ["이렇게 입력값을 리스트로 받아서", "쉽게 토크나이저를 사용할 수 있답니다"]

encoded_sentence = tokenizer.encode(sentence)
encoded_sentences = tokenizer.encode_batch(sentences)

print("인코더 형식 :", type(encoded_sentence))

print("단일 문장 토큰화 :", encoded_sentence.tokens)
print("여러 문장 토큰화 :", [enc.tokens for enc in encoded_sentences])

print("단일 문장 정수 인코딩 :", encoded_sentence.ids)
print("여러 문장 정수 인코딩 :", [enc.ids for enc in encoded_sentences])

print("정수 인코딩에서 문장 변환 :", tokenizer.decode(encoded_sentence.ids))

학습이 완료된 json 형태의 정보를 통해 토크나이저를 수행할 수 있다.

 

https://product.kyobobook.co.kr/detail/S000209621433