자연어 처리 프로세스

효과적인 데이터 전처리: 깨끗한 데이터로 시작하는 분석의 첫걸음

안녕하세요, 데이터 분석가 여러분! 오늘은 데이터 분석의 핵심이라고 할 수 있는 데이터 전처리 과정에 대해 알아보겠습니다. 깨끗하고 정제된 데이터는 정확한 분석 결과의 기반이 됩니다. 그럼 지금부터 효과적인 데이터 전처리 5단계를 살펴볼까요?

1. 데이터 확인

첫 번째 단계는 데이터를 꼼꼼히 살펴보는 것입니다. 데이터의 구조, 각 열의 의미, 데이터 타입 등을 파악합니다. Python에서는

df.info()

,

df.describe()

,

df.head()

등의 함수를 활용하면 좋죠.

2. 중복 데이터 제거

중복된 데이터는 분석 결과를 왜곡시킬 수 있습니다. pandas의

drop_duplicates()

함수를 사용하여 쉽게 중복을 제거할 수 있습니다.

pythondf = df.drop_duplicates()

3. Null 제거

결측치(Null 값)는 분석에 큰 장애물이 될 수 있습니다. 상황에 따라 제거하거나 적절한 값으로 대체해야 합니다.

pythondf = df.dropna() *# Null 값이 있는 행 제거# 또는* df = df.fillna(value) *# Null 값을 특정 값으로 대체*

4. 빈공간 제거

문자열 데이터에 불필요한 공백이 있다면 제거해 주어야 합니다.

strip()

함수를 활용하면 됩니다.

pythondf['column'] = df['column'].str.strip()

5. 특수문자 제거

특수문자가 분석에 불필요하다면 정규표현식을 사용하여 제거할 수 있습니다.

`pythonimport re

df['column'] = df['column'].apply(lambda x: re.sub('[^A-Za-z0-9가-힣]', '', str(x)))`

이렇게 5단계의 데이터 전처리 과정을 거치면, 더욱 깨끗하고 분석하기 좋은 데이터를 얻을 수 있습니다. 물론 각 데이터셋의 특성에 따라 추가적인 전처리 과정이 필요할 수도 있습니다.데이터 전처리는 지루하고 시간이 많이 소요되는 작업일 수 있지만, 정확한 분석 결과를 위해서는 반드시 필요한 과정입니다. 꼼꼼하고 체계적인 전처리로 여러분의 데이터 분석 프로젝트를 성공으로 이끌어 보세요!

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import urllib.request

# 데이터 확인하기
input_data = 데이터 입력

# 중복 데이터 제거
input_data.drop_duplicates(subset=['document'], inplace=True)

# null 데이터 삭제
input_data.dropna(inplace=True)

# 양끝의 빈공간 삭제
input_data['document'] = input_data['document'].str.strip()
input_data['document'] = input_data['document'].str.replace('[^가-힣 ]','', regex=True)

print('이벤트 문자열 최대 길이 :{}'.format(max(len(l) for l in features)))
print('이벤트 문자열 평균 길이 :{}'.format(sum(map(len, features))/len(features)))

# 라벨 처리 
input_data= {'불안':0, '분노':1, '상처':2, '슬픔':3, '당황':4, '기쁨':5}
input_data['label'] = input_data['label'].map(label_dict)

데이터 분리

from sklearn.model_selection import train_test_split

# X, Y 분리
x_features = input_data['document'].values
y_labels = input_data['label'].values

# 학습, 테스트 데이터 분리
x_train, x_test, y_train, y_test = train_test_split(x_features , y_labels , test_size=0.2, stratify=labels, random_state=41)
x_train.shape, x_test.shape, y_train.shape, y_test.shape

# 토크나이저
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Tokenizer 단어 사전 만들기
tokenizer = Tokenizer()
tokenizer.fit_on_texts(x_train) #학습 단어로할지 전체 단어로할지 확인

# 단어별 숫자 확인
print(tokenizer.word_index)

# 총 단어 갯수 확인
max_words = len(tokenizer.index_word)

tokenizer.texts_to_sequences( )

LSTM 모델학습

# Import 
from tensorflow.keras.models import Sequential
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.layers import Dense, Flatten, Conv1D, MaxPool2D
from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, SimpleRNN, GRU

