Corpus Preprocessing

Ⅰ. 전처리

ⅰ. 코퍼스란?

• 단일 언어 코퍼스(monolingual corpus) : 한 가지 언어로 구성된 코퍼스를 의미한다.

• 이중 언어 코퍼스(bilingual corpus) : 2가지 언어로 구성된 코퍼스를 의미한다.

• 다중 언어 코퍼스(multilingual corpus) : 다수의 언어로 구성된 코퍼스를 의미한다.

• 병렬 코퍼스(parallel corpus) : 언어 간에 쌍으로 구성되는 코퍼스를 의미한다.

영문	한글
I love to go to school.	나는 학교에 가는 것을 좋아한다.
I am a doctor.	나는 의사입니다.

ⅱ. 전처리 과정 개요

1. 코퍼스 수집

2. 정제

3. 문장 단위 분절

4. 분절

5. 병렬 코퍼스 정렬(생략가능)

6. 서브워드 분절

1. 코퍼스 수집

$ wget https://www.ted.com/robots.txt
$ cat robots.txt
User-agent: *
Disallow: /latest
Disallow: /latest-talk
Disallow: /latest-playlist
Disallow: /people
Disallow: /profiles
Disallow: /conversations

User-agent: Baiduspider
Disallow: /search
Disallow: /latest
Disallow: /latest-talk
Disallow: /latest-playlist
Disallow: /people
Disallow: /profiles

2. 정제

• 전각 문자 제거
일반적으로 사용되는 반각 문자로 변환해주는 작업이 필요하다.





! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 
: ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
[ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~

즉, 위의 전각문자들을 각 문자에 해당하는 반각문자로 바꾸어주는 작업이 필요하다.
 

• 대소문자 통일
일부 영어 코퍼스에서는 약자등에서 대소문자 표현이 통일되지 않을 때가 있습니다.
예를 들어 New York City의 줄임말(약자)인 NYC의 경우 다음과 같이 표현할 수 있다.

• 정규 표현식을 사용한 정제
통상적으로 크롤링을 통해 얻어낸 대량의 코퍼스들은 잡다한 노이즈가 섞일 때가 많다. 혹은 웹사이트 성격에 따라 일정한 패턴을 지니는 경우도 많다. 이를 효과적으로 정제하는데 있어 정규표현식(regex)을 잘 활용해야 한다.
 
👉 정규표현식 시각화 사이트 : https://regexper.com/
간단한 문법만 정리해보자.
• [ ] : 대괄호 안에 들어가 있는 각 요소를 or로 표기한다.
• [23456cde] → 2 or 3 or 4 or 5 or 6 or c or d or e
• - : 연속된 숫자 또는 알파벳을 표현할 수 있다.
• [2-5c-e] → 2~5 and c~e
• [^] : Not을 ^ 기호로 표현할 수 있다.
• [^2-5c-e] → Not (2~5 and c~e)
• ( ) : 괄호를 이용해 그룹을 만들 수 있다.
• (x)(yz) → x와 yz를 각각의 그룹으로 묶는다.
• | : | 기호를 이용하여 or을 표현할 수 있다.
• (x|y) → x or y
• ?, *, + : 각 기호에 따라 의미하는 바가 다르다.
• ? : 앞의 수식하는 부분이 나타나지 않거나 한 번만 나타날 때는 “?”를 사용한다.
• x? → x가 나타나지 않거나 한 번만 나타남.
• + : 앞에 수식하는 부분이 한 번 이상 나타날 때 ‘+’를 사용한다.
• x+ → x가 한 번 이상 나타난다.
• * : 앞의 수식하는 부분이 나타나지 않거나 여러 번 나타날 때 ‘*’를 사용한다.
• x* → x가 나타나지 않거나 여러번 나타난다.
• {n}, {n,}, {n,m} : 각 기호에 따라 의미하는 바가 다르다.
• {n} : 정확한 반복횟수를 알고있을 때 표현한다.
• x{n} → x가 n번 나타난다.
• {n,} : n번 이상 반복할 때 표현한다.
• x{n,} → x가 n번 이상 나타난다.
• {n,m} : 정확한 반복횟수의 범위를 알고있을 때 표현한다.
• x{n,.m} → x가 n번에서 m번 만큼 나타난다.
• . : 매우 강력한 표현. 어떤 글자던 다 포함한다.
• ^과 $ : ‘[’과’]’안에 포함되지 않은 ‘^’은 라인의 시작을 의미하며 ‘$’은 라인의 종료를 의미한다.
• ^x$ → (start of line) x (end of line)
• 지정문자
• \s : 공백문자
• \S : 공백문자를 제외한 모든 문자
• \w : alphanumeric(알파벳+숫자)+’_’ (= [A-Za-z0-9_])
• \W : nonalphnumeric 문자 및 ‘_’ 제외(=[^A-Za-z0-9_])
• \d : 숫자(=[0-9])
• \D : 숫자를 제외한 모든 문자 (=[^0-9])

# 파이썬에서 정규표현식 사용

# Hello Ki, I would like to introduce regular expression in this section
# ~~
# Thank you!
# Sincerely,
# Ki: +82-10-1234-5678
# ▲ 위 텍스트에서 마지막줄을 모든 경우에 대해 정제하는 정규표현식을 짜보자.

# 마지막줄을 보고 아래 규칙을 생각해 볼 수 있다.
# - 이름이 전화번호 앞에 나올 수도 있다.
# - 이름 뒤에는 콜론이 나올 수도 있다.
# - 콜론 앞/뒤로는 (탭을 포함한) 공백이 다수 존재할 수도 있다.
# - 전화번호는 국가번호를 포함할 수도 있다.
# - 국가번호는 최대 3자리이다.
# - 국가번호의 앞에는 '+'가 붙을 수도 있다.
# - 전화번호 사이에 '-'가 들어갈 수도 있다.
# - 전화번호는 빈칸 없이 표현된다.
# - 전화번호 맨 앞과 지역번호(또는 010)의 다음에는 괄호가 들어갈 수도 있다.
# - 괄호는 한쪽만 나올 수도 있다.
# - 지역번호 자리의 맨 처음에 나오는 0은 빠질 수도 있다. 즉, 2자리가 될 수도 있따.
# - 지역번호 다음 번호 그룹은 3에서 4자리 숫자이다.
# - 마지막은 항상 4자리 숫자이다.


import re
regex = r"([\w]+\s*:?\s*)?\(?\+?([0-9]{1,3})?\-?[0-9]{2,3}(\)|\-)?[0-9]{3,4}\-?[0-9]{4}"

x = "Ki: +82-10-1234-5678"
re.sub(regex, "REMOVED", x) # REMOVED

# 치환자 사용
# 아래 x에 대한 텍스트 데이터 중 문자사이에 숫자가 들어간 경우에 대해서만 정제해보자.
x = """abcdefg
12345
ab12
a1bc2d
12ab
a1b
1a2
a1
1a
hijklmnop"""

regex = r'([a-z])[0-9]+([a-z])'
to = r'\1\2'#그룹을 변수명처럼 활용

y = ' '.join([re.sub(regex, to, x_i) for x_i in x.split('\n')])
# 'abcdefg 12345 ab12 abcd 12ab ab 1a2 a1 1a hijklmnop'

• 문장 단위 분절
보통 다루려는 문제들은 입력 단위가 문장 단위인 경우가 많다.
즉, 대부분의 경우 한 라인에 한 문장만 있어야 한다. 여러 문장이 한 라인에 있거나, 한 문장이 여러 라인에 걸쳐 있는 경우에는 문장 단위 분절이 필요합니다.
다만, 단순히 마침표를 기준으로 문장단위 분절을 수행하는것 보단 널리 알려진 자연어 처리 툴킷인 NLTK(3.2.5 version 이상)을 사용하는게 좋다.
• 문장 단위 분절 예제

import sys, fileinput, re
from nltk.tokenize import sent_tokenize


if __name__=="__main__":
    for line in fileinput.input():
        if line.strip() != "":
            line = re.sub(r'([a-z])\.([A-Z])', r'\1.\2', line.strip())

            sentences = sent_tokenize(line.strip())

            print("="*100)

            for s in sentences:
                if s != "":
                    sys.stdout.write(s+"\n")


# - 결과 -
# > 적용 전 데이터
# 자연어처리는 인공지능의 한 줄기 입니다. 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼  수 있게 된 것입니다.
# ====================================================================================================
# > 적용 후 데이터
# 자연어처리는 인공지능의 한 줄기 입니다.
# 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다.
# 문장을 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수 있게 된 것입니다.

• 문장 합치기 및 분절 예제

import sys, fileinput, re
from nltk.tokenize import sent_tokenize

if __name__=="__main__":
    # - 적용 전 데이터 -
    # 자연어처리는 인공지능의 한 줄기 입니다.\n
    # 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을 \n
    # 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수 \n
    # 있게 된 것입니다.
    buf = []

    text = ["자연어처리는 인공지능의 한 줄기 입니다.\n",
    "시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을\n",
    "받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수\n",
    "있게 된 것입니다.\n"]

    for line in text:
        if line.strip() != "":
            buf += [line.strip()]
            sentences = sent_tokenize(" ".join(buf))

            if len(sentences) > 1:
                buf = sentences[1:]

                sys.stdout.write(sentences[0] + '\n')

    sys.stdout.write(" ".join(buf) + "\n")

# - 결과 -
# > 적용 전 데이터
# 자연어처리는 인공지능의 한 줄기 입니다.\n
# 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을 \n
# 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수 \n
# 있게 된 것입니다.
# ====================================================================================================
# > 적용 후 데이터
# 자연어처리는 인공지능의 한 줄기 입니다.
# 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다.
# 문장을 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수 있게 된 것입니다.

• 전체 예제 통합

import sys, fileinput, re
from nltk.tokenize import sent_tokenize


def seperate_sentence():
    # - 적용 전 데이터 -
    # 자연어처리는 인공지능의 한 줄기 입니다. 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수 있게 된 것입니다.
    for line in fileinput.input():
        if line.strip() != "":
            line = re.sub(r'([a-z])\.([A-Z])', r'\1.\2', line.strip())

            sentences = sent_tokenize(line.strip())

            print("="*100)

            for s in sentences:
                if s != "":
                    sys.stdout.write(s+"\n")

def combine_sentence():
    # - 적용 전 데이터 -
    # 자연어처리는 인공지능의 한 줄기 입니다.\n
    # 시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을 \n
    # 받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수 \n
    # 있게 된 것입니다.
    buf = []

    text = ["자연어처리는 인공지능의 한 줄기 입니다.\n",
    "시퀀스 투 시퀀스의 등장 이후로 딥러닝을 활용한 자연어처리는 새로운 전기를 맞이하게 되었습니다. 문장을\n",
    "받아 단순히 수치로 나타내던 시절을 넘어, 원하는대로 문장을 만들어낼 수\n",
    "있게 된 것입니다.\n"]

    for line in text:
        if line.strip() != "":
            buf += [line.strip()]
            sentences = sent_tokenize(" ".join(buf))

            if len(sentences) > 1:
                buf = sentences[1:]

                sys.stdout.write(sentences[0] + '\n')

    sys.stdout.write(" ".join(buf) + "\n")

if __name__=="__main__":
    combine_sentence()

    seperate_sentence()

• 분절
분절의 종류는 형태소 분석과 단순분절로 구분지을 수 있고, 이를 통해 정규화를 수행한다.
그중 한국어는 매우 까다롭고 어려운 상위언어에 속하고 주요 프로그램으로 Mecab과 KoNLPy를 이용한다.

• 병렬 코퍼스 정렬
대부분의 병렬 코퍼스들은 여러 문장 단위로 정렬된다.
예를 들어, 영자 신문에서 크롤링한 영문 뉴스 기사는 한글 뉴스기사에 맵핑되지만, 문서와 문서 단위의 맵핑일 뿐 문장 대 문장에 관한 정렬은 이루어져 있지 않다.
해당 부분에 대해서는 seq2seq모델과 Transformer 모델 학습시기에 다시한번 살펴보겠다.
 

3. 토치텍스트

4. 토큰화(Tokenizing)

import spacy
spacy_en = spacy.load('en_core_web_sm')

def tokenize(en_text):
    return [tok.text for tok in spacy_en.tokenizer(en_text)]

en_text = "A Dog Run back corner near spare bedrooms"
print(tokenize(en_text))

import nltk
from nltk.tokenize import word_tokenize

nltk.download('punkt')

en_text = "A Dog Run back corner near spare bedrooms"
print(f'NLTK : {word_tokenize(en_text)}')

• 단어집합(vocabulary) : 중복을 제거한 텍스트의 총 단어 집합(set)을 의미한다.

from konlpy.tag import Mecab
tokenizer = Mecab()
print(tokenizer.morphs(kor_text))

#['사과', '의', '놀라운', '효능', '이', '라는', '글', '을', '봤', '어', '.', '그래서', '오늘', '사과', '를', '먹', '으려고', '했', '는데', '사과', '가', '썩', '어서', '슈퍼', '에', '가', '서', '사과', '랑', '오렌지', '사', '왔', '어']

import urllib.request
import pandas as pd
from eunjeon import Mecab
from nltk import FreqDist
import numpy as np
import matplotlib.pyplot as plt

urllib.request.urlretrieve("https://raw.githubusercontent.com/e9t/nsmc/master/ratings.txt", filename="ratings.txt")
data = pd.read_table('ratings.txt')
print(data[:10])
print('전체 샘플의 수 : {}'.format(len(data)))

sample_data = data[:100]
sample_data['document'] = sample_data['document'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣]", "")

stop_words = ['의','가','이','은','들','는','좀','잘','걍','과','도','를','으로','자','에','와','한','하다']
tokenizer = Mecab()
tokenized = []
for sentence in sample_data['document']:
    temp = tokenizer.morphs(sentence)
    temp = [word for word in temp if not word in stop_words]
    tokenized.append(temp)
# print(tokenized[:10])
vocab = FreqDist(np.hsatck(tokenized))
# print(f'단어 집합의 크기 : {len(vocab)}')
vocab_size = 500
vocab = vocab.most_common(vocab_size) # 상위 vocab_size개의 단어만 보존

word_to_index = {word[0]:index+2 for index, word in enumerate(vocab)}
word_to_index['pad'] = 1
word_to_index['unk'] = 0

encoded = []
for line in tokenized:
    temp = []
    for w in line:
        try:
            temp.append(word_to_index[w])
        except KeyError:
            temp.append(word_to_index['unk'])
    encoded.append(temp)

max_len = max(len(l) for l in encoded)
for line in encoded:
    if len(line) < max_len:
        line += [word_to_index['pad']] * (max_len - len(line))

5. torchtext를 이용한 전처리 간소화

from torchtext import data
from torchtext.data import TabularDataset, Iterator
import urllib.request
import pandas as pd


urllib.request.urlretrieve("https://raw.githubusercontent.com/LawrenceDuan/IMDb-Review-Analysis/master/IMDb_Reviews.csv", filename="IMDb_Reviews.csv")
df = pd.read_csv('IMDb_Reviews.csv', encoding='latin1')

train_df = df[:25000]
test_df = df[25000:]

train_df.to_csv("train_data.csv", index=False)
test_df.to_csv("test_data.csv", index=False)

# field Definition
TEXT = data.Field(sequential=True, use_vocab=True, tokenize=str.split, lower=True, batch_first=True, fix_length=20)
LABEL = data.Field(sequential=False, use_vocab=False, batch_first=False, is_target=True)

# sequential : 시퀀스 데이터 여부. (True가 기본값)
# use_vocab : 단어 집합을 만들 것인지 여부. (True가 기본값)
# tokenize : 어떤 토큰화 함수를 사용할 것인지 지정. (string.split이 기본값)
# lower : 영어 데이터를 전부 소문자화한다. (False가 기본값)
# batch_first : 미니 배치 차원을 맨 앞으로 하여 데이터를 불러올 것인지 여부. (False가 기본값)
# is_target : 레이블 데이터 여부. (False가 기본값)
# fix_length : 최대 허용 길이. 이 길이에 맞춰서 패딩 작업(Padding)이 진행된다.

# TabularDataset은 데이터를 불러오면서 필드에서 정의했던 토큰화 방법으로 토큰화를 수행합니다.
train_data, test_data = TabularDataset.splits(
    path=".", trainn='train_data.csv', test='test_data.csv', format='csv',
    fields=[('text', TEXT), ('label', LABEL)], skip_header=True)

# path : 파일이 위치한 경로.
# format : 데이터의 포맷.
# fields : 위에서 정의한 필드를 지정. 첫번째 원소는 데이터 셋 내에서 해당 필드를 호칭할 이름, 두번째 원소는 지정할 필드.
# skip_header : 데이터의 첫번째 줄은 무시.

TEXT.build_vocab(train_data, min_freq=10, max_size=10000)
# min_freq : 단어 집합에 추가 시 단어의 최소 등장 빈도 조건을 추가.
# max_size : 단어 집합의 최대 크기를 지정.


batch_size = 5
train_loader = Iterator(dataset=train_data, batch_size=batch_size)
test_loader = Iterator(dataset=test_data, batch_size=batch_size)

batch = next(iter(train_loader)) #첫번째 미니배치