자연어 처리 쪽으로 아주 괜찮은 위키독스를 발견하여 쭉 읽어보고 있다. 나중에도 두고두고 볼 것 같아서 정리해 두는 글.
✅ 토큰화
주어진 코퍼스에서 용도에 맞게 토큰이라 불리는 단위로 나누는 작업
📌 단어 토큰화
토큰의 기준 : 단어
from nltk.tokenize import word_tokenize
print('단어 토큰화1 :',word_tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop."))
단어 토큰화1 : ['Do', "n't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr.', 'Jone', "'s", 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.']
from nltk.tokenize import WordPunctTokenizer
print('단어 토큰화2 :',WordPunctTokenizer().tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop."))
['Don', "'", 't', 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr', '.', 'Jone', "'", 's', 'Orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.']
from tensorflow.keras.preprocessing.text import text_to_word_sequence
print('단어 토큰화3 :',text_to_word_sequence("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop."))
단어 토큰화3 : ["don't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', 'mr', "jone's", 'orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop']다음의 경우를 고려하여 토큰화를 진행해야 한다.
1. Ph.D, $45.55, 24/08/14와 같이 단어 자체에 구두점이나 특수문자가 있는 경우
2. We're, New York과 같이 줄임말과 단어 내 띄어쓰기가 있는 경우
이를 고려한 토큰화 방법 중 하나로 Penn Treebank Tokenization이 있다. 이 방법은 다음 규칙을 따른다.
1. 하이픈으로 구서오딘 단어는 하나로 유지
2. 아포스트로피로 '접어'가 함께하는 단어는 분리
from nltk.tokenize import TreebankWordTokenizer
tokenizer = TreebankWordTokenizer()
text = "Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own."
print('트리뱅크 워드토크나이저 :',tokenizer.tokenize(text))
트리뱅크 워드토크나이저 : ['Starting', 'a', 'home-based', 'restaurant', 'may', 'be', 'an', 'ideal.', 'it', 'does', "n't", 'have', 'a', 'food', 'chain', 'or', 'restaurant', 'of', 'their', 'own', '.']📌 문장 토큰화
NLTK는 단순히 마침표를 구분자로 하여 문장을 구분하지 않기 때문에 Ph.D.와 같이 구두점이 있어도 문장 내의 단어로 인식한다.
from nltk.tokenize import sent_tokenize
text = "I am actively looking for Ph.D. students. and you are a Ph.D student."
print('문장 토큰화 :',sent_tokenize(text))
문장 토큰화 : ['I am actively looking for Ph.D. students.', 'and you are a Ph.D student.']한국어 문장 토큰화 도구는 박상길님의 KSS(Korean Sentence Splitter)가 있다.
pip install kss
import kss
text = '딥 러닝 자연어 처리가 재미있기는 합니다. 그런데 문제는 영어보다 한국어로 할 때 너무 어렵습니다. 이제 해보면 알걸요?'
print('한국어 문장 토큰화 :',kss.split_sentences(text))
한국어 문장 토큰화 : ['딥 러닝 자연어 처리가 재미있기는 합니다.', '그런데 문제는 영어보다 한국어로 할 때 너무 어렵습니다.', '이제 해보면 알걸요?']📌 한국어 토큰화의 어려움
- 한국어는 영어와 달리 조사와 어미가 붙는 교착어의 특징을 갖는다. 따라서 띄어쓰기 단위가 아닌 형태소 단위 토큰화를 해주어야 한다.
- 한국어는 영어보다 띄어쓰기가 어렵고 잘 지켜지지 않는다.
📌 품사 태깅
NLTK에서는 Penn Treebank POS Tags라는 기준을 사용하여 품사를 태깅한다.
from nltk.tokenize import word_tokenize
from nltk.tag import pos_tag
text = "I am actively looking for Ph.D. students. and you are a Ph.D. student."
tokenized_sentence = word_tokenize(text)
print('단어 토큰화 :',tokenized_sentence)
print('품사 태깅 :',pos_tag(tokenized_sentence))
단어 토큰화 : ['I', 'am', 'actively', 'looking', 'for', 'Ph.D.', 'students', '.', 'and', 'you', 'are', 'a', 'Ph.D.', 'student', '.']
품사 태깅 : [('I', 'PRP'), ('am', 'VBP'), ('actively', 'RB'), ('looking', 'VBG'), ('for', 'IN'), ('Ph.D.', 'NNP'), ('students', 'NNS'), ('.', '.'), ('and', 'CC'), ('you', 'PRP'), ('are', 'VBP'), ('a', 'DT'), ('Ph.D.', 'NNP'), ('student', 'NN'), ('.', '.')]한국어 자연어 처리를 위해서는 KoNLPy라는 파이썬 패키지를 활용할 수 있다. KoNLPy로 사용할 수 있는 형태소 분석기에는 Okt(Open Korea Text), 메캅(Mecab), 코모란(Komoran), 한나눔(Hannanum), 꼬꼬마(Kkma)가 있다.
from konlpy.tag import Okt
from konlpy.tag import Kkma
okt = Okt()
kkma = Kkma()
print('OKT 형태소 분석 :',okt.morphs("열심히 코딩한 당신, 연휴에는 여행을 가봐요"))
print('OKT 품사 태깅 :',okt.pos("열심히 코딩한 당신, 연휴에는 여행을 가봐요"))
print('OKT 명사 추출 :',okt.nouns("열심히 코딩한 당신, 연휴에는 여행을 가봐요"))
OKT 형태소 분석 : ['열심히', '코딩', '한', '당신', ',', '연휴', '에는', '여행', '을', '가봐요']
OKT 품사 태깅 : [('열심히', 'Adverb'), ('코딩', 'Noun'), ('한', 'Josa'), ('당신', 'Noun'), (',', 'Punctuation'), ('연휴', 'Noun'), ('에는', 'Josa'), ('여행', 'Noun'), ('을', 'Josa'), ('가봐요', 'Verb')]
OKT 명사 추출 : ['코딩', '당신', '연휴', '여행']
print('꼬꼬마 형태소 분석 :',kkma.morphs("열심히 코딩한 당신, 연휴에는 여행을 가봐요"))
print('꼬꼬마 품사 태깅 :',kkma.pos("열심히 코딩한 당신, 연휴에는 여행을 가봐요"))
print('꼬꼬마 명사 추출 :',kkma.nouns("열심히 코딩한 당신, 연휴에는 여행을 가봐요"))
꼬꼬마 형태소 분석 : ['열심히', '코딩', '하', 'ㄴ', '당신', ',', '연휴', '에', '는', '여행', '을', '가보', '아요']
꼬꼬마 품사 태깅 : [('열심히', 'MAG'), ('코딩', 'NNG'), ('하', 'XSV'), ('ㄴ', 'ETD'), ('당신', 'NP'), (',', 'SP'), ('연휴', 'NNG'), ('에', 'JKM'), ('는', 'JX'), ('여행', 'NNG'), ('을', 'JKO'), ('가보', 'VV'), ('아요', 'EFN')]
꼬꼬마 명사 추출 : ['코딩', '당신', '연휴', '여행']분석기마다 성능과 결과가 다르기에 필요 용도에 따라 적절한 형태소 분석기를 판단하여 사용하면 된다. 속도가 중요한 경우에는 메캅을 사용할 수 있다.
✅ 정제 및 정규화
정제와 정규화는 토큰화 작업 전후에 텍스트 데이터를 용도에 맞게 전처리하는 작업이다.
- 정제(cleaning) : 갖고 있는 코퍼스로부터 분석 목적에 맞지 않는 노이즈 데이터 제거
- 특수 문자- 등장 빈도 적은 단어
- 길이가 짧은 단어
- 정규화(normalization) : 표현 방법이 다른 단어들을 통합시켜 같은 단어로 설정
- US = USA- 대소문자 통합
✅ 표제어 추출 및 어간 추출
정규화 기법 중 코퍼스에 있는 단어의 개수를 줄일 수 있는 기법
📌 표제어 추출
am, are, is의 표제어는 be
표제어 추출은 어간 추출과 달리 단어의 형태가 적절히 보존되는 양상을 보인다.
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
words = ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting']
print('표제어 추출 전 :',words)
print('표제어 추출 후 :',[lemmatizer.lemmatize(word) for word in words])
표제어 추출 전 : ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting']
표제어 추출 후 : ['policy', 'doing', 'organization', 'have', 'going', 'love', 'life', 'fly', 'dy', 'watched', 'ha', 'starting']하지만 'dy', 'ha'와 같이 결과를 내기도 하는데, 이는 본래 단어의 품사 정보를 알아야 정확한 결과를 얻을 수 있기 때문이다. 이러한 경우 WordNetLemmatizer를 사용하여 단어의 품사를 알려줄 수 있다.
lemmatizer.lemmatize('dies', 'v')
'die'
lemmatizer.lemmatize('watched', 'v')
'watch'
lemmatizer.lemmatize('has', 'v')
'have'📌 어간 추출
형태소의 종류
- 어간 : 단어의 의미를 담고 있는 단어의 핵심 부분
- 접사 : 단어에 추가 의미를 주는 부분
from nltk.stem import PorterStemmer
from nltk.stem import LancasterStemmer
porter_stemmer = PorterStemmer()
lancaster_stemmer = LancasterStemmer()
words = ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting']
print('어간 추출 전 :', words)
print('포터 스테머의 어간 추출 후:',[porter_stemmer.stem(w) for w in words])
print('랭커스터 스테머의 어간 추출 후:',[lancaster_stemmer.stem(w) for w in words])
어간 추출 전 : ['policy', 'doing', 'organization', 'have', 'going', 'love', 'lives', 'fly', 'dies', 'watched', 'has', 'starting']
포터 스테머의 어간 추출 후: ['polici', 'do', 'organ', 'have', 'go', 'love', 'live', 'fli', 'die', 'watch', 'ha', 'start']
랭커스터 스테머의 어간 추출 후: ['policy', 'doing', 'org', 'hav', 'going', 'lov', 'liv', 'fly', 'die', 'watch', 'has', 'start']스태머도 종류에 따라 결과가 상이하기 때문에 사용하고자 하는 코퍼스에 적용해보고 적합성을 판단한 뒤 사용해야 한다.
✅ 불용어
- 조사, 접미사, I, my, me, over과 같이 자주 등장하지만 분석에 큰 도움이 되지 않는 단어들
- 개발자가 직접 정의할 수도 있고 패키지를 활용할 수도 있음
📌 NLTK에서 불용어 확인 및 제거
stop_words_list = stopwords.words('english')
print('불용어 개수 :', len(stop_words_list))
print('불용어 10개 출력 :',stop_words_list[:10])
불용어 개수 : 179
불용어 10개 출력 : ['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're"]
example = "Family is not an important thing. It's everything."
stop_words = set(stopwords.words('english'))
word_tokens = word_tokenize(example)
result = []
for word in word_tokens:
if word not in stop_words:
result.append(word)
print('불용어 제거 전 :',word_tokens)
print('불용어 제거 후 :',result)
불용어 제거 전 : ['Family', 'is', 'not', 'an', 'important', 'thing', '.', 'It', "'s", 'everything', '.']
불용어 제거 후 : ['Family', 'important', 'thing', '.', 'It', "'s", 'everything', '.']📌 한국어에서 불용어 제거
한국어에서 불용어 제거 방법으로는 토큰화 후 조사나 접속사 등을 제거하는 방법이 있지만 제거하다 보면 명사나 형용사 중에서도 불용어로 제거하고 싶은 단어들이 생기기도 하므로 사용자가 직접 불용어 사전을 만들게 되는 경우가 많다.
okt = Okt()
example = "고기를 아무렇게나 구우려고 하면 안 돼. 고기라고 다 같은 게 아니거든. 예컨대 삼겹살을 구울 때는 중요한 게 있지."
stop_words = "를 아무렇게나 구 우려 고 안 돼 같은 게 구울 때 는"
stop_words = set(stop_words.split(' '))
word_tokens = okt.morphs(example)
result = [word for word in word_tokens if not word in stop_words]
print('불용어 제거 전 :',word_tokens)
print('불용어 제거 후 :',result)
불용어 제거 전 : ['고기', '를', '아무렇게나', '구', '우려', '고', '하면', '안', '돼', '.', '고기', '라고', '다', '같은', '게', '아니거든', '.', '예컨대', '삼겹살', '을', '구울', '때', '는', '중요한', '게', '있지', '.']
불용어 제거 후 : ['고기', '하면', '.', '고기', '라고', '다', '아니거든', '.', '예컨대', '삼겹살', '을', '중요한', '있지', '.']한국어 불용어 리스트 예시
위 링크는 보편적으로 선택할 수 있는 한국어 불용어 리스트를 보여준다. 하나의 예시이며, 직접 구성해도 되고 인터넷에 '한국어 불용어 리스트'를 검색해서 나오는 결과를 참고해도 된다. 불용어가 많은 경우 코드 내에서 직접 정의하지 않고 txt 파일이나 csv 파일로 정리해놓고 불러와서 사용하기도 한다.
✅ 정규 표현식
파이썬에서 지원하는 정규 표현식 모듈 re를 활용하면 특정 규칙이 있는 텍스트 데이터를 빠르게 정제할 수 있다. 상세 내용은 아래 링크 참고.
정규 표현식
✅ 정수 인코딩
컴퓨터는 텍스트보다 숫자를 더 잘 처리하기 때문에 자연어 처리에서는 텍스트를 숫자로 바꾸는 여러 기법들이 있다. 그리고 그러한 기법을 적용하기 전 각 단어를 고유한 정수에 매핑시키는 전처리 작업이 필요할 때가 있다.
📌 정수 인코딩
- dictionary를 사용하는 방법
from nltk.tokenize import sent_tokenize
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
raw_text = "A barber is a person. a barber is good person. a barber is huge person. he Knew A Secret! The Secret He Kept is huge secret. Huge secret. His barber kept his word. a barber kept his word. His barber kept his secret. But keeping and keeping such a huge secret to himself was driving the barber crazy. the barber went up a huge mountain."
# 문장 토큰화
sentences = sent_tokenize(raw_text)
print(sentences)
['A barber is a person.', 'a barber is good person.', 'a barber is huge person.', 'he Knew A Secret!', 'The Secret He Kept is huge secret.', 'Huge secret.', 'His barber kept his word.', 'a barber kept his word.', 'His barber kept his secret.', 'But keeping and keeping such a huge secret to himself was driving the barber crazy.', 'the barber went up a huge mountain.']
vocab = {}
preprocessed_sentences = []
stop_words = set(stopwords.words('english'))
for sentence in sentences:
# 단어 토큰화
tokenized_sentence = word_tokenize(sentence)
result = []
for word in tokenized_sentence:
word = word.lower() # 모든 단어를 소문자화하여 단어의 개수를 줄인다.
if word not in stop_words: # 단어 토큰화 된 결과에 대해서 불용어를 제거한다.
if len(word) > 2: # 단어 길이가 2이하인 경우에 대하여 추가로 단어를 제거한다.
result.append(word)
if word not in vocab:
vocab[word] = 0
vocab[word] += 1
preprocessed_sentences.append(result)
print(preprocessed_sentences)
[['barber', 'person'], ['barber', 'good', 'person'], ['barber', 'huge', 'person'], ['knew', 'secret'], ['secret', 'kept', 'huge', 'secret'], ['huge', 'secret'], ['barber', 'kept', 'word'], ['barber', 'kept', 'word'], ['barber', 'kept', 'secret'], ['keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy'], ['barber', 'went', 'huge', 'mountain']]
print('단어 집합 :',vocab)
단어 집합 : {'barber': 8, 'person': 3, 'good': 1, 'huge': 5, 'knew': 1, 'secret': 6, 'kept': 4, 'word': 2, 'keeping': 2, 'driving': 1, 'crazy': 1, 'went': 1, 'mountain': 1}
word_to_index = {}
i = 0
for (word, frequency) in vocab_sorted :
if frequency > 1 : # 빈도수가 작은 단어는 제외.
i = i + 1
word_to_index[word] = i
print(word_to_index)
{'barber': 1, 'secret': 2, 'huge': 3, 'kept': 4, 'person': 5, 'word': 6, 'keeping': 7}- Counter를 사용하는 방법
# words = np.hstack(preprocessed_sentences)으로도 수행 가능.
all_words_list = sum(preprocessed_sentences, [])
print(all_words_list)
['barber', 'person', 'barber', 'good', 'person', 'barber', 'huge', 'person', 'knew', 'secret', 'secret', 'kept', 'huge', 'secret', 'huge', 'secret', 'barber', 'kept', 'word', 'barber', 'kept', 'word', 'barber', 'kept', 'secret', 'keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy', 'barber', 'went', 'huge', 'mountain']
# 파이썬의 Counter 모듈을 이용하여 단어의 빈도수 카운트
vocab = Counter(all_words_list)
print(vocab)
Counter({'barber': 8, 'secret': 6, 'huge': 5, 'kept': 4, 'person': 3, 'word': 2, 'keeping': 2, 'good': 1, 'knew': 1, 'driving': 1, 'crazy': 1, 'went': 1, 'mountain': 1})
word_to_index = {}
i = 0
for (word, frequency) in vocab :
i = i + 1
word_to_index[word] = i
print(word_to_index)- NLTK의 FreqDist를 사용하는 방법
from nltk import FreqDist
import numpy as np
# np.hstack으로 문장 구분을 제거
vocab = FreqDist(np.hstack(preprocessed_sentences))
vocab_size = 5
vocab = vocab.most_common(vocab_size) # 등장 빈도수가 높은 상위 5개의 단어만 저장
word_to_index = {word[0] : index + 1 for index, word in enumerate(vocab)}
print(word_to_index)- enumerate를 사용하는 방법
test_input = ['a', 'b', 'c', 'd', 'e']
for index, value in enumerate(test_input): # 입력의 순서대로 0부터 인덱스를 부여함.
print("value : {}, index: {}".format(value, index))📌 케라스의 텍스트 전처리
from tensorflow.keras.preprocessing.text import Tokenizer
tokenizer = Tokenizer()
# fit_on_texts()안에 코퍼스를 입력으로 하면 빈도수를 기준으로 단어 집합을 생성.
tokenizer.fit_on_texts(preprocessed_sentences)
print(tokenizer.word_index)✅ 패딩
자연어 처리를 할 때 각 문장의 길이가 서로 다른 경우가 있다. 기계는 길이가 동일한 문서들에 대해서는 하나의 행렬로 보고 한꺼번에 묶어서 처리할 수 있기 때문에 병렬 연산을 위해 여러 문장의 길이를 임의로 동일하게 맞춰주는 작업이 필요할 때가 있다.
📌 Numpy로 패딩하기
import numpy as np
from tensorflow.keras.preprocessing.text import Tokenizer
preprocessed_sentences = [['barber', 'person'], ['barber', 'good', 'person'], ['barber', 'huge', 'person'], ['knew', 'secret'], ['secret', 'kept', 'huge', 'secret'], ['huge', 'secret'], ['barber', 'kept', 'word'], ['barber', 'kept', 'word'], ['barber', 'kept', 'secret'], ['keeping', 'keeping', 'huge', 'secret', 'driving', 'barber', 'crazy'], ['barber', 'went', 'huge', 'mountain']]
tokenizer = Tokenizer()
tokenizer.fit_on_texts(preprocessed_sentences)
encoded = tokenizer.texts_to_sequences(preprocessed_sentences)
print(encoded)
max_len = max(len(item) for item in encoded)
for sentence in encoded:
while len(sentence) < max_len:
sentence.append(0)
padded_np = np.array(encoded)
padded_np
array([[ 1, 5, 0, 0, 0, 0, 0],
[ 1, 8, 5, 0, 0, 0, 0],
[ 1, 3, 5, 0, 0, 0, 0],
[ 9, 2, 0, 0, 0, 0, 0],
[ 2, 4, 3, 2, 0, 0, 0],
[ 3, 2, 0, 0, 0, 0, 0],
[ 1, 4, 6, 0, 0, 0, 0],
[ 1, 4, 6, 0, 0, 0, 0],
[ 1, 4, 2, 0, 0, 0, 0],
[ 7, 7, 3, 2, 10, 1, 11],
[ 1, 12, 3, 13, 0, 0, 0]])📌 케라스 전처리 도구로 패딩하기
pad_sequences는 기본적으로 문서의 뒤가 아닌 앞에 0으로 채우기 때문에 Numpy로 패딩했을 때와 결과가 다르다. 뒤에 0을 채우고 싶으면 padding = 'post'를 주면 된다. maxlen의 인자로 정수를 주면 가장 긴 길이의 문서가 아니라 해당 정수로 모든 문서의 길이를 동일하게 할 수 있다. 이 경우 길이가 5보다 긴 문장은 앞의 데이터가 손실되는데, 뒤의 단어가 삭제되도록 하고 싶다면 truncating='post'를 사용하면 된다.
from tensorflow.keras.preprocessing.sequence import pad_sequences
encoded = tokenizer.texts_to_sequences(preprocessed_sentences)
padded = pad_sequences(encoded, padding='post', truncating='post', maxlen=5)
padded
array([[ 1, 5, 0, 0, 0],
[ 1, 8, 5, 0, 0],
[ 1, 3, 5, 0, 0],
[ 9, 2, 0, 0, 0],
[ 2, 4, 3, 2, 0],
[ 3, 2, 0, 0, 0],
[ 1, 4, 6, 0, 0],
[ 1, 4, 6, 0, 0],
[ 1, 4, 2, 0, 0],
[ 7, 7, 3, 2, 10],
[ 1, 12, 3, 13, 0]], dtype=int32)✅ 원-핫 인코딩
정수 인코딩 부분에서 언급했듯 컴퓨터는 문자보다 숫자를 더 잘 처리하기 때문에 자연어 처리에서는 문자를 숫자로 바꾸는 여러 기법들이 있다. 원-핫 인코딩은 그 중 가장 기본적인 표현 방법이다. 원-핫 인코딩은 단어 집합의 크기를 벡터의 차원으로 하고, 표현하고 싶은 단어의 인덱스에 1의 값을 부여하고, 다른 인덱스에는 0을 부여하는 단어의 벡터 표현 방식이다.
📌 함수를 만들어서 하는 방법
from konlpy.tag import Okt
okt = Okt()
tokens = okt.morphs("나는 자연어 처리를 배운다")
word_to_index = {word : index for index, word in enumerate(tokens)}
def one_hot_encoding(word, word_to_index):
one_hot_vector = [0]*(len(word_to_index))
index = word_to_index[word]
one_hot_vector[index] = 1
return one_hot_vector
one_hot_encoding("자연어", word_to_index)
[0, 0, 1, 0, 0, 0] 📌 케라스를 활용하는 방법
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.utils import to_categorical
sub_text = "점심 먹으러 갈래 메뉴는 햄버거 최고야"
encoded = tokenizer.texts_to_sequences([sub_text])[0]
one_hot = to_categorical(encoded)
print(one_hot)
[[0. 0. 1. 0. 0. 0. 0. 0.] # 인덱스 2의 원-핫 벡터
[0. 0. 0. 0. 0. 1. 0. 0.] # 인덱스 5의 원-핫 벡터
[0. 1. 0. 0. 0. 0. 0. 0.] # 인덱스 1의 원-핫 벡터
[0. 0. 0. 0. 0. 0. 1. 0.] # 인덱스 6의 원-핫 벡터
[0. 0. 0. 1. 0. 0. 0. 0.] # 인덱스 3의 원-핫 벡터
[0. 0. 0. 0. 0. 0. 0. 1.]] # 인덱스 7의 원-핫 벡터📌 원-핫 인코딩의 한계
- 공간 비효율적 : 단어 개수가 늘어날수록 벡터를 저장하기 위해 필요한 공간이 계속 늘어난다.
- 단어의 유사도 표현 불가
- 해결책
▶ 카운트 기반 벡터화 방법인 LSA(잠재 의미 분석), HAL 등
▶ 예측 기반으로 벡터화하는 NNLM, RNNLM, Word2Vec, FastText 등
▶ 카운트 기반과 예측 기반 두 가지 방법을 모두 사용하는 방법인 GloVe
✅ 데이터 분리
머신러닝 모델 학습 및 평가 시 데이터를 적절하게 분리하는 방법
📌 지도 학습
비유로 설명하자면 기계가 정답이 적힌 문제지를 문제와 정답을 함께 보며 공부하고, 향후 정답 없는 문제에 대해서도 정답을 잘 예측하게 하는 학습 방법이다.
<훈련 데이터>
X_train : 문제지 데이터
y_train : 문제지에 대한 정답 데이터
<테스트 데이터>
X_test : 시험지 데이터
y_test : 시험지에 대한 정답 데이터
📌 X, y 분리
- zip 함수를 이용하는 방법
zip()함수는 동일한 개수를 가지는 시퀀스 자료형에서 각 순서에 등장하는 원소들끼리 묶어주는 역할을 한다.
X, y = zip(['a', 1], ['b', 2], ['c', 3])
print('X 데이터 :',X)
print('y 데이터 :',y)
X 데이터 : ('a', 'b', 'c')
y 데이터 : (1, 2, 3)-
데이터프레임을 이용하는 방법
-
Numpy를 이용하는 방법
np_array = np.arange(0,16).reshape((4,4))
print('전체 데이터 :')
X = np_array[:, :3]
y = np_array[:,3]
print('X 데이터 :')
print(X)
print('y 데이터 :',y)
X 데이터 :
[[ 0 1 2]
[ 4 5 6]
[ 8 9 10]
[12 13 14]]
y 데이터 : [ 3 7 11 15]📌 테스트 데이터 분리
- 사이킷런을 이용하는 방법
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2, random_state=1234)- 수동으로 분리하는 방법
수동 분리 할 경우 데이터가 섞이지 않은 채 어느 지점에서 데이터를 앞과 뒤로 분리하므로 데이터 분리 전 수동으로 데이터를 섞는 과정이 필요할 수 있다.
# 실습을 위해 임의로 X와 y가 이미 분리 된 데이터를 생성
X, y = np.arange(0,24).reshape((12,2)), range(12)
num_of_train = int(len(X) * 0.8) # 데이터의 전체 길이의 80%에 해당하는 길이값을 구한다.
num_of_test = int(len(X) - num_of_train) # 전체 길이에서 80%에 해당하는 길이를 뺀다.
X_test = X[num_of_train:] # 전체 데이터 중에서 20%만큼 뒤의 데이터 저장
y_test = y[num_of_train:] # 전체 데이터 중에서 20%만큼 뒤의 데이터 저장
X_train = X[:num_of_train] # 전체 데이터 중에서 80%만큼 앞의 데이터 저장
y_train = y[:num_of_train] # 전체 데이터 중에서 80%만큼 앞의 데이터 저장✅ 한국어 전처리 패키지
📌 PyKoSpacing : 띄어쓰기
pip install git+https://github.com/haven-jeon/PyKoSpacing.git
from pykospacing import Spacing
spacing = Spacing()
sent = "오늘은광복절전날입니다. 광복절은한반도가일본제국으로부터해방된것을기념하는 날입니다."
kospacing_sent = spacing(sent) 📌 Py-Hanspell : 맞춤법, 띄어쓰기
현재 제대로 동작하지 않음
📌 SOYNLP : 품사 태깅, 단어 토큰화
SOYNLP는 기본적으로 학습에 기반한 토크나이저이다. 학습 방법은 아래 참고.
SOYNLP 학습
📌 Customized KoNLPy
pip install customized_konlpy
from ckonlpy.tag import Twitter
twitter = Twitter()
twitter.morphs('은경이는 사무실로 갔습니다.')
twitter.add_dictionary('은경이', 'Noun')
twitter.morphs('은경이는 사무실로 갔습니다.')
['은경이', '는', '사무실', '로', '갔습니다', '.']