# 하이퍼 파라미터 설정 
max_words = max_words + 1    # 총 단어 갯수 + padding 0 번호
max_len = max(len(line) for line in x_train_seq)           # 최대 문장 길이
embedding_dim = 64      # embedding 차원

# 모델 선언
model = Sequential()

# 벡터 축소 
model.add(Embedding(max_words, embedding_dim, input_length=max_len))

# LSTM 모델
model.add(LSTM(16, return_sequences=True))
model.add(LSTM(16, return_sequences=True))
model.add(Flatten())
model.add(Dense(128, activation='swish'))
model.add(Dense(32, activation='swish'))
model.add(Dense(2, activation='softmax'))

model.compile(loss = 'sparse_categorical_crossentropy',
              optimizer = 'adam',
              metrics = ['accuracy'])
model.summary()

# 조기종료 콜백함수 정의(EarlyStopping)
es = EarlyStopping(monitor='val_loss', patience=10, verbose=1)

# 체크포인트 저장(EarlyStopping)
checkpoint_path = 'checkpoint.keras'
cp = ModelCheckpoint(checkpoint_path, monitor='val_loss', verbose=1, save_best_only=True)

x_train_pad.shape,y_train.shape , x_test_pad.shape,y_test.shape

# 모델 학습(fit) 
history = model.fit(x_train_pad, y_train, epochs=50, batch_size=512,
                      validation_data=(x_test_pad, y_test), verbose =1, callbacks=[es, cp])

model.evaluate(x_test_pad, y_test)

print(f'문자열 : {x_test[0]}')
print(f'Sequence : {x_test_pad[0]}')

# 모델 예측하기(predict)
predict = model.predict(x_test_pad[:1])

---

TF-IDF 방법

# 말뭉치를 TF-IDF로 변환하기

from sklearn.feature_extraction.text import TfidfVectorizer

tfidf = TfidfVectorizer()
x_train_v = tfidf.fit_transform( x_train )
x_test_v = tfidf.transform( x_test )

y_train_v = y_train.copy()
y_test_v = y_test.copy()

머신러닝 모델

# 머신러닝 코드 

from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import SGDClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
import time

start = time.time()

# 로지스틱 회귀 모델로 예측하기
# model = LogisticRegression(random_state=42, max_iter=1000)
# model.fit(x_train_v, y_train_v)

# predict = model.predict(x_test_v[:1])
# predict_proba = model.predict_proba(x_test_v[:1])
# print(f'예측 결과: {predict}')
# print(f'예측 확률: {predict_proba}')

# 랜덤포레스트 모델
# model = RandomForestClassifier()
# model.fit(x_train_v, y_train_v)
# print(f'RandomForestClassifier 성능 : { model.score(x_test_v, y_test_v) }')

# SGD 모델 
model = SGDClassifier()
model.fit(x_train_v, y_train_v)
print(f'SGDClassifier 성능 : { model.score(x_test_v, y_test_v) }')

end = time.time()
print(f'총학습시간: { end - start }')

print(f'검증데이터셋의 첫번째 TF-IDF : {x_test_v[:1]}')
print(f'검증데이터셋의 첫번째 TF-IDF 역변환 : {tfidf.inverse_transform(x_test_v[:1])}')

# RandomForest 모델로 예측하기
predict = model.predict(x_test_v[:1])
print(predict)

---

형태소 분석기 사용시

• MECAP 사용시 (정확도가 높음)

    https://konlpy.org/en/latest/install/
  
    !git clone https://github.com/SOMJANG/Mecab-ko-for-Google-Colab.git
    %cd Mecab-ko-for-Google-Colab
    !bash install_mecab-ko_on_colab_light_220429.sh
  
    # 형태소 분석기 임포트
    from konlpy.tag import Mecab
    mecab = Mecab()
  
    # 토큰화 함수 정의
    def mecab_morphs(doc):
        return mecab.morphs(doc)
  
    # 토큰화 적용
    train_data['tokenized'] = train_data['comments'].apply(mecab_morphs)
    test_data['tokenized'] = test_data['comments'].apply(mecab_morphs)
  

• Okt 사용시 (설치가 간편함)

    !pip install KoNLPy
  
    # !pip install KoNLPy
  
    from konlpy.tag import Okt
    # Okt 객체 생성
    okt = Okt()
  
    # '문장' 열의 각 항목에 대해 형태소 분석 수행
    final_data['형태소'] = final_data['문장'].apply(lambda x: okt.morphs(x